"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var src_exports = {};
__export(src_exports, {
  HTMLSPECIALCHARS_ENT_COMPAT: () => HTMLSPECIALCHARS_ENT_COMPAT,
  HTMLSPECIALCHARS_ENT_HTML_QUOTE_DOUBLE: () => HTMLSPECIALCHARS_ENT_HTML_QUOTE_DOUBLE,
  HTMLSPECIALCHARS_ENT_HTML_QUOTE_SINGLE: () => HTMLSPECIALCHARS_ENT_HTML_QUOTE_SINGLE,
  HTMLSPECIALCHARS_ENT_IGNORE: () => HTMLSPECIALCHARS_ENT_IGNORE,
  HTMLSPECIALCHARS_ENT_NOQUOTES: () => HTMLSPECIALCHARS_ENT_NOQUOTES,
  HTMLSPECIALCHARS_ENT_QUOTES: () => HTMLSPECIALCHARS_ENT_QUOTES,
  htmlspecialchars: () => htmlspecialchars,
  md5: () => md5,
  serialize: () => serialize,
  unserialize: () => unserialize,
  utf8Decode: () => utf8Decode,
  utf8Encode: () => utf8Encode
});
module.exports = __toCommonJS(src_exports);

// src/locutus/htmlspecialchars/htmlspecialchars.ts
var HTMLSPECIALCHARS_ENT_NOQUOTES = "ENT_NOQUOTES";
var HTMLSPECIALCHARS_ENT_HTML_QUOTE_SINGLE = "ENT_HTML_QUOTE_SINGLE";
var HTMLSPECIALCHARS_ENT_HTML_QUOTE_DOUBLE = "ENT_HTML_QUOTE_DOUBLE";
var HTMLSPECIALCHARS_ENT_COMPAT = "ENT_COMPAT";
var HTMLSPECIALCHARS_ENT_QUOTES = "ENT_QUOTES";
var HTMLSPECIALCHARS_ENT_IGNORE = "ENT_IGNORE";
function htmlspecialchars(string, quoteStyle, charset, doubleEncode) {
  let optTemp = 0;
  let index = 0;
  let noquotes = false;
  if (quoteStyle === void 0 || quoteStyle === null) {
    quoteStyle = 2;
  }
  string = string || "";
  string = string.toString();
  if (doubleEncode !== false) {
    string = string.replace(/&/g, "&");
  }
  string = string.replace(/</g, "&lt;").replace(/>/g, "&gt;");
  const OPTS = {
    ENT_NOQUOTES: 0,
    ENT_HTML_QUOTE_SINGLE: 1,
    ENT_HTML_QUOTE_DOUBLE: 2,
    ENT_COMPAT: 2,
    ENT_QUOTES: 3,
    ENT_IGNORE: 4
  };
  if (quoteStyle === 0) {
    noquotes = true;
  }
  if (typeof quoteStyle !== "number") {
    quoteStyle = Array.isArray(quoteStyle) ? quoteStyle : [quoteStyle];
    for (index = 0; index < quoteStyle.length; index++) {
      if (OPTS[quoteStyle[index]] === 0) {
        noquotes = true;
      } else if (OPTS[quoteStyle[index]]) {
        optTemp = optTemp | OPTS[quoteStyle[index]];
      }
    }
    quoteStyle = optTemp;
  }
  if (quoteStyle & OPTS.ENT_HTML_QUOTE_SINGLE) {
    string = string.replace(/'/g, "&#039;");
  }
  if (!noquotes) {
    string = string.replace(/"/g, "&quot;");
  }
  return string;
}

// src/locutus/utf8-encode/utf8-encode.ts
function utf8Encode(string) {
  if (string === null || string === void 0) {
    return "";
  }
  const strData = String(string);
  let utftext = "";
  let start;
  let end;
  const stringl = strData.length;
  start = end = 0;
  for (let n = 0; n < stringl; n++) {
    let c1 = strData.charCodeAt(n);
    let enc = null;
    if (c1 < 128) {
      end++;
    } else if (c1 > 127 && c1 < 2048) {
      enc = String.fromCharCode(c1 >> 6 | 192, c1 & 63 | 128);
    } else if ((c1 & 63488) !== 55296) {
      enc = String.fromCharCode(c1 >> 12 | 224, c1 >> 6 & 63 | 128, c1 & 63 | 128);
    } else {
      if ((c1 & 64512) !== 55296) {
        throw new RangeError("Unmatched trail surrogate at " + n);
      }
      const c2 = strData.charCodeAt(++n);
      if ((c2 & 64512) !== 56320) {
        throw new RangeError("Unmatched lead surrogate at " + (n - 1));
      }
      c1 = ((c1 & 1023) << 10) + (c2 & 1023) + 65536;
      enc = String.fromCharCode(c1 >> 18 | 240, c1 >> 12 & 63 | 128, c1 >> 6 & 63 | 128, c1 & 63 | 128);
    }
    if (enc !== null) {
      if (end > start) {
        utftext += strData.slice(start, end);
      }
      utftext += enc;
      start = end = n + 1;
    }
  }
  if (end > start) {
    utftext += strData.slice(start, stringl);
  }
  return utftext;
}

// src/locutus/md5/md5.ts
function md5(string) {
  if (string === void 0 || string === null) {
    return "";
  }
  let hash;
  try {
    const crypto = require("crypto");
    const md5sum = crypto.createHash("md5");
    md5sum.update(string);
    hash = md5sum.digest("hex");
  } catch {
    hash = void 0;
  }
  if (hash !== void 0) {
    return hash;
  }
  const _rotateLeft = function(lValue, indexShiftBits) {
    return lValue << indexShiftBits | lValue >>> 32 - indexShiftBits;
  };
  const _addUnsigned = function(lX, lY) {
    const lX8 = lX & 2147483648;
    const lY8 = lY & 2147483648;
    const lX4 = lX & 1073741824;
    const lY4 = lY & 1073741824;
    const lResult = (lX & 1073741823) + (lY & 1073741823);
    if (lX4 & lY4) {
      return lResult ^ 2147483648 ^ lX8 ^ lY8;
    }
    if (lX4 | lY4) {
      return lResult & 1073741824 ? lResult ^ 3221225472 ^ lX8 ^ lY8 : lResult ^ 1073741824 ^ lX8 ^ lY8;
    } else {
      return lResult ^ lX8 ^ lY8;
    }
  };
  const _F = function(x2, y, z) {
    return x2 & y | ~x2 & z;
  };
  const _G = function(x2, y, z) {
    return x2 & z | y & ~z;
  };
  const _H = function(x2, y, z) {
    return x2 ^ y ^ z;
  };
  const _I = function(x2, y, z) {
    return y ^ (x2 | ~z);
  };
  const _FF = function(a2, b2, c2, d2, x2, s, ac) {
    a2 = _addUnsigned(a2, _addUnsigned(_addUnsigned(_F(b2, c2, d2), x2), ac));
    return _addUnsigned(_rotateLeft(a2, s), b2);
  };
  const _GG = function(a2, b2, c2, d2, x2, s, ac) {
    a2 = _addUnsigned(a2, _addUnsigned(_addUnsigned(_G(b2, c2, d2), x2), ac));
    return _addUnsigned(_rotateLeft(a2, s), b2);
  };
  const _HH = function(a2, b2, c2, d2, x2, s, ac) {
    a2 = _addUnsigned(a2, _addUnsigned(_addUnsigned(_H(b2, c2, d2), x2), ac));
    return _addUnsigned(_rotateLeft(a2, s), b2);
  };
  const _II = function(a2, b2, c2, d2, x2, s, ac) {
    a2 = _addUnsigned(a2, _addUnsigned(_addUnsigned(_I(b2, c2, d2), x2), ac));
    return _addUnsigned(_rotateLeft(a2, s), b2);
  };
  const _convertToWordArray = function(string2) {
    let lWordCount;
    const lMessageLength = string2.length;
    const lNumberOfWordsTemporary1 = lMessageLength + 8;
    const lNumberOfWordsTemporary2 = (lNumberOfWordsTemporary1 - lNumberOfWordsTemporary1 % 64) / 64;
    const lNumberOfWords = (lNumberOfWordsTemporary2 + 1) * 16;
    const lWordArray = Array.from({ length: lNumberOfWords - 1 });
    let lBytePosition = 0;
    let lByteCount = 0;
    while (lByteCount < lMessageLength) {
      lWordCount = (lByteCount - lByteCount % 4) / 4;
      lBytePosition = lByteCount % 4 * 8;
      lWordArray[lWordCount] = lWordArray[lWordCount] | string2.charCodeAt(lByteCount) << lBytePosition;
      lByteCount++;
    }
    lWordCount = (lByteCount - lByteCount % 4) / 4;
    lBytePosition = lByteCount % 4 * 8;
    lWordArray[lWordCount] = lWordArray[lWordCount] | 128 << lBytePosition;
    lWordArray[lNumberOfWords - 2] = lMessageLength << 3;
    lWordArray[lNumberOfWords - 1] = lMessageLength >>> 29;
    return lWordArray;
  };
  const _wordToHex = function(lValue) {
    let wordToHexValue = "";
    let wordToHexValueTemporary = "";
    let lByte;
    let lCount;
    for (lCount = 0; lCount <= 3; lCount++) {
      lByte = lValue >>> lCount * 8 & 255;
      wordToHexValueTemporary = "0" + lByte.toString(16);
      wordToHexValue = wordToHexValue + wordToHexValueTemporary.slice(-2, wordToHexValueTemporary.length - 2 + 2);
    }
    return wordToHexValue;
  };
  let k;
  let AA;
  let BB;
  let CC;
  let DD;
  let a;
  let b;
  let c;
  let d;
  const S11 = 7;
  const S12 = 12;
  const S13 = 17;
  const S14 = 22;
  const S21 = 5;
  const S22 = 9;
  const S23 = 14;
  const S24 = 20;
  const S31 = 4;
  const S32 = 11;
  const S33 = 16;
  const S34 = 23;
  const S41 = 6;
  const S42 = 10;
  const S43 = 15;
  const S44 = 21;
  string = utf8Encode(string);
  const x = _convertToWordArray(string);
  a = 1732584193;
  b = 4023233417;
  c = 2562383102;
  d = 271733878;
  const xl = x.length;
  for (k = 0; k < xl; k += 16) {
    AA = a;
    BB = b;
    CC = c;
    DD = d;
    a = _FF(a, b, c, d, x[k + 0], S11, 3614090360);
    d = _FF(d, a, b, c, x[k + 1], S12, 3905402710);
    c = _FF(c, d, a, b, x[k + 2], S13, 606105819);
    b = _FF(b, c, d, a, x[k + 3], S14, 3250441966);
    a = _FF(a, b, c, d, x[k + 4], S11, 4118548399);
    d = _FF(d, a, b, c, x[k + 5], S12, 1200080426);
    c = _FF(c, d, a, b, x[k + 6], S13, 2821735955);
    b = _FF(b, c, d, a, x[k + 7], S14, 4249261313);
    a = _FF(a, b, c, d, x[k + 8], S11, 1770035416);
    d = _FF(d, a, b, c, x[k + 9], S12, 2336552879);
    c = _FF(c, d, a, b, x[k + 10], S13, 4294925233);
    b = _FF(b, c, d, a, x[k + 11], S14, 2304563134);
    a = _FF(a, b, c, d, x[k + 12], S11, 1804603682);
    d = _FF(d, a, b, c, x[k + 13], S12, 4254626195);
    c = _FF(c, d, a, b, x[k + 14], S13, 2792965006);
    b = _FF(b, c, d, a, x[k + 15], S14, 1236535329);
    a = _GG(a, b, c, d, x[k + 1], S21, 4129170786);
    d = _GG(d, a, b, c, x[k + 6], S22, 3225465664);
    c = _GG(c, d, a, b, x[k + 11], S23, 643717713);
    b = _GG(b, c, d, a, x[k + 0], S24, 3921069994);
    a = _GG(a, b, c, d, x[k + 5], S21, 3593408605);
    d = _GG(d, a, b, c, x[k + 10], S22, 38016083);
    c = _GG(c, d, a, b, x[k + 15], S23, 3634488961);
    b = _GG(b, c, d, a, x[k + 4], S24, 3889429448);
    a = _GG(a, b, c, d, x[k + 9], S21, 568446438);
    d = _GG(d, a, b, c, x[k + 14], S22, 3275163606);
    c = _GG(c, d, a, b, x[k + 3], S23, 4107603335);
    b = _GG(b, c, d, a, x[k + 8], S24, 1163531501);
    a = _GG(a, b, c, d, x[k + 13], S21, 2850285829);
    d = _GG(d, a, b, c, x[k + 2], S22, 4243563512);
    c = _GG(c, d, a, b, x[k + 7], S23, 1735328473);
    b = _GG(b, c, d, a, x[k + 12], S24, 2368359562);
    a = _HH(a, b, c, d, x[k + 5], S31, 4294588738);
    d = _HH(d, a, b, c, x[k + 8], S32, 2272392833);
    c = _HH(c, d, a, b, x[k + 11], S33, 1839030562);
    b = _HH(b, c, d, a, x[k + 14], S34, 4259657740);
    a = _HH(a, b, c, d, x[k + 1], S31, 2763975236);
    d = _HH(d, a, b, c, x[k + 4], S32, 1272893353);
    c = _HH(c, d, a, b, x[k + 7], S33, 4139469664);
    b = _HH(b, c, d, a, x[k + 10], S34, 3200236656);
    a = _HH(a, b, c, d, x[k + 13], S31, 681279174);
    d = _HH(d, a, b, c, x[k + 0], S32, 3936430074);
    c = _HH(c, d, a, b, x[k + 3], S33, 3572445317);
    b = _HH(b, c, d, a, x[k + 6], S34, 76029189);
    a = _HH(a, b, c, d, x[k + 9], S31, 3654602809);
    d = _HH(d, a, b, c, x[k + 12], S32, 3873151461);
    c = _HH(c, d, a, b, x[k + 15], S33, 530742520);
    b = _HH(b, c, d, a, x[k + 2], S34, 3299628645);
    a = _II(a, b, c, d, x[k + 0], S41, 4096336452);
    d = _II(d, a, b, c, x[k + 7], S42, 1126891415);
    c = _II(c, d, a, b, x[k + 14], S43, 2878612391);
    b = _II(b, c, d, a, x[k + 5], S44, 4237533241);
    a = _II(a, b, c, d, x[k + 12], S41, 1700485571);
    d = _II(d, a, b, c, x[k + 3], S42, 2399980690);
    c = _II(c, d, a, b, x[k + 10], S43, 4293915773);
    b = _II(b, c, d, a, x[k + 1], S44, 2240044497);
    a = _II(a, b, c, d, x[k + 8], S41, 1873313359);
    d = _II(d, a, b, c, x[k + 15], S42, 4264355552);
    c = _II(c, d, a, b, x[k + 6], S43, 2734768916);
    b = _II(b, c, d, a, x[k + 13], S44, 1309151649);
    a = _II(a, b, c, d, x[k + 4], S41, 4149444226);
    d = _II(d, a, b, c, x[k + 11], S42, 3174756917);
    c = _II(c, d, a, b, x[k + 2], S43, 718787259);
    b = _II(b, c, d, a, x[k + 9], S44, 3951481745);
    a = _addUnsigned(a, AA);
    b = _addUnsigned(b, BB);
    c = _addUnsigned(c, CC);
    d = _addUnsigned(d, DD);
  }
  const temporary = _wordToHex(a) + _wordToHex(b) + _wordToHex(c) + _wordToHex(d);
  return temporary.toLowerCase();
}

// src/locutus/serialize/serialize.ts
function serialize(mixedValue) {
  let value;
  let key;
  let okey;
  let ktype = "";
  let vals = "";
  let count = 0;
  const _utf8Size = function(string) {
    return ~-encodeURI(string).split(/%..|./).length;
  };
  const _getType = function(input) {
    let match;
    let key2;
    let cons;
    let types;
    let type2 = typeof input;
    if (type2 === "object" && !input) {
      return "null";
    }
    if (type2 === "object") {
      if (!input.constructor) {
        return "object";
      }
      cons = input.constructor.toString();
      match = cons.match(/(\w+)\(/);
      if (match) {
        cons = match[1].toLowerCase();
      }
      types = ["boolean", "number", "string", "array"];
      for (key2 in types) {
        if (cons === types[key2]) {
          type2 = types[key2];
          break;
        }
      }
    }
    return type2;
  };
  const type = _getType(mixedValue);
  switch (type) {
    case "function":
      value = "";
      break;
    case "boolean":
      value = "b:" + (mixedValue ? "1" : "0");
      break;
    case "number":
      value = (Math.round(mixedValue) === mixedValue ? "i" : "d") + ":" + mixedValue;
      break;
    case "string":
      value = "s:" + _utf8Size(mixedValue) + ':"' + mixedValue + '"';
      break;
    case "array":
    case "object":
      value = "a";
      for (key in mixedValue) {
        if (Object.prototype.hasOwnProperty.call(mixedValue, key)) {
          ktype = _getType(mixedValue[key]);
          if (ktype === "function") {
            continue;
          }
          okey = /^\d+$/.test(key) ? Number.parseInt(key, 10) : key;
          vals += serialize(okey) + serialize(mixedValue[key]);
          count++;
        }
      }
      value += ":" + count + ":{" + vals + "}";
      break;
    // case 'undefined':
    default:
      value = "N";
      break;
  }
  if (type !== "object" && type !== "array") {
    value += ";";
  }
  return value;
}

// src/locutus/unserialize/unserialize.ts
function unserialize(string, showError = false) {
  try {
    if (typeof string !== "string") {
      return string;
    }
    return expectType(string, initCache())[0];
  } catch (error) {
    if (showError) {
      console.error(error);
    }
    return string;
  }
}
function initCache() {
  const store = [];
  const cache = function cache2(value) {
    store.push(value[0]);
    return value;
  };
  cache.get = (index) => {
    if (index >= store.length) {
      throw new RangeError(`Can't resolve reference ${index + 1}`);
    }
    return store[index];
  };
  return cache;
}
function expectType(string, cache) {
  const types = /^(?:N(?=;)|[CORSabdirs](?=:)|[^:]+(?=:))/g;
  const type = (types.exec(string) || [])[0];
  if (!type) {
    throw new SyntaxError("Invalid input: " + string);
  }
  switch (type) {
    case "N":
      return cache([null, 2]);
    case "b":
      return cache(expectBool(string));
    case "i":
      return cache(expectInt(string));
    case "d":
      return cache(expectFloat(string));
    case "s":
      return cache(expectString(string));
    case "S":
      return cache(expectEscapedString(string));
    case "a":
      return expectArray(string, cache);
    case "O":
      return expectObject(string, cache);
    case "C":
      throw new Error("Not yet implemented");
    // return expectClass(string, cache);
    case "r":
    case "R":
      return expectReference(string, cache);
    default:
      throw new SyntaxError(`Invalid or unsupported data type: ${type}`);
  }
}
function expectBool(string) {
  const reBool = /^b:([01]);/;
  const [match, boolMatch] = reBool.exec(string) || [];
  if (!boolMatch) {
    throw new SyntaxError("Invalid bool value, expected 0 or 1");
  }
  return [boolMatch === "1", match.length];
}
function expectInt(string) {
  const reInt = /^i:([+-]?\d+);/;
  const [match, intMatch] = reInt.exec(string) || [];
  if (!intMatch) {
    throw new SyntaxError("Expected an integer value");
  }
  return [Number.parseInt(intMatch, 10), match.length];
}
function expectFloat(string) {
  const reFloat = /^d:(NAN|-?INF|(?:\d+\.\d*|\d*\.\d+|\d+)(?:[Ee][+-]\d+)?);/;
  const [match, floatMatch] = reFloat.exec(string) || [];
  if (!floatMatch) {
    throw new SyntaxError("Expected a float value");
  }
  let floatValue;
  switch (floatMatch) {
    case "NAN":
      floatValue = Number.NaN;
      break;
    case "-INF":
      floatValue = Number.NEGATIVE_INFINITY;
      break;
    case "INF":
      floatValue = Number.POSITIVE_INFINITY;
      break;
    default:
      floatValue = Number.parseFloat(floatMatch);
      break;
  }
  return [floatValue, match.length];
}
function readBytes(string, length, escapedString = false) {
  let bytes = 0;
  let out = "";
  let c = 0;
  const stringLength = string.length;
  let wasHighSurrogate = false;
  let escapedChars = 0;
  while (bytes < length && c < stringLength) {
    let chr = string.charAt(c);
    const code = chr.charCodeAt(0);
    const isHighSurrogate = code >= 55296 && code <= 56319;
    const isLowSurrogate = code >= 56320 && code <= 57343;
    if (escapedString && chr === "\\") {
      chr = String.fromCharCode(Number.parseInt(string.slice(c + 1, 2), 16));
      escapedChars++;
      c += 2;
    }
    c++;
    bytes += isHighSurrogate || isLowSurrogate && wasHighSurrogate ? (
      // if high surrogate, count 2 bytes, as expectation is to be followed by low surrogate
      // if low surrogate preceded by high surrogate, add 2 bytes
      2
    ) : code > 2047 ? (
      // otherwise low surrogate falls into this part
      3
    ) : code > 127 ? 2 : 1;
    bytes += wasHighSurrogate && !isLowSurrogate ? 1 : 0;
    out += chr;
    wasHighSurrogate = isHighSurrogate;
  }
  return [out, bytes, escapedChars];
}
function expectString(string) {
  const reStringLength = /^s:(\d+):"/g;
  const [match, byteLengthMatch] = reStringLength.exec(string) || [];
  if (!match) {
    throw new SyntaxError("Expected a string value");
  }
  const length = Number.parseInt(byteLengthMatch, 10);
  string = string.slice(match.length);
  const [stringMatch, bytes] = readBytes(string, length);
  if (bytes !== length) {
    throw new SyntaxError(`Expected string of ${length} bytes, but got ${bytes}`);
  }
  string = string.slice(stringMatch.length);
  if (!string.startsWith('";')) {
    throw new SyntaxError('Expected ";');
  }
  return [stringMatch, match.length + stringMatch.length + 2];
}
function expectEscapedString(string) {
  const reStringLength = /^S:(\d+):"/g;
  const [match, stringLengthMatch] = reStringLength.exec(string) || [];
  if (!match) {
    throw new SyntaxError("Expected an escaped string value");
  }
  const length = Number.parseInt(stringLengthMatch, 10);
  string = string.slice(match.length);
  const [stringMatch, bytes, escapedChars] = readBytes(string, length, true);
  if (bytes !== length) {
    throw new SyntaxError(`Expected escaped string of ${length} bytes, but got ${bytes}`);
  }
  string = string.slice(stringMatch.length + escapedChars * 2);
  if (!string.startsWith('";')) {
    throw new SyntaxError('Expected ";');
  }
  return [stringMatch, match.length + stringMatch.length + 2];
}
function expectKeyOrIndex(string) {
  try {
    return expectString(string);
  } catch {
  }
  try {
    return expectEscapedString(string);
  } catch {
  }
  try {
    return expectInt(string);
  } catch {
    throw new SyntaxError("Expected key or index");
  }
}
function expectObject(string, cache) {
  const reObjectLiteral = /^O:(\d+):"([^"]+)":(\d+):{/;
  const [objectLiteralBeginMatch, , className, propertyCountMatch] = reObjectLiteral.exec(string) || [];
  if (!objectLiteralBeginMatch) {
    throw new SyntaxError("Invalid input");
  }
  if (className !== "stdClass") {
    throw new SyntaxError(`Unsupported object type: ${className}`);
  }
  let totalOffset = objectLiteralBeginMatch.length;
  const propertyCount = Number.parseInt(propertyCountMatch, 10);
  const object = {};
  cache([object]);
  string = string.slice(totalOffset);
  for (let index = 0; index < propertyCount; index++) {
    const property = expectKeyOrIndex(string);
    string = string.slice(property[1]);
    totalOffset += property[1];
    const value = expectType(string, cache);
    string = string.slice(value[1]);
    totalOffset += value[1];
    object[property[0]] = value[0];
  }
  if (string.charAt(0) !== "}") {
    throw new SyntaxError("Expected }");
  }
  return [object, totalOffset + 1];
}
function expectReference(string, cache) {
  const reReference = /^[Rr]:([1-9]\d*);/;
  const [match, referenceIndex] = reReference.exec(string) || [];
  if (!match) {
    throw new SyntaxError("Expected reference value");
  }
  return [cache.get(Number.parseInt(referenceIndex, 10) - 1), match.length];
}
function expectArray(string, cache) {
  const reArrayLength = /^a:(\d+):{/;
  const [arrayLiteralBeginMatch, arrayLengthMatch] = reArrayLength.exec(string) || [];
  if (!arrayLengthMatch) {
    throw new SyntaxError("Expected array length annotation");
  }
  string = string.slice(arrayLiteralBeginMatch.length);
  const array = expectArrayItems(string, Number.parseInt(arrayLengthMatch, 10), cache);
  if (string.charAt(array[1]) !== "}") {
    throw new SyntaxError("Expected }");
  }
  return [array[0], arrayLiteralBeginMatch.length + array[1] + 1];
}
function expectArrayItems(string, expectedItems = 0, cache) {
  let key;
  let item;
  let totalOffset = 0;
  let hasContinousIndexes = true;
  let lastIndex = -1;
  let items = {};
  cache([items]);
  for (let index = 0; index < expectedItems; index++) {
    key = expectKeyOrIndex(string);
    hasContinousIndexes = hasContinousIndexes && typeof key[0] === "number" && key[0] === lastIndex + 1;
    lastIndex = key[0];
    string = string.slice(key[1]);
    totalOffset += key[1];
    item = expectType(string, cache);
    string = string.slice(item[1]);
    totalOffset += item[1];
    items[key[0]] = item[0];
  }
  if (hasContinousIndexes) {
    items = Object.values(items);
  }
  return [items, totalOffset];
}

// src/locutus/utf8-decode/utf8-decode.ts
function utf8Decode(string) {
  let strData = string;
  if (strData === null || strData === void 0) {
    return "";
  }
  const tmpArr = [];
  let index = 0;
  let c1 = 0;
  let seqlen = 0;
  strData = String(strData);
  while (index < strData.length) {
    c1 = strData.charCodeAt(index) & 255;
    seqlen = 0;
    if (c1 <= 191) {
      c1 = c1 & 127;
      seqlen = 1;
    } else if (c1 <= 223) {
      c1 = c1 & 31;
      seqlen = 2;
    } else if (c1 <= 239) {
      c1 = c1 & 15;
      seqlen = 3;
    } else {
      c1 = c1 & 7;
      seqlen = 4;
    }
    for (let ai = 1; ai < seqlen; ++ai) {
      c1 = c1 << 6 | strData.charCodeAt(ai + index) & 63;
    }
    if (seqlen === 4) {
      c1 -= 65536;
      tmpArr.push(String.fromCharCode(55296 | c1 >> 10 & 1023), String.fromCharCode(56320 | c1 & 1023));
    } else {
      tmpArr.push(String.fromCharCode(c1));
    }
    index += seqlen;
  }
  return tmpArr.join("");
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  HTMLSPECIALCHARS_ENT_COMPAT,
  HTMLSPECIALCHARS_ENT_HTML_QUOTE_DOUBLE,
  HTMLSPECIALCHARS_ENT_HTML_QUOTE_SINGLE,
  HTMLSPECIALCHARS_ENT_IGNORE,
  HTMLSPECIALCHARS_ENT_NOQUOTES,
  HTMLSPECIALCHARS_ENT_QUOTES,
  htmlspecialchars,
  md5,
  serialize,
  unserialize,
  utf8Decode,
  utf8Encode
});