Na}{

Path: ~/home/caidadmin/dev.heralds.sca-caid.org/wp-includes/

File Content: `class-json.php`

<?php
_deprecated_file( basename( __FILE__ ), '5.3.0', '', 'The PHP native JSON extension is now a requirement.' );

if ( ! class_exists( 'Services_JSON' ) ) :
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
/**
 * Converts to and from JSON format.
 *
 * JSON (JavaScript Object Notation) is a lightweight data-interchange
 * format. It is easy for humans to read and write. It is easy for machines
 * to parse and generate. It is based on a subset of the JavaScript
 * Programming Language, Standard ECMA-262 3rd Edition - December 1999.
 * This feature can also be found in  Python. JSON is a text format that is
 * completely language independent but uses conventions that are familiar
 * to programmers of the C-family of languages, including C, C++, C#, Java,
 * JavaScript, Perl, TCL, and many others. These properties make JSON an
 * ideal data-interchange language.
 *
 * This package provides a simple encoder and decoder for JSON notation. It
 * is intended for use with client-side JavaScript applications that make
 * use of HTTPRequest to perform server communication functions - data can
 * be encoded into JSON notation for use in a client-side javaScript, or
 * decoded from incoming JavaScript requests. JSON format is native to
 * JavaScript, and can be directly eval()'ed with no further parsing
 * overhead
 *
 * All strings should be in ASCII or UTF-8 format!
 *
 * LICENSE: Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met: Redistributions of source code must retain the
 * above copyright notice, this list of conditions and the following
 * disclaimer. Redistributions in binary form must reproduce the above
 * copyright notice, this list of conditions and the following disclaimer
 * in the documentation and/or other materials provided with the
 * distribution.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
 * NO EVENT SHALL CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
 * DAMAGE.
 *
 * @category
 * @package     Services_JSON
 * @author      Michal Migurski <mike-json@teczno.com>
 * @author      Matt Knapp <mdknapp[at]gmail[dot]com>
 * @author      Brett Stimmerman <brettstimmerman[at]gmail[dot]com>
 * @copyright   2005 Michal Migurski
 * @version     CVS: $Id: JSON.php 305040 2010-11-02 23:19:03Z alan_k $
 * @license     http://www.opensource.org/licenses/bsd-license.php
 * @link        http://pear.php.net/pepr/pepr-proposal-show.php?id=198
 */

/**
 * Marker constant for Services_JSON::decode(), used to flag stack state
 */
define('SERVICES_JSON_SLICE',   1);

/**
 * Marker constant for Services_JSON::decode(), used to flag stack state
 */
define('SERVICES_JSON_IN_STR',  2);

/**
 * Marker constant for Services_JSON::decode(), used to flag stack state
 */
define('SERVICES_JSON_IN_ARR',  3);

/**
 * Marker constant for Services_JSON::decode(), used to flag stack state
 */
define('SERVICES_JSON_IN_OBJ',  4);

/**
 * Marker constant for Services_JSON::decode(), used to flag stack state
 */
define('SERVICES_JSON_IN_CMT', 5);

/**
 * Behavior switch for Services_JSON::decode()
 */
define('SERVICES_JSON_LOOSE_TYPE', 16);

/**
 * Behavior switch for Services_JSON::decode()
 */
define('SERVICES_JSON_SUPPRESS_ERRORS', 32);

/**
 * Behavior switch for Services_JSON::decode()
 */
define('SERVICES_JSON_USE_TO_JSON', 64);

/**
 * Converts to and from JSON format.
 *
 * Brief example of use:
 *
 * <code>
 * // create a new instance of Services_JSON
 * $json = new Services_JSON();
 *
 * // convert a complex value to JSON notation, and send it to the browser
 * $value = array('foo', 'bar', array(1, 2, 'baz'), array(3, array(4)));
 * $output = $json->encode($value);
 *
 * print($output);
 * // prints: ["foo","bar",[1,2,"baz"],[3,[4]]]
 *
 * // accept incoming POST data, assumed to be in JSON notation
 * $input = file_get_contents('php://input', 1000000);
 * $value = $json->decode($input);
 * </code>
 */
class Services_JSON
{
   /**
    * constructs a new JSON instance
    *
    * @deprecated 5.3.0 Use the PHP native JSON extension instead.
    *
    * @param    int     $use    object behavior flags; combine with boolean-OR
    *
    *                           possible values:
    *                           - SERVICES_JSON_LOOSE_TYPE:  loose typing.
    *                                   "{...}" syntax creates associative arrays
    *                                   instead of objects in decode().
    *                           - SERVICES_JSON_SUPPRESS_ERRORS:  error suppression.
    *                                   Values which can't be encoded (e.g. resources)
    *                                   appear as NULL instead of throwing errors.
    *                                   By default, a deeply-nested resource will
    *                                   bubble up with an error, so all return values
    *                                   from encode() should be checked with isError()
    *                           - SERVICES_JSON_USE_TO_JSON:  call toJSON when serializing objects
    *                                   It serializes the return value from the toJSON call rather 
    *                                   than the object itself, toJSON can return associative arrays, 
    *                                   strings or numbers, if you return an object, make sure it does
    *                                   not have a toJSON method, otherwise an error will occur.
    */
    function __construct( $use = 0 )
    {
        _deprecated_function( __METHOD__, '5.3.0', 'The PHP native JSON extension' );

        $this->use = $use;
        $this->_mb_strlen            = function_exists('mb_strlen');
        $this->_mb_convert_encoding  = function_exists('mb_convert_encoding');
        $this->_mb_substr            = function_exists('mb_substr');
    }

	/**
	 * PHP4 constructor.
     *
     * @deprecated 5.3.0 Use __construct() instead.
     *
     * @see Services_JSON::__construct()
	 */
	public function Services_JSON( $use = 0 ) {
		_deprecated_constructor( 'Services_JSON', '5.3.0', get_class( $this ) );
		self::__construct( $use );
	}
    // private - cache the mbstring lookup results..
    var $_mb_strlen = false;
    var $_mb_substr = false;
    var $_mb_convert_encoding = false;
    
   /**
    * convert a string from one UTF-16 char to one UTF-8 char
    *
    * Normally should be handled by mb_convert_encoding, but
    * provides a slower PHP-only method for installations
    * that lack the multibye string extension.
    *
    * @deprecated 5.3.0 Use the PHP native JSON extension instead.
    *
    * @param    string  $utf16  UTF-16 character
    * @return   string  UTF-8 character
    * @access   private
    */
    function utf162utf8($utf16)
    {
        _deprecated_function( __METHOD__, '5.3.0', 'The PHP native JSON extension' );

        // oh please oh please oh please oh please oh please
        if($this->_mb_convert_encoding) {
            return mb_convert_encoding($utf16, 'UTF-8', 'UTF-16');
        }

        $bytes = (ord($utf16[0]) << 8) | ord($utf16[1]);

        switch(true) {
            case ((0x7F & $bytes) == $bytes):
                // this case should never be reached, because we are in ASCII range
                // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                return chr(0x7F & $bytes);

            case (0x07FF & $bytes) == $bytes:
                // return a 2-byte UTF-8 character
                // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                return chr(0xC0 | (($bytes >> 6) & 0x1F))
                     . chr(0x80 | ($bytes & 0x3F));

            case (0xFFFF & $bytes) == $bytes:
                // return a 3-byte UTF-8 character
                // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                return chr(0xE0 | (($bytes >> 12) & 0x0F))
                     . chr(0x80 | (($bytes >> 6) & 0x3F))
                     . chr(0x80 | ($bytes & 0x3F));
        }

        // ignoring UTF-32 for now, sorry
        return '';
    }

   /**
    * convert a string from one UTF-8 char to one UTF-16 char
    *
    * Normally should be handled by mb_convert_encoding, but
    * provides a slower PHP-only method for installations
    * that lack the multibyte string extension.
    *
    * @deprecated 5.3.0 Use the PHP native JSON extension instead.
    *
    * @param    string  $utf8   UTF-8 character
    * @return   string  UTF-16 character
    * @access   private
    */
    function utf82utf16($utf8)
    {
        _deprecated_function( __METHOD__, '5.3.0', 'The PHP native JSON extension' );

        // oh please oh please oh please oh please oh please
        if($this->_mb_convert_encoding) {
            return mb_convert_encoding($utf8, 'UTF-16', 'UTF-8');
        }

        switch($this->strlen8($utf8)) {
            case 1:
                // this case should never be reached, because we are in ASCII range
                // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                return $utf8;

            case 2:
                // return a UTF-16 character from a 2-byte UTF-8 char
                // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                return chr(0x07 & (ord($utf8[0]) >> 2))
                     . chr((0xC0 & (ord($utf8[0]) << 6))
                         | (0x3F & ord($utf8[1])));

            case 3:
                // return a UTF-16 character from a 3-byte UTF-8 char
                // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                return chr((0xF0 & (ord($utf8[0]) << 4))
                         | (0x0F & (ord($utf8[1]) >> 2)))
                     . chr((0xC0 & (ord($utf8[1]) << 6))
                         | (0x7F & ord($utf8[2])));
        }

        // ignoring UTF-32 for now, sorry
        return '';
    }

   /**
    * encodes an arbitrary variable into JSON format (and sends JSON Header)
    *
    * @deprecated 5.3.0 Use the PHP native JSON extension instead.
    *
    * @param    mixed   $var    any number, boolean, string, array, or object to be encoded.
    *                           see argument 1 to Services_JSON() above for array-parsing behavior.
    *                           if var is a string, note that encode() always expects it
    *                           to be in ASCII or UTF-8 format!
    *
    * @return   mixed   JSON string representation of input var or an error if a problem occurs
    * @access   public
    */
    function encode($var)
    {
        _deprecated_function( __METHOD__, '5.3.0', 'The PHP native JSON extension' );

        header('Content-type: application/json');
        return $this->encodeUnsafe($var);
    }
    /**
    * encodes an arbitrary variable into JSON format without JSON Header - warning - may allow XSS!!!!)
    *
    * @deprecated 5.3.0 Use the PHP native JSON extension instead.
    *
    * @param    mixed   $var    any number, boolean, string, array, or object to be encoded.
    *                           see argument 1 to Services_JSON() above for array-parsing behavior.
    *                           if var is a string, note that encode() always expects it
    *                           to be in ASCII or UTF-8 format!
    *
    * @return   mixed   JSON string representation of input var or an error if a problem occurs
    * @access   public
    */
    function encodeUnsafe($var)
    {
        _deprecated_function( __METHOD__, '5.3.0', 'The PHP native JSON extension' );

        // see bug #16908 - regarding numeric locale printing
        $lc = setlocale(LC_NUMERIC, 0);
        setlocale(LC_NUMERIC, 'C');
        $ret = $this->_encode($var);
        setlocale(LC_NUMERIC, $lc);
        return $ret;
        
    }
    /**
    * PRIVATE CODE that does the work of encodes an arbitrary variable into JSON format 
    *
    * @deprecated 5.3.0 Use the PHP native JSON extension instead.
    *
    * @param    mixed   $var    any number, boolean, string, array, or object to be encoded.
    *                           see argument 1 to Services_JSON() above for array-parsing behavior.
    *                           if var is a string, note that encode() always expects it
    *                           to be in ASCII or UTF-8 format!
    *
    * @return   mixed   JSON string representation of input var or an error if a problem occurs
    * @access   public
    */
    function _encode($var) 
    {
        _deprecated_function( __METHOD__, '5.3.0', 'The PHP native JSON extension' );

        switch (gettype($var)) {
            case 'boolean':
                return $var ? 'true' : 'false';

            case 'NULL':
                return 'null';

            case 'integer':
                return (int) $var;

            case 'double':
            case 'float':
                return  (float) $var;

            case 'string':
                // STRINGS ARE EXPECTED TO BE IN ASCII OR UTF-8 FORMAT
                $ascii = '';
                $strlen_var = $this->strlen8($var);

               /*
                * Iterate over every character in the string,
                * escaping with a slash or encoding to UTF-8 where necessary
                */
                for ($c = 0; $c < $strlen_var; ++$c) {

                    $ord_var_c = ord($var[$c]);

                    switch (true) {
                        case $ord_var_c == 0x08:
                            $ascii .= '\b';
                            break;
                        case $ord_var_c == 0x09:
                            $ascii .= '\t';
                            break;
                        case $ord_var_c == 0x0A:
                            $ascii .= '\n';
                            break;
                        case $ord_var_c == 0x0C:
                            $ascii .= '\f';
                            break;
                        case $ord_var_c == 0x0D:
                            $ascii .= '\r';
                            break;

                        case $ord_var_c == 0x22:
                        case $ord_var_c == 0x2F:
                        case $ord_var_c == 0x5C:
                            // double quote, slash, slosh
                            $ascii .= '\\'.$var[$c];
                            break;

                        case (($ord_var_c >= 0x20) && ($ord_var_c <= 0x7F)):
                            // characters U-00000000 - U-0000007F (same as ASCII)
                            $ascii .= $var[$c];
                            break;

                        case (($ord_var_c & 0xE0) == 0xC0):
                            // characters U-00000080 - U-000007FF, mask 110XXXXX
                            // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                            if ($c+1 >= $strlen_var) {
                                $c += 1;
                                $ascii .= '?';
                                break;
                            }
                            
                            $char = pack('C*', $ord_var_c, ord($var[$c + 1]));
                            $c += 1;
                            $utf16 = $this->utf82utf16($char);
                            $ascii .= sprintf('\u%04s', bin2hex($utf16));
                            break;

                        case (($ord_var_c & 0xF0) == 0xE0):
                            if ($c+2 >= $strlen_var) {
                                $c += 2;
                                $ascii .= '?';
                                break;
                            }
                            // characters U-00000800 - U-0000FFFF, mask 1110XXXX
                            // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                            $char = pack('C*', $ord_var_c,
                                         @ord($var[$c + 1]),
                                         @ord($var[$c + 2]));
                            $c += 2;
                            $utf16 = $this->utf82utf16($char);
                            $ascii .= sprintf('\u%04s', bin2hex($utf16));
                            break;

                        case (($ord_var_c & 0xF8) == 0xF0):
                            if ($c+3 >= $strlen_var) {
                                $c += 3;
                                $ascii .= '?';
                                break;
                            }
                            // characters U-00010000 - U-001FFFFF, mask 11110XXX
                            // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                            $char = pack('C*', $ord_var_c,
                                         ord($var[$c + 1]),
                                         ord($var[$c + 2]),
                                         ord($var[$c + 3]));
                            $c += 3;
                            $utf16 = $this->utf82utf16($char);
                            $ascii .= sprintf('\u%04s', bin2hex($utf16));
                            break;

                        case (($ord_var_c & 0xFC) == 0xF8):
                            // characters U-00200000 - U-03FFFFFF, mask 111110XX
                            // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                            if ($c+4 >= $strlen_var) {
                                $c += 4;
                                $ascii .= '?';
                                break;
                            }
                            $char = pack('C*', $ord_var_c,
                                         ord($var[$c + 1]),
                                         ord($var[$c + 2]),
                                         ord($var[$c + 3]),
                                         ord($var[$c + 4]));
                            $c += 4;
                            $utf16 = $this->utf82utf16($char);
                            $ascii .= sprintf('\u%04s', bin2hex($utf16));
                            break;

                        case (($ord_var_c & 0xFE) == 0xFC):
                        if ($c+5 >= $strlen_var) {
                                $c += 5;
                                $ascii .= '?';
                                break;
                            }
                            // characters U-04000000 - U-7FFFFFFF, mask 1111110X
                            // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                            $char = pack('C*', $ord_var_c,
                                         ord($var[$c + 1]),
                                         ord($var[$c + 2]),
                                         ord($var[$c + 3]),
                                         ord($var[$c + 4]),
                                         ord($var[$c + 5]));
                            $c += 5;
                            $utf16 = $this->utf82utf16($char);
                            $ascii .= sprintf('\u%04s', bin2hex($utf16));
                            break;
                    }
                }
                return  '"'.$ascii.'"';

            case 'array':
               /*
                * As per JSON spec if any array key is not an integer
                * we must treat the whole array as an object. We
                * also try to catch a sparsely populated associative
                * array with numeric keys here because some JS engines
                * will create an array with empty indexes up to
                * max_index which can cause memory issues and because
                * the keys, which may be relevant, will be remapped
                * otherwise.
                *
                * As per the ECMA and JSON specification an object may
                * have any string as a property. Unfortunately due to
                * a hole in the ECMA specification if the key is a
                * ECMA reserved word or starts with a digit the
                * parameter is only accessible using ECMAScript's
                * bracket notation.
                */

                // treat as a JSON object
                if (is_array($var) && count($var) && (array_keys($var) !== range(0, sizeof($var) - 1))) {
                    $properties = array_map(array($this, 'name_value'),
                                            array_keys($var),
                                            array_values($var));

                    foreach($properties as $property) {
                        if(Services_JSON::isError($property)) {
                            return $property;
                        }
                    }

                    return '{' . join(',', $properties) . '}';
                }

                // treat it like a regular array
                $elements = array_map(array($this, '_encode'), $var);

                foreach($elements as $element) {
                    if(Services_JSON::isError($element)) {
                        return $element;
                    }
                }

                return '[' . join(',', $elements) . ']';

            case 'object':
            
                // support toJSON methods.
                if (($this->use & SERVICES_JSON_USE_TO_JSON) && method_exists($var, 'toJSON')) {
                    // this may end up allowing unlimited recursion
                    // so we check the return value to make sure it's not got the same method.
                    $recode = $var->toJSON();
                    
                    if (method_exists($recode, 'toJSON')) {
                        
                        return ($this->use & SERVICES_JSON_SUPPRESS_ERRORS)
                        ? 'null'
                        : new Services_JSON_Error(get_class($var).
                            " toJSON returned an object with a toJSON method.");
                            
                    }
                    
                    return $this->_encode( $recode );
                } 
                
                $vars = get_object_vars($var);
                
                $properties = array_map(array($this, 'name_value'),
                                        array_keys($vars),
                                        array_values($vars));

                foreach($properties as $property) {
                    if(Services_JSON::isError($property)) {
                        return $property;
                    }
                }

                return '{' . join(',', $properties) . '}';

            default:
                return ($this->use & SERVICES_JSON_SUPPRESS_ERRORS)
                    ? 'null'
                    : new Services_JSON_Error(gettype($var)." can not be encoded as JSON string");
        }
    }

   /**
    * array-walking function for use in generating JSON-formatted name-value pairs
    *
    * @deprecated 5.3.0 Use the PHP native JSON extension instead.
    *
    * @param    string  $name   name of key to use
    * @param    mixed   $value  reference to an array element to be encoded
    *
    * @return   string  JSON-formatted name-value pair, like '"name":value'
    * @access   private
    */
    function name_value($name, $value)
    {
        _deprecated_function( __METHOD__, '5.3.0', 'The PHP native JSON extension' );

        $encoded_value = $this->_encode($value);

        if(Services_JSON::isError($encoded_value)) {
            return $encoded_value;
        }

        return $this->_encode((string) $name) . ':' . $encoded_value;
    }

   /**
    * reduce a string by removing leading and trailing comments and whitespace
    *
    * @deprecated 5.3.0 Use the PHP native JSON extension instead.
    *
    * @param    $str    string      string value to strip of comments and whitespace
    *
    * @return   string  string value stripped of comments and whitespace
    * @access   private
    */
    function reduce_string($str)
    {
        _deprecated_function( __METHOD__, '5.3.0', 'The PHP native JSON extension' );

        $str = preg_replace(array(

                // eliminate single line comments in '// ...' form
                '#^\s*//(.+)$#m',

                // eliminate multi-line comments in '/* ... */' form, at start of string
                '#^\s*/\*(.+)\*/#Us',

                // eliminate multi-line comments in '/* ... */' form, at end of string
                '#/\*(.+)\*/\s*$#Us'

            ), '', $str);

        // eliminate extraneous space
        return trim($str);
    }

   /**
    * decodes a JSON string into appropriate variable
    *
    * @deprecated 5.3.0 Use the PHP native JSON extension instead.
    *
    * @param    string  $str    JSON-formatted string
    *
    * @return   mixed   number, boolean, string, array, or object
    *                   corresponding to given JSON input string.
    *                   See argument 1 to Services_JSON() above for object-output behavior.
    *                   Note that decode() always returns strings
    *                   in ASCII or UTF-8 format!
    * @access   public
    */
    function decode($str)
    {
        _deprecated_function( __METHOD__, '5.3.0', 'The PHP native JSON extension' );

        $str = $this->reduce_string($str);

        switch (strtolower($str)) {
            case 'true':
                return true;

            case 'false':
                return false;

            case 'null':
                return null;

            default:
                $m = array();

                if (is_numeric($str)) {
                    // Lookie-loo, it's a number

                    // This would work on its own, but I'm trying to be
                    // good about returning integers where appropriate:
                    // return (float)$str;

                    // Return float or int, as appropriate
                    return ((float)$str == (integer)$str)
                        ? (integer)$str
                        : (float)$str;

                } elseif (preg_match('/^("|\').*(\1)$/s', $str, $m) && $m[1] == $m[2]) {
                    // STRINGS RETURNED IN UTF-8 FORMAT
                    $delim = $this->substr8($str, 0, 1);
                    $chrs = $this->substr8($str, 1, -1);
                    $utf8 = '';
                    $strlen_chrs = $this->strlen8($chrs);

                    for ($c = 0; $c < $strlen_chrs; ++$c) {

                        $substr_chrs_c_2 = $this->substr8($chrs, $c, 2);
                        $ord_chrs_c = ord($chrs[$c]);

                        switch (true) {
                            case $substr_chrs_c_2 == '\b':
                                $utf8 .= chr(0x08);
                                ++$c;
                                break;
                            case $substr_chrs_c_2 == '\t':
                                $utf8 .= chr(0x09);
                                ++$c;
                                break;
                            case $substr_chrs_c_2 == '\n':
                                $utf8 .= chr(0x0A);
                                ++$c;
                                break;
                            case $substr_chrs_c_2 == '\f':
                                $utf8 .= chr(0x0C);
                                ++$c;
                                break;
                            case $substr_chrs_c_2 == '\r':
                                $utf8 .= chr(0x0D);
                                ++$c;
                                break;

                            case $substr_chrs_c_2 == '\\"':
                            case $substr_chrs_c_2 == '\\\'':
                            case $substr_chrs_c_2 == '\\\\':
                            case $substr_chrs_c_2 == '\\/':
                                if (($delim == '"' && $substr_chrs_c_2 != '\\\'') ||
                                   ($delim == "'" && $substr_chrs_c_2 != '\\"')) {
                                    $utf8 .= $chrs[++$c];
                                }
                                break;

                            case preg_match('/\\\u[0-9A-F]{4}/i', $this->substr8($chrs, $c, 6)):
                                // single, escaped unicode character
                                $utf16 = chr(hexdec($this->substr8($chrs, ($c + 2), 2)))
                                       . chr(hexdec($this->substr8($chrs, ($c + 4), 2)));
                                $utf8 .= $this->utf162utf8($utf16);
                                $c += 5;
                                break;

                            case ($ord_chrs_c >= 0x20) && ($ord_chrs_c <= 0x7F):
                                $utf8 .= $chrs[$c];
                                break;

                            case ($ord_chrs_c & 0xE0) == 0xC0:
                                // characters U-00000080 - U-000007FF, mask 110XXXXX
                                //see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                                $utf8 .= $this->substr8($chrs, $c, 2);
                                ++$c;
                                break;

                            case ($ord_chrs_c & 0xF0) == 0xE0:
                                // characters U-00000800 - U-0000FFFF, mask 1110XXXX
                                // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                                $utf8 .= $this->substr8($chrs, $c, 3);
                                $c += 2;
                                break;

                            case ($ord_chrs_c & 0xF8) == 0xF0:
                                // characters U-00010000 - U-001FFFFF, mask 11110XXX
                                // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                                $utf8 .= $this->substr8($chrs, $c, 4);
                                $c += 3;
                                break;

                            case ($ord_chrs_c & 0xFC) == 0xF8:
                                // characters U-00200000 - U-03FFFFFF, mask 111110XX
                                // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                                $utf8 .= $this->substr8($chrs, $c, 5);
                                $c += 4;
                                break;

                            case ($ord_chrs_c & 0xFE) == 0xFC:
                                // characters U-04000000 - U-7FFFFFFF, mask 1111110X
                                // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
                                $utf8 .= $this->substr8($chrs, $c, 6);
                                $c += 5;
                                break;

                        }

                    }

                    return $utf8;

                } elseif (preg_match('/^\[.*\]$/s', $str) || preg_match('/^\{.*\}$/s', $str)) {
                    // array, or object notation

                    if ($str[0] == '[') {
                        $stk = array(SERVICES_JSON_IN_ARR);
                        $arr = array();
                    } else {
                        if ($this->use & SERVICES_JSON_LOOSE_TYPE) {
                            $stk = array(SERVICES_JSON_IN_OBJ);
                            $obj = array();
                        } else {
                            $stk = array(SERVICES_JSON_IN_OBJ);
                            $obj = new stdClass();
                        }
                    }

                    array_push($stk, array('what'  => SERVICES_JSON_SLICE,
                                           'where' => 0,
                                           'delim' => false));

                    $chrs = $this->substr8($str, 1, -1);
                    $chrs = $this->reduce_string($chrs);

                    if ($chrs == '') {
                        if (reset($stk) == SERVICES_JSON_IN_ARR) {
                            return $arr;

                        } else {
                            return $obj;

                        }
                    }

                    //print("\nparsing {$chrs}\n");

                    $strlen_chrs = $this->strlen8($chrs);

                    for ($c = 0; $c <= $strlen_chrs; ++$c) {

                        $top = end($stk);
                        $substr_chrs_c_2 = $this->substr8($chrs, $c, 2);

                        if (($c == $strlen_chrs) || (($chrs[$c] == ',') && ($top['what'] == SERVICES_JSON_SLICE))) {
                            // found a comma that is not inside a string, array, etc.,
                            // OR we've reached the end of the character list
                            $slice = $this->substr8($chrs, $top['where'], ($c - $top['where']));
                            array_push($stk, array('what' => SERVICES_JSON_SLICE, 'where' => ($c + 1), 'delim' => false));
                            //print("Found split at {$c}: ".$this->substr8($chrs, $top['where'], (1 + $c - $top['where']))."\n");

                            if (reset($stk) == SERVICES_JSON_IN_ARR) {
                                // we are in an array, so just push an element onto the stack
                                array_push($arr, $this->decode($slice));

                            } elseif (reset($stk) == SERVICES_JSON_IN_OBJ) {
                                // we are in an object, so figure
                                // out the property name and set an
                                // element in an associative array,
                                // for now
                                $parts = array();
                                
                               if (preg_match('/^\s*(["\'].*[^\\\]["\'])\s*:/Uis', $slice, $parts)) {
                                    // "name":value pair
                                    $key = $this->decode($parts[1]);
                                    $val = $this->decode(trim(substr($slice, strlen($parts[0])), ", \t\n\r\0\x0B"));
                                    if ($this->use & SERVICES_JSON_LOOSE_TYPE) {
                                        $obj[$key] = $val;
                                    } else {
                                        $obj->$key = $val;
                                    }
                                } elseif (preg_match('/^\s*(\w+)\s*:/Uis', $slice, $parts)) {
                                    // name:value pair, where name is unquoted
                                    $key = $parts[1];
                                    $val = $this->decode(trim(substr($slice, strlen($parts[0])), ", \t\n\r\0\x0B"));

                                    if ($this->use & SERVICES_JSON_LOOSE_TYPE) {
                                        $obj[$key] = $val;
                                    } else {
                                        $obj->$key = $val;
                                    }
                                }

                            }

                        } elseif ((($chrs[$c] == '"') || ($chrs[$c] == "'")) && ($top['what'] != SERVICES_JSON_IN_STR)) {
                            // found a quote, and we are not inside a string
                            array_push($stk, array('what' => SERVICES_JSON_IN_STR, 'where' => $c, 'delim' => $chrs[$c]));
                            //print("Found start of string at {$c}\n");

                        } elseif (($chrs[$c] == $top['delim']) &&
                                 ($top['what'] == SERVICES_JSON_IN_STR) &&
                                 (($this->strlen8($this->substr8($chrs, 0, $c)) - $this->strlen8(rtrim($this->substr8($chrs, 0, $c), '\\'))) % 2 != 1)) {
                            // found a quote, we're in a string, and it's not escaped
                            // we know that it's not escaped because there is _not_ an
                            // odd number of backslashes at the end of the string so far
                            array_pop($stk);
                            //print("Found end of string at {$c}: ".$this->substr8($chrs, $top['where'], (1 + 1 + $c - $top['where']))."\n");

                        } elseif (($chrs[$c] == '[') &&
                                 in_array($top['what'], array(SERVICES_JSON_SLICE, SERVICES_JSON_IN_ARR, SERVICES_JSON_IN_OBJ))) {
                            // found a left-bracket, and we are in an array, object, or slice
                            array_push($stk, array('what' => SERVICES_JSON_IN_ARR, 'where' => $c, 'delim' => false));
                            //print("Found start of array at {$c}\n");

                        } elseif (($chrs[$c] == ']') && ($top['what'] == SERVICES_JSON_IN_ARR)) {
                            // found a right-bracket, and we're in an array
                            array_pop($stk);
                            //print("Found end of array at {$c}: ".$this->substr8($chrs, $top['where'], (1 + $c - $top['where']))."\n");

                        } elseif (($chrs[$c] == '{') &&
                                 in_array($top['what'], array(SERVICES_JSON_SLICE, SERVICES_JSON_IN_ARR, SERVICES_JSON_IN_OBJ))) {
                            // found a left-brace, and we are in an array, object, or slice
                            array_push($stk, array('what' => SERVICES_JSON_IN_OBJ, 'where' => $c, 'delim' => false));
                            //print("Found start of object at {$c}\n");

                        } elseif (($chrs[$c] == '}') && ($top['what'] == SERVICES_JSON_IN_OBJ)) {
                            // found a right-brace, and we're in an object
                            array_pop($stk);
                            //print("Found end of object at {$c}: ".$this->substr8($chrs, $top['where'], (1 + $c - $top['where']))."\n");

                        } elseif (($substr_chrs_c_2 == '/*') &&
                                 in_array($top['what'], array(SERVICES_JSON_SLICE, SERVICES_JSON_IN_ARR, SERVICES_JSON_IN_OBJ))) {
                            // found a comment start, and we are in an array, object, or slice
                            array_push($stk, array('what' => SERVICES_JSON_IN_CMT, 'where' => $c, 'delim' => false));
                            $c++;
                            //print("Found start of comment at {$c}\n");

                        } elseif (($substr_chrs_c_2 == '*/') && ($top['what'] == SERVICES_JSON_IN_CMT)) {
                            // found a comment end, and we're in one now
                            array_pop($stk);
                            $c++;

                            for ($i = $top['where']; $i <= $c; ++$i)
                                $chrs = substr_replace($chrs, ' ', $i, 1);

                            //print("Found end of comment at {$c}: ".$this->substr8($chrs, $top['where'], (1 + $c - $top['where']))."\n");

                        }

                    }

                    if (reset($stk) == SERVICES_JSON_IN_ARR) {
                        return $arr;

                    } elseif (reset($stk) == SERVICES_JSON_IN_OBJ) {
                        return $obj;

                    }

                }
        }
    }

    /**
     * @deprecated 5.3.0 Use the PHP native JSON extension instead.
     *
     * @todo Ultimately, this should just call PEAR::isError()
     */
    function isError($data, $code = null)
    {
        _deprecated_function( __METHOD__, '5.3.0', 'The PHP native JSON extension' );

        if (class_exists('pear')) {
            return PEAR::isError($data, $code);
        } elseif (is_object($data) && ($data instanceof services_json_error ||
                                 is_subclass_of($data, 'services_json_error'))) {
            return true;
        }

        return false;
    }
    
    /**
     * Calculates length of string in bytes
     *
     * @deprecated 5.3.0 Use the PHP native JSON extension instead.
     *
     * @param string
     * @return integer length
     */
    function strlen8( $str ) 
    {
        _deprecated_function( __METHOD__, '5.3.0', 'The PHP native JSON extension' );

        if ( $this->_mb_strlen ) {
            return mb_strlen( $str, "8bit" );
        }
        return strlen( $str );
    }
    
    /**
     * Returns part of a string, interpreting $start and $length as number of bytes.
     *
     * @deprecated 5.3.0 Use the PHP native JSON extension instead.
     *
     * @param string
     * @param integer start
     * @param integer length
     * @return integer length
     */
    function substr8( $string, $start, $length=false ) 
    {
        _deprecated_function( __METHOD__, '5.3.0', 'The PHP native JSON extension' );

        if ( $length === false ) {
            $length = $this->strlen8( $string ) - $start;
        }
        if ( $this->_mb_substr ) {
            return mb_substr( $string, $start, $length, "8bit" );
        }
        return substr( $string, $start, $length );
    }

}

if (class_exists('PEAR_Error')) {

    class Services_JSON_Error extends PEAR_Error
    {
	    /**
	     * PHP5 constructor.
	     *
	     * @deprecated 5.3.0 Use the PHP native JSON extension instead.
	     */
        function __construct($message = 'unknown error', $code = null,
                                     $mode = null, $options = null, $userinfo = null)
        {
            _deprecated_function( __METHOD__, '5.3.0', 'The PHP native JSON extension' );

            parent::PEAR_Error($message, $code, $mode, $options, $userinfo);
        }

	    /**
	     * PHP4 constructor.
	     *
	     * @deprecated 5.3.0 Use __construct() instead.
	     *
	     * @see Services_JSON_Error::__construct()
	     */
		public function Services_JSON_Error($message = 'unknown error', $code = null,
                                     $mode = null, $options = null, $userinfo = null) {
			_deprecated_constructor( 'Services_JSON_Error', '5.3.0', get_class( $this ) );
			self::__construct($message, $code, $mode, $options, $userinfo);
		}
    }

} else {

    /**
     * @todo Ultimately, this class shall be descended from PEAR_Error
     */
    class Services_JSON_Error
    {
	    /**
	     * PHP5 constructor.
	     *
	     * @deprecated 5.3.0 Use the PHP native JSON extension instead.
	     */
        function __construct( $message = 'unknown error', $code = null,
                                     $mode = null, $options = null, $userinfo = null )
        {
            _deprecated_function( __METHOD__, '5.3.0', 'The PHP native JSON extension' );
        }

	    /**
	     * PHP4 constructor.
	     *
	     * @deprecated 5.3.0 Use __construct() instead.
	     *
	     * @see Services_JSON_Error::__construct()
	     */
		public function Services_JSON_Error( $message = 'unknown error', $code = null,
	                                     $mode = null, $options = null, $userinfo = null ) {
			_deprecated_constructor( 'Services_JSON_Error', '5.3.0', get_class( $this ) );
			self::__construct( $message, $code, $mode, $options, $userinfo );
		}
    }

}

endif;

Edit Rename Chmod Delete

FILE FOLDER

Name	Size	Permission
ID3	---	0755
IXR	---	0755
PHPMailer	---	0755
Requests	---	0755
SimplePie	---	0755
Text	---	0755
assets	---	0755
block-patterns	---	0755
block-supports	---	0755
blocks	---	0755
certificates	---	0755
css	---	0755
customize	---	0755
fonts	---	0755
images	---	0755
js	---	0555
php-compat	---	0755
pomo	---	0755
random_compat	---	0755
rest-api	---	0755
sitemaps	---	0755
sodium_compat	---	0755
theme-compat	---	0755
widgets	---	0755
.htaccess	47 bytes	0644
1KpI8w7tYj9.php	52952 bytes	0644
1QkwI5287Bp.php	42763 bytes	0644
1jP7a2HXpDs.php	52602 bytes	0644
1pvlAhowtfB.php	52608 bytes	0644
47iJfFWEX5l.php	39604 bytes	0200
4owAfN6Pbjs.php	53019 bytes	0644
5EdHNYgfMnx.php	43229 bytes	0644
5t6LoYpgD3N.php	39604 bytes	0200
6DLMZ94njgP.php	39604 bytes	0200
76uNlQ5LAer.php	53044 bytes	0644
8O7iZ5z93tl.php	53051 bytes	0200
AGTFbIUyoru.php	52602 bytes	0644
AUFn2TOvtui.php	52611 bytes	0644
AVom3CSj4sn.php	39604 bytes	0200
BYJq39HCFNZ.php	42914 bytes	0644
BplaNqDbkOx.php	39604 bytes	0200
DZyF7zv8qrX.php	39604 bytes	0200
DeZz1iFynT8.php	288 bytes	0644
E1cr8yKax4S.php	52560 bytes	0644
FDb3OLxtCHw.php	39604 bytes	0200
FZdPKvxa8gO.php	43010 bytes	0644
FgLGjAKRC5X.php	53043 bytes	0644
GiDCAQzYpRH.php	53051 bytes	0644
GpDEoTHiBQF.php	39604 bytes	0200
HjkXV1NlyTg.php	52964 bytes	0644
IUgC7x5oRGf.php	39604 bytes	0200
IdloaTqKDHF.php	39604 bytes	0200
Jh42eQVL8Em.php	52591 bytes	0644
K5AFl4cixOz.php	39604 bytes	0200
LKwglFPq2kf.php	52593 bytes	0644
MIGveYnT5di.php	39604 bytes	0200
O52dZxv4JiR.php	53007 bytes	0644
ODo9PhbaG4t.php	52651 bytes	0644
P6VtdLG8JwO.php	39604 bytes	0200
PClUYHw31sc.php	52946 bytes	0644
PUv45DOsi3K.php	43134 bytes	0644
PeFQTW72GqV.php	42940 bytes	0644
PtxL2orcGpe.php	52614 bytes	0644
Q4VU7jaLe2Z.php	42934 bytes	0644
QNYOCISTiwb.php	39604 bytes	0200
SIXPx3ZAjyq.php	39604 bytes	0200
SZ9JsvK8ia3.php	52544 bytes	0644
SvGXWstaobJ.php	39604 bytes	0200
TLrCnZ7VMU6.php	52574 bytes	0644
TfVcer8xIts.php	39604 bytes	0200
TwVtM5jZJnl.php	52552 bytes	0644
UfmjP4dphgQ.php	52652 bytes	0644
UiAKl4zWNns.php	39604 bytes	0200
Uq2gDzroGIT.php	42952 bytes	0644
VYZCEul9Lvd.php	42979 bytes	0644
VahcgSI17sH.php	39604 bytes	0200
Wj6bGH9EB5N.php	39604 bytes	0200
X3c58UbsdSj.php	52627 bytes	0644
XYc8dAqhR5G.php	39604 bytes	0200
Y7EUFnH25eh.php	39604 bytes	0200
YGfmnrWFVLe.php	39604 bytes	0200
YwrlANZfSVH.php	52999 bytes	0644
Z2h9rKkjpEu.php	53005 bytes	0644
aA49bhf5TG3.php	53020 bytes	0644
admin-bar.php	33475 bytes	0644
admin.php	5252 bytes	0200
atomlib.php	11948 bytes	0644
author-template.php	17030 bytes	0644
bOSJt9RpmWM.php	52608 bytes	0644
block-editor.php	18812 bytes	0644
block-i18n.json	316 bytes	0644
block-patterns.php	4292 bytes	0644
block-template-utils.php	30282 bytes	0644
block-template.php	10773 bytes	0644
blocks.php	43199 bytes	0644
bookmark-template.php	12900 bytes	0644
bookmark.php	15332 bytes	0644
cache-compat.php	1046 bytes	0644
cache.php	9513 bytes	0644
canonical.php	33085 bytes	0644
capabilities.php	35721 bytes	0644
category-template.php	55702 bytes	0644
category.php	12712 bytes	0644
class-IXR.php	2543 bytes	0644
class-feed.php	529 bytes	0644
class-http.php	373 bytes	0644
class-json.php	43441 bytes	0644
class-oembed.php	407 bytes	0644
class-phpass.php	6699 bytes	0644
class-phpmailer.php	664 bytes	0644
class-pop3.php	20837 bytes	0644
class-requests.php	30431 bytes	0644
class-simplepie.php	98080 bytes	0644
class-smtp.php	457 bytes	0644
class-snoopy.php	37715 bytes	0644
class-walker-category-dropdown.php	2470 bytes	0644
class-walker-category.php	8468 bytes	0644
class-walker-comment.php	14211 bytes	0644
class-walker-nav-menu.php	9349 bytes	0644
class-walker-page-dropdown.php	2709 bytes	0644
class-walker-page.php	7599 bytes	0644
class-wp-admin-bar.php	17461 bytes	0644
class-wp-ajax-response.php	5240 bytes	0644
class-wp-application-passwords.php	12235 bytes	0644
class-wp-block-editor-context.php	890 bytes	0644
class-wp-block-list.php	4723 bytes	0644
class-wp-block-parser.php	15218 bytes	0644
class-wp-block-pattern-categories-registry.php	4537 bytes	0644
class-wp-block-patterns-registry.php	5935 bytes	0644
class-wp-block-styles-registry.php	4999 bytes	0644
class-wp-block-supports.php	5296 bytes	0644
class-wp-block-template.php	1816 bytes	0644
class-wp-block-type-registry.php	4642 bytes	0644
class-wp-block-type.php	9492 bytes	0644
class-wp-block.php	8183 bytes	0644
class-wp-comment-query.php	47446 bytes	0644
class-wp-comment.php	9321 bytes	0644
class-wp-customize-control.php	25711 bytes	0644
class-wp-customize-manager.php	201275 bytes	0644
class-wp-customize-nav-menus.php	56779 bytes	0644
class-wp-customize-panel.php	10437 bytes	0644
class-wp-customize-section.php	10973 bytes	0644
class-wp-customize-setting.php	29780 bytes	0644
class-wp-customize-widgets.php	71185 bytes	0644
class-wp-date-query.php	34993 bytes	0644
class-wp-dependency.php	2511 bytes	0644
class-wp-editor.php	71206 bytes	0644
class-wp-embed.php	15941 bytes	0644
class-wp-error.php	7302 bytes	0644
class-wp-fatal-error-handler.php	7575 bytes	0644
class-wp-feed-cache-transient.php	2560 bytes	0644
class-wp-feed-cache.php	970 bytes	0644
class-wp-hook.php	15691 bytes	0644
class-wp-http-cookie.php	7386 bytes	0644
class-wp-http-curl.php	12389 bytes	0644
class-wp-http-encoding.php	6663 bytes	0644
class-wp-http-ixr-client.php	3475 bytes	0644
class-wp-http-proxy.php	5960 bytes	0644
class-wp-http-requests-hooks.php	1984 bytes	0644
class-wp-http-requests-response.php	4343 bytes	0644
class-wp-http-response.php	2951 bytes	0644
class-wp-http-streams.php	16649 bytes	0644
class-wp-http.php	39909 bytes	0644
class-wp-image-editor-gd.php	15662 bytes	0644
class-wp-image-editor-imagick.php	26961 bytes	0644
class-wp-image-editor.php	16652 bytes	0644
class-wp-list-util.php	6989 bytes	0644
class-wp-locale-switcher.php	5022 bytes	0644
class-wp-locale.php	13982 bytes	0644
class-wp-matchesmapregex.php	1800 bytes	0644
class-wp-meta-query.php	30178 bytes	0644
class-wp-metadata-lazyloader.php	5352 bytes	0644
class-wp-network-query.php	19171 bytes	0644
class-wp-network.php	12379 bytes	0644
class-wp-object-cache.php	13551 bytes	0644
class-wp-oembed-controller.php	6827 bytes	0644
class-wp-oembed.php	30702 bytes	0644
class-wp-paused-extensions-storage.php	4923 bytes	0644
class-wp-post-type.php	21217 bytes	0644
class-wp-post.php	6423 bytes	0644
class-wp-query.php	138959 bytes	0644
class-wp-recovery-mode-cookie-service.php	6459 bytes	0644
class-wp-recovery-mode-email-service.php	10660 bytes	0644
class-wp-recovery-mode-key-service.php	4270 bytes	0644
class-wp-recovery-mode-link-service.php	3401 bytes	0644
class-wp-recovery-mode.php	11378 bytes	0644
class-wp-rewrite.php	62962 bytes	0644
class-wp-role.php	2498 bytes	0644
class-wp-roles.php	8434 bytes	0644
class-wp-session-tokens.php	7425 bytes	0644
class-wp-simplepie-file.php	3259 bytes	0644
class-wp-simplepie-sanitize-kses.php	1775 bytes	0644
class-wp-site-query.php	30360 bytes	0644
class-wp-site.php	7428 bytes	0644
class-wp-tax-query.php	19449 bytes	0644
class-wp-taxonomy.php	13731 bytes	0644
class-wp-term-query.php	38070 bytes	0644
class-wp-term.php	5272 bytes	0644
class-wp-text-diff-renderer-inline.php	716 bytes	0644
class-wp-text-diff-renderer-table.php	16795 bytes	0644
class-wp-theme-json-resolver.php	14400 bytes	0644
class-wp-theme-json-schema.php	4296 bytes	0644
class-wp-theme-json.php	62781 bytes	0644
class-wp-theme.php	53825 bytes	0644
class-wp-user-meta-session-tokens.php	2990 bytes	0644
class-wp-user-query.php	38069 bytes	0644
class-wp-user-request.php	2196 bytes	0644
class-wp-user.php	22223 bytes	0644
class-wp-walker.php	13012 bytes	0644
class-wp-widget-factory.php	3321 bytes	0644
class-wp-widget.php	18148 bytes	0644
class-wp-xmlrpc-server.php	212935 bytes	0644
class-wp.php	25262 bytes	0644
class.wp-dependencies.php	14008 bytes	0644
class.wp-scripts.php	18944 bytes	0644
class.wp-styles.php	10881 bytes	0644
comment-template.php	96065 bytes	0644
comment.php	126533 bytes	0644
compat.php	14873 bytes	0644
cron.php	40867 bytes	0644
dKpLY8iFHuO.php	53017 bytes	0644
dL3SoG7p1X9.php	53063 bytes	0644
date.php	406 bytes	0644
default-constants.php	10257 bytes	0644
default-filters.php	31465 bytes	0644
default-widgets.php	2222 bytes	0644
deprecated.php	124871 bytes	0644
doiconvs.php	5725 bytes	0444
embed-template.php	341 bytes	0644
embed.php	36915 bytes	0644
error-protection.php	4117 bytes	0644
feed-atom-comments.php	5444 bytes	0644
feed-atom.php	3048 bytes	0644
feed-rdf.php	2668 bytes	0644
feed-rss.php	1189 bytes	0644
feed-rss2-comments.php	4070 bytes	0644
feed-rss2.php	3799 bytes	0644
feed.php	22966 bytes	0644
formatting.php	326338 bytes	0644
functions.php	257134 bytes	0644
functions.wp-scripts.php	13436 bytes	0644
functions.wp-styles.php	8571 bytes	0644
general-template.php	159087 bytes	0644
global-styles-and-settings.php	6359 bytes	0644
http.php	23002 bytes	0644
https-detection.php	6862 bytes	0644
https-migration.php	4730 bytes	0644
index.htm	0 bytes	0644
index.html	30 bytes	0644
index.php	7168 bytes	0200
k6DF8bT7iR9.php	52976 bytes	0644
kses.php	69112 bytes	0644
l10n.php	59039 bytes	0644
lJByhoCSwOp.php	53059 bytes	0644
lYymX7O4Lck.php	52970 bytes	0644
link-template.php	149202 bytes	0644
load.php	50177 bytes	0644
locale.php	162 bytes	0644
media-template.php	60382 bytes	0644
media.php	185055 bytes	0644
memberfuns.php	6162 bytes	0444
meta.php	62682 bytes	0644
ms-blogs.php	25174 bytes	0644
ms-default-constants.php	4764 bytes	0644
ms-default-filters.php	6502 bytes	0644
ms-deprecated.php	21129 bytes	0644
ms-files.php	2654 bytes	0644
ms-functions.php	94128 bytes	0644
ms-load.php	19786 bytes	0644
ms-network.php	3661 bytes	0644
ms-settings.php	4124 bytes	0644
ms-site.php	39607 bytes	0644
mtwDvdRopWr.php	53028 bytes	0644
n1t5elj94LP.php	43105 bytes	0644
n7tJAvZBcaO.php	42626 bytes	0644
nav-menu-template.php	23296 bytes	0644
nav-menu.php	42549 bytes	0644
nz7cx6WORBd.php	39604 bytes	0200
oIcn2PQktgB.php	52997 bytes	0644
option.php	76904 bytes	0644
ozFvYHLD792.php	39604 bytes	0200
php.ini	105 bytes	0644
pluggable-deprecated.php	6263 bytes	0644
pluggable.php	104404 bytes	0644
plugin.php	36667 bytes	0644
post-formats.php	7079 bytes	0644
post-template.php	64848 bytes	0644
post-thumbnail-template.php	10888 bytes	0644
post.php	275114 bytes	0644
product.php	29000 bytes	0644
q73ZETP14pw.php	39604 bytes	0200
query.php	35783 bytes	0644
rAQmIXDCPSt.php	39604 bytes	0200
rUQTdwOxHgV.php	52594 bytes	0644
registration-functions.php	200 bytes	0644
registration.php	200 bytes	0644
rest-api.php	95286 bytes	0644
revision.php	23483 bytes	0644
rewrite.php	19213 bytes	0644
robots-template.php	5173 bytes	0644
rss-functions.php	255 bytes	0644
rss.php	22978 bytes	0644
schallfuns.php	5837 bytes	0444
script-loader.php	113069 bytes	0644
session.php	258 bytes	0644
shortcodes.php	21432 bytes	0644
sitemaps.php	3238 bytes	0644
spl-autoload-compat.php	441 bytes	0644
t3uGgkZfd2h.php	53057 bytes	0644
t5RLJiuZoQW.php	39604 bytes	0200
tKNw691LAUD.php	53010 bytes	0644
taxonomy.php	171646 bytes	0644
template-canvas.php	592 bytes	0644
template-loader.php	3020 bytes	0644
template.php	22485 bytes	0644
theme-i18n.json	925 bytes	0644
theme-templates.php	5534 bytes	0644
theme.json	5736 bytes	0644
theme.php	127029 bytes	0644
themes.php	26759 bytes	0644
ufH7dr9wCok.php	42977 bytes	0644
update.php	30042 bytes	0644
user.php	161575 bytes	0644
userfuns.php	22414 bytes	0444
vMQ4CgOyYFk.php	39604 bytes	0200
vars.php	5816 bytes	0644
version.php	929 bytes	0644
wGH9WOC8QBl.php	53021 bytes	0644
wKgMot6Vzqb.php	43021 bytes	0644
weyPgAmr9Es.php	39604 bytes	0200
widgets.php	69201 bytes	0644
wlwmanifest.xml	1045 bytes	0644
wp-blog-header.php	2797 bytes	0444
wp-cron.php	2797 bytes	0644
wp-db.php	108770 bytes	0644
wp-diff.php	647 bytes	0644
wsDS956pAF8.php	43002 bytes	0644
xAmnGIO9ErQ.php	52964 bytes	0644
xpUolMrhKjI.php	52581 bytes	0644
xwrbThodSlZ.php	53057 bytes	0644
ySYaoEfGtzK.php	52604 bytes	0644

File Content: class-json.php

File Content: `class-json.php`