Commit realizado el 12:13:52 08-04-2024

wp-content/plugins/wpforms-lite/vendor/symfony/polyfill-iconv/Iconv.php

@@ -0,0 +1,741 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Polyfill\Iconv;
+
+/**
+ * iconv implementation in pure PHP, UTF-8 centric.
+ *
+ * Implemented:
+ * - iconv              - Convert string to requested character encoding
+ * - iconv_mime_decode  - Decodes a MIME header field
+ * - iconv_mime_decode_headers - Decodes multiple MIME header fields at once
+ * - iconv_get_encoding - Retrieve internal configuration variables of iconv extension
+ * - iconv_set_encoding - Set current setting for character encoding conversion
+ * - iconv_mime_encode  - Composes a MIME header field
+ * - iconv_strlen       - Returns the character count of string
+ * - iconv_strpos       - Finds position of first occurrence of a needle within a haystack
+ * - iconv_strrpos      - Finds the last occurrence of a needle within a haystack
+ * - iconv_substr       - Cut out part of a string
+ *
+ * Charsets available for conversion are defined by files
+ * in the charset/ directory and by Iconv::$alias below.
+ * You're welcome to send back any addition you make.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ *
+ * @internal
+ */
+final class Iconv
+{
+    const ERROR_ILLEGAL_CHARACTER = 'iconv(): Detected an illegal character in input string';
+    const ERROR_WRONG_CHARSET = 'iconv(): Wrong charset, conversion from `%s\' to `%s\' is not allowed';
+
+    public static $inputEncoding = 'utf-8';
+    public static $outputEncoding = 'utf-8';
+    public static $internalEncoding = 'utf-8';
+
+    private static $alias = array(
+        'utf8' => 'utf-8',
+        'ascii' => 'us-ascii',
+        'tis-620' => 'iso-8859-11',
+        'cp1250' => 'windows-1250',
+        'cp1251' => 'windows-1251',
+        'cp1252' => 'windows-1252',
+        'cp1253' => 'windows-1253',
+        'cp1254' => 'windows-1254',
+        'cp1255' => 'windows-1255',
+        'cp1256' => 'windows-1256',
+        'cp1257' => 'windows-1257',
+        'cp1258' => 'windows-1258',
+        'shift-jis' => 'cp932',
+        'shift_jis' => 'cp932',
+        'latin1' => 'iso-8859-1',
+        'latin2' => 'iso-8859-2',
+        'latin3' => 'iso-8859-3',
+        'latin4' => 'iso-8859-4',
+        'latin5' => 'iso-8859-9',
+        'latin6' => 'iso-8859-10',
+        'latin7' => 'iso-8859-13',
+        'latin8' => 'iso-8859-14',
+        'latin9' => 'iso-8859-15',
+        'latin10' => 'iso-8859-16',
+        'iso8859-1' => 'iso-8859-1',
+        'iso8859-2' => 'iso-8859-2',
+        'iso8859-3' => 'iso-8859-3',
+        'iso8859-4' => 'iso-8859-4',
+        'iso8859-5' => 'iso-8859-5',
+        'iso8859-6' => 'iso-8859-6',
+        'iso8859-7' => 'iso-8859-7',
+        'iso8859-8' => 'iso-8859-8',
+        'iso8859-9' => 'iso-8859-9',
+        'iso8859-10' => 'iso-8859-10',
+        'iso8859-11' => 'iso-8859-11',
+        'iso8859-12' => 'iso-8859-12',
+        'iso8859-13' => 'iso-8859-13',
+        'iso8859-14' => 'iso-8859-14',
+        'iso8859-15' => 'iso-8859-15',
+        'iso8859-16' => 'iso-8859-16',
+        'iso_8859-1' => 'iso-8859-1',
+        'iso_8859-2' => 'iso-8859-2',
+        'iso_8859-3' => 'iso-8859-3',
+        'iso_8859-4' => 'iso-8859-4',
+        'iso_8859-5' => 'iso-8859-5',
+        'iso_8859-6' => 'iso-8859-6',
+        'iso_8859-7' => 'iso-8859-7',
+        'iso_8859-8' => 'iso-8859-8',
+        'iso_8859-9' => 'iso-8859-9',
+        'iso_8859-10' => 'iso-8859-10',
+        'iso_8859-11' => 'iso-8859-11',
+        'iso_8859-12' => 'iso-8859-12',
+        'iso_8859-13' => 'iso-8859-13',
+        'iso_8859-14' => 'iso-8859-14',
+        'iso_8859-15' => 'iso-8859-15',
+        'iso_8859-16' => 'iso-8859-16',
+        'iso88591' => 'iso-8859-1',
+        'iso88592' => 'iso-8859-2',
+        'iso88593' => 'iso-8859-3',
+        'iso88594' => 'iso-8859-4',
+        'iso88595' => 'iso-8859-5',
+        'iso88596' => 'iso-8859-6',
+        'iso88597' => 'iso-8859-7',
+        'iso88598' => 'iso-8859-8',
+        'iso88599' => 'iso-8859-9',
+        'iso885910' => 'iso-8859-10',
+        'iso885911' => 'iso-8859-11',
+        'iso885912' => 'iso-8859-12',
+        'iso885913' => 'iso-8859-13',
+        'iso885914' => 'iso-8859-14',
+        'iso885915' => 'iso-8859-15',
+        'iso885916' => 'iso-8859-16',
+    );
+    private static $translitMap = array();
+    private static $convertMap = array();
+    private static $errorHandler;
+    private static $lastError;
+
+    private static $ulenMask = array("\xC0" => 2, "\xD0" => 2, "\xE0" => 3, "\xF0" => 4);
+    private static $isValidUtf8;
+
+    public static function iconv($inCharset, $outCharset, $str)
+    {
+        $str = (string) $str;
+        if ('' === $str) {
+            return '';
+        }
+
+        // Prepare for //IGNORE and //TRANSLIT
+
+        $translit = $ignore = '';
+
+        $outCharset = strtolower($outCharset);
+        $inCharset = strtolower($inCharset);
+
+        if ('' === $outCharset) {
+            $outCharset = 'iso-8859-1';
+        }
+        if ('' === $inCharset) {
+            $inCharset = 'iso-8859-1';
+        }
+
+        do {
+            $loop = false;
+
+            if ('//translit' === substr($outCharset, -10)) {
+                $loop = $translit = true;
+                $outCharset = substr($outCharset, 0, -10);
+            }
+
+            if ('//ignore' === substr($outCharset, -8)) {
+                $loop = $ignore = true;
+                $outCharset = substr($outCharset, 0, -8);
+            }
+        } while ($loop);
+
+        do {
+            $loop = false;
+
+            if ('//translit' === substr($inCharset, -10)) {
+                $loop = true;
+                $inCharset = substr($inCharset, 0, -10);
+            }
+
+            if ('//ignore' === substr($inCharset, -8)) {
+                $loop = true;
+                $inCharset = substr($inCharset, 0, -8);
+            }
+        } while ($loop);
+
+        if (isset(self::$alias[$inCharset])) {
+            $inCharset = self::$alias[$inCharset];
+        }
+        if (isset(self::$alias[$outCharset])) {
+            $outCharset = self::$alias[$outCharset];
+        }
+
+        // Load charset maps
+
+        if (('utf-8' !== $inCharset && !self::loadMap('from.', $inCharset, $inMap))
+          || ('utf-8' !== $outCharset && !self::loadMap('to.', $outCharset, $outMap))) {
+            trigger_error(sprintf(self::ERROR_WRONG_CHARSET, $inCharset, $outCharset));
+
+            return false;
+        }
+
+        if ('utf-8' !== $inCharset) {
+            // Convert input to UTF-8
+            $result = '';
+            if (self::mapToUtf8($result, $inMap, $str, $ignore)) {
+                $str = $result;
+            } else {
+                $str = false;
+            }
+            self::$isValidUtf8 = true;
+        } else {
+            self::$isValidUtf8 = preg_match('//u', $str);
+
+            if (!self::$isValidUtf8 && !$ignore) {
+                trigger_error(self::ERROR_ILLEGAL_CHARACTER);
+
+                return false;
+            }
+
+            if ('utf-8' === $outCharset) {
+                // UTF-8 validation
+                $str = self::utf8ToUtf8($str, $ignore);
+            }
+        }
+
+        if ('utf-8' !== $outCharset && false !== $str) {
+            // Convert output to UTF-8
+            $result = '';
+            if (self::mapFromUtf8($result, $outMap, $str, $ignore, $translit)) {
+                return $result;
+            }
+
+            return false;
+        }
+
+        return $str;
+    }
+
+    public static function iconv_mime_decode_headers($str, $mode = 0, $charset = null)
+    {
+        if (null === $charset) {
+            $charset = self::$internalEncoding;
+        }
+
+        if (false !== strpos($str, "\r")) {
+            $str = strtr(str_replace("\r\n", "\n", $str), "\r", "\n");
+        }
+        $str = explode("\n\n", $str, 2);
+
+        $headers = array();
+
+        $str = preg_split('/\n(?![ \t])/', $str[0]);
+        foreach ($str as $str) {
+            $str = self::iconv_mime_decode($str, $mode, $charset);
+            if (false === $str) {
+                return false;
+            }
+            $str = explode(':', $str, 2);
+
+            if (2 === \count($str)) {
+                if (isset($headers[$str[0]])) {
+                    if (!\is_array($headers[$str[0]])) {
+                        $headers[$str[0]] = array($headers[$str[0]]);
+                    }
+                    $headers[$str[0]][] = ltrim($str[1]);
+                } else {
+                    $headers[$str[0]] = ltrim($str[1]);
+                }
+            }
+        }
+
+        return $headers;
+    }
+
+    public static function iconv_mime_decode($str, $mode = 0, $charset = null)
+    {
+        if (null === $charset) {
+            $charset = self::$internalEncoding;
+        }
+        if (ICONV_MIME_DECODE_CONTINUE_ON_ERROR & $mode) {
+            $charset .= '//IGNORE';
+        }
+
+        if (false !== strpos($str, "\r")) {
+            $str = strtr(str_replace("\r\n", "\n", $str), "\r", "\n");
+        }
+        $str = preg_split('/\n(?![ \t])/', rtrim($str), 2);
+        $str = preg_replace('/[ \t]*\n[ \t]+/', ' ', rtrim($str[0]));
+        $str = preg_split('/=\?([^?]+)\?([bqBQ])\?(.*?)\?=/', $str, -1, PREG_SPLIT_DELIM_CAPTURE);
+
+        $result = self::iconv('utf-8', $charset, $str[0]);
+        if (false === $result) {
+            return false;
+        }
+
+        $i = 1;
+        $len = \count($str);
+
+        while ($i < $len) {
+            $c = strtolower($str[$i]);
+            if ((ICONV_MIME_DECODE_CONTINUE_ON_ERROR & $mode)
+              && 'utf-8' !== $c
+              && !isset(self::$alias[$c])
+              && !self::loadMap('from.', $c, $d)) {
+                $d = false;
+            } elseif ('B' === strtoupper($str[$i + 1])) {
+                $d = base64_decode($str[$i + 2]);
+            } else {
+                $d = rawurldecode(strtr(str_replace('%', '%25', $str[$i + 2]), '=_', '% '));
+            }
+
+            if (false !== $d) {
+                if ('' !== $d) {
+                    if ('' === $d = self::iconv($c, $charset, $d)) {
+                        $str[$i + 3] = substr($str[$i + 3], 1);
+                    } else {
+                        $result .= $d;
+                    }
+                }
+                $d = self::iconv('utf-8', $charset, $str[$i + 3]);
+                if ('' !== trim($d)) {
+                    $result .= $d;
+                }
+            } elseif (ICONV_MIME_DECODE_CONTINUE_ON_ERROR & $mode) {
+                $result .= "=?{$str[$i]}?{$str[$i + 1]}?{$str[$i + 2]}?={$str[$i + 3]}";
+            } else {
+                $result = false;
+                break;
+            }
+
+            $i += 4;
+        }
+
+        return $result;
+    }
+
+    public static function iconv_get_encoding($type = 'all')
+    {
+        switch ($type) {
+            case 'input_encoding': return self::$inputEncoding;
+            case 'output_encoding': return self::$outputEncoding;
+            case 'internal_encoding': return self::$internalEncoding;
+        }
+
+        return array(
+            'input_encoding' => self::$inputEncoding,
+            'output_encoding' => self::$outputEncoding,
+            'internal_encoding' => self::$internalEncoding,
+        );
+    }
+
+    public static function iconv_set_encoding($type, $charset)
+    {
+        switch ($type) {
+            case 'input_encoding': self::$inputEncoding = $charset; break;
+            case 'output_encoding': self::$outputEncoding = $charset; break;
+            case 'internal_encoding': self::$internalEncoding = $charset; break;
+
+            default: return false;
+        }
+
+        return true;
+    }
+
+    public static function iconv_mime_encode($fieldName, $fieldValue, $pref = null)
+    {
+        if (!\is_array($pref)) {
+            $pref = array();
+        }
+
+        $pref += array(
+            'scheme' => 'B',
+            'input-charset' => self::$internalEncoding,
+            'output-charset' => self::$internalEncoding,
+            'line-length' => 76,
+            'line-break-chars' => "\r\n",
+        );
+
+        if (preg_match('/[\x80-\xFF]/', $fieldName)) {
+            $fieldName = '';
+        }
+
+        $scheme = strtoupper(substr($pref['scheme'], 0, 1));
+        $in = strtolower($pref['input-charset']);
+        $out = strtolower($pref['output-charset']);
+
+        if ('utf-8' !== $in && false === $fieldValue = self::iconv($in, 'utf-8', $fieldValue)) {
+            return false;
+        }
+
+        preg_match_all('/./us', $fieldValue, $chars);
+
+        $chars = isset($chars[0]) ? $chars[0] : array();
+
+        $lineBreak = (int) $pref['line-length'];
+        $lineStart = "=?{$pref['output-charset']}?{$scheme}?";
+        $lineLength = \strlen($fieldName) + 2 + \strlen($lineStart) + 2;
+        $lineOffset = \strlen($lineStart) + 3;
+        $lineData = '';
+
+        $fieldValue = array();
+
+        $Q = 'Q' === $scheme;
+
+        foreach ($chars as $c) {
+            if ('utf-8' !== $out && false === $c = self::iconv('utf-8', $out, $c)) {
+                return false;
+            }
+
+            $o = $Q
+                ? $c = preg_replace_callback(
+                    '/[=_\?\x00-\x1F\x80-\xFF]/',
+                    array(__CLASS__, 'qpByteCallback'),
+                    $c
+                )
+                : base64_encode($lineData.$c);
+
+            if (isset($o[$lineBreak - $lineLength])) {
+                if (!$Q) {
+                    $lineData = base64_encode($lineData);
+                }
+                $fieldValue[] = $lineStart.$lineData.'?=';
+                $lineLength = $lineOffset;
+                $lineData = '';
+            }
+
+            $lineData .= $c;
+            $Q && $lineLength += \strlen($c);
+        }
+
+        if ('' !== $lineData) {
+            if (!$Q) {
+                $lineData = base64_encode($lineData);
+            }
+            $fieldValue[] = $lineStart.$lineData.'?=';
+        }
+
+        return $fieldName.': '.implode($pref['line-break-chars'].' ', $fieldValue);
+    }
+
+    public static function iconv_strlen($s, $encoding = null)
+    {
+        static $hasXml = null;
+        if (null === $hasXml) {
+            $hasXml = \extension_loaded('xml');
+        }
+
+        if ($hasXml) {
+            return self::strlen1($s, $encoding);
+        }
+
+        return self::strlen2($s, $encoding);
+    }
+
+    public static function strlen1($s, $encoding = null)
+    {
+        if (null === $encoding) {
+            $encoding = self::$internalEncoding;
+        }
+        if (0 !== stripos($encoding, 'utf-8') && false === $s = self::iconv($encoding, 'utf-8', $s)) {
+            return false;
+        }
+
+        return \strlen(utf8_decode($s));
+    }
+
+    public static function strlen2($s, $encoding = null)
+    {
+        if (null === $encoding) {
+            $encoding = self::$internalEncoding;
+        }
+        if (0 !== stripos($encoding, 'utf-8') && false === $s = self::iconv($encoding, 'utf-8', $s)) {
+            return false;
+        }
+
+        $ulenMask = self::$ulenMask;
+
+        $i = 0;
+        $j = 0;
+        $len = \strlen($s);
+
+        while ($i < $len) {
+            $u = $s[$i] & "\xF0";
+            $i += isset($ulenMask[$u]) ? $ulenMask[$u] : 1;
+            ++$j;
+        }
+
+        return $j;
+    }
+
+    public static function iconv_strpos($haystack, $needle, $offset = 0, $encoding = null)
+    {
+        if (null === $encoding) {
+            $encoding = self::$internalEncoding;
+        }
+
+        if (0 !== stripos($encoding, 'utf-8')) {
+            if (false === $haystack = self::iconv($encoding, 'utf-8', $haystack)) {
+                return false;
+            }
+            if (false === $needle = self::iconv($encoding, 'utf-8', $needle)) {
+                return false;
+            }
+        }
+
+        if ($offset = (int) $offset) {
+            $haystack = self::iconv_substr($haystack, $offset, 2147483647, 'utf-8');
+        }
+        $pos = strpos($haystack, $needle);
+
+        return false === $pos ? false : ($offset + ($pos ? self::iconv_strlen(substr($haystack, 0, $pos), 'utf-8') : 0));
+    }
+
+    public static function iconv_strrpos($haystack, $needle, $encoding = null)
+    {
+        if (null === $encoding) {
+            $encoding = self::$internalEncoding;
+        }
+
+        if (0 !== stripos($encoding, 'utf-8')) {
+            if (false === $haystack = self::iconv($encoding, 'utf-8', $haystack)) {
+                return false;
+            }
+            if (false === $needle = self::iconv($encoding, 'utf-8', $needle)) {
+                return false;
+            }
+        }
+
+        $pos = isset($needle[0]) ? strrpos($haystack, $needle) : false;
+
+        return false === $pos ? false : self::iconv_strlen($pos ? substr($haystack, 0, $pos) : $haystack, 'utf-8');
+    }
+
+    public static function iconv_substr($s, $start, $length = 2147483647, $encoding = null)
+    {
+        if (null === $encoding) {
+            $encoding = self::$internalEncoding;
+        }
+        if (0 !== stripos($encoding, 'utf-8')) {
+            $encoding = null;
+        } elseif (false === $s = self::iconv($encoding, 'utf-8', $s)) {
+            return false;
+        }
+
+        $s = (string) $s;
+        $slen = self::iconv_strlen($s, 'utf-8');
+        $start = (int) $start;
+
+        if (0 > $start) {
+            $start += $slen;
+        }
+        if (0 > $start) {
+            return false;
+        }
+        if ($start >= $slen) {
+            return false;
+        }
+
+        $rx = $slen - $start;
+
+        if (0 > $length) {
+            $length += $rx;
+        }
+        if (0 === $length) {
+            return '';
+        }
+        if (0 > $length) {
+            return false;
+        }
+
+        if ($length > $rx) {
+            $length = $rx;
+        }
+
+        $rx = '/^'.($start ? self::pregOffset($start) : '').'('.self::pregOffset($length).')/u';
+
+        $s = preg_match($rx, $s, $s) ? $s[1] : '';
+
+        if (null === $encoding) {
+            return $s;
+        }
+
+        return self::iconv('utf-8', $encoding, $s);
+    }
+
+    private static function loadMap($type, $charset, &$map)
+    {
+        if (!isset(self::$convertMap[$type.$charset])) {
+            if (false === $map = self::getData($type.$charset)) {
+                if ('to.' === $type && self::loadMap('from.', $charset, $map)) {
+                    $map = array_flip($map);
+                } else {
+                    return false;
+                }
+            }
+
+            self::$convertMap[$type.$charset] = $map;
+        } else {
+            $map = self::$convertMap[$type.$charset];
+        }
+
+        return true;
+    }
+
+    private static function utf8ToUtf8($str, $ignore)
+    {
+        $ulenMask = self::$ulenMask;
+        $valid = self::$isValidUtf8;
+
+        $u = $str;
+        $i = $j = 0;
+        $len = \strlen($str);
+
+        while ($i < $len) {
+            if ($str[$i] < "\x80") {
+                $u[$j++] = $str[$i++];
+            } else {
+                $ulen = $str[$i] & "\xF0";
+                $ulen = isset($ulenMask[$ulen]) ? $ulenMask[$ulen] : 1;
+                $uchr = substr($str, $i, $ulen);
+
+                if (1 === $ulen || !($valid || preg_match('/^.$/us', $uchr))) {
+                    if ($ignore) {
+                        ++$i;
+                        continue;
+                    }
+
+                    trigger_error(self::ERROR_ILLEGAL_CHARACTER);
+
+                    return false;
+                } else {
+                    $i += $ulen;
+                }
+
+                $u[$j++] = $uchr[0];
+
+                isset($uchr[1]) && 0 !== ($u[$j++] = $uchr[1])
+                    && isset($uchr[2]) && 0 !== ($u[$j++] = $uchr[2])
+                    && isset($uchr[3]) && 0 !== ($u[$j++] = $uchr[3]);
+            }
+        }
+
+        return substr($u, 0, $j);
+    }
+
+    private static function mapToUtf8(&$result, array $map, $str, $ignore)
+    {
+        $len = \strlen($str);
+        for ($i = 0; $i < $len; ++$i) {
+            if (isset($str[$i + 1], $map[$str[$i].$str[$i + 1]])) {
+                $result .= $map[$str[$i].$str[++$i]];
+            } elseif (isset($map[$str[$i]])) {
+                $result .= $map[$str[$i]];
+            } elseif (!$ignore) {
+                trigger_error(self::ERROR_ILLEGAL_CHARACTER);
+
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    private static function mapFromUtf8(&$result, array $map, $str, $ignore, $translit)
+    {
+        $ulenMask = self::$ulenMask;
+        $valid = self::$isValidUtf8;
+
+        if ($translit && !self::$translitMap) {
+            self::$translitMap = self::getData('translit');
+        }
+
+        $i = 0;
+        $len = \strlen($str);
+
+        while ($i < $len) {
+            if ($str[$i] < "\x80") {
+                $uchr = $str[$i++];
+            } else {
+                $ulen = $str[$i] & "\xF0";
+                $ulen = isset($ulenMask[$ulen]) ? $ulenMask[$ulen] : 1;
+                $uchr = substr($str, $i, $ulen);
+
+                if ($ignore && (1 === $ulen || !($valid || preg_match('/^.$/us', $uchr)))) {
+                    ++$i;
+                    continue;
+                } else {
+                    $i += $ulen;
+                }
+            }
+
+            if (isset($map[$uchr])) {
+                $result .= $map[$uchr];
+            } elseif ($translit) {
+                if (isset(self::$translitMap[$uchr])) {
+                    $uchr = self::$translitMap[$uchr];
+                } elseif ($uchr >= "\xC3\x80") {
+                    $uchr = \Normalizer::normalize($uchr, \Normalizer::NFD);
+
+                    if ($uchr[0] < "\x80") {
+                        $uchr = $uchr[0];
+                    } elseif ($ignore) {
+                        continue;
+                    } else {
+                        return false;
+                    }
+                } elseif ($ignore) {
+                    continue;
+                } else {
+                    return false;
+                }
+
+                $str = $uchr.substr($str, $i);
+                $len = \strlen($str);
+                $i = 0;
+            } elseif (!$ignore) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    private static function qpByteCallback(array $m)
+    {
+        return '='.strtoupper(dechex(\ord($m[0])));
+    }
+
+    private static function pregOffset($offset)
+    {
+        $rx = array();
+        $offset = (int) $offset;
+
+        while ($offset > 65535) {
+            $rx[] = '.{65535}';
+            $offset -= 65535;
+        }
+
+        return implode('', $rx).'.{'.$offset.'}';
+    }
+
+    private static function getData($file)
+    {
+        if (file_exists($file = __DIR__.'/Resources/charset/'.$file.'.php')) {
+            return require $file;
+        }
+
+        return false;
+    }
+}

wp-content/plugins/wpforms-lite/vendor/symfony/polyfill-iconv/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2015-2019 Fabien Potencier
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished
+to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

wp-content/plugins/wpforms-lite/vendor/symfony/polyfill-iconv/bootstrap.php

@@ -0,0 +1,84 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Symfony\Polyfill\Iconv as p;
+
+if (extension_loaded('iconv')) {
+    return;
+}
+
+if (!defined('ICONV_IMPL')) {
+    define('ICONV_IMPL', 'Symfony');
+}
+if (!defined('ICONV_VERSION')) {
+    define('ICONV_VERSION', '1.0');
+}
+if (!defined('ICONV_MIME_DECODE_STRICT')) {
+    define('ICONV_MIME_DECODE_STRICT', 1);
+}
+if (!defined('ICONV_MIME_DECODE_CONTINUE_ON_ERROR')) {
+    define('ICONV_MIME_DECODE_CONTINUE_ON_ERROR', 2);
+}
+
+if (!function_exists('iconv')) {
+    function iconv($from, $to, $s) { return p\Iconv::iconv($from, $to, $s); }
+}
+if (!function_exists('iconv_get_encoding')) {
+    function iconv_get_encoding($type = 'all') { return p\Iconv::iconv_get_encoding($type); }
+}
+if (!function_exists('iconv_set_encoding')) {
+    function iconv_set_encoding($type, $charset) { return p\Iconv::iconv_set_encoding($type, $charset); }
+}
+if (!function_exists('iconv_mime_encode')) {
+    function iconv_mime_encode($name, $value, $pref = null) { return p\Iconv::iconv_mime_encode($name, $value, $pref); }
+}
+if (!function_exists('iconv_mime_decode_headers')) {
+    function iconv_mime_decode_headers($encodedHeaders, $mode = 0, $enc = null) { return p\Iconv::iconv_mime_decode_headers($encodedHeaders, $mode, $enc); }
+}
+
+if (extension_loaded('mbstring')) {
+    if (!function_exists('iconv_strlen')) {
+        function iconv_strlen($s, $enc = null) { null === $enc and $enc = p\Iconv::$internalEncoding; return mb_strlen($s, $enc); }
+    }
+    if (!function_exists('iconv_strpos')) {
+        function iconv_strpos($s, $needle, $offset = 0, $enc = null) { null === $enc and $enc = p\Iconv::$internalEncoding; return mb_strpos($s, $needle, $offset, $enc); }
+    }
+    if (!function_exists('iconv_strrpos')) {
+        function iconv_strrpos($s, $needle, $enc = null) { null === $enc and $enc = p\Iconv::$internalEncoding; return mb_strrpos($s, $needle, 0, $enc); }
+    }
+    if (!function_exists('iconv_substr')) {
+        function iconv_substr($s, $start, $length = 2147483647, $enc = null) { null === $enc and $enc = p\Iconv::$internalEncoding; return mb_substr($s, $start, $length, $enc); }
+    }
+    if (!function_exists('iconv_mime_decode')) {
+        function iconv_mime_decode($encodedHeaders, $mode = 0, $enc = null) { null === $enc and $enc = p\Iconv::$internalEncoding; return mb_decode_mimeheader($encodedHeaders, $mode, $enc); }
+    }
+} else {
+    if (!function_exists('iconv_strlen')) {
+        if (extension_loaded('xml')) {
+            function iconv_strlen($s, $enc = null) { return p\Iconv::strlen1($s, $enc); }
+        } else {
+            function iconv_strlen($s, $enc = null) { return p\Iconv::strlen2($s, $enc); }
+        }
+    }
+
+    if (!function_exists('iconv_strpos')) {
+        function iconv_strpos($s, $needle, $offset = 0, $enc = null) { return p\Iconv::iconv_strpos($s, $needle, $offset, $enc); }
+    }
+    if (!function_exists('iconv_strrpos')) {
+        function iconv_strrpos($s, $needle, $enc = null) { return p\Iconv::iconv_strrpos($s, $needle, $enc); }
+    }
+    if (!function_exists('iconv_substr')) {
+        function iconv_substr($s, $start, $length = 2147483647, $enc = null) { return p\Iconv::iconv_substr($s, $start, $length, $enc); }
+    }
+    if (!function_exists('iconv_mime_decode')) {
+        function iconv_mime_decode($encodedHeaders, $mode = 0, $enc = null) { return p\Iconv::iconv_mime_decode($encodedHeaders, $mode, $enc); }
+    }
+}

wp-content/plugins/wpforms-lite/vendor/symfony/polyfill-mbstring/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2015-2019 Fabien Potencier
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished
+to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

wp-content/plugins/wpforms-lite/vendor/symfony/polyfill-mbstring/Mbstring.php

@@ -0,0 +1,847 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Polyfill\Mbstring;
+
+/**
+ * Partial mbstring implementation in PHP, iconv based, UTF-8 centric.
+ *
+ * Implemented:
+ * - mb_chr                  - Returns a specific character from its Unicode code point
+ * - mb_convert_encoding     - Convert character encoding
+ * - mb_convert_variables    - Convert character code in variable(s)
+ * - mb_decode_mimeheader    - Decode string in MIME header field
+ * - mb_encode_mimeheader    - Encode string for MIME header XXX NATIVE IMPLEMENTATION IS REALLY BUGGED
+ * - mb_decode_numericentity - Decode HTML numeric string reference to character
+ * - mb_encode_numericentity - Encode character to HTML numeric string reference
+ * - mb_convert_case         - Perform case folding on a string
+ * - mb_detect_encoding      - Detect character encoding
+ * - mb_get_info             - Get internal settings of mbstring
+ * - mb_http_input           - Detect HTTP input character encoding
+ * - mb_http_output          - Set/Get HTTP output character encoding
+ * - mb_internal_encoding    - Set/Get internal character encoding
+ * - mb_list_encodings       - Returns an array of all supported encodings
+ * - mb_ord                  - Returns the Unicode code point of a character
+ * - mb_output_handler       - Callback function converts character encoding in output buffer
+ * - mb_scrub                - Replaces ill-formed byte sequences with substitute characters
+ * - mb_strlen               - Get string length
+ * - mb_strpos               - Find position of first occurrence of string in a string
+ * - mb_strrpos              - Find position of last occurrence of a string in a string
+ * - mb_str_split            - Convert a string to an array
+ * - mb_strtolower           - Make a string lowercase
+ * - mb_strtoupper           - Make a string uppercase
+ * - mb_substitute_character - Set/Get substitution character
+ * - mb_substr               - Get part of string
+ * - mb_stripos              - Finds position of first occurrence of a string within another, case insensitive
+ * - mb_stristr              - Finds first occurrence of a string within another, case insensitive
+ * - mb_strrchr              - Finds the last occurrence of a character in a string within another
+ * - mb_strrichr             - Finds the last occurrence of a character in a string within another, case insensitive
+ * - mb_strripos             - Finds position of last occurrence of a string within another, case insensitive
+ * - mb_strstr               - Finds first occurrence of a string within another
+ * - mb_strwidth             - Return width of string
+ * - mb_substr_count         - Count the number of substring occurrences
+ *
+ * Not implemented:
+ * - mb_convert_kana         - Convert "kana" one from another ("zen-kaku", "han-kaku" and more)
+ * - mb_ereg_*               - Regular expression with multibyte support
+ * - mb_parse_str            - Parse GET/POST/COOKIE data and set global variable
+ * - mb_preferred_mime_name  - Get MIME charset string
+ * - mb_regex_encoding       - Returns current encoding for multibyte regex as string
+ * - mb_regex_set_options    - Set/Get the default options for mbregex functions
+ * - mb_send_mail            - Send encoded mail
+ * - mb_split                - Split multibyte string using regular expression
+ * - mb_strcut               - Get part of string
+ * - mb_strimwidth           - Get truncated string with specified width
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ *
+ * @internal
+ */
+final class Mbstring
+{
+    const MB_CASE_FOLD = PHP_INT_MAX;
+
+    private static $encodingList = array('ASCII', 'UTF-8');
+    private static $language = 'neutral';
+    private static $internalEncoding = 'UTF-8';
+    private static $caseFold = array(
+        array('µ', 'ſ', "\xCD\x85", 'ς', "\xCF\x90", "\xCF\x91", "\xCF\x95", "\xCF\x96", "\xCF\xB0", "\xCF\xB1", "\xCF\xB5", "\xE1\xBA\x9B", "\xE1\xBE\xBE"),
+        array('μ', 's', 'ι',        'σ', 'β',        'θ',        'φ',        'π',        'κ',        'ρ',        'ε',        "\xE1\xB9\xA1", 'ι'),
+    );
+
+    public static function mb_convert_encoding($s, $toEncoding, $fromEncoding = null)
+    {
+        if (\is_array($fromEncoding) || false !== strpos($fromEncoding, ',')) {
+            $fromEncoding = self::mb_detect_encoding($s, $fromEncoding);
+        } else {
+            $fromEncoding = self::getEncoding($fromEncoding);
+        }
+
+        $toEncoding = self::getEncoding($toEncoding);
+
+        if ('BASE64' === $fromEncoding) {
+            $s = base64_decode($s);
+            $fromEncoding = $toEncoding;
+        }
+
+        if ('BASE64' === $toEncoding) {
+            return base64_encode($s);
+        }
+
+        if ('HTML-ENTITIES' === $toEncoding || 'HTML' === $toEncoding) {
+            if ('HTML-ENTITIES' === $fromEncoding || 'HTML' === $fromEncoding) {
+                $fromEncoding = 'Windows-1252';
+            }
+            if ('UTF-8' !== $fromEncoding) {
+                $s = iconv($fromEncoding, 'UTF-8//IGNORE', $s);
+            }
+
+            return preg_replace_callback('/[\x80-\xFF]+/', array(__CLASS__, 'html_encoding_callback'), $s);
+        }
+
+        if ('HTML-ENTITIES' === $fromEncoding) {
+            $s = html_entity_decode($s, ENT_COMPAT, 'UTF-8');
+            $fromEncoding = 'UTF-8';
+        }
+
+        return iconv($fromEncoding, $toEncoding.'//IGNORE', $s);
+    }
+
+    public static function mb_convert_variables($toEncoding, $fromEncoding, &$a = null, &$b = null, &$c = null, &$d = null, &$e = null, &$f = null)
+    {
+        $vars = array(&$a, &$b, &$c, &$d, &$e, &$f);
+
+        $ok = true;
+        array_walk_recursive($vars, function (&$v) use (&$ok, $toEncoding, $fromEncoding) {
+            if (false === $v = Mbstring::mb_convert_encoding($v, $toEncoding, $fromEncoding)) {
+                $ok = false;
+            }
+        });
+
+        return $ok ? $fromEncoding : false;
+    }
+
+    public static function mb_decode_mimeheader($s)
+    {
+        return iconv_mime_decode($s, 2, self::$internalEncoding);
+    }
+
+    public static function mb_encode_mimeheader($s, $charset = null, $transferEncoding = null, $linefeed = null, $indent = null)
+    {
+        trigger_error('mb_encode_mimeheader() is bugged. Please use iconv_mime_encode() instead', E_USER_WARNING);
+    }
+
+    public static function mb_decode_numericentity($s, $convmap, $encoding = null)
+    {
+        if (null !== $s && !\is_scalar($s) && !(\is_object($s) && \method_exists($s, '__toString'))) {
+            trigger_error('mb_decode_numericentity() expects parameter 1 to be string, '.\gettype($s).' given', E_USER_WARNING);
+
+            return null;
+        }
+
+        if (!\is_array($convmap) || !$convmap) {
+            return false;
+        }
+
+        if (null !== $encoding && !\is_scalar($encoding)) {
+            trigger_error('mb_decode_numericentity() expects parameter 3 to be string, '.\gettype($s).' given', E_USER_WARNING);
+
+            return '';  // Instead of null (cf. mb_encode_numericentity).
+        }
+
+        $s = (string) $s;
+        if ('' === $s) {
+            return '';
+        }
+
+        $encoding = self::getEncoding($encoding);
+
+        if ('UTF-8' === $encoding) {
+            $encoding = null;
+            if (!preg_match('//u', $s)) {
+                $s = @iconv('UTF-8', 'UTF-8//IGNORE', $s);
+            }
+        } else {
+            $s = iconv($encoding, 'UTF-8//IGNORE', $s);
+        }
+
+        $cnt = floor(\count($convmap) / 4) * 4;
+
+        for ($i = 0; $i < $cnt; $i += 4) {
+            // collector_decode_htmlnumericentity ignores $convmap[$i + 3]
+            $convmap[$i] += $convmap[$i + 2];
+            $convmap[$i + 1] += $convmap[$i + 2];
+        }
+
+        $s = preg_replace_callback('/&#(?:0*([0-9]+)|x0*([0-9a-fA-F]+))(?!&);?/', function (array $m) use ($cnt, $convmap) {
+            $c = isset($m[2]) ? (int) hexdec($m[2]) : $m[1];
+            for ($i = 0; $i < $cnt; $i += 4) {
+                if ($c >= $convmap[$i] && $c <= $convmap[$i + 1]) {
+                    return Mbstring::mb_chr($c - $convmap[$i + 2]);
+                }
+            }
+
+            return $m[0];
+        }, $s);
+
+        if (null === $encoding) {
+            return $s;
+        }
+
+        return iconv('UTF-8', $encoding.'//IGNORE', $s);
+    }
+
+    public static function mb_encode_numericentity($s, $convmap, $encoding = null, $is_hex = false)
+    {
+        if (null !== $s && !\is_scalar($s) && !(\is_object($s) && \method_exists($s, '__toString'))) {
+            trigger_error('mb_encode_numericentity() expects parameter 1 to be string, '.\gettype($s).' given', E_USER_WARNING);
+
+            return null;
+        }
+
+        if (!\is_array($convmap) || !$convmap) {
+            return false;
+        }
+
+        if (null !== $encoding && !\is_scalar($encoding)) {
+            trigger_error('mb_encode_numericentity() expects parameter 3 to be string, '.\gettype($s).' given', E_USER_WARNING);
+
+            return null;  // Instead of '' (cf. mb_decode_numericentity).
+        }
+
+        if (null !== $is_hex && !\is_scalar($is_hex)) {
+            trigger_error('mb_encode_numericentity() expects parameter 4 to be boolean, '.\gettype($s).' given', E_USER_WARNING);
+
+            return null;
+        }
+
+        $s = (string) $s;
+        if ('' === $s) {
+            return '';
+        }
+
+        $encoding = self::getEncoding($encoding);
+
+        if ('UTF-8' === $encoding) {
+            $encoding = null;
+            if (!preg_match('//u', $s)) {
+                $s = @iconv('UTF-8', 'UTF-8//IGNORE', $s);
+            }
+        } else {
+            $s = iconv($encoding, 'UTF-8//IGNORE', $s);
+        }
+
+        static $ulenMask = array("\xC0" => 2, "\xD0" => 2, "\xE0" => 3, "\xF0" => 4);
+
+        $cnt = floor(\count($convmap) / 4) * 4;
+        $i = 0;
+        $len = \strlen($s);
+        $result = '';
+
+        while ($i < $len) {
+            $ulen = $s[$i] < "\x80" ? 1 : $ulenMask[$s[$i] & "\xF0"];
+            $uchr = substr($s, $i, $ulen);
+            $i += $ulen;
+            $c = self::mb_ord($uchr);
+
+            for ($j = 0; $j < $cnt; $j += 4) {
+                if ($c >= $convmap[$j] && $c <= $convmap[$j + 1]) {
+                    $cOffset = ($c + $convmap[$j + 2]) & $convmap[$j + 3];
+                    $result .= $is_hex ? sprintf('&#x%X;', $cOffset) : '&#'.$cOffset.';';
+                    continue 2;
+                }
+            }
+            $result .= $uchr;
+        }
+
+        if (null === $encoding) {
+            return $result;
+        }
+
+        return iconv('UTF-8', $encoding.'//IGNORE', $result);
+    }
+
+    public static function mb_convert_case($s, $mode, $encoding = null)
+    {
+        $s = (string) $s;
+        if ('' === $s) {
+            return '';
+        }
+
+        $encoding = self::getEncoding($encoding);
+
+        if ('UTF-8' === $encoding) {
+            $encoding = null;
+            if (!preg_match('//u', $s)) {
+                $s = @iconv('UTF-8', 'UTF-8//IGNORE', $s);
+            }
+        } else {
+            $s = iconv($encoding, 'UTF-8//IGNORE', $s);
+        }
+
+        if (MB_CASE_TITLE == $mode) {
+            static $titleRegexp = null;
+            if (null === $titleRegexp) {
+                $titleRegexp = self::getData('titleCaseRegexp');
+            }
+            $s = preg_replace_callback($titleRegexp, array(__CLASS__, 'title_case'), $s);
+        } else {
+            if (MB_CASE_UPPER == $mode) {
+                static $upper = null;
+                if (null === $upper) {
+                    $upper = self::getData('upperCase');
+                }
+                $map = $upper;
+            } else {
+                if (self::MB_CASE_FOLD === $mode) {
+                    $s = str_replace(self::$caseFold[0], self::$caseFold[1], $s);
+                }
+
+                static $lower = null;
+                if (null === $lower) {
+                    $lower = self::getData('lowerCase');
+                }
+                $map = $lower;
+            }
+
+            static $ulenMask = array("\xC0" => 2, "\xD0" => 2, "\xE0" => 3, "\xF0" => 4);
+
+            $i = 0;
+            $len = \strlen($s);
+
+            while ($i < $len) {
+                $ulen = $s[$i] < "\x80" ? 1 : $ulenMask[$s[$i] & "\xF0"];
+                $uchr = substr($s, $i, $ulen);
+                $i += $ulen;
+
+                if (isset($map[$uchr])) {
+                    $uchr = $map[$uchr];
+                    $nlen = \strlen($uchr);
+
+                    if ($nlen == $ulen) {
+                        $nlen = $i;
+                        do {
+                            $s[--$nlen] = $uchr[--$ulen];
+                        } while ($ulen);
+                    } else {
+                        $s = substr_replace($s, $uchr, $i - $ulen, $ulen);
+                        $len += $nlen - $ulen;
+                        $i += $nlen - $ulen;
+                    }
+                }
+            }
+        }
+
+        if (null === $encoding) {
+            return $s;
+        }
+
+        return iconv('UTF-8', $encoding.'//IGNORE', $s);
+    }
+
+    public static function mb_internal_encoding($encoding = null)
+    {
+        if (null === $encoding) {
+            return self::$internalEncoding;
+        }
+
+        $encoding = self::getEncoding($encoding);
+
+        if ('UTF-8' === $encoding || false !== @iconv($encoding, $encoding, ' ')) {
+            self::$internalEncoding = $encoding;
+
+            return true;
+        }
+
+        return false;
+    }
+
+    public static function mb_language($lang = null)
+    {
+        if (null === $lang) {
+            return self::$language;
+        }
+
+        switch ($lang = strtolower($lang)) {
+            case 'uni':
+            case 'neutral':
+                self::$language = $lang;
+
+                return true;
+        }
+
+        return false;
+    }
+
+    public static function mb_list_encodings()
+    {
+        return array('UTF-8');
+    }
+
+    public static function mb_encoding_aliases($encoding)
+    {
+        switch (strtoupper($encoding)) {
+            case 'UTF8':
+            case 'UTF-8':
+                return array('utf8');
+        }
+
+        return false;
+    }
+
+    public static function mb_check_encoding($var = null, $encoding = null)
+    {
+        if (null === $encoding) {
+            if (null === $var) {
+                return false;
+            }
+            $encoding = self::$internalEncoding;
+        }
+
+        return self::mb_detect_encoding($var, array($encoding)) || false !== @iconv($encoding, $encoding, $var);
+    }
+
+    public static function mb_detect_encoding($str, $encodingList = null, $strict = false)
+    {
+        if (null === $encodingList) {
+            $encodingList = self::$encodingList;
+        } else {
+            if (!\is_array($encodingList)) {
+                $encodingList = array_map('trim', explode(',', $encodingList));
+            }
+            $encodingList = array_map('strtoupper', $encodingList);
+        }
+
+        foreach ($encodingList as $enc) {
+            switch ($enc) {
+                case 'ASCII':
+                    if (!preg_match('/[\x80-\xFF]/', $str)) {
+                        return $enc;
+                    }
+                    break;
+
+                case 'UTF8':
+                case 'UTF-8':
+                    if (preg_match('//u', $str)) {
+                        return 'UTF-8';
+                    }
+                    break;
+
+                default:
+                    if (0 === strncmp($enc, 'ISO-8859-', 9)) {
+                        return $enc;
+                    }
+            }
+        }
+
+        return false;
+    }
+
+    public static function mb_detect_order($encodingList = null)
+    {
+        if (null === $encodingList) {
+            return self::$encodingList;
+        }
+
+        if (!\is_array($encodingList)) {
+            $encodingList = array_map('trim', explode(',', $encodingList));
+        }
+        $encodingList = array_map('strtoupper', $encodingList);
+
+        foreach ($encodingList as $enc) {
+            switch ($enc) {
+                default:
+                    if (strncmp($enc, 'ISO-8859-', 9)) {
+                        return false;
+                    }
+                    // no break
+                case 'ASCII':
+                case 'UTF8':
+                case 'UTF-8':
+            }
+        }
+
+        self::$encodingList = $encodingList;
+
+        return true;
+    }
+
+    public static function mb_strlen($s, $encoding = null)
+    {
+        $encoding = self::getEncoding($encoding);
+        if ('CP850' === $encoding || 'ASCII' === $encoding) {
+            return \strlen($s);
+        }
+
+        return @iconv_strlen($s, $encoding);
+    }
+
+    public static function mb_strpos($haystack, $needle, $offset = 0, $encoding = null)
+    {
+        $encoding = self::getEncoding($encoding);
+        if ('CP850' === $encoding || 'ASCII' === $encoding) {
+            return strpos($haystack, $needle, $offset);
+        }
+
+        $needle = (string) $needle;
+        if ('' === $needle) {
+            trigger_error(__METHOD__.': Empty delimiter', E_USER_WARNING);
+
+            return false;
+        }
+
+        return iconv_strpos($haystack, $needle, $offset, $encoding);
+    }
+
+    public static function mb_strrpos($haystack, $needle, $offset = 0, $encoding = null)
+    {
+        $encoding = self::getEncoding($encoding);
+        if ('CP850' === $encoding || 'ASCII' === $encoding) {
+            return strrpos($haystack, $needle, $offset);
+        }
+
+        if ($offset != (int) $offset) {
+            $offset = 0;
+        } elseif ($offset = (int) $offset) {
+            if ($offset < 0) {
+                if (0 > $offset += self::mb_strlen($needle)) {
+                    $haystack = self::mb_substr($haystack, 0, $offset, $encoding);
+                }
+                $offset = 0;
+            } else {
+                $haystack = self::mb_substr($haystack, $offset, 2147483647, $encoding);
+            }
+        }
+
+        $pos = iconv_strrpos($haystack, $needle, $encoding);
+
+        return false !== $pos ? $offset + $pos : false;
+    }
+
+    public static function mb_str_split($string, $split_length = 1, $encoding = null)
+    {
+        if (null !== $string && !\is_scalar($string) && !(\is_object($string) && \method_exists($string, '__toString'))) {
+            trigger_error('mb_str_split() expects parameter 1 to be string, '.\gettype($string).' given', E_USER_WARNING);
+
+            return null;
+        }
+
+        if (1 > $split_length = (int) $split_length) {
+            trigger_error('The length of each segment must be greater than zero', E_USER_WARNING);
+
+            return false;
+        }
+
+        if (null === $encoding) {
+            $encoding = mb_internal_encoding();
+        }
+
+        if ('UTF-8' === $encoding = self::getEncoding($encoding)) {
+            $rx = '/(';
+            while (65535 < $split_length) {
+                $rx .= '.{65535}';
+                $split_length -= 65535;
+            }
+            $rx .= '.{'.$split_length.'})/us';
+
+            return preg_split($rx, $string, null, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY);
+        }
+
+        $result = array();
+        $length = mb_strlen($string, $encoding);
+
+        for ($i = 0; $i < $length; $i += $split_length) {
+            $result[] = mb_substr($string, $i, $split_length, $encoding);
+        }
+
+        return $result;
+    }
+
+    public static function mb_strtolower($s, $encoding = null)
+    {
+        return self::mb_convert_case($s, MB_CASE_LOWER, $encoding);
+    }
+
+    public static function mb_strtoupper($s, $encoding = null)
+    {
+        return self::mb_convert_case($s, MB_CASE_UPPER, $encoding);
+    }
+
+    public static function mb_substitute_character($c = null)
+    {
+        if (0 === strcasecmp($c, 'none')) {
+            return true;
+        }
+
+        return null !== $c ? false : 'none';
+    }
+
+    public static function mb_substr($s, $start, $length = null, $encoding = null)
+    {
+        $encoding = self::getEncoding($encoding);
+        if ('CP850' === $encoding || 'ASCII' === $encoding) {
+            return (string) substr($s, $start, null === $length ? 2147483647 : $length);
+        }
+
+        if ($start < 0) {
+            $start = iconv_strlen($s, $encoding) + $start;
+            if ($start < 0) {
+                $start = 0;
+            }
+        }
+
+        if (null === $length) {
+            $length = 2147483647;
+        } elseif ($length < 0) {
+            $length = iconv_strlen($s, $encoding) + $length - $start;
+            if ($length < 0) {
+                return '';
+            }
+        }
+
+        return (string) iconv_substr($s, $start, $length, $encoding);
+    }
+
+    public static function mb_stripos($haystack, $needle, $offset = 0, $encoding = null)
+    {
+        $haystack = self::mb_convert_case($haystack, self::MB_CASE_FOLD, $encoding);
+        $needle = self::mb_convert_case($needle, self::MB_CASE_FOLD, $encoding);
+
+        return self::mb_strpos($haystack, $needle, $offset, $encoding);
+    }
+
+    public static function mb_stristr($haystack, $needle, $part = false, $encoding = null)
+    {
+        $pos = self::mb_stripos($haystack, $needle, 0, $encoding);
+
+        return self::getSubpart($pos, $part, $haystack, $encoding);
+    }
+
+    public static function mb_strrchr($haystack, $needle, $part = false, $encoding = null)
+    {
+        $encoding = self::getEncoding($encoding);
+        if ('CP850' === $encoding || 'ASCII' === $encoding) {
+            return strrchr($haystack, $needle, $part);
+        }
+        $needle = self::mb_substr($needle, 0, 1, $encoding);
+        $pos = iconv_strrpos($haystack, $needle, $encoding);
+
+        return self::getSubpart($pos, $part, $haystack, $encoding);
+    }
+
+    public static function mb_strrichr($haystack, $needle, $part = false, $encoding = null)
+    {
+        $needle = self::mb_substr($needle, 0, 1, $encoding);
+        $pos = self::mb_strripos($haystack, $needle, $encoding);
+
+        return self::getSubpart($pos, $part, $haystack, $encoding);
+    }
+
+    public static function mb_strripos($haystack, $needle, $offset = 0, $encoding = null)
+    {
+        $haystack = self::mb_convert_case($haystack, self::MB_CASE_FOLD, $encoding);
+        $needle = self::mb_convert_case($needle, self::MB_CASE_FOLD, $encoding);
+
+        return self::mb_strrpos($haystack, $needle, $offset, $encoding);
+    }
+
+    public static function mb_strstr($haystack, $needle, $part = false, $encoding = null)
+    {
+        $pos = strpos($haystack, $needle);
+        if (false === $pos) {
+            return false;
+        }
+        if ($part) {
+            return substr($haystack, 0, $pos);
+        }
+
+        return substr($haystack, $pos);
+    }
+
+    public static function mb_get_info($type = 'all')
+    {
+        $info = array(
+            'internal_encoding' => self::$internalEncoding,
+            'http_output' => 'pass',
+            'http_output_conv_mimetypes' => '^(text/|application/xhtml\+xml)',
+            'func_overload' => 0,
+            'func_overload_list' => 'no overload',
+            'mail_charset' => 'UTF-8',
+            'mail_header_encoding' => 'BASE64',
+            'mail_body_encoding' => 'BASE64',
+            'illegal_chars' => 0,
+            'encoding_translation' => 'Off',
+            'language' => self::$language,
+            'detect_order' => self::$encodingList,
+            'substitute_character' => 'none',
+            'strict_detection' => 'Off',
+        );
+
+        if ('all' === $type) {
+            return $info;
+        }
+        if (isset($info[$type])) {
+            return $info[$type];
+        }
+
+        return false;
+    }
+
+    public static function mb_http_input($type = '')
+    {
+        return false;
+    }
+
+    public static function mb_http_output($encoding = null)
+    {
+        return null !== $encoding ? 'pass' === $encoding : 'pass';
+    }
+
+    public static function mb_strwidth($s, $encoding = null)
+    {
+        $encoding = self::getEncoding($encoding);
+
+        if ('UTF-8' !== $encoding) {
+            $s = iconv($encoding, 'UTF-8//IGNORE', $s);
+        }
+
+        $s = preg_replace('/[\x{1100}-\x{115F}\x{2329}\x{232A}\x{2E80}-\x{303E}\x{3040}-\x{A4CF}\x{AC00}-\x{D7A3}\x{F900}-\x{FAFF}\x{FE10}-\x{FE19}\x{FE30}-\x{FE6F}\x{FF00}-\x{FF60}\x{FFE0}-\x{FFE6}\x{20000}-\x{2FFFD}\x{30000}-\x{3FFFD}]/u', '', $s, -1, $wide);
+
+        return ($wide << 1) + iconv_strlen($s, 'UTF-8');
+    }
+
+    public static function mb_substr_count($haystack, $needle, $encoding = null)
+    {
+        return substr_count($haystack, $needle);
+    }
+
+    public static function mb_output_handler($contents, $status)
+    {
+        return $contents;
+    }
+
+    public static function mb_chr($code, $encoding = null)
+    {
+        if (0x80 > $code %= 0x200000) {
+            $s = \chr($code);
+        } elseif (0x800 > $code) {
+            $s = \chr(0xC0 | $code >> 6).\chr(0x80 | $code & 0x3F);
+        } elseif (0x10000 > $code) {
+            $s = \chr(0xE0 | $code >> 12).\chr(0x80 | $code >> 6 & 0x3F).\chr(0x80 | $code & 0x3F);
+        } else {
+            $s = \chr(0xF0 | $code >> 18).\chr(0x80 | $code >> 12 & 0x3F).\chr(0x80 | $code >> 6 & 0x3F).\chr(0x80 | $code & 0x3F);
+        }
+
+        if ('UTF-8' !== $encoding = self::getEncoding($encoding)) {
+            $s = mb_convert_encoding($s, $encoding, 'UTF-8');
+        }
+
+        return $s;
+    }
+
+    public static function mb_ord($s, $encoding = null)
+    {
+        if ('UTF-8' !== $encoding = self::getEncoding($encoding)) {
+            $s = mb_convert_encoding($s, 'UTF-8', $encoding);
+        }
+
+        if (1 === \strlen($s)) {
+            return \ord($s);
+        }
+
+        $code = ($s = unpack('C*', substr($s, 0, 4))) ? $s[1] : 0;
+        if (0xF0 <= $code) {
+            return (($code - 0xF0) << 18) + (($s[2] - 0x80) << 12) + (($s[3] - 0x80) << 6) + $s[4] - 0x80;
+        }
+        if (0xE0 <= $code) {
+            return (($code - 0xE0) << 12) + (($s[2] - 0x80) << 6) + $s[3] - 0x80;
+        }
+        if (0xC0 <= $code) {
+            return (($code - 0xC0) << 6) + $s[2] - 0x80;
+        }
+
+        return $code;
+    }
+
+    private static function getSubpart($pos, $part, $haystack, $encoding)
+    {
+        if (false === $pos) {
+            return false;
+        }
+        if ($part) {
+            return self::mb_substr($haystack, 0, $pos, $encoding);
+        }
+
+        return self::mb_substr($haystack, $pos, null, $encoding);
+    }
+
+    private static function html_encoding_callback(array $m)
+    {
+        $i = 1;
+        $entities = '';
+        $m = unpack('C*', htmlentities($m[0], ENT_COMPAT, 'UTF-8'));
+
+        while (isset($m[$i])) {
+            if (0x80 > $m[$i]) {
+                $entities .= \chr($m[$i++]);
+                continue;
+            }
+            if (0xF0 <= $m[$i]) {
+                $c = (($m[$i++] - 0xF0) << 18) + (($m[$i++] - 0x80) << 12) + (($m[$i++] - 0x80) << 6) + $m[$i++] - 0x80;
+            } elseif (0xE0 <= $m[$i]) {
+                $c = (($m[$i++] - 0xE0) << 12) + (($m[$i++] - 0x80) << 6) + $m[$i++] - 0x80;
+            } else {
+                $c = (($m[$i++] - 0xC0) << 6) + $m[$i++] - 0x80;
+            }
+
+            $entities .= '&#'.$c.';';
+        }
+
+        return $entities;
+    }
+
+    private static function title_case(array $s)
+    {
+        return self::mb_convert_case($s[1], MB_CASE_UPPER, 'UTF-8').self::mb_convert_case($s[2], MB_CASE_LOWER, 'UTF-8');
+    }
+
+    private static function getData($file)
+    {
+        if (file_exists($file = __DIR__.'/Resources/unidata/'.$file.'.php')) {
+            return require $file;
+        }
+
+        return false;
+    }
+
+    private static function getEncoding($encoding)
+    {
+        if (null === $encoding) {
+            return self::$internalEncoding;
+        }
+
+        if ('UTF-8' === $encoding) {
+            return 'UTF-8';
+        }
+
+        $encoding = strtoupper($encoding);
+
+        if ('8BIT' === $encoding || 'BINARY' === $encoding) {
+            return 'CP850';
+        }
+
+        if ('UTF8' === $encoding) {
+            return 'UTF-8';
+        }
+
+        return $encoding;
+    }
+}

wp-content/plugins/wpforms-lite/vendor/symfony/polyfill-mbstring/bootstrap.php

@@ -0,0 +1,141 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+use Symfony\Polyfill\Mbstring as p;
+
+if (!function_exists('mb_convert_encoding')) {
+    function mb_convert_encoding($s, $to, $from = null) { return p\Mbstring::mb_convert_encoding($s, $to, $from); }
+}
+if (!function_exists('mb_decode_mimeheader')) {
+    function mb_decode_mimeheader($s) { return p\Mbstring::mb_decode_mimeheader($s); }
+}
+if (!function_exists('mb_encode_mimeheader')) {
+    function mb_encode_mimeheader($s, $charset = null, $transferEnc = null, $lf = null, $indent = null) { return p\Mbstring::mb_encode_mimeheader($s, $charset, $transferEnc, $lf, $indent); }
+}
+if (!function_exists('mb_decode_numericentity')) {
+    function mb_decode_numericentity($s, $convmap, $enc = null) { return p\Mbstring::mb_decode_numericentity($s, $convmap, $enc); }
+}
+if (!function_exists('mb_encode_numericentity')) {
+    function mb_encode_numericentity($s, $convmap, $enc = null, $is_hex = false) { return p\Mbstring::mb_encode_numericentity($s, $convmap, $enc, $is_hex); }
+}
+if (!function_exists('mb_convert_case')) {
+    function mb_convert_case($s, $mode, $enc = null) { return p\Mbstring::mb_convert_case($s, $mode, $enc); }
+}
+if (!function_exists('mb_internal_encoding')) {
+    function mb_internal_encoding($enc = null) { return p\Mbstring::mb_internal_encoding($enc); }
+}
+if (!function_exists('mb_language')) {
+    function mb_language($lang = null) { return p\Mbstring::mb_language($lang); }
+}
+if (!function_exists('mb_list_encodings')) {
+    function mb_list_encodings() { return p\Mbstring::mb_list_encodings(); }
+}
+if (!function_exists('mb_encoding_aliases')) {
+    function mb_encoding_aliases($encoding) { return p\Mbstring::mb_encoding_aliases($encoding); }
+}
+if (!function_exists('mb_check_encoding')) {
+    function mb_check_encoding($var = null, $encoding = null) { return p\Mbstring::mb_check_encoding($var, $encoding); }
+}
+if (!function_exists('mb_detect_encoding')) {
+    function mb_detect_encoding($str, $encodingList = null, $strict = false) { return p\Mbstring::mb_detect_encoding($str, $encodingList, $strict); }
+}
+if (!function_exists('mb_detect_order')) {
+    function mb_detect_order($encodingList = null) { return p\Mbstring::mb_detect_order($encodingList); }
+}
+if (!function_exists('mb_parse_str')) {
+    function mb_parse_str($s, &$result = array()) { parse_str($s, $result); }
+}
+if (!function_exists('mb_strlen')) {
+    function mb_strlen($s, $enc = null) { return p\Mbstring::mb_strlen($s, $enc); }
+}
+if (!function_exists('mb_strpos')) {
+    function mb_strpos($s, $needle, $offset = 0, $enc = null) { return p\Mbstring::mb_strpos($s, $needle, $offset, $enc); }
+}
+if (!function_exists('mb_strtolower')) {
+    function mb_strtolower($s, $enc = null) { return p\Mbstring::mb_strtolower($s, $enc); }
+}
+if (!function_exists('mb_strtoupper')) {
+    function mb_strtoupper($s, $enc = null) { return p\Mbstring::mb_strtoupper($s, $enc); }
+}
+if (!function_exists('mb_substitute_character')) {
+    function mb_substitute_character($char = null) { return p\Mbstring::mb_substitute_character($char); }
+}
+if (!function_exists('mb_substr')) {
+    function mb_substr($s, $start, $length = 2147483647, $enc = null) { return p\Mbstring::mb_substr($s, $start, $length, $enc); }
+}
+if (!function_exists('mb_stripos')) {
+    function mb_stripos($s, $needle, $offset = 0, $enc = null) { return p\Mbstring::mb_stripos($s, $needle, $offset, $enc); }
+}
+if (!function_exists('mb_stristr')) {
+    function mb_stristr($s, $needle, $part = false, $enc = null) { return p\Mbstring::mb_stristr($s, $needle, $part, $enc); }
+}
+if (!function_exists('mb_strrchr')) {
+    function mb_strrchr($s, $needle, $part = false, $enc = null) { return p\Mbstring::mb_strrchr($s, $needle, $part, $enc); }
+}
+if (!function_exists('mb_strrichr')) {
+    function mb_strrichr($s, $needle, $part = false, $enc = null) { return p\Mbstring::mb_strrichr($s, $needle, $part, $enc); }
+}
+if (!function_exists('mb_strripos')) {
+    function mb_strripos($s, $needle, $offset = 0, $enc = null) { return p\Mbstring::mb_strripos($s, $needle, $offset, $enc); }
+}
+if (!function_exists('mb_strrpos')) {
+    function mb_strrpos($s, $needle, $offset = 0, $enc = null) { return p\Mbstring::mb_strrpos($s, $needle, $offset, $enc); }
+}
+if (!function_exists('mb_strstr')) {
+    function mb_strstr($s, $needle, $part = false, $enc = null) { return p\Mbstring::mb_strstr($s, $needle, $part, $enc); }
+}
+if (!function_exists('mb_get_info')) {
+    function mb_get_info($type = 'all') { return p\Mbstring::mb_get_info($type); }
+}
+if (!function_exists('mb_http_output')) {
+    function mb_http_output($enc = null) { return p\Mbstring::mb_http_output($enc); }
+}
+if (!function_exists('mb_strwidth')) {
+    function mb_strwidth($s, $enc = null) { return p\Mbstring::mb_strwidth($s, $enc); }
+}
+if (!function_exists('mb_substr_count')) {
+    function mb_substr_count($haystack, $needle, $enc = null) { return p\Mbstring::mb_substr_count($haystack, $needle, $enc); }
+}
+if (!function_exists('mb_output_handler')) {
+    function mb_output_handler($contents, $status) { return p\Mbstring::mb_output_handler($contents, $status); }
+}
+if (!function_exists('mb_http_input')) {
+    function mb_http_input($type = '') { return p\Mbstring::mb_http_input($type); }
+}
+if (!function_exists('mb_convert_variables')) {
+    function mb_convert_variables($toEncoding, $fromEncoding, &$a = null, &$b = null, &$c = null, &$d = null, &$e = null, &$f = null) { return p\Mbstring::mb_convert_variables($toEncoding, $fromEncoding, $a, $b, $c, $d, $e, $f); }
+}
+if (!function_exists('mb_ord')) {
+    function mb_ord($s, $enc = null) { return p\Mbstring::mb_ord($s, $enc); }
+}
+if (!function_exists('mb_chr')) {
+    function mb_chr($code, $enc = null) { return p\Mbstring::mb_chr($code, $enc); }
+}
+if (!function_exists('mb_scrub')) {
+    function mb_scrub($s, $enc = null) { $enc = null === $enc ? mb_internal_encoding() : $enc; return mb_convert_encoding($s, $enc, $enc); }
+}
+if (!function_exists('mb_str_split')) {
+    function mb_str_split($string, $split_length = 1, $encoding = null) { return p\Mbstring::mb_str_split($string, $split_length, $encoding); }
+}
+
+if (extension_loaded('mbstring')) {
+    return;
+}
+
+if (!defined('MB_CASE_UPPER')) {
+    define('MB_CASE_UPPER', 0);
+}
+if (!defined('MB_CASE_LOWER')) {
+    define('MB_CASE_LOWER', 1);
+}
+if (!defined('MB_CASE_TITLE')) {
+    define('MB_CASE_TITLE', 2);
+}