import process from 'node:process';globalThis._importMeta_=globalThis._importMeta_||{url:"file:///_entry.js",env:process.env};import http from 'node:http';
import https from 'node:https';
import { toValue } from 'vue';
import { promises, existsSync } from 'node:fs';
import { fileURLToPath } from 'node:url';
import { dirname as dirname$1, resolve as resolve$2, join } from 'node:path';

const suspectProtoRx = /"(?:_|\\u0{2}5[Ff]){2}(?:p|\\u0{2}70)(?:r|\\u0{2}72)(?:o|\\u0{2}6[Ff])(?:t|\\u0{2}74)(?:o|\\u0{2}6[Ff])(?:_|\\u0{2}5[Ff]){2}"\s*:/;
const suspectConstructorRx = /"(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)"\s*:/;
const JsonSigRx = /^\s*["[{]|^\s*-?\d{1,16}(\.\d{1,17})?([Ee][+-]?\d+)?\s*$/;
function jsonParseTransform(key, value) {
  if (key === "__proto__" || key === "constructor" && value && typeof value === "object" && "prototype" in value) {
    warnKeyDropped(key);
    return;
  }
  return value;
}
function warnKeyDropped(key) {
  console.warn(`[destr] Dropping "${key}" key to prevent prototype pollution.`);
}
function destr(value, options = {}) {
  if (typeof value !== "string") {
    return value;
  }
  const _value = value.trim();
  if (
    // eslint-disable-next-line unicorn/prefer-at
    value[0] === '"' && value.endsWith('"') && !value.includes("\\")
  ) {
    return _value.slice(1, -1);
  }
  if (_value.length <= 9) {
    const _lval = _value.toLowerCase();
    if (_lval === "true") {
      return true;
    }
    if (_lval === "false") {
      return false;
    }
    if (_lval === "undefined") {
      return undefined;
    }
    if (_lval === "null") {
      return null;
    }
    if (_lval === "nan") {
      return Number.NaN;
    }
    if (_lval === "infinity") {
      return Number.POSITIVE_INFINITY;
    }
    if (_lval === "-infinity") {
      return Number.NEGATIVE_INFINITY;
    }
  }
  if (!JsonSigRx.test(value)) {
    if (options.strict) {
      throw new SyntaxError("[destr] Invalid JSON");
    }
    return value;
  }
  try {
    if (suspectProtoRx.test(value) || suspectConstructorRx.test(value)) {
      if (options.strict) {
        throw new Error("[destr] Possible prototype pollution");
      }
      return JSON.parse(value, jsonParseTransform);
    }
    return JSON.parse(value);
  } catch (error) {
    if (options.strict) {
      throw error;
    }
    return value;
  }
}

const HASH_RE = /#/g;
const AMPERSAND_RE = /&/g;
const SLASH_RE = /\//g;
const EQUAL_RE = /=/g;
const PLUS_RE = /\+/g;
const ENC_CARET_RE = /%5e/gi;
const ENC_BACKTICK_RE = /%60/gi;
const ENC_PIPE_RE = /%7c/gi;
const ENC_SPACE_RE = /%20/gi;
const ENC_SLASH_RE = /%2f/gi;
function encode(text) {
  return encodeURI("" + text).replace(ENC_PIPE_RE, "|");
}
function encodeQueryValue(input) {
  return encode(typeof input === "string" ? input : JSON.stringify(input)).replace(PLUS_RE, "%2B").replace(ENC_SPACE_RE, "+").replace(HASH_RE, "%23").replace(AMPERSAND_RE, "%26").replace(ENC_BACKTICK_RE, "`").replace(ENC_CARET_RE, "^").replace(SLASH_RE, "%2F");
}
function encodeQueryKey(text) {
  return encodeQueryValue(text).replace(EQUAL_RE, "%3D");
}
function decode$1(text = "") {
  try {
    return decodeURIComponent("" + text);
  } catch {
    return "" + text;
  }
}
function decodePath(text) {
  return decode$1(text.replace(ENC_SLASH_RE, "%252F"));
}
function decodeQueryKey(text) {
  return decode$1(text.replace(PLUS_RE, " "));
}
function decodeQueryValue(text) {
  return decode$1(text.replace(PLUS_RE, " "));
}

function parseQuery(parametersString = "") {
  const object = {};
  if (parametersString[0] === "?") {
    parametersString = parametersString.slice(1);
  }
  for (const parameter of parametersString.split("&")) {
    const s = parameter.match(/([^=]+)=?(.*)/) || [];
    if (s.length < 2) {
      continue;
    }
    const key = decodeQueryKey(s[1]);
    if (key === "__proto__" || key === "constructor") {
      continue;
    }
    const value = decodeQueryValue(s[2] || "");
    if (object[key] === undefined) {
      object[key] = value;
    } else if (Array.isArray(object[key])) {
      object[key].push(value);
    } else {
      object[key] = [object[key], value];
    }
  }
  return object;
}
function encodeQueryItem(key, value) {
  if (typeof value === "number" || typeof value === "boolean") {
    value = String(value);
  }
  if (!value) {
    return encodeQueryKey(key);
  }
  if (Array.isArray(value)) {
    return value.map((_value) => `${encodeQueryKey(key)}=${encodeQueryValue(_value)}`).join("&");
  }
  return `${encodeQueryKey(key)}=${encodeQueryValue(value)}`;
}
function stringifyQuery(query) {
  return Object.keys(query).filter((k) => query[k] !== undefined).map((k) => encodeQueryItem(k, query[k])).filter(Boolean).join("&");
}

const PROTOCOL_STRICT_REGEX = /^[\s\w\0+.-]{2,}:([/\\]{1,2})/;
const PROTOCOL_REGEX = /^[\s\w\0+.-]{2,}:([/\\]{2})?/;
const PROTOCOL_RELATIVE_REGEX = /^([/\\]\s*){2,}[^/\\]/;
const JOIN_LEADING_SLASH_RE = /^\.?\//;
function hasProtocol(inputString, opts = {}) {
  if (typeof opts === "boolean") {
    opts = { acceptRelative: opts };
  }
  if (opts.strict) {
    return PROTOCOL_STRICT_REGEX.test(inputString);
  }
  return PROTOCOL_REGEX.test(inputString) || (opts.acceptRelative ? PROTOCOL_RELATIVE_REGEX.test(inputString) : false);
}
function hasTrailingSlash(input = "", respectQueryAndFragment) {
  {
    return input.endsWith("/");
  }
}
function withoutTrailingSlash(input = "", respectQueryAndFragment) {
  {
    return (hasTrailingSlash(input) ? input.slice(0, -1) : input) || "/";
  }
}
function withTrailingSlash(input = "", respectQueryAndFragment) {
  {
    return input.endsWith("/") ? input : input + "/";
  }
}
function hasLeadingSlash(input = "") {
  return input.startsWith("/");
}
function withLeadingSlash(input = "") {
  return hasLeadingSlash(input) ? input : "/" + input;
}
function withBase(input, base) {
  if (isEmptyURL(base) || hasProtocol(input)) {
    return input;
  }
  const _base = withoutTrailingSlash(base);
  if (input.startsWith(_base)) {
    return input;
  }
  return joinURL(_base, input);
}
function withoutBase(input, base) {
  if (isEmptyURL(base)) {
    return input;
  }
  const _base = withoutTrailingSlash(base);
  if (!input.startsWith(_base)) {
    return input;
  }
  const trimmed = input.slice(_base.length);
  return trimmed[0] === "/" ? trimmed : "/" + trimmed;
}
function withQuery(input, query) {
  const parsed = parseURL(input);
  const mergedQuery = { ...parseQuery(parsed.search), ...query };
  parsed.search = stringifyQuery(mergedQuery);
  return stringifyParsedURL(parsed);
}
function getQuery$1(input) {
  return parseQuery(parseURL(input).search);
}
function isEmptyURL(url) {
  return !url || url === "/";
}
function isNonEmptyURL(url) {
  return url && url !== "/";
}
function joinURL(base, ...input) {
  let url = base || "";
  for (const segment of input.filter((url2) => isNonEmptyURL(url2))) {
    if (url) {
      const _segment = segment.replace(JOIN_LEADING_SLASH_RE, "");
      url = withTrailingSlash(url) + _segment;
    } else {
      url = segment;
    }
  }
  return url;
}
function joinRelativeURL(..._input) {
  const JOIN_SEGMENT_SPLIT_RE = /\/(?!\/)/;
  const input = _input.filter(Boolean);
  const segments = [];
  let segmentsDepth = 0;
  for (const i of input) {
    if (!i || i === "/") {
      continue;
    }
    for (const [sindex, s] of i.split(JOIN_SEGMENT_SPLIT_RE).entries()) {
      if (!s || s === ".") {
        continue;
      }
      if (s === "..") {
        if (segments.length === 1 && hasProtocol(segments[0])) {
          continue;
        }
        segments.pop();
        segmentsDepth--;
        continue;
      }
      if (sindex === 1 && segments[segments.length - 1]?.endsWith(":/")) {
        segments[segments.length - 1] += "/" + s;
        continue;
      }
      segments.push(s);
      segmentsDepth++;
    }
  }
  let url = segments.join("/");
  if (segmentsDepth >= 0) {
    if (input[0]?.startsWith("/") && !url.startsWith("/")) {
      url = "/" + url;
    } else if (input[0]?.startsWith("./") && !url.startsWith("./")) {
      url = "./" + url;
    }
  } else {
    url = "../".repeat(-1 * segmentsDepth) + url;
  }
  if (input[input.length - 1]?.endsWith("/") && !url.endsWith("/")) {
    url += "/";
  }
  return url;
}
function withHttps(input) {
  return withProtocol(input, "https://");
}
function withProtocol(input, protocol) {
  let match = input.match(PROTOCOL_REGEX);
  if (!match) {
    match = input.match(/^\/{2,}/);
  }
  if (!match) {
    return protocol + input;
  }
  return protocol + input.slice(match[0].length);
}

const protocolRelative = Symbol.for("ufo:protocolRelative");
function parseURL(input = "", defaultProto) {
  const _specialProtoMatch = input.match(
    /^[\s\0]*(blob:|data:|javascript:|vbscript:)(.*)/i
  );
  if (_specialProtoMatch) {
    const [, _proto, _pathname = ""] = _specialProtoMatch;
    return {
      protocol: _proto.toLowerCase(),
      pathname: _pathname,
      href: _proto + _pathname,
      auth: "",
      host: "",
      search: "",
      hash: ""
    };
  }
  if (!hasProtocol(input, { acceptRelative: true })) {
    return parsePath(input);
  }
  const [, protocol = "", auth, hostAndPath = ""] = input.replace(/\\/g, "/").match(/^[\s\0]*([\w+.-]{2,}:)?\/\/([^/@]+@)?(.*)/) || [];
  let [, host = "", path = ""] = hostAndPath.match(/([^#/?]*)(.*)?/) || [];
  if (protocol === "file:") {
    path = path.replace(/\/(?=[A-Za-z]:)/, "");
  }
  const { pathname, search, hash } = parsePath(path);
  return {
    protocol: protocol.toLowerCase(),
    auth: auth ? auth.slice(0, Math.max(0, auth.length - 1)) : "",
    host,
    pathname,
    search,
    hash,
    [protocolRelative]: !protocol
  };
}
function parsePath(input = "") {
  const [pathname = "", search = "", hash = ""] = (input.match(/([^#?]*)(\?[^#]*)?(#.*)?/) || []).splice(1);
  return {
    pathname,
    search,
    hash
  };
}
function stringifyParsedURL(parsed) {
  const pathname = parsed.pathname || "";
  const search = parsed.search ? (parsed.search.startsWith("?") ? "" : "?") + parsed.search : "";
  const hash = parsed.hash || "";
  const auth = parsed.auth ? parsed.auth + "@" : "";
  const host = parsed.host || "";
  const proto = parsed.protocol || parsed[protocolRelative] ? (parsed.protocol || "") + "//" : "";
  return proto + auth + host + pathname + search + hash;
}

function parse(str, options) {
  if (typeof str !== "string") {
    throw new TypeError("argument str must be a string");
  }
  const obj = {};
  const opt = options || {};
  const dec = opt.decode || decode;
  let index = 0;
  while (index < str.length) {
    const eqIdx = str.indexOf("=", index);
    if (eqIdx === -1) {
      break;
    }
    let endIdx = str.indexOf(";", index);
    if (endIdx === -1) {
      endIdx = str.length;
    } else if (endIdx < eqIdx) {
      index = str.lastIndexOf(";", eqIdx - 1) + 1;
      continue;
    }
    const key = str.slice(index, eqIdx).trim();
    if (opt?.filter && !opt?.filter(key)) {
      index = endIdx + 1;
      continue;
    }
    if (undefined === obj[key]) {
      let val = str.slice(eqIdx + 1, endIdx).trim();
      if (val.codePointAt(0) === 34) {
        val = val.slice(1, -1);
      }
      obj[key] = tryDecode(val, dec);
    }
    index = endIdx + 1;
  }
  return obj;
}
function decode(str) {
  return str.includes("%") ? decodeURIComponent(str) : str;
}
function tryDecode(str, decode2) {
  try {
    return decode2(str);
  } catch {
    return str;
  }
}

const fieldContentRegExp = /^[\u0009\u0020-\u007E\u0080-\u00FF]+$/;
function serialize(name, value, options) {
  const opt = options || {};
  const enc = opt.encode || encodeURIComponent;
  if (typeof enc !== "function") {
    throw new TypeError("option encode is invalid");
  }
  if (!fieldContentRegExp.test(name)) {
    throw new TypeError("argument name is invalid");
  }
  const encodedValue = enc(value);
  if (encodedValue && !fieldContentRegExp.test(encodedValue)) {
    throw new TypeError("argument val is invalid");
  }
  let str = name + "=" + encodedValue;
  if (undefined !== opt.maxAge && opt.maxAge !== null) {
    const maxAge = opt.maxAge - 0;
    if (Number.isNaN(maxAge) || !Number.isFinite(maxAge)) {
      throw new TypeError("option maxAge is invalid");
    }
    str += "; Max-Age=" + Math.floor(maxAge);
  }
  if (opt.domain) {
    if (!fieldContentRegExp.test(opt.domain)) {
      throw new TypeError("option domain is invalid");
    }
    str += "; Domain=" + opt.domain;
  }
  if (opt.path) {
    if (!fieldContentRegExp.test(opt.path)) {
      throw new TypeError("option path is invalid");
    }
    str += "; Path=" + opt.path;
  }
  if (opt.expires) {
    if (!isDate(opt.expires) || Number.isNaN(opt.expires.valueOf())) {
      throw new TypeError("option expires is invalid");
    }
    str += "; Expires=" + opt.expires.toUTCString();
  }
  if (opt.httpOnly) {
    str += "; HttpOnly";
  }
  if (opt.secure) {
    str += "; Secure";
  }
  if (opt.priority) {
    const priority = typeof opt.priority === "string" ? opt.priority.toLowerCase() : opt.priority;
    switch (priority) {
      case "low": {
        str += "; Priority=Low";
        break;
      }
      case "medium": {
        str += "; Priority=Medium";
        break;
      }
      case "high": {
        str += "; Priority=High";
        break;
      }
      default: {
        throw new TypeError("option priority is invalid");
      }
    }
  }
  if (opt.sameSite) {
    const sameSite = typeof opt.sameSite === "string" ? opt.sameSite.toLowerCase() : opt.sameSite;
    switch (sameSite) {
      case true: {
        str += "; SameSite=Strict";
        break;
      }
      case "lax": {
        str += "; SameSite=Lax";
        break;
      }
      case "strict": {
        str += "; SameSite=Strict";
        break;
      }
      case "none": {
        str += "; SameSite=None";
        break;
      }
      default: {
        throw new TypeError("option sameSite is invalid");
      }
    }
  }
  if (opt.partitioned) {
    str += "; Partitioned";
  }
  return str;
}
function isDate(val) {
  return Object.prototype.toString.call(val) === "[object Date]" || val instanceof Date;
}

const defaults = Object.freeze({
  ignoreUnknown: false,
  respectType: false,
  respectFunctionNames: false,
  respectFunctionProperties: false,
  unorderedObjects: true,
  unorderedArrays: false,
  unorderedSets: false,
  excludeKeys: undefined,
  excludeValues: undefined,
  replacer: undefined
});
function objectHash(object, options) {
  if (options) {
    options = { ...defaults, ...options };
  } else {
    options = defaults;
  }
  const hasher = createHasher(options);
  hasher.dispatch(object);
  return hasher.toString();
}
const defaultPrototypesKeys = Object.freeze([
  "prototype",
  "__proto__",
  "constructor"
]);
function createHasher(options) {
  let buff = "";
  let context = /* @__PURE__ */ new Map();
  const write = (str) => {
    buff += str;
  };
  return {
    toString() {
      return buff;
    },
    getContext() {
      return context;
    },
    dispatch(value) {
      if (options.replacer) {
        value = options.replacer(value);
      }
      const type = value === null ? "null" : typeof value;
      return this[type](value);
    },
    object(object) {
      if (object && typeof object.toJSON === "function") {
        return this.object(object.toJSON());
      }
      const objString = Object.prototype.toString.call(object);
      let objType = "";
      const objectLength = objString.length;
      if (objectLength < 10) {
        objType = "unknown:[" + objString + "]";
      } else {
        objType = objString.slice(8, objectLength - 1);
      }
      objType = objType.toLowerCase();
      let objectNumber = null;
      if ((objectNumber = context.get(object)) === undefined) {
        context.set(object, context.size);
      } else {
        return this.dispatch("[CIRCULAR:" + objectNumber + "]");
      }
      if (typeof Buffer !== "undefined" && Buffer.isBuffer && Buffer.isBuffer(object)) {
        write("buffer:");
        return write(object.toString("utf8"));
      }
      if (objType !== "object" && objType !== "function" && objType !== "asyncfunction") {
        if (this[objType]) {
          this[objType](object);
        } else if (!options.ignoreUnknown) {
          this.unkown(object, objType);
        }
      } else {
        let keys = Object.keys(object);
        if (options.unorderedObjects) {
          keys = keys.sort();
        }
        let extraKeys = [];
        if (options.respectType !== false && !isNativeFunction(object)) {
          extraKeys = defaultPrototypesKeys;
        }
        if (options.excludeKeys) {
          keys = keys.filter((key) => {
            return !options.excludeKeys(key);
          });
          extraKeys = extraKeys.filter((key) => {
            return !options.excludeKeys(key);
          });
        }
        write("object:" + (keys.length + extraKeys.length) + ":");
        const dispatchForKey = (key) => {
          this.dispatch(key);
          write(":");
          if (!options.excludeValues) {
            this.dispatch(object[key]);
          }
          write(",");
        };
        for (const key of keys) {
          dispatchForKey(key);
        }
        for (const key of extraKeys) {
          dispatchForKey(key);
        }
      }
    },
    array(arr, unordered) {
      unordered = unordered === undefined ? options.unorderedArrays !== false : unordered;
      write("array:" + arr.length + ":");
      if (!unordered || arr.length <= 1) {
        for (const entry of arr) {
          this.dispatch(entry);
        }
        return;
      }
      const contextAdditions = /* @__PURE__ */ new Map();
      const entries = arr.map((entry) => {
        const hasher = createHasher(options);
        hasher.dispatch(entry);
        for (const [key, value] of hasher.getContext()) {
          contextAdditions.set(key, value);
        }
        return hasher.toString();
      });
      context = contextAdditions;
      entries.sort();
      return this.array(entries, false);
    },
    date(date) {
      return write("date:" + date.toJSON());
    },
    symbol(sym) {
      return write("symbol:" + sym.toString());
    },
    unkown(value, type) {
      write(type);
      if (!value) {
        return;
      }
      write(":");
      if (value && typeof value.entries === "function") {
        return this.array(
          Array.from(value.entries()),
          true
          /* ordered */
        );
      }
    },
    error(err) {
      return write("error:" + err.toString());
    },
    boolean(bool) {
      return write("bool:" + bool);
    },
    string(string) {
      write("string:" + string.length + ":");
      write(string);
    },
    function(fn) {
      write("fn:");
      if (isNativeFunction(fn)) {
        this.dispatch("[native]");
      } else {
        this.dispatch(fn.toString());
      }
      if (options.respectFunctionNames !== false) {
        this.dispatch("function-name:" + String(fn.name));
      }
      if (options.respectFunctionProperties) {
        this.object(fn);
      }
    },
    number(number) {
      return write("number:" + number);
    },
    xml(xml) {
      return write("xml:" + xml.toString());
    },
    null() {
      return write("Null");
    },
    undefined() {
      return write("Undefined");
    },
    regexp(regex) {
      return write("regex:" + regex.toString());
    },
    uint8array(arr) {
      write("uint8array:");
      return this.dispatch(Array.prototype.slice.call(arr));
    },
    uint8clampedarray(arr) {
      write("uint8clampedarray:");
      return this.dispatch(Array.prototype.slice.call(arr));
    },
    int8array(arr) {
      write("int8array:");
      return this.dispatch(Array.prototype.slice.call(arr));
    },
    uint16array(arr) {
      write("uint16array:");
      return this.dispatch(Array.prototype.slice.call(arr));
    },
    int16array(arr) {
      write("int16array:");
      return this.dispatch(Array.prototype.slice.call(arr));
    },
    uint32array(arr) {
      write("uint32array:");
      return this.dispatch(Array.prototype.slice.call(arr));
    },
    int32array(arr) {
      write("int32array:");
      return this.dispatch(Array.prototype.slice.call(arr));
    },
    float32array(arr) {
      write("float32array:");
      return this.dispatch(Array.prototype.slice.call(arr));
    },
    float64array(arr) {
      write("float64array:");
      return this.dispatch(Array.prototype.slice.call(arr));
    },
    arraybuffer(arr) {
      write("arraybuffer:");
      return this.dispatch(new Uint8Array(arr));
    },
    url(url) {
      return write("url:" + url.toString());
    },
    map(map) {
      write("map:");
      const arr = [...map];
      return this.array(arr, options.unorderedSets !== false);
    },
    set(set) {
      write("set:");
      const arr = [...set];
      return this.array(arr, options.unorderedSets !== false);
    },
    file(file) {
      write("file:");
      return this.dispatch([file.name, file.size, file.type, file.lastModfied]);
    },
    blob() {
      if (options.ignoreUnknown) {
        return write("[blob]");
      }
      throw new Error(
        'Hashing Blob objects is currently not supported\nUse "options.replacer" or "options.ignoreUnknown"\n'
      );
    },
    domwindow() {
      return write("domwindow");
    },
    bigint(number) {
      return write("bigint:" + number.toString());
    },
    /* Node.js standard native objects */
    process() {
      return write("process");
    },
    timer() {
      return write("timer");
    },
    pipe() {
      return write("pipe");
    },
    tcp() {
      return write("tcp");
    },
    udp() {
      return write("udp");
    },
    tty() {
      return write("tty");
    },
    statwatcher() {
      return write("statwatcher");
    },
    securecontext() {
      return write("securecontext");
    },
    connection() {
      return write("connection");
    },
    zlib() {
      return write("zlib");
    },
    context() {
      return write("context");
    },
    nodescript() {
      return write("nodescript");
    },
    httpparser() {
      return write("httpparser");
    },
    dataview() {
      return write("dataview");
    },
    signal() {
      return write("signal");
    },
    fsevent() {
      return write("fsevent");
    },
    tlswrap() {
      return write("tlswrap");
    }
  };
}
const nativeFunc = "[native code] }";
const nativeFuncLength = nativeFunc.length;
function isNativeFunction(f) {
  if (typeof f !== "function") {
    return false;
  }
  return Function.prototype.toString.call(f).slice(-nativeFuncLength) === nativeFunc;
}

var __defProp$1 = Object.defineProperty;
var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __publicField$1 = (obj, key, value) => {
  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
  return value;
};
class WordArray {
  constructor(words, sigBytes) {
    __publicField$1(this, "words");
    __publicField$1(this, "sigBytes");
    words = this.words = words || [];
    this.sigBytes = sigBytes === undefined ? words.length * 4 : sigBytes;
  }
  toString(encoder) {
    return (encoder || Hex).stringify(this);
  }
  concat(wordArray) {
    this.clamp();
    if (this.sigBytes % 4) {
      for (let i = 0; i < wordArray.sigBytes; i++) {
        const thatByte = wordArray.words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
        this.words[this.sigBytes + i >>> 2] |= thatByte << 24 - (this.sigBytes + i) % 4 * 8;
      }
    } else {
      for (let j = 0; j < wordArray.sigBytes; j += 4) {
        this.words[this.sigBytes + j >>> 2] = wordArray.words[j >>> 2];
      }
    }
    this.sigBytes += wordArray.sigBytes;
    return this;
  }
  clamp() {
    this.words[this.sigBytes >>> 2] &= 4294967295 << 32 - this.sigBytes % 4 * 8;
    this.words.length = Math.ceil(this.sigBytes / 4);
  }
  clone() {
    return new WordArray([...this.words]);
  }
}
const Hex = {
  stringify(wordArray) {
    const hexChars = [];
    for (let i = 0; i < wordArray.sigBytes; i++) {
      const bite = wordArray.words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
      hexChars.push((bite >>> 4).toString(16), (bite & 15).toString(16));
    }
    return hexChars.join("");
  }
};
const Base64 = {
  stringify(wordArray) {
    const keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
    const base64Chars = [];
    for (let i = 0; i < wordArray.sigBytes; i += 3) {
      const byte1 = wordArray.words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
      const byte2 = wordArray.words[i + 1 >>> 2] >>> 24 - (i + 1) % 4 * 8 & 255;
      const byte3 = wordArray.words[i + 2 >>> 2] >>> 24 - (i + 2) % 4 * 8 & 255;
      const triplet = byte1 << 16 | byte2 << 8 | byte3;
      for (let j = 0; j < 4 && i * 8 + j * 6 < wordArray.sigBytes * 8; j++) {
        base64Chars.push(keyStr.charAt(triplet >>> 6 * (3 - j) & 63));
      }
    }
    return base64Chars.join("");
  }
};
const Latin1 = {
  parse(latin1Str) {
    const latin1StrLength = latin1Str.length;
    const words = [];
    for (let i = 0; i < latin1StrLength; i++) {
      words[i >>> 2] |= (latin1Str.charCodeAt(i) & 255) << 24 - i % 4 * 8;
    }
    return new WordArray(words, latin1StrLength);
  }
};
const Utf8 = {
  parse(utf8Str) {
    return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
  }
};
class BufferedBlockAlgorithm {
  constructor() {
    __publicField$1(this, "_data", new WordArray());
    __publicField$1(this, "_nDataBytes", 0);
    __publicField$1(this, "_minBufferSize", 0);
    __publicField$1(this, "blockSize", 512 / 32);
  }
  reset() {
    this._data = new WordArray();
    this._nDataBytes = 0;
  }
  _append(data) {
    if (typeof data === "string") {
      data = Utf8.parse(data);
    }
    this._data.concat(data);
    this._nDataBytes += data.sigBytes;
  }
  _doProcessBlock(_dataWords, _offset) {
  }
  _process(doFlush) {
    let processedWords;
    let nBlocksReady = this._data.sigBytes / (this.blockSize * 4);
    if (doFlush) {
      nBlocksReady = Math.ceil(nBlocksReady);
    } else {
      nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);
    }
    const nWordsReady = nBlocksReady * this.blockSize;
    const nBytesReady = Math.min(nWordsReady * 4, this._data.sigBytes);
    if (nWordsReady) {
      for (let offset = 0; offset < nWordsReady; offset += this.blockSize) {
        this._doProcessBlock(this._data.words, offset);
      }
      processedWords = this._data.words.splice(0, nWordsReady);
      this._data.sigBytes -= nBytesReady;
    }
    return new WordArray(processedWords, nBytesReady);
  }
}
class Hasher extends BufferedBlockAlgorithm {
  update(messageUpdate) {
    this._append(messageUpdate);
    this._process();
    return this;
  }
  finalize(messageUpdate) {
    if (messageUpdate) {
      this._append(messageUpdate);
    }
  }
}

var __defProp$3 = Object.defineProperty;
var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __publicField$3 = (obj, key, value) => {
  __defNormalProp$3(obj, key + "" , value);
  return value;
};
const H = [
  1779033703,
  -1150833019,
  1013904242,
  -1521486534,
  1359893119,
  -1694144372,
  528734635,
  1541459225
];
const K = [
  1116352408,
  1899447441,
  -1245643825,
  -373957723,
  961987163,
  1508970993,
  -1841331548,
  -1424204075,
  -670586216,
  310598401,
  607225278,
  1426881987,
  1925078388,
  -2132889090,
  -1680079193,
  -1046744716,
  -459576895,
  -272742522,
  264347078,
  604807628,
  770255983,
  1249150122,
  1555081692,
  1996064986,
  -1740746414,
  -1473132947,
  -1341970488,
  -1084653625,
  -958395405,
  -710438585,
  113926993,
  338241895,
  666307205,
  773529912,
  1294757372,
  1396182291,
  1695183700,
  1986661051,
  -2117940946,
  -1838011259,
  -1564481375,
  -1474664885,
  -1035236496,
  -949202525,
  -778901479,
  -694614492,
  -200395387,
  275423344,
  430227734,
  506948616,
  659060556,
  883997877,
  958139571,
  1322822218,
  1537002063,
  1747873779,
  1955562222,
  2024104815,
  -2067236844,
  -1933114872,
  -1866530822,
  -1538233109,
  -1090935817,
  -965641998
];
const W = [];
class SHA256 extends Hasher {
  constructor() {
    super(...arguments);
    __publicField$3(this, "_hash", new WordArray([...H]));
  }
  /**
   * Resets the internal state of the hash object to initial values.
   */
  reset() {
    super.reset();
    this._hash = new WordArray([...H]);
  }
  _doProcessBlock(M, offset) {
    const H2 = this._hash.words;
    let a = H2[0];
    let b = H2[1];
    let c = H2[2];
    let d = H2[3];
    let e = H2[4];
    let f = H2[5];
    let g = H2[6];
    let h = H2[7];
    for (let i = 0; i < 64; i++) {
      if (i < 16) {
        W[i] = M[offset + i] | 0;
      } else {
        const gamma0x = W[i - 15];
        const gamma0 = (gamma0x << 25 | gamma0x >>> 7) ^ (gamma0x << 14 | gamma0x >>> 18) ^ gamma0x >>> 3;
        const gamma1x = W[i - 2];
        const gamma1 = (gamma1x << 15 | gamma1x >>> 17) ^ (gamma1x << 13 | gamma1x >>> 19) ^ gamma1x >>> 10;
        W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16];
      }
      const ch = e & f ^ ~e & g;
      const maj = a & b ^ a & c ^ b & c;
      const sigma0 = (a << 30 | a >>> 2) ^ (a << 19 | a >>> 13) ^ (a << 10 | a >>> 22);
      const sigma1 = (e << 26 | e >>> 6) ^ (e << 21 | e >>> 11) ^ (e << 7 | e >>> 25);
      const t1 = h + sigma1 + ch + K[i] + W[i];
      const t2 = sigma0 + maj;
      h = g;
      g = f;
      f = e;
      e = d + t1 | 0;
      d = c;
      c = b;
      b = a;
      a = t1 + t2 | 0;
    }
    H2[0] = H2[0] + a | 0;
    H2[1] = H2[1] + b | 0;
    H2[2] = H2[2] + c | 0;
    H2[3] = H2[3] + d | 0;
    H2[4] = H2[4] + e | 0;
    H2[5] = H2[5] + f | 0;
    H2[6] = H2[6] + g | 0;
    H2[7] = H2[7] + h | 0;
  }
  /**
   * Finishes the hash calculation and returns the hash as a WordArray.
   *
   * @param {string} messageUpdate - Additional message content to include in the hash.
   * @returns {WordArray} The finalised hash as a WordArray.
   */
  finalize(messageUpdate) {
    super.finalize(messageUpdate);
    const nBitsTotal = this._nDataBytes * 8;
    const nBitsLeft = this._data.sigBytes * 8;
    this._data.words[nBitsLeft >>> 5] |= 128 << 24 - nBitsLeft % 32;
    this._data.words[(nBitsLeft + 64 >>> 9 << 4) + 14] = Math.floor(
      nBitsTotal / 4294967296
    );
    this._data.words[(nBitsLeft + 64 >>> 9 << 4) + 15] = nBitsTotal;
    this._data.sigBytes = this._data.words.length * 4;
    this._process();
    return this._hash;
  }
}
function sha256base64(message) {
  return new SHA256().finalize(message).toString(Base64);
}

function hash(object, options = {}) {
  const hashed = typeof object === "string" ? object : objectHash(object, options);
  return sha256base64(hashed).slice(0, 10);
}

function isEqual(object1, object2, hashOptions = {}) {
  if (object1 === object2) {
    return true;
  }
  if (objectHash(object1, hashOptions) === objectHash(object2, hashOptions)) {
    return true;
  }
  return false;
}

const NODE_TYPES = {
  NORMAL: 0,
  WILDCARD: 1,
  PLACEHOLDER: 2
};

function createRouter$1(options = {}) {
  const ctx = {
    options,
    rootNode: createRadixNode(),
    staticRoutesMap: {}
  };
  const normalizeTrailingSlash = (p) => options.strictTrailingSlash ? p : p.replace(/\/$/, "") || "/";
  if (options.routes) {
    for (const path in options.routes) {
      insert(ctx, normalizeTrailingSlash(path), options.routes[path]);
    }
  }
  return {
    ctx,
    lookup: (path) => lookup(ctx, normalizeTrailingSlash(path)),
    insert: (path, data) => insert(ctx, normalizeTrailingSlash(path), data),
    remove: (path) => remove(ctx, normalizeTrailingSlash(path))
  };
}
function lookup(ctx, path) {
  const staticPathNode = ctx.staticRoutesMap[path];
  if (staticPathNode) {
    return staticPathNode.data;
  }
  const sections = path.split("/");
  const params = {};
  let paramsFound = false;
  let wildcardNode = null;
  let node = ctx.rootNode;
  let wildCardParam = null;
  for (let i = 0; i < sections.length; i++) {
    const section = sections[i];
    if (node.wildcardChildNode !== null) {
      wildcardNode = node.wildcardChildNode;
      wildCardParam = sections.slice(i).join("/");
    }
    const nextNode = node.children.get(section);
    if (nextNode === undefined) {
      if (node && node.placeholderChildren.length > 1) {
        const remaining = sections.length - i;
        node = node.placeholderChildren.find((c) => c.maxDepth === remaining) || null;
      } else {
        node = node.placeholderChildren[0] || null;
      }
      if (!node) {
        break;
      }
      if (node.paramName) {
        params[node.paramName] = section;
      }
      paramsFound = true;
    } else {
      node = nextNode;
    }
  }
  if ((node === null || node.data === null) && wildcardNode !== null) {
    node = wildcardNode;
    params[node.paramName || "_"] = wildCardParam;
    paramsFound = true;
  }
  if (!node) {
    return null;
  }
  if (paramsFound) {
    return {
      ...node.data,
      params: paramsFound ? params : undefined
    };
  }
  return node.data;
}
function insert(ctx, path, data) {
  let isStaticRoute = true;
  const sections = path.split("/");
  let node = ctx.rootNode;
  let _unnamedPlaceholderCtr = 0;
  const matchedNodes = [node];
  for (const section of sections) {
    let childNode;
    if (childNode = node.children.get(section)) {
      node = childNode;
    } else {
      const type = getNodeType(section);
      childNode = createRadixNode({ type, parent: node });
      node.children.set(section, childNode);
      if (type === NODE_TYPES.PLACEHOLDER) {
        childNode.paramName = section === "*" ? `_${_unnamedPlaceholderCtr++}` : section.slice(1);
        node.placeholderChildren.push(childNode);
        isStaticRoute = false;
      } else if (type === NODE_TYPES.WILDCARD) {
        node.wildcardChildNode = childNode;
        childNode.paramName = section.slice(
          3
          /* "**:" */
        ) || "_";
        isStaticRoute = false;
      }
      matchedNodes.push(childNode);
      node = childNode;
    }
  }
  for (const [depth, node2] of matchedNodes.entries()) {
    node2.maxDepth = Math.max(matchedNodes.length - depth, node2.maxDepth || 0);
  }
  node.data = data;
  if (isStaticRoute === true) {
    ctx.staticRoutesMap[path] = node;
  }
  return node;
}
function remove(ctx, path) {
  let success = false;
  const sections = path.split("/");
  let node = ctx.rootNode;
  for (const section of sections) {
    node = node.children.get(section);
    if (!node) {
      return success;
    }
  }
  if (node.data) {
    const lastSection = sections.at(-1) || "";
    node.data = null;
    if (Object.keys(node.children).length === 0 && node.parent) {
      node.parent.children.delete(lastSection);
      node.parent.wildcardChildNode = null;
      node.parent.placeholderChildren = [];
    }
    success = true;
  }
  return success;
}
function createRadixNode(options = {}) {
  return {
    type: options.type || NODE_TYPES.NORMAL,
    maxDepth: 0,
    parent: options.parent || null,
    children: /* @__PURE__ */ new Map(),
    data: options.data || null,
    paramName: options.paramName || null,
    wildcardChildNode: null,
    placeholderChildren: []
  };
}
function getNodeType(str) {
  if (str.startsWith("**")) {
    return NODE_TYPES.WILDCARD;
  }
  if (str[0] === ":" || str === "*") {
    return NODE_TYPES.PLACEHOLDER;
  }
  return NODE_TYPES.NORMAL;
}

function toRouteMatcher(router) {
  const table = _routerNodeToTable("", router.ctx.rootNode);
  return _createMatcher(table, router.ctx.options.strictTrailingSlash);
}
function _createMatcher(table, strictTrailingSlash) {
  return {
    ctx: { table },
    matchAll: (path) => _matchRoutes(path, table, strictTrailingSlash)
  };
}
function _createRouteTable() {
  return {
    static: /* @__PURE__ */ new Map(),
    wildcard: /* @__PURE__ */ new Map(),
    dynamic: /* @__PURE__ */ new Map()
  };
}
function _matchRoutes(path, table, strictTrailingSlash) {
  if (strictTrailingSlash !== true && path.endsWith("/")) {
    path = path.slice(0, -1) || "/";
  }
  const matches = [];
  for (const [key, value] of _sortRoutesMap(table.wildcard)) {
    if (path === key || path.startsWith(key + "/")) {
      matches.push(value);
    }
  }
  for (const [key, value] of _sortRoutesMap(table.dynamic)) {
    if (path.startsWith(key + "/")) {
      const subPath = "/" + path.slice(key.length).split("/").splice(2).join("/");
      matches.push(..._matchRoutes(subPath, value));
    }
  }
  const staticMatch = table.static.get(path);
  if (staticMatch) {
    matches.push(staticMatch);
  }
  return matches.filter(Boolean);
}
function _sortRoutesMap(m) {
  return [...m.entries()].sort((a, b) => a[0].length - b[0].length);
}
function _routerNodeToTable(initialPath, initialNode) {
  const table = _createRouteTable();
  function _addNode(path, node) {
    if (path) {
      if (node.type === NODE_TYPES.NORMAL && !(path.includes("*") || path.includes(":"))) {
        if (node.data) {
          table.static.set(path, node.data);
        }
      } else if (node.type === NODE_TYPES.WILDCARD) {
        table.wildcard.set(path.replace("/**", ""), node.data);
      } else if (node.type === NODE_TYPES.PLACEHOLDER) {
        const subTable = _routerNodeToTable("", node);
        if (node.data) {
          subTable.static.set("/", node.data);
        }
        table.dynamic.set(path.replace(/\/\*|\/:\w+/, ""), subTable);
        return;
      }
    }
    for (const [childPath, child] of node.children.entries()) {
      _addNode(`${path}/${childPath}`.replace("//", "/"), child);
    }
  }
  _addNode(initialPath, initialNode);
  return table;
}

function isPlainObject(value) {
  if (value === null || typeof value !== "object") {
    return false;
  }
  const prototype = Object.getPrototypeOf(value);
  if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) {
    return false;
  }
  if (Symbol.iterator in value) {
    return false;
  }
  if (Symbol.toStringTag in value) {
    return Object.prototype.toString.call(value) === "[object Module]";
  }
  return true;
}

function _defu(baseObject, defaults, namespace = ".", merger) {
  if (!isPlainObject(defaults)) {
    return _defu(baseObject, {}, namespace, merger);
  }
  const object = Object.assign({}, defaults);
  for (const key in baseObject) {
    if (key === "__proto__" || key === "constructor") {
      continue;
    }
    const value = baseObject[key];
    if (value === null || value === undefined) {
      continue;
    }
    if (merger && merger(object, key, value, namespace)) {
      continue;
    }
    if (Array.isArray(value) && Array.isArray(object[key])) {
      object[key] = [...value, ...object[key]];
    } else if (isPlainObject(value) && isPlainObject(object[key])) {
      object[key] = _defu(
        value,
        object[key],
        (namespace ? `${namespace}.` : "") + key.toString(),
        merger
      );
    } else {
      object[key] = value;
    }
  }
  return object;
}
function createDefu(merger) {
  return (...arguments_) => (
    // eslint-disable-next-line unicorn/no-array-reduce
    arguments_.reduce((p, c) => _defu(p, c, "", merger), {})
  );
}
const defu = createDefu();
const defuFn = createDefu((object, key, currentValue) => {
  if (object[key] !== undefined && typeof currentValue === "function") {
    object[key] = currentValue(object[key]);
    return true;
  }
});

function rawHeaders(headers) {
  const rawHeaders2 = [];
  for (const key in headers) {
    if (Array.isArray(headers[key])) {
      for (const h of headers[key]) {
        rawHeaders2.push(key, h);
      }
    } else {
      rawHeaders2.push(key, headers[key]);
    }
  }
  return rawHeaders2;
}
function mergeFns(...functions) {
  return function(...args) {
    for (const fn of functions) {
      fn(...args);
    }
  };
}
function createNotImplementedError(name) {
  throw new Error(`[unenv] ${name} is not implemented yet!`);
}

let defaultMaxListeners = 10;
let EventEmitter$1 = class EventEmitter {
  __unenv__ = true;
  _events = /* @__PURE__ */ Object.create(null);
  _maxListeners;
  static get defaultMaxListeners() {
    return defaultMaxListeners;
  }
  static set defaultMaxListeners(arg) {
    if (typeof arg !== "number" || arg < 0 || Number.isNaN(arg)) {
      throw new RangeError(
        'The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + "."
      );
    }
    defaultMaxListeners = arg;
  }
  setMaxListeners(n) {
    if (typeof n !== "number" || n < 0 || Number.isNaN(n)) {
      throw new RangeError(
        'The value of "n" is out of range. It must be a non-negative number. Received ' + n + "."
      );
    }
    this._maxListeners = n;
    return this;
  }
  getMaxListeners() {
    return _getMaxListeners(this);
  }
  emit(type, ...args) {
    if (!this._events[type] || this._events[type].length === 0) {
      return false;
    }
    if (type === "error") {
      let er;
      if (args.length > 0) {
        er = args[0];
      }
      if (er instanceof Error) {
        throw er;
      }
      const err = new Error(
        "Unhandled error." + (er ? " (" + er.message + ")" : "")
      );
      err.context = er;
      throw err;
    }
    for (const _listener of this._events[type]) {
      (_listener.listener || _listener).apply(this, args);
    }
    return true;
  }
  addListener(type, listener) {
    return _addListener(this, type, listener, false);
  }
  on(type, listener) {
    return _addListener(this, type, listener, false);
  }
  prependListener(type, listener) {
    return _addListener(this, type, listener, true);
  }
  once(type, listener) {
    return this.on(type, _wrapOnce(this, type, listener));
  }
  prependOnceListener(type, listener) {
    return this.prependListener(type, _wrapOnce(this, type, listener));
  }
  removeListener(type, listener) {
    return _removeListener(this, type, listener);
  }
  off(type, listener) {
    return this.removeListener(type, listener);
  }
  removeAllListeners(type) {
    return _removeAllListeners(this, type);
  }
  listeners(type) {
    return _listeners(this, type, true);
  }
  rawListeners(type) {
    return _listeners(this, type, false);
  }
  listenerCount(type) {
    return this.rawListeners(type).length;
  }
  eventNames() {
    return Object.keys(this._events);
  }
};
function _addListener(target, type, listener, prepend) {
  _checkListener(listener);
  if (target._events.newListener !== undefined) {
    target.emit("newListener", type, listener.listener || listener);
  }
  if (!target._events[type]) {
    target._events[type] = [];
  }
  if (prepend) {
    target._events[type].unshift(listener);
  } else {
    target._events[type].push(listener);
  }
  const maxListeners = _getMaxListeners(target);
  if (maxListeners > 0 && target._events[type].length > maxListeners && !target._events[type].warned) {
    target._events[type].warned = true;
    const warning = new Error(
      `[unenv] Possible EventEmitter memory leak detected. ${target._events[type].length} ${type} listeners added. Use emitter.setMaxListeners() to increase limit`
    );
    warning.name = "MaxListenersExceededWarning";
    warning.emitter = target;
    warning.type = type;
    warning.count = target._events[type]?.length;
    console.warn(warning);
  }
  return target;
}
function _removeListener(target, type, listener) {
  _checkListener(listener);
  if (!target._events[type] || target._events[type].length === 0) {
    return target;
  }
  const lenBeforeFilter = target._events[type].length;
  target._events[type] = target._events[type].filter((fn) => fn !== listener);
  if (lenBeforeFilter === target._events[type].length) {
    return target;
  }
  if (target._events.removeListener) {
    target.emit("removeListener", type, listener.listener || listener);
  }
  if (target._events[type].length === 0) {
    delete target._events[type];
  }
  return target;
}
function _removeAllListeners(target, type) {
  if (!target._events[type] || target._events[type].length === 0) {
    return target;
  }
  if (target._events.removeListener) {
    for (const _listener of target._events[type]) {
      target.emit("removeListener", type, _listener.listener || _listener);
    }
  }
  delete target._events[type];
  return target;
}
function _wrapOnce(target, type, listener) {
  let fired = false;
  const wrapper = (...args) => {
    if (fired) {
      return;
    }
    target.removeListener(type, wrapper);
    fired = true;
    return args.length === 0 ? listener.call(target) : listener.apply(target, args);
  };
  wrapper.listener = listener;
  return wrapper;
}
function _getMaxListeners(target) {
  return target._maxListeners ?? EventEmitter$1.defaultMaxListeners;
}
function _listeners(target, type, unwrap) {
  let listeners = target._events[type];
  if (typeof listeners === "function") {
    listeners = [listeners];
  }
  return unwrap ? listeners.map((l) => l.listener || l) : listeners;
}
function _checkListener(listener) {
  if (typeof listener !== "function") {
    throw new TypeError(
      'The "listener" argument must be of type Function. Received type ' + typeof listener
    );
  }
}

const EventEmitter = globalThis.EventEmitter || EventEmitter$1;

class _Readable extends EventEmitter {
  __unenv__ = true;
  readableEncoding = null;
  readableEnded = true;
  readableFlowing = false;
  readableHighWaterMark = 0;
  readableLength = 0;
  readableObjectMode = false;
  readableAborted = false;
  readableDidRead = false;
  closed = false;
  errored = null;
  readable = false;
  destroyed = false;
  static from(_iterable, options) {
    return new _Readable(options);
  }
  constructor(_opts) {
    super();
  }
  _read(_size) {
  }
  read(_size) {
  }
  setEncoding(_encoding) {
    return this;
  }
  pause() {
    return this;
  }
  resume() {
    return this;
  }
  isPaused() {
    return true;
  }
  unpipe(_destination) {
    return this;
  }
  unshift(_chunk, _encoding) {
  }
  wrap(_oldStream) {
    return this;
  }
  push(_chunk, _encoding) {
    return false;
  }
  _destroy(_error, _callback) {
    this.removeAllListeners();
  }
  destroy(error) {
    this.destroyed = true;
    this._destroy(error);
    return this;
  }
  pipe(_destenition, _options) {
    return {};
  }
  compose(stream, options) {
    throw new Error("[unenv] Method not implemented.");
  }
  [Symbol.asyncDispose]() {
    this.destroy();
    return Promise.resolve();
  }
  // eslint-disable-next-line require-yield
  async *[Symbol.asyncIterator]() {
    throw createNotImplementedError("Readable.asyncIterator");
  }
  iterator(options) {
    throw createNotImplementedError("Readable.iterator");
  }
  map(fn, options) {
    throw createNotImplementedError("Readable.map");
  }
  filter(fn, options) {
    throw createNotImplementedError("Readable.filter");
  }
  forEach(fn, options) {
    throw createNotImplementedError("Readable.forEach");
  }
  reduce(fn, initialValue, options) {
    throw createNotImplementedError("Readable.reduce");
  }
  find(fn, options) {
    throw createNotImplementedError("Readable.find");
  }
  findIndex(fn, options) {
    throw createNotImplementedError("Readable.findIndex");
  }
  some(fn, options) {
    throw createNotImplementedError("Readable.some");
  }
  toArray(options) {
    throw createNotImplementedError("Readable.toArray");
  }
  every(fn, options) {
    throw createNotImplementedError("Readable.every");
  }
  flatMap(fn, options) {
    throw createNotImplementedError("Readable.flatMap");
  }
  drop(limit, options) {
    throw createNotImplementedError("Readable.drop");
  }
  take(limit, options) {
    throw createNotImplementedError("Readable.take");
  }
  asIndexedPairs(options) {
    throw createNotImplementedError("Readable.asIndexedPairs");
  }
}
const Readable = globalThis.Readable || _Readable;

class _Writable extends EventEmitter {
  __unenv__ = true;
  writable = true;
  writableEnded = false;
  writableFinished = false;
  writableHighWaterMark = 0;
  writableLength = 0;
  writableObjectMode = false;
  writableCorked = 0;
  closed = false;
  errored = null;
  writableNeedDrain = false;
  destroyed = false;
  _data;
  _encoding = "utf-8";
  constructor(_opts) {
    super();
  }
  pipe(_destenition, _options) {
    return {};
  }
  _write(chunk, encoding, callback) {
    if (this.writableEnded) {
      if (callback) {
        callback();
      }
      return;
    }
    if (this._data === undefined) {
      this._data = chunk;
    } else {
      const a = typeof this._data === "string" ? Buffer.from(this._data, this._encoding || encoding || "utf8") : this._data;
      const b = typeof chunk === "string" ? Buffer.from(chunk, encoding || this._encoding || "utf8") : chunk;
      this._data = Buffer.concat([a, b]);
    }
    this._encoding = encoding;
    if (callback) {
      callback();
    }
  }
  _writev(_chunks, _callback) {
  }
  _destroy(_error, _callback) {
  }
  _final(_callback) {
  }
  write(chunk, arg2, arg3) {
    const encoding = typeof arg2 === "string" ? this._encoding : "utf-8";
    const cb = typeof arg2 === "function" ? arg2 : typeof arg3 === "function" ? arg3 : undefined;
    this._write(chunk, encoding, cb);
    return true;
  }
  setDefaultEncoding(_encoding) {
    return this;
  }
  end(arg1, arg2, arg3) {
    const callback = typeof arg1 === "function" ? arg1 : typeof arg2 === "function" ? arg2 : typeof arg3 === "function" ? arg3 : undefined;
    if (this.writableEnded) {
      if (callback) {
        callback();
      }
      return this;
    }
    const data = arg1 === callback ? undefined : arg1;
    if (data) {
      const encoding = arg2 === callback ? undefined : arg2;
      this.write(data, encoding, callback);
    }
    this.writableEnded = true;
    this.writableFinished = true;
    this.emit("close");
    this.emit("finish");
    return this;
  }
  cork() {
  }
  uncork() {
  }
  destroy(_error) {
    this.destroyed = true;
    delete this._data;
    this.removeAllListeners();
    return this;
  }
  compose(stream, options) {
    throw new Error("[h3] Method not implemented.");
  }
}
const Writable = globalThis.Writable || _Writable;

const __Duplex = class {
  allowHalfOpen = true;
  _destroy;
  constructor(readable = new Readable(), writable = new Writable()) {
    Object.assign(this, readable);
    Object.assign(this, writable);
    this._destroy = mergeFns(readable._destroy, writable._destroy);
  }
};
function getDuplex() {
  Object.assign(__Duplex.prototype, Readable.prototype);
  Object.assign(__Duplex.prototype, Writable.prototype);
  return __Duplex;
}
const _Duplex = /* @__PURE__ */ getDuplex();
const Duplex = globalThis.Duplex || _Duplex;

class Socket extends Duplex {
  __unenv__ = true;
  bufferSize = 0;
  bytesRead = 0;
  bytesWritten = 0;
  connecting = false;
  destroyed = false;
  pending = false;
  localAddress = "";
  localPort = 0;
  remoteAddress = "";
  remoteFamily = "";
  remotePort = 0;
  autoSelectFamilyAttemptedAddresses = [];
  readyState = "readOnly";
  constructor(_options) {
    super();
  }
  write(_buffer, _arg1, _arg2) {
    return false;
  }
  connect(_arg1, _arg2, _arg3) {
    return this;
  }
  end(_arg1, _arg2, _arg3) {
    return this;
  }
  setEncoding(_encoding) {
    return this;
  }
  pause() {
    return this;
  }
  resume() {
    return this;
  }
  setTimeout(_timeout, _callback) {
    return this;
  }
  setNoDelay(_noDelay) {
    return this;
  }
  setKeepAlive(_enable, _initialDelay) {
    return this;
  }
  address() {
    return {};
  }
  unref() {
    return this;
  }
  ref() {
    return this;
  }
  destroySoon() {
    this.destroy();
  }
  resetAndDestroy() {
    const err = new Error("ERR_SOCKET_CLOSED");
    err.code = "ERR_SOCKET_CLOSED";
    this.destroy(err);
    return this;
  }
}

class IncomingMessage extends Readable {
  __unenv__ = {};
  aborted = false;
  httpVersion = "1.1";
  httpVersionMajor = 1;
  httpVersionMinor = 1;
  complete = true;
  connection;
  socket;
  headers = {};
  trailers = {};
  method = "GET";
  url = "/";
  statusCode = 200;
  statusMessage = "";
  closed = false;
  errored = null;
  readable = false;
  constructor(socket) {
    super();
    this.socket = this.connection = socket || new Socket();
  }
  get rawHeaders() {
    return rawHeaders(this.headers);
  }
  get rawTrailers() {
    return [];
  }
  setTimeout(_msecs, _callback) {
    return this;
  }
  get headersDistinct() {
    return _distinct(this.headers);
  }
  get trailersDistinct() {
    return _distinct(this.trailers);
  }
}
function _distinct(obj) {
  const d = {};
  for (const [key, value] of Object.entries(obj)) {
    if (key) {
      d[key] = (Array.isArray(value) ? value : [value]).filter(
        Boolean
      );
    }
  }
  return d;
}

class ServerResponse extends Writable {
  __unenv__ = true;
  statusCode = 200;
  statusMessage = "";
  upgrading = false;
  chunkedEncoding = false;
  shouldKeepAlive = false;
  useChunkedEncodingByDefault = false;
  sendDate = false;
  finished = false;
  headersSent = false;
  strictContentLength = false;
  connection = null;
  socket = null;
  req;
  _headers = {};
  constructor(req) {
    super();
    this.req = req;
  }
  assignSocket(socket) {
    socket._httpMessage = this;
    this.socket = socket;
    this.connection = socket;
    this.emit("socket", socket);
    this._flush();
  }
  _flush() {
    this.flushHeaders();
  }
  detachSocket(_socket) {
  }
  writeContinue(_callback) {
  }
  writeHead(statusCode, arg1, arg2) {
    if (statusCode) {
      this.statusCode = statusCode;
    }
    if (typeof arg1 === "string") {
      this.statusMessage = arg1;
      arg1 = undefined;
    }
    const headers = arg2 || arg1;
    if (headers) {
      if (Array.isArray(headers)) ; else {
        for (const key in headers) {
          this.setHeader(key, headers[key]);
        }
      }
    }
    this.headersSent = true;
    return this;
  }
  writeProcessing() {
  }
  setTimeout(_msecs, _callback) {
    return this;
  }
  appendHeader(name, value) {
    name = name.toLowerCase();
    const current = this._headers[name];
    const all = [
      ...Array.isArray(current) ? current : [current],
      ...Array.isArray(value) ? value : [value]
    ].filter(Boolean);
    this._headers[name] = all.length > 1 ? all : all[0];
    return this;
  }
  setHeader(name, value) {
    this._headers[name.toLowerCase()] = value;
    return this;
  }
  getHeader(name) {
    return this._headers[name.toLowerCase()];
  }
  getHeaders() {
    return this._headers;
  }
  getHeaderNames() {
    return Object.keys(this._headers);
  }
  hasHeader(name) {
    return name.toLowerCase() in this._headers;
  }
  removeHeader(name) {
    delete this._headers[name.toLowerCase()];
  }
  addTrailers(_headers) {
  }
  flushHeaders() {
  }
  writeEarlyHints(_headers, cb) {
    if (typeof cb === "function") {
      cb();
    }
  }
}

function hasProp(obj, prop) {
  try {
    return prop in obj;
  } catch {
    return false;
  }
}

var __defProp$2 = Object.defineProperty;
var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __publicField$2 = (obj, key, value) => {
  __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
  return value;
};
class H3Error extends Error {
  constructor(message, opts = {}) {
    super(message, opts);
    __publicField$2(this, "statusCode", 500);
    __publicField$2(this, "fatal", false);
    __publicField$2(this, "unhandled", false);
    __publicField$2(this, "statusMessage");
    __publicField$2(this, "data");
    __publicField$2(this, "cause");
    if (opts.cause && !this.cause) {
      this.cause = opts.cause;
    }
  }
  toJSON() {
    const obj = {
      message: this.message,
      statusCode: sanitizeStatusCode(this.statusCode, 500)
    };
    if (this.statusMessage) {
      obj.statusMessage = sanitizeStatusMessage(this.statusMessage);
    }
    if (this.data !== undefined) {
      obj.data = this.data;
    }
    return obj;
  }
}
__publicField$2(H3Error, "__h3_error__", true);
function createError$1(input) {
  if (typeof input === "string") {
    return new H3Error(input);
  }
  if (isError(input)) {
    return input;
  }
  const err = new H3Error(input.message ?? input.statusMessage ?? "", {
    cause: input.cause || input
  });
  if (hasProp(input, "stack")) {
    try {
      Object.defineProperty(err, "stack", {
        get() {
          return input.stack;
        }
      });
    } catch {
      try {
        err.stack = input.stack;
      } catch {
      }
    }
  }
  if (input.data) {
    err.data = input.data;
  }
  if (input.statusCode) {
    err.statusCode = sanitizeStatusCode(input.statusCode, err.statusCode);
  } else if (input.status) {
    err.statusCode = sanitizeStatusCode(input.status, err.statusCode);
  }
  if (input.statusMessage) {
    err.statusMessage = input.statusMessage;
  } else if (input.statusText) {
    err.statusMessage = input.statusText;
  }
  if (err.statusMessage) {
    const originalMessage = err.statusMessage;
    const sanitizedMessage = sanitizeStatusMessage(err.statusMessage);
    if (sanitizedMessage !== originalMessage) {
      console.warn(
        "[h3] Please prefer using `message` for longer error messages instead of `statusMessage`. In the future, `statusMessage` will be sanitized by default."
      );
    }
  }
  if (input.fatal !== undefined) {
    err.fatal = input.fatal;
  }
  if (input.unhandled !== undefined) {
    err.unhandled = input.unhandled;
  }
  return err;
}
function sendError(event, error, debug) {
  if (event.handled) {
    return;
  }
  const h3Error = isError(error) ? error : createError$1(error);
  const responseBody = {
    statusCode: h3Error.statusCode,
    statusMessage: h3Error.statusMessage,
    stack: [],
    data: h3Error.data
  };
  if (debug) {
    responseBody.stack = (h3Error.stack || "").split("\n").map((l) => l.trim());
  }
  if (event.handled) {
    return;
  }
  const _code = Number.parseInt(h3Error.statusCode);
  setResponseStatus(event, _code, h3Error.statusMessage);
  event.node.res.setHeader("content-type", MIMES.json);
  event.node.res.end(JSON.stringify(responseBody, undefined, 2));
}
function isError(input) {
  return input?.constructor?.__h3_error__ === true;
}

function getQuery(event) {
  return getQuery$1(event.path || "");
}
function isMethod(event, expected, allowHead) {
  if (typeof expected === "string") {
    if (event.method === expected) {
      return true;
    }
  } else if (expected.includes(event.method)) {
    return true;
  }
  return false;
}
function assertMethod(event, expected, allowHead) {
  if (!isMethod(event, expected)) {
    throw createError$1({
      statusCode: 405,
      statusMessage: "HTTP method is not allowed."
    });
  }
}
function getRequestHeaders(event) {
  const _headers = {};
  for (const key in event.node.req.headers) {
    const val = event.node.req.headers[key];
    _headers[key] = Array.isArray(val) ? val.filter(Boolean).join(", ") : val;
  }
  return _headers;
}
function getRequestHeader(event, name) {
  const headers = getRequestHeaders(event);
  const value = headers[name.toLowerCase()];
  return value;
}
const getHeader = getRequestHeader;
function getRequestHost(event, opts = {}) {
  if (opts.xForwardedHost) {
    const xForwardedHost = event.node.req.headers["x-forwarded-host"];
    if (xForwardedHost) {
      return xForwardedHost;
    }
  }
  return event.node.req.headers.host || "localhost";
}
function getRequestProtocol(event, opts = {}) {
  if (opts.xForwardedProto !== false && event.node.req.headers["x-forwarded-proto"] === "https") {
    return "https";
  }
  return event.node.req.connection?.encrypted ? "https" : "http";
}

const RawBodySymbol = Symbol.for("h3RawBody");
const PayloadMethods$1 = ["PATCH", "POST", "PUT", "DELETE"];
function readRawBody(event, encoding = "utf8") {
  assertMethod(event, PayloadMethods$1);
  const _rawBody = event._requestBody || event.web?.request?.body || event.node.req[RawBodySymbol] || event.node.req.rawBody || event.node.req.body;
  if (_rawBody) {
    const promise2 = Promise.resolve(_rawBody).then((_resolved) => {
      if (Buffer.isBuffer(_resolved)) {
        return _resolved;
      }
      if (typeof _resolved.pipeTo === "function") {
        return new Promise((resolve, reject) => {
          const chunks = [];
          _resolved.pipeTo(
            new WritableStream({
              write(chunk) {
                chunks.push(chunk);
              },
              close() {
                resolve(Buffer.concat(chunks));
              },
              abort(reason) {
                reject(reason);
              }
            })
          ).catch(reject);
        });
      } else if (typeof _resolved.pipe === "function") {
        return new Promise((resolve, reject) => {
          const chunks = [];
          _resolved.on("data", (chunk) => {
            chunks.push(chunk);
          }).on("end", () => {
            resolve(Buffer.concat(chunks));
          }).on("error", reject);
        });
      }
      if (_resolved.constructor === Object) {
        return Buffer.from(JSON.stringify(_resolved));
      }
      if (_resolved instanceof URLSearchParams) {
        return Buffer.from(_resolved.toString());
      }
      return Buffer.from(_resolved);
    });
    return encoding ? promise2.then((buff) => buff.toString(encoding)) : promise2;
  }
  if (!Number.parseInt(event.node.req.headers["content-length"] || "") && !String(event.node.req.headers["transfer-encoding"] ?? "").split(",").map((e) => e.trim()).filter(Boolean).includes("chunked")) {
    return Promise.resolve(undefined);
  }
  const promise = event.node.req[RawBodySymbol] = new Promise(
    (resolve, reject) => {
      const bodyData = [];
      event.node.req.on("error", (err) => {
        reject(err);
      }).on("data", (chunk) => {
        bodyData.push(chunk);
      }).on("end", () => {
        resolve(Buffer.concat(bodyData));
      });
    }
  );
  const result = encoding ? promise.then((buff) => buff.toString(encoding)) : promise;
  return result;
}
function getRequestWebStream(event) {
  if (!PayloadMethods$1.includes(event.method)) {
    return;
  }
  const bodyStream = event.web?.request?.body || event._requestBody;
  if (bodyStream) {
    return bodyStream;
  }
  const _hasRawBody = RawBodySymbol in event.node.req || "rawBody" in event.node.req || "body" in event.node.req || "__unenv__" in event.node.req;
  if (_hasRawBody) {
    return new ReadableStream({
      async start(controller) {
        const _rawBody = await readRawBody(event, false);
        if (_rawBody) {
          controller.enqueue(_rawBody);
        }
        controller.close();
      }
    });
  }
  return new ReadableStream({
    start: (controller) => {
      event.node.req.on("data", (chunk) => {
        controller.enqueue(chunk);
      });
      event.node.req.on("end", () => {
        controller.close();
      });
      event.node.req.on("error", (err) => {
        controller.error(err);
      });
    }
  });
}

function handleCacheHeaders(event, opts) {
  const cacheControls = ["public", ...opts.cacheControls || []];
  let cacheMatched = false;
  if (opts.maxAge !== undefined) {
    cacheControls.push(`max-age=${+opts.maxAge}`, `s-maxage=${+opts.maxAge}`);
  }
  if (opts.modifiedTime) {
    const modifiedTime = new Date(opts.modifiedTime);
    const ifModifiedSince = event.node.req.headers["if-modified-since"];
    event.node.res.setHeader("last-modified", modifiedTime.toUTCString());
    if (ifModifiedSince && new Date(ifModifiedSince) >= opts.modifiedTime) {
      cacheMatched = true;
    }
  }
  if (opts.etag) {
    event.node.res.setHeader("etag", opts.etag);
    const ifNonMatch = event.node.req.headers["if-none-match"];
    if (ifNonMatch === opts.etag) {
      cacheMatched = true;
    }
  }
  event.node.res.setHeader("cache-control", cacheControls.join(", "));
  if (cacheMatched) {
    event.node.res.statusCode = 304;
    if (!event.handled) {
      event.node.res.end();
    }
    return true;
  }
  return false;
}

const MIMES = {
  html: "text/html",
  json: "application/json"
};

const DISALLOWED_STATUS_CHARS = /[^\u0009\u0020-\u007E]/g;
function sanitizeStatusMessage(statusMessage = "") {
  return statusMessage.replace(DISALLOWED_STATUS_CHARS, "");
}
function sanitizeStatusCode(statusCode, defaultStatusCode = 200) {
  if (!statusCode) {
    return defaultStatusCode;
  }
  if (typeof statusCode === "string") {
    statusCode = Number.parseInt(statusCode, 10);
  }
  if (statusCode < 100 || statusCode > 999) {
    return defaultStatusCode;
  }
  return statusCode;
}

function parseCookies(event) {
  return parse(event.node.req.headers.cookie || "");
}
function getCookie(event, name) {
  return parseCookies(event)[name];
}
function setCookie(event, name, value, serializeOptions) {
  serializeOptions = { path: "/", ...serializeOptions };
  const cookieStr = serialize(name, value, serializeOptions);
  let setCookies = event.node.res.getHeader("set-cookie");
  if (!Array.isArray(setCookies)) {
    setCookies = [setCookies];
  }
  const _optionsHash = objectHash(serializeOptions);
  setCookies = setCookies.filter((cookieValue) => {
    return cookieValue && _optionsHash !== objectHash(parse(cookieValue));
  });
  event.node.res.setHeader("set-cookie", [...setCookies, cookieStr]);
}
function deleteCookie(event, name, serializeOptions) {
  setCookie(event, name, "", {
    ...serializeOptions,
    maxAge: 0
  });
}
function splitCookiesString(cookiesString) {
  if (Array.isArray(cookiesString)) {
    return cookiesString.flatMap((c) => splitCookiesString(c));
  }
  if (typeof cookiesString !== "string") {
    return [];
  }
  const cookiesStrings = [];
  let pos = 0;
  let start;
  let ch;
  let lastComma;
  let nextStart;
  let cookiesSeparatorFound;
  const skipWhitespace = () => {
    while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) {
      pos += 1;
    }
    return pos < cookiesString.length;
  };
  const notSpecialChar = () => {
    ch = cookiesString.charAt(pos);
    return ch !== "=" && ch !== ";" && ch !== ",";
  };
  while (pos < cookiesString.length) {
    start = pos;
    cookiesSeparatorFound = false;
    while (skipWhitespace()) {
      ch = cookiesString.charAt(pos);
      if (ch === ",") {
        lastComma = pos;
        pos += 1;
        skipWhitespace();
        nextStart = pos;
        while (pos < cookiesString.length && notSpecialChar()) {
          pos += 1;
        }
        if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
          cookiesSeparatorFound = true;
          pos = nextStart;
          cookiesStrings.push(cookiesString.slice(start, lastComma));
          start = pos;
        } else {
          pos = lastComma + 1;
        }
      } else {
        pos += 1;
      }
    }
    if (!cookiesSeparatorFound || pos >= cookiesString.length) {
      cookiesStrings.push(cookiesString.slice(start));
    }
  }
  return cookiesStrings;
}

const defer = typeof setImmediate === "undefined" ? (fn) => fn() : setImmediate;
function send(event, data, type) {
  if (type) {
    defaultContentType(event, type);
  }
  return new Promise((resolve) => {
    defer(() => {
      if (!event.handled) {
        event.node.res.end(data);
      }
      resolve();
    });
  });
}
function sendNoContent(event, code) {
  if (event.handled) {
    return;
  }
  if (!code && event.node.res.statusCode !== 200) {
    code = event.node.res.statusCode;
  }
  const _code = sanitizeStatusCode(code, 204);
  if (_code === 204) {
    event.node.res.removeHeader("content-length");
  }
  event.node.res.writeHead(_code);
  event.node.res.end();
}
function setResponseStatus(event, code, text) {
  if (code) {
    event.node.res.statusCode = sanitizeStatusCode(
      code,
      event.node.res.statusCode
    );
  }
  if (text) {
    event.node.res.statusMessage = sanitizeStatusMessage(text);
  }
}
function getResponseStatus(event) {
  return event.node.res.statusCode;
}
function getResponseStatusText(event) {
  return event.node.res.statusMessage;
}
function defaultContentType(event, type) {
  if (type && event.node.res.statusCode !== 304 && !event.node.res.getHeader("content-type")) {
    event.node.res.setHeader("content-type", type);
  }
}
function sendRedirect(event, location, code = 302) {
  event.node.res.statusCode = sanitizeStatusCode(
    code,
    event.node.res.statusCode
  );
  event.node.res.setHeader("location", location);
  const encodedLoc = location.replace(/"/g, "%22");
  const html = `<!DOCTYPE html><html><head><meta http-equiv="refresh" content="0; url=${encodedLoc}"></head></html>`;
  return send(event, html, MIMES.html);
}
function getResponseHeader(event, name) {
  return event.node.res.getHeader(name);
}
function setResponseHeaders(event, headers) {
  for (const [name, value] of Object.entries(headers)) {
    event.node.res.setHeader(
      name,
      value
    );
  }
}
const setHeaders = setResponseHeaders;
function setResponseHeader(event, name, value) {
  event.node.res.setHeader(name, value);
}
const setHeader = setResponseHeader;
function appendResponseHeader(event, name, value) {
  let current = event.node.res.getHeader(name);
  if (!current) {
    event.node.res.setHeader(name, value);
    return;
  }
  if (!Array.isArray(current)) {
    current = [current.toString()];
  }
  event.node.res.setHeader(name, [...current, value]);
}
function removeResponseHeader(event, name) {
  return event.node.res.removeHeader(name);
}
function isStream(data) {
  if (!data || typeof data !== "object") {
    return false;
  }
  if (typeof data.pipe === "function") {
    if (typeof data._read === "function") {
      return true;
    }
    if (typeof data.abort === "function") {
      return true;
    }
  }
  if (typeof data.pipeTo === "function") {
    return true;
  }
  return false;
}
function isWebResponse(data) {
  return typeof Response !== "undefined" && data instanceof Response;
}
function sendStream(event, stream) {
  if (!stream || typeof stream !== "object") {
    throw new Error("[h3] Invalid stream provided.");
  }
  event.node.res._data = stream;
  if (!event.node.res.socket) {
    event._handled = true;
    return Promise.resolve();
  }
  if (hasProp(stream, "pipeTo") && typeof stream.pipeTo === "function") {
    return stream.pipeTo(
      new WritableStream({
        write(chunk) {
          event.node.res.write(chunk);
        }
      })
    ).then(() => {
      event.node.res.end();
    });
  }
  if (hasProp(stream, "pipe") && typeof stream.pipe === "function") {
    return new Promise((resolve, reject) => {
      stream.pipe(event.node.res);
      if (stream.on) {
        stream.on("end", () => {
          event.node.res.end();
          resolve();
        });
        stream.on("error", (error) => {
          reject(error);
        });
      }
      event.node.res.on("close", () => {
        if (stream.abort) {
          stream.abort();
        }
      });
    });
  }
  throw new Error("[h3] Invalid or incompatible stream provided.");
}
function sendWebResponse(event, response) {
  for (const [key, value] of response.headers) {
    if (key === "set-cookie") {
      event.node.res.appendHeader(key, splitCookiesString(value));
    } else {
      event.node.res.setHeader(key, value);
    }
  }
  if (response.status) {
    event.node.res.statusCode = sanitizeStatusCode(
      response.status,
      event.node.res.statusCode
    );
  }
  if (response.statusText) {
    event.node.res.statusMessage = sanitizeStatusMessage(response.statusText);
  }
  if (response.redirected) {
    event.node.res.setHeader("location", response.url);
  }
  if (!response.body) {
    event.node.res.end();
    return;
  }
  return sendStream(event, response.body);
}

const PayloadMethods = /* @__PURE__ */ new Set(["PATCH", "POST", "PUT", "DELETE"]);
const ignoredHeaders = /* @__PURE__ */ new Set([
  "transfer-encoding",
  "connection",
  "keep-alive",
  "upgrade",
  "expect",
  "host",
  "accept"
]);
async function proxyRequest(event, target, opts = {}) {
  let body;
  let duplex;
  if (PayloadMethods.has(event.method)) {
    if (opts.streamRequest) {
      body = getRequestWebStream(event);
      duplex = "half";
    } else {
      body = await readRawBody(event, false).catch(() => undefined);
    }
  }
  const method = opts.fetchOptions?.method || event.method;
  const fetchHeaders = mergeHeaders$1(
    getProxyRequestHeaders(event),
    opts.fetchOptions?.headers,
    opts.headers
  );
  return sendProxy(event, target, {
    ...opts,
    fetchOptions: {
      method,
      body,
      duplex,
      ...opts.fetchOptions,
      headers: fetchHeaders
    }
  });
}
async function sendProxy(event, target, opts = {}) {
  let response;
  try {
    response = await _getFetch(opts.fetch)(target, {
      headers: opts.headers,
      ignoreResponseError: true,
      // make $ofetch.raw transparent
      ...opts.fetchOptions
    });
  } catch (error) {
    throw createError$1({
      status: 502,
      statusMessage: "Bad Gateway",
      cause: error
    });
  }
  event.node.res.statusCode = sanitizeStatusCode(
    response.status,
    event.node.res.statusCode
  );
  event.node.res.statusMessage = sanitizeStatusMessage(response.statusText);
  const cookies = [];
  for (const [key, value] of response.headers.entries()) {
    if (key === "content-encoding") {
      continue;
    }
    if (key === "content-length") {
      continue;
    }
    if (key === "set-cookie") {
      cookies.push(...splitCookiesString(value));
      continue;
    }
    event.node.res.setHeader(key, value);
  }
  if (cookies.length > 0) {
    event.node.res.setHeader(
      "set-cookie",
      cookies.map((cookie) => {
        if (opts.cookieDomainRewrite) {
          cookie = rewriteCookieProperty(
            cookie,
            opts.cookieDomainRewrite,
            "domain"
          );
        }
        if (opts.cookiePathRewrite) {
          cookie = rewriteCookieProperty(
            cookie,
            opts.cookiePathRewrite,
            "path"
          );
        }
        return cookie;
      })
    );
  }
  if (opts.onResponse) {
    await opts.onResponse(event, response);
  }
  if (response._data !== undefined) {
    return response._data;
  }
  if (event.handled) {
    return;
  }
  if (opts.sendStream === false) {
    const data = new Uint8Array(await response.arrayBuffer());
    return event.node.res.end(data);
  }
  if (response.body) {
    for await (const chunk of response.body) {
      event.node.res.write(chunk);
    }
  }
  return event.node.res.end();
}
function getProxyRequestHeaders(event) {
  const headers = /* @__PURE__ */ Object.create(null);
  const reqHeaders = getRequestHeaders(event);
  for (const name in reqHeaders) {
    if (!ignoredHeaders.has(name)) {
      headers[name] = reqHeaders[name];
    }
  }
  return headers;
}
function fetchWithEvent(event, req, init, options) {
  return _getFetch(options?.fetch)(req, {
    ...init,
    context: init?.context || event.context,
    headers: {
      ...getProxyRequestHeaders(event),
      ...init?.headers
    }
  });
}
function _getFetch(_fetch) {
  if (_fetch) {
    return _fetch;
  }
  if (globalThis.fetch) {
    return globalThis.fetch;
  }
  throw new Error(
    "fetch is not available. Try importing `node-fetch-native/polyfill` for Node.js."
  );
}
function rewriteCookieProperty(header, map, property) {
  const _map = typeof map === "string" ? { "*": map } : map;
  return header.replace(
    new RegExp(`(;\\s*${property}=)([^;]+)`, "gi"),
    (match, prefix, previousValue) => {
      let newValue;
      if (previousValue in _map) {
        newValue = _map[previousValue];
      } else if ("*" in _map) {
        newValue = _map["*"];
      } else {
        return match;
      }
      return newValue ? prefix + newValue : "";
    }
  );
}
function mergeHeaders$1(defaults, ...inputs) {
  const _inputs = inputs.filter(Boolean);
  if (_inputs.length === 0) {
    return defaults;
  }
  const merged = new Headers(defaults);
  for (const input of _inputs) {
    for (const [key, value] of Object.entries(input)) {
      if (value !== undefined) {
        merged.set(key, value);
      }
    }
  }
  return merged;
}

var __defProp = Object.defineProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __publicField = (obj, key, value) => {
  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
  return value;
};
class H3Event {
  constructor(req, res) {
    __publicField(this, "__is_event__", true);
    // Context
    __publicField(this, "node");
    // Node
    __publicField(this, "web");
    // Web
    __publicField(this, "context", {});
    // Shared
    // Request
    __publicField(this, "_method");
    __publicField(this, "_path");
    __publicField(this, "_headers");
    __publicField(this, "_requestBody");
    // Response
    __publicField(this, "_handled", false);
    // Hooks
    __publicField(this, "_onBeforeResponseCalled");
    __publicField(this, "_onAfterResponseCalled");
    this.node = { req, res };
  }
  // --- Request ---
  get method() {
    if (!this._method) {
      this._method = (this.node.req.method || "GET").toUpperCase();
    }
    return this._method;
  }
  get path() {
    return this._path || this.node.req.url || "/";
  }
  get headers() {
    if (!this._headers) {
      this._headers = _normalizeNodeHeaders(this.node.req.headers);
    }
    return this._headers;
  }
  // --- Respoonse ---
  get handled() {
    return this._handled || this.node.res.writableEnded || this.node.res.headersSent;
  }
  respondWith(response) {
    return Promise.resolve(response).then(
      (_response) => sendWebResponse(this, _response)
    );
  }
  // --- Utils ---
  toString() {
    return `[${this.method}] ${this.path}`;
  }
  toJSON() {
    return this.toString();
  }
  // --- Deprecated ---
  /** @deprecated Please use `event.node.req` instead. */
  get req() {
    return this.node.req;
  }
  /** @deprecated Please use `event.node.res` instead. */
  get res() {
    return this.node.res;
  }
}
function isEvent(input) {
  return hasProp(input, "__is_event__");
}
function createEvent(req, res) {
  return new H3Event(req, res);
}
function _normalizeNodeHeaders(nodeHeaders) {
  const headers = new Headers();
  for (const [name, value] of Object.entries(nodeHeaders)) {
    if (Array.isArray(value)) {
      for (const item of value) {
        headers.append(name, item);
      }
    } else if (value) {
      headers.set(name, value);
    }
  }
  return headers;
}

function defineEventHandler(handler) {
  if (typeof handler === "function") {
    handler.__is_handler__ = true;
    return handler;
  }
  const _hooks = {
    onRequest: _normalizeArray(handler.onRequest),
    onBeforeResponse: _normalizeArray(handler.onBeforeResponse)
  };
  const _handler = (event) => {
    return _callHandler(event, handler.handler, _hooks);
  };
  _handler.__is_handler__ = true;
  _handler.__resolve__ = handler.handler.__resolve__;
  _handler.__websocket__ = handler.websocket;
  return _handler;
}
function _normalizeArray(input) {
  return input ? Array.isArray(input) ? input : [input] : undefined;
}
async function _callHandler(event, handler, hooks) {
  if (hooks.onRequest) {
    for (const hook of hooks.onRequest) {
      await hook(event);
      if (event.handled) {
        return;
      }
    }
  }
  const body = await handler(event);
  const response = { body };
  if (hooks.onBeforeResponse) {
    for (const hook of hooks.onBeforeResponse) {
      await hook(event, response);
    }
  }
  return response.body;
}
const eventHandler = defineEventHandler;
function isEventHandler(input) {
  return hasProp(input, "__is_handler__");
}
function toEventHandler(input, _, _route) {
  if (!isEventHandler(input)) {
    console.warn(
      "[h3] Implicit event handler conversion is deprecated. Use `eventHandler()` or `fromNodeMiddleware()` to define event handlers.",
      _route && _route !== "/" ? `
     Route: ${_route}` : "",
      `
     Handler: ${input}`
    );
  }
  return input;
}
function defineLazyEventHandler(factory) {
  let _promise;
  let _resolved;
  const resolveHandler = () => {
    if (_resolved) {
      return Promise.resolve(_resolved);
    }
    if (!_promise) {
      _promise = Promise.resolve(factory()).then((r) => {
        const handler2 = r.default || r;
        if (typeof handler2 !== "function") {
          throw new TypeError(
            "Invalid lazy handler result. It should be a function:",
            handler2
          );
        }
        _resolved = { handler: toEventHandler(r.default || r) };
        return _resolved;
      });
    }
    return _promise;
  };
  const handler = eventHandler((event) => {
    if (_resolved) {
      return _resolved.handler(event);
    }
    return resolveHandler().then((r) => r.handler(event));
  });
  handler.__resolve__ = resolveHandler;
  return handler;
}
const lazyEventHandler = defineLazyEventHandler;

function createApp(options = {}) {
  const stack = [];
  const handler = createAppEventHandler(stack, options);
  const resolve = createResolver(stack);
  handler.__resolve__ = resolve;
  const getWebsocket = cachedFn(() => websocketOptions(resolve, options));
  const app = {
    // @ts-expect-error
    use: (arg1, arg2, arg3) => use(app, arg1, arg2, arg3),
    resolve,
    handler,
    stack,
    options,
    get websocket() {
      return getWebsocket();
    }
  };
  return app;
}
function use(app, arg1, arg2, arg3) {
  if (Array.isArray(arg1)) {
    for (const i of arg1) {
      use(app, i, arg2, arg3);
    }
  } else if (Array.isArray(arg2)) {
    for (const i of arg2) {
      use(app, arg1, i, arg3);
    }
  } else if (typeof arg1 === "string") {
    app.stack.push(
      normalizeLayer({ ...arg3, route: arg1, handler: arg2 })
    );
  } else if (typeof arg1 === "function") {
    app.stack.push(normalizeLayer({ ...arg2, handler: arg1 }));
  } else {
    app.stack.push(normalizeLayer({ ...arg1 }));
  }
  return app;
}
function createAppEventHandler(stack, options) {
  const spacing = options.debug ? 2 : undefined;
  return eventHandler(async (event) => {
    event.node.req.originalUrl = event.node.req.originalUrl || event.node.req.url || "/";
    const _reqPath = event._path || event.node.req.url || "/";
    let _layerPath;
    if (options.onRequest) {
      await options.onRequest(event);
    }
    for (const layer of stack) {
      if (layer.route.length > 1) {
        if (!_reqPath.startsWith(layer.route)) {
          continue;
        }
        _layerPath = _reqPath.slice(layer.route.length) || "/";
      } else {
        _layerPath = _reqPath;
      }
      if (layer.match && !layer.match(_layerPath, event)) {
        continue;
      }
      event._path = _layerPath;
      event.node.req.url = _layerPath;
      const val = await layer.handler(event);
      const _body = val === undefined ? undefined : await val;
      if (_body !== undefined) {
        const _response = { body: _body };
        if (options.onBeforeResponse) {
          event._onBeforeResponseCalled = true;
          await options.onBeforeResponse(event, _response);
        }
        await handleHandlerResponse(event, _response.body, spacing);
        if (options.onAfterResponse) {
          event._onAfterResponseCalled = true;
          await options.onAfterResponse(event, _response);
        }
        return;
      }
      if (event.handled) {
        if (options.onAfterResponse) {
          event._onAfterResponseCalled = true;
          await options.onAfterResponse(event, undefined);
        }
        return;
      }
    }
    if (!event.handled) {
      throw createError$1({
        statusCode: 404,
        statusMessage: `Cannot find any path matching ${event.path || "/"}.`
      });
    }
    if (options.onAfterResponse) {
      event._onAfterResponseCalled = true;
      await options.onAfterResponse(event, undefined);
    }
  });
}
function createResolver(stack) {
  return async (path) => {
    let _layerPath;
    for (const layer of stack) {
      if (layer.route === "/" && !layer.handler.__resolve__) {
        continue;
      }
      if (!path.startsWith(layer.route)) {
        continue;
      }
      _layerPath = path.slice(layer.route.length) || "/";
      if (layer.match && !layer.match(_layerPath, undefined)) {
        continue;
      }
      let res = { route: layer.route, handler: layer.handler };
      if (res.handler.__resolve__) {
        const _res = await res.handler.__resolve__(_layerPath);
        if (!_res) {
          continue;
        }
        res = {
          ...res,
          ..._res,
          route: joinURL(res.route || "/", _res.route || "/")
        };
      }
      return res;
    }
  };
}
function normalizeLayer(input) {
  let handler = input.handler;
  if (handler.handler) {
    handler = handler.handler;
  }
  if (input.lazy) {
    handler = lazyEventHandler(handler);
  } else if (!isEventHandler(handler)) {
    handler = toEventHandler(handler, undefined, input.route);
  }
  return {
    route: withoutTrailingSlash(input.route),
    match: input.match,
    handler
  };
}
function handleHandlerResponse(event, val, jsonSpace) {
  if (val === null) {
    return sendNoContent(event);
  }
  if (val) {
    if (isWebResponse(val)) {
      return sendWebResponse(event, val);
    }
    if (isStream(val)) {
      return sendStream(event, val);
    }
    if (val.buffer) {
      return send(event, val);
    }
    if (val.arrayBuffer && typeof val.arrayBuffer === "function") {
      return val.arrayBuffer().then((arrayBuffer) => {
        return send(event, Buffer.from(arrayBuffer), val.type);
      });
    }
    if (val instanceof Error) {
      throw createError$1(val);
    }
    if (typeof val.end === "function") {
      return true;
    }
  }
  const valType = typeof val;
  if (valType === "string") {
    return send(event, val, MIMES.html);
  }
  if (valType === "object" || valType === "boolean" || valType === "number") {
    return send(event, JSON.stringify(val, undefined, jsonSpace), MIMES.json);
  }
  if (valType === "bigint") {
    return send(event, val.toString(), MIMES.json);
  }
  throw createError$1({
    statusCode: 500,
    statusMessage: `[h3] Cannot send ${valType} as response.`
  });
}
function cachedFn(fn) {
  let cache;
  return () => {
    if (!cache) {
      cache = fn();
    }
    return cache;
  };
}
function websocketOptions(evResolver, appOptions) {
  return {
    ...appOptions.websocket,
    async resolve(info) {
      const url = info.request?.url || info.url || "/";
      const { pathname } = typeof url === "string" ? parseURL(url) : url;
      const resolved = await evResolver(pathname);
      return resolved?.handler?.__websocket__ || {};
    }
  };
}

const RouterMethods = [
  "connect",
  "delete",
  "get",
  "head",
  "options",
  "post",
  "put",
  "trace",
  "patch"
];
function createRouter(opts = {}) {
  const _router = createRouter$1({});
  const routes = {};
  let _matcher;
  const router = {};
  const addRoute = (path, handler, method) => {
    let route = routes[path];
    if (!route) {
      routes[path] = route = { path, handlers: {} };
      _router.insert(path, route);
    }
    if (Array.isArray(method)) {
      for (const m of method) {
        addRoute(path, handler, m);
      }
    } else {
      route.handlers[method] = toEventHandler(handler, undefined, path);
    }
    return router;
  };
  router.use = router.add = (path, handler, method) => addRoute(path, handler, method || "all");
  for (const method of RouterMethods) {
    router[method] = (path, handle) => router.add(path, handle, method);
  }
  const matchHandler = (path = "/", method = "get") => {
    const qIndex = path.indexOf("?");
    if (qIndex !== -1) {
      path = path.slice(0, Math.max(0, qIndex));
    }
    const matched = _router.lookup(path);
    if (!matched || !matched.handlers) {
      return {
        error: createError$1({
          statusCode: 404,
          name: "Not Found",
          statusMessage: `Cannot find any route matching ${path || "/"}.`
        })
      };
    }
    let handler = matched.handlers[method] || matched.handlers.all;
    if (!handler) {
      if (!_matcher) {
        _matcher = toRouteMatcher(_router);
      }
      const _matches = _matcher.matchAll(path).reverse();
      for (const _match of _matches) {
        if (_match.handlers[method]) {
          handler = _match.handlers[method];
          matched.handlers[method] = matched.handlers[method] || handler;
          break;
        }
        if (_match.handlers.all) {
          handler = _match.handlers.all;
          matched.handlers.all = matched.handlers.all || handler;
          break;
        }
      }
    }
    if (!handler) {
      return {
        error: createError$1({
          statusCode: 405,
          name: "Method Not Allowed",
          statusMessage: `Method ${method} is not allowed on this route.`
        })
      };
    }
    return { matched, handler };
  };
  const isPreemptive = opts.preemptive || opts.preemtive;
  router.handler = eventHandler((event) => {
    const match = matchHandler(
      event.path,
      event.method.toLowerCase()
    );
    if ("error" in match) {
      if (isPreemptive) {
        throw match.error;
      } else {
        return;
      }
    }
    event.context.matchedRoute = match.matched;
    const params = match.matched.params || {};
    event.context.params = params;
    return Promise.resolve(match.handler(event)).then((res) => {
      if (res === undefined && isPreemptive) {
        return null;
      }
      return res;
    });
  });
  router.handler.__resolve__ = async (path) => {
    path = withLeadingSlash(path);
    const match = matchHandler(path);
    if ("error" in match) {
      return;
    }
    let res = {
      route: match.matched.path,
      handler: match.handler
    };
    if (match.handler.__resolve__) {
      const _res = await match.handler.__resolve__(path);
      if (!_res) {
        return;
      }
      res = { ...res, ..._res };
    }
    return res;
  };
  return router;
}
function toNodeListener(app) {
  const toNodeHandle = async function(req, res) {
    const event = createEvent(req, res);
    try {
      await app.handler(event);
    } catch (_error) {
      const error = createError$1(_error);
      if (!isError(_error)) {
        error.unhandled = true;
      }
      setResponseStatus(event, error.statusCode, error.statusMessage);
      if (app.options.onError) {
        await app.options.onError(error, event);
      }
      if (event.handled) {
        return;
      }
      if (error.unhandled || error.fatal) {
        console.error("[h3]", error.fatal ? "[fatal]" : "[unhandled]", error);
      }
      if (app.options.onBeforeResponse && !event._onBeforeResponseCalled) {
        await app.options.onBeforeResponse(event, { body: error });
      }
      await sendError(event, error, !!app.options.debug);
      if (app.options.onAfterResponse && !event._onAfterResponseCalled) {
        await app.options.onAfterResponse(event, { body: error });
      }
    }
  };
  return toNodeHandle;
}

function flatHooks(configHooks, hooks = {}, parentName) {
  for (const key in configHooks) {
    const subHook = configHooks[key];
    const name = parentName ? `${parentName}:${key}` : key;
    if (typeof subHook === "object" && subHook !== null) {
      flatHooks(subHook, hooks, name);
    } else if (typeof subHook === "function") {
      hooks[name] = subHook;
    }
  }
  return hooks;
}
const defaultTask = { run: (function_) => function_() };
const _createTask = () => defaultTask;
const createTask = typeof console.createTask !== "undefined" ? console.createTask : _createTask;
function serialTaskCaller(hooks, args) {
  const name = args.shift();
  const task = createTask(name);
  return hooks.reduce(
    (promise, hookFunction) => promise.then(() => task.run(() => hookFunction(...args))),
    Promise.resolve()
  );
}
function parallelTaskCaller(hooks, args) {
  const name = args.shift();
  const task = createTask(name);
  return Promise.all(hooks.map((hook) => task.run(() => hook(...args))));
}
function callEachWith(callbacks, arg0) {
  for (const callback of [...callbacks]) {
    callback(arg0);
  }
}

class Hookable {
  constructor() {
    this._hooks = {};
    this._before = undefined;
    this._after = undefined;
    this._deprecatedMessages = undefined;
    this._deprecatedHooks = {};
    this.hook = this.hook.bind(this);
    this.callHook = this.callHook.bind(this);
    this.callHookWith = this.callHookWith.bind(this);
  }
  hook(name, function_, options = {}) {
    if (!name || typeof function_ !== "function") {
      return () => {
      };
    }
    const originalName = name;
    let dep;
    while (this._deprecatedHooks[name]) {
      dep = this._deprecatedHooks[name];
      name = dep.to;
    }
    if (dep && !options.allowDeprecated) {
      let message = dep.message;
      if (!message) {
        message = `${originalName} hook has been deprecated` + (dep.to ? `, please use ${dep.to}` : "");
      }
      if (!this._deprecatedMessages) {
        this._deprecatedMessages = /* @__PURE__ */ new Set();
      }
      if (!this._deprecatedMessages.has(message)) {
        console.warn(message);
        this._deprecatedMessages.add(message);
      }
    }
    if (!function_.name) {
      try {
        Object.defineProperty(function_, "name", {
          get: () => "_" + name.replace(/\W+/g, "_") + "_hook_cb",
          configurable: true
        });
      } catch {
      }
    }
    this._hooks[name] = this._hooks[name] || [];
    this._hooks[name].push(function_);
    return () => {
      if (function_) {
        this.removeHook(name, function_);
        function_ = undefined;
      }
    };
  }
  hookOnce(name, function_) {
    let _unreg;
    let _function = (...arguments_) => {
      if (typeof _unreg === "function") {
        _unreg();
      }
      _unreg = undefined;
      _function = undefined;
      return function_(...arguments_);
    };
    _unreg = this.hook(name, _function);
    return _unreg;
  }
  removeHook(name, function_) {
    if (this._hooks[name]) {
      const index = this._hooks[name].indexOf(function_);
      if (index !== -1) {
        this._hooks[name].splice(index, 1);
      }
      if (this._hooks[name].length === 0) {
        delete this._hooks[name];
      }
    }
  }
  deprecateHook(name, deprecated) {
    this._deprecatedHooks[name] = typeof deprecated === "string" ? { to: deprecated } : deprecated;
    const _hooks = this._hooks[name] || [];
    delete this._hooks[name];
    for (const hook of _hooks) {
      this.hook(name, hook);
    }
  }
  deprecateHooks(deprecatedHooks) {
    Object.assign(this._deprecatedHooks, deprecatedHooks);
    for (const name in deprecatedHooks) {
      this.deprecateHook(name, deprecatedHooks[name]);
    }
  }
  addHooks(configHooks) {
    const hooks = flatHooks(configHooks);
    const removeFns = Object.keys(hooks).map(
      (key) => this.hook(key, hooks[key])
    );
    return () => {
      for (const unreg of removeFns.splice(0, removeFns.length)) {
        unreg();
      }
    };
  }
  removeHooks(configHooks) {
    const hooks = flatHooks(configHooks);
    for (const key in hooks) {
      this.removeHook(key, hooks[key]);
    }
  }
  removeAllHooks() {
    for (const key in this._hooks) {
      delete this._hooks[key];
    }
  }
  callHook(name, ...arguments_) {
    arguments_.unshift(name);
    return this.callHookWith(serialTaskCaller, name, ...arguments_);
  }
  callHookParallel(name, ...arguments_) {
    arguments_.unshift(name);
    return this.callHookWith(parallelTaskCaller, name, ...arguments_);
  }
  callHookWith(caller, name, ...arguments_) {
    const event = this._before || this._after ? { name, args: arguments_, context: {} } : undefined;
    if (this._before) {
      callEachWith(this._before, event);
    }
    const result = caller(
      name in this._hooks ? [...this._hooks[name]] : [],
      arguments_
    );
    if (result instanceof Promise) {
      return result.finally(() => {
        if (this._after && event) {
          callEachWith(this._after, event);
        }
      });
    }
    if (this._after && event) {
      callEachWith(this._after, event);
    }
    return result;
  }
  beforeEach(function_) {
    this._before = this._before || [];
    this._before.push(function_);
    return () => {
      if (this._before !== undefined) {
        const index = this._before.indexOf(function_);
        if (index !== -1) {
          this._before.splice(index, 1);
        }
      }
    };
  }
  afterEach(function_) {
    this._after = this._after || [];
    this._after.push(function_);
    return () => {
      if (this._after !== undefined) {
        const index = this._after.indexOf(function_);
        if (index !== -1) {
          this._after.splice(index, 1);
        }
      }
    };
  }
}
function createHooks() {
  return new Hookable();
}

const s=globalThis.Headers,i=globalThis.AbortController,l=globalThis.fetch||(()=>{throw new Error("[node-fetch-native] Failed to fetch: `globalThis.fetch` is not available!")});

class FetchError extends Error {
  constructor(message, opts) {
    super(message, opts);
    this.name = "FetchError";
    if (opts?.cause && !this.cause) {
      this.cause = opts.cause;
    }
  }
}
function createFetchError(ctx) {
  const errorMessage = ctx.error?.message || ctx.error?.toString() || "";
  const method = ctx.request?.method || ctx.options?.method || "GET";
  const url = ctx.request?.url || String(ctx.request) || "/";
  const requestStr = `[${method}] ${JSON.stringify(url)}`;
  const statusStr = ctx.response ? `${ctx.response.status} ${ctx.response.statusText}` : "<no response>";
  const message = `${requestStr}: ${statusStr}${errorMessage ? ` ${errorMessage}` : ""}`;
  const fetchError = new FetchError(
    message,
    ctx.error ? { cause: ctx.error } : undefined
  );
  for (const key of ["request", "options", "response"]) {
    Object.defineProperty(fetchError, key, {
      get() {
        return ctx[key];
      }
    });
  }
  for (const [key, refKey] of [
    ["data", "_data"],
    ["status", "status"],
    ["statusCode", "status"],
    ["statusText", "statusText"],
    ["statusMessage", "statusText"]
  ]) {
    Object.defineProperty(fetchError, key, {
      get() {
        return ctx.response && ctx.response[refKey];
      }
    });
  }
  return fetchError;
}

const payloadMethods = new Set(
  Object.freeze(["PATCH", "POST", "PUT", "DELETE"])
);
function isPayloadMethod(method = "GET") {
  return payloadMethods.has(method.toUpperCase());
}
function isJSONSerializable(value) {
  if (value === undefined) {
    return false;
  }
  const t = typeof value;
  if (t === "string" || t === "number" || t === "boolean" || t === null) {
    return true;
  }
  if (t !== "object") {
    return false;
  }
  if (Array.isArray(value)) {
    return true;
  }
  if (value.buffer) {
    return false;
  }
  return value.constructor && value.constructor.name === "Object" || typeof value.toJSON === "function";
}
const textTypes = /* @__PURE__ */ new Set([
  "image/svg",
  "application/xml",
  "application/xhtml",
  "application/html"
]);
const JSON_RE = /^application\/(?:[\w!#$%&*.^`~-]*\+)?json(;.+)?$/i;
function detectResponseType(_contentType = "") {
  if (!_contentType) {
    return "json";
  }
  const contentType = _contentType.split(";").shift() || "";
  if (JSON_RE.test(contentType)) {
    return "json";
  }
  if (textTypes.has(contentType) || contentType.startsWith("text/")) {
    return "text";
  }
  return "blob";
}
function resolveFetchOptions(request, input, defaults, Headers) {
  const headers = mergeHeaders(
    input?.headers ?? request?.headers,
    defaults?.headers,
    Headers
  );
  let query;
  if (defaults?.query || defaults?.params || input?.params || input?.query) {
    query = {
      ...defaults?.params,
      ...defaults?.query,
      ...input?.params,
      ...input?.query
    };
  }
  return {
    ...defaults,
    ...input,
    query,
    params: query,
    headers
  };
}
function mergeHeaders(input, defaults, Headers) {
  if (!defaults) {
    return new Headers(input);
  }
  const headers = new Headers(defaults);
  if (input) {
    for (const [key, value] of Symbol.iterator in input || Array.isArray(input) ? input : new Headers(input)) {
      headers.set(key, value);
    }
  }
  return headers;
}
async function callHooks(context, hooks) {
  if (hooks) {
    if (Array.isArray(hooks)) {
      for (const hook of hooks) {
        await hook(context);
      }
    } else {
      await hooks(context);
    }
  }
}

const retryStatusCodes = /* @__PURE__ */ new Set([
  408,
  // Request Timeout
  409,
  // Conflict
  425,
  // Too Early (Experimental)
  429,
  // Too Many Requests
  500,
  // Internal Server Error
  502,
  // Bad Gateway
  503,
  // Service Unavailable
  504
  // Gateway Timeout
]);
const nullBodyResponses$1 = /* @__PURE__ */ new Set([101, 204, 205, 304]);
function createFetch$1(globalOptions = {}) {
  const {
    fetch = globalThis.fetch,
    Headers = globalThis.Headers,
    AbortController = globalThis.AbortController
  } = globalOptions;
  async function onError(context) {
    const isAbort = context.error && context.error.name === "AbortError" && !context.options.timeout || false;
    if (context.options.retry !== false && !isAbort) {
      let retries;
      if (typeof context.options.retry === "number") {
        retries = context.options.retry;
      } else {
        retries = isPayloadMethod(context.options.method) ? 0 : 1;
      }
      const responseCode = context.response && context.response.status || 500;
      if (retries > 0 && (Array.isArray(context.options.retryStatusCodes) ? context.options.retryStatusCodes.includes(responseCode) : retryStatusCodes.has(responseCode))) {
        const retryDelay = typeof context.options.retryDelay === "function" ? context.options.retryDelay(context) : context.options.retryDelay || 0;
        if (retryDelay > 0) {
          await new Promise((resolve) => setTimeout(resolve, retryDelay));
        }
        return $fetchRaw(context.request, {
          ...context.options,
          retry: retries - 1
        });
      }
    }
    const error = createFetchError(context);
    if (Error.captureStackTrace) {
      Error.captureStackTrace(error, $fetchRaw);
    }
    throw error;
  }
  const $fetchRaw = async function $fetchRaw2(_request, _options = {}) {
    const context = {
      request: _request,
      options: resolveFetchOptions(
        _request,
        _options,
        globalOptions.defaults,
        Headers
      ),
      response: undefined,
      error: undefined
    };
    if (context.options.method) {
      context.options.method = context.options.method.toUpperCase();
    }
    if (context.options.onRequest) {
      await callHooks(context, context.options.onRequest);
    }
    if (typeof context.request === "string") {
      if (context.options.baseURL) {
        context.request = withBase(context.request, context.options.baseURL);
      }
      if (context.options.query) {
        context.request = withQuery(context.request, context.options.query);
        delete context.options.query;
      }
      if ("query" in context.options) {
        delete context.options.query;
      }
      if ("params" in context.options) {
        delete context.options.params;
      }
    }
    if (context.options.body && isPayloadMethod(context.options.method)) {
      if (isJSONSerializable(context.options.body)) {
        context.options.body = typeof context.options.body === "string" ? context.options.body : JSON.stringify(context.options.body);
        context.options.headers = new Headers(context.options.headers || {});
        if (!context.options.headers.has("content-type")) {
          context.options.headers.set("content-type", "application/json");
        }
        if (!context.options.headers.has("accept")) {
          context.options.headers.set("accept", "application/json");
        }
      } else if (
        // ReadableStream Body
        "pipeTo" in context.options.body && typeof context.options.body.pipeTo === "function" || // Node.js Stream Body
        typeof context.options.body.pipe === "function"
      ) {
        if (!("duplex" in context.options)) {
          context.options.duplex = "half";
        }
      }
    }
    let abortTimeout;
    if (!context.options.signal && context.options.timeout) {
      const controller = new AbortController();
      abortTimeout = setTimeout(() => {
        const error = new Error(
          "[TimeoutError]: The operation was aborted due to timeout"
        );
        error.name = "TimeoutError";
        error.code = 23;
        controller.abort(error);
      }, context.options.timeout);
      context.options.signal = controller.signal;
    }
    try {
      context.response = await fetch(
        context.request,
        context.options
      );
    } catch (error) {
      context.error = error;
      if (context.options.onRequestError) {
        await callHooks(
          context,
          context.options.onRequestError
        );
      }
      return await onError(context);
    } finally {
      if (abortTimeout) {
        clearTimeout(abortTimeout);
      }
    }
    const hasBody = (context.response.body || // https://github.com/unjs/ofetch/issues/324
    // https://github.com/unjs/ofetch/issues/294
    // https://github.com/JakeChampion/fetch/issues/1454
    context.response._bodyInit) && !nullBodyResponses$1.has(context.response.status) && context.options.method !== "HEAD";
    if (hasBody) {
      const responseType = (context.options.parseResponse ? "json" : context.options.responseType) || detectResponseType(context.response.headers.get("content-type") || "");
      switch (responseType) {
        case "json": {
          const data = await context.response.text();
          const parseFunction = context.options.parseResponse || destr;
          context.response._data = parseFunction(data);
          break;
        }
        case "stream": {
          context.response._data = context.response.body || context.response._bodyInit;
          break;
        }
        default: {
          context.response._data = await context.response[responseType]();
        }
      }
    }
    if (context.options.onResponse) {
      await callHooks(
        context,
        context.options.onResponse
      );
    }
    if (!context.options.ignoreResponseError && context.response.status >= 400 && context.response.status < 600) {
      if (context.options.onResponseError) {
        await callHooks(
          context,
          context.options.onResponseError
        );
      }
      return await onError(context);
    }
    return context.response;
  };
  const $fetch = async function $fetch2(request, options) {
    const r = await $fetchRaw(request, options);
    return r._data;
  };
  $fetch.raw = $fetchRaw;
  $fetch.native = (...args) => fetch(...args);
  $fetch.create = (defaultOptions = {}, customGlobalOptions = {}) => createFetch$1({
    ...globalOptions,
    ...customGlobalOptions,
    defaults: {
      ...globalOptions.defaults,
      ...customGlobalOptions.defaults,
      ...defaultOptions
    }
  });
  return $fetch;
}

function createNodeFetch() {
  const useKeepAlive = JSON.parse(process.env.FETCH_KEEP_ALIVE || "false");
  if (!useKeepAlive) {
    return l;
  }
  const agentOptions = { keepAlive: true };
  const httpAgent = new http.Agent(agentOptions);
  const httpsAgent = new https.Agent(agentOptions);
  const nodeFetchOptions = {
    agent(parsedURL) {
      return parsedURL.protocol === "http:" ? httpAgent : httpsAgent;
    }
  };
  return function nodeFetchWithKeepAlive(input, init) {
    return l(input, { ...nodeFetchOptions, ...init });
  };
}
const fetch = globalThis.fetch ? (...args) => globalThis.fetch(...args) : createNodeFetch();
const Headers$1 = globalThis.Headers || s;
const AbortController$1 = globalThis.AbortController || i;
const ofetch = createFetch$1({ fetch, Headers: Headers$1, AbortController: AbortController$1 });
const $fetch = ofetch;

const nullBodyResponses = /* @__PURE__ */ new Set([101, 204, 205, 304]);
function createCall(handle) {
  return function callHandle(context) {
    const req = new IncomingMessage();
    const res = new ServerResponse(req);
    req.url = context.url || "/";
    req.method = context.method || "GET";
    req.headers = {};
    if (context.headers) {
      const headerEntries = typeof context.headers.entries === "function" ? context.headers.entries() : Object.entries(context.headers);
      for (const [name, value] of headerEntries) {
        if (!value) {
          continue;
        }
        req.headers[name.toLowerCase()] = value;
      }
    }
    req.headers.host = req.headers.host || context.host || "localhost";
    req.connection.encrypted = // @ts-ignore
    req.connection.encrypted || context.protocol === "https";
    req.body = context.body || null;
    req.__unenv__ = context.context;
    return handle(req, res).then(() => {
      let body = res._data;
      if (nullBodyResponses.has(res.statusCode) || req.method.toUpperCase() === "HEAD") {
        body = null;
        delete res._headers["content-length"];
      }
      const r = {
        body,
        headers: res._headers,
        status: res.statusCode,
        statusText: res.statusMessage
      };
      req.destroy();
      res.destroy();
      return r;
    });
  };
}

function createFetch(call, _fetch = global.fetch) {
  return async function ufetch(input, init) {
    const url = input.toString();
    if (!url.startsWith("/")) {
      return _fetch(url, init);
    }
    try {
      const r = await call({ url, ...init });
      return new Response(r.body, {
        status: r.status,
        statusText: r.statusText,
        headers: Object.fromEntries(
          Object.entries(r.headers).map(([name, value]) => [
            name,
            Array.isArray(value) ? value.join(",") : String(value) || ""
          ])
        )
      });
    } catch (error) {
      return new Response(error.toString(), {
        status: Number.parseInt(error.statusCode || error.code) || 500,
        statusText: error.statusText
      });
    }
  };
}

function hasReqHeader(event, name, includes) {
  const value = getRequestHeader(event, name);
  return value && typeof value === "string" && value.toLowerCase().includes(includes);
}
function isJsonRequest(event) {
  if (hasReqHeader(event, "accept", "text/html")) {
    return false;
  }
  return hasReqHeader(event, "accept", "application/json") || hasReqHeader(event, "user-agent", "curl/") || hasReqHeader(event, "user-agent", "httpie/") || hasReqHeader(event, "sec-fetch-mode", "cors") || event.path.startsWith("/api/") || event.path.endsWith(".json");
}
function normalizeError(error, isDev) {
  const cwd = typeof process.cwd === "function" ? process.cwd() : "/";
  const stack = (error.unhandled || error.fatal) ? [] : (error.stack || "").split("\n").splice(1).filter((line) => line.includes("at ")).map((line) => {
    const text = line.replace(cwd + "/", "./").replace("webpack:/", "").replace("file://", "").trim();
    return {
      text,
      internal: line.includes("node_modules") && !line.includes(".cache") || line.includes("internal") || line.includes("new Promise")
    };
  });
  const statusCode = error.statusCode || 500;
  const statusMessage = error.statusMessage ?? (statusCode === 404 ? "Not Found" : "");
  const message = error.unhandled ? "internal server error" : error.message || error.toString();
  return {
    stack,
    statusCode,
    statusMessage,
    message
  };
}
function _captureError(error, type) {
  console.error(`[nitro] [${type}]`, error);
  useNitroApp().captureError(error, { tags: [type] });
}
function trapUnhandledNodeErrors() {
  process.on(
    "unhandledRejection",
    (error) => _captureError(error, "unhandledRejection")
  );
  process.on(
    "uncaughtException",
    (error) => _captureError(error, "uncaughtException")
  );
}
function joinHeaders(value) {
  return Array.isArray(value) ? value.join(", ") : String(value);
}
function normalizeFetchResponse(response) {
  if (!response.headers.has("set-cookie")) {
    return response;
  }
  return new Response(response.body, {
    status: response.status,
    statusText: response.statusText,
    headers: normalizeCookieHeaders(response.headers)
  });
}
function normalizeCookieHeader(header = "") {
  return splitCookiesString(joinHeaders(header));
}
function normalizeCookieHeaders(headers) {
  const outgoingHeaders = new Headers();
  for (const [name, header] of headers) {
    if (name === "set-cookie") {
      for (const cookie of normalizeCookieHeader(header)) {
        outgoingHeaders.append("set-cookie", cookie);
      }
    } else {
      outgoingHeaders.set(name, joinHeaders(header));
    }
  }
  return outgoingHeaders;
}

const errorHandler = (async function errorhandler(error, event) {
  const { stack, statusCode, statusMessage, message } = normalizeError(error);
  const errorObject = {
    url: event.path,
    statusCode,
    statusMessage,
    message,
    stack: "",
    // TODO: check and validate error.data for serialisation into query
    data: error.data
  };
  if (error.unhandled || error.fatal) {
    const tags = [
      "[nuxt]",
      "[request error]",
      error.unhandled && "[unhandled]",
      error.fatal && "[fatal]",
      Number(errorObject.statusCode) !== 200 && `[${errorObject.statusCode}]`
    ].filter(Boolean).join(" ");
    console.error(tags, (error.message || error.toString() || "internal server error") + "\n" + stack.map((l) => "  " + l.text).join("  \n"));
  }
  if (event.handled) {
    return;
  }
  setResponseStatus(event, errorObject.statusCode !== 200 && errorObject.statusCode || 500, errorObject.statusMessage);
  if (isJsonRequest(event)) {
    setResponseHeader(event, "Content-Type", "application/json");
    return send(event, JSON.stringify(errorObject));
  }
  const reqHeaders = getRequestHeaders(event);
  const isRenderingError = event.path.startsWith("/__nuxt_error") || !!reqHeaders["x-nuxt-error"];
  const res = isRenderingError ? null : await useNitroApp().localFetch(
    withQuery(joinURL(useRuntimeConfig(event).app.baseURL, "/__nuxt_error"), errorObject),
    {
      headers: { ...reqHeaders, "x-nuxt-error": "true" },
      redirect: "manual"
    }
  ).catch(() => null);
  if (!res) {
    const { template } = await import('./error-500.mjs');
    if (event.handled) {
      return;
    }
    setResponseHeader(event, "Content-Type", "text/html;charset=UTF-8");
    return send(event, template(errorObject));
  }
  const html = await res.text();
  if (event.handled) {
    return;
  }
  for (const [header, value] of res.headers.entries()) {
    setResponseHeader(event, header, value);
  }
  setResponseStatus(event, res.status && res.status !== 200 ? res.status : undefined, res.statusText);
  return send(event, html);
});

function klona(x) {
	if (typeof x !== 'object') return x;

	var k, tmp, str=Object.prototype.toString.call(x);

	if (str === '[object Object]') {
		if (x.constructor !== Object && typeof x.constructor === 'function') {
			tmp = new x.constructor();
			for (k in x) {
				if (x.hasOwnProperty(k) && tmp[k] !== x[k]) {
					tmp[k] = klona(x[k]);
				}
			}
		} else {
			tmp = {}; // null
			for (k in x) {
				if (k === '__proto__') {
					Object.defineProperty(tmp, k, {
						value: klona(x[k]),
						configurable: true,
						enumerable: true,
						writable: true,
					});
				} else {
					tmp[k] = klona(x[k]);
				}
			}
		}
		return tmp;
	}

	if (str === '[object Array]') {
		k = x.length;
		for (tmp=Array(k); k--;) {
			tmp[k] = klona(x[k]);
		}
		return tmp;
	}

	if (str === '[object Set]') {
		tmp = new Set;
		x.forEach(function (val) {
			tmp.add(klona(val));
		});
		return tmp;
	}

	if (str === '[object Map]') {
		tmp = new Map;
		x.forEach(function (val, key) {
			tmp.set(klona(key), klona(val));
		});
		return tmp;
	}

	if (str === '[object Date]') {
		return new Date(+x);
	}

	if (str === '[object RegExp]') {
		tmp = new RegExp(x.source, x.flags);
		tmp.lastIndex = x.lastIndex;
		return tmp;
	}

	if (str === '[object DataView]') {
		return new x.constructor( klona(x.buffer) );
	}

	if (str === '[object ArrayBuffer]') {
		return x.slice(0);
	}

	// ArrayBuffer.isView(x)
	// ~> `new` bcuz `Buffer.slice` => ref
	if (str.slice(-6) === 'Array]') {
		return new x.constructor(x);
	}

	return x;
}

const inlineAppConfig = {
  "nuxt": {}
};



const appConfig = defuFn(inlineAppConfig);

const NUMBER_CHAR_RE = /\d/;
const STR_SPLITTERS = ["-", "_", "/", "."];
function isUppercase(char = "") {
  if (NUMBER_CHAR_RE.test(char)) {
    return undefined;
  }
  return char !== char.toLowerCase();
}
function splitByCase(str, separators) {
  const splitters = STR_SPLITTERS;
  const parts = [];
  if (!str || typeof str !== "string") {
    return parts;
  }
  let buff = "";
  let previousUpper;
  let previousSplitter;
  for (const char of str) {
    const isSplitter = splitters.includes(char);
    if (isSplitter === true) {
      parts.push(buff);
      buff = "";
      previousUpper = undefined;
      continue;
    }
    const isUpper = isUppercase(char);
    if (previousSplitter === false) {
      if (previousUpper === false && isUpper === true) {
        parts.push(buff);
        buff = char;
        previousUpper = isUpper;
        continue;
      }
      if (previousUpper === true && isUpper === false && buff.length > 1) {
        const lastChar = buff.at(-1);
        parts.push(buff.slice(0, Math.max(0, buff.length - 1)));
        buff = lastChar + char;
        previousUpper = isUpper;
        continue;
      }
    }
    buff += char;
    previousUpper = isUpper;
    previousSplitter = isSplitter;
  }
  parts.push(buff);
  return parts;
}
function kebabCase(str, joiner) {
  return str ? (Array.isArray(str) ? str : splitByCase(str)).map((p) => p.toLowerCase()).join(joiner) : "";
}
function snakeCase(str) {
  return kebabCase(str || "", "_");
}

function getEnv(key, opts) {
  const envKey = snakeCase(key).toUpperCase();
  return destr(
    process.env[opts.prefix + envKey] ?? process.env[opts.altPrefix + envKey]
  );
}
function _isObject(input) {
  return typeof input === "object" && !Array.isArray(input);
}
function applyEnv(obj, opts, parentKey = "") {
  for (const key in obj) {
    const subKey = parentKey ? `${parentKey}_${key}` : key;
    const envValue = getEnv(subKey, opts);
    if (_isObject(obj[key])) {
      if (_isObject(envValue)) {
        obj[key] = { ...obj[key], ...envValue };
        applyEnv(obj[key], opts, subKey);
      } else if (envValue === undefined) {
        applyEnv(obj[key], opts, subKey);
      } else {
        obj[key] = envValue ?? obj[key];
      }
    } else {
      obj[key] = envValue ?? obj[key];
    }
    if (opts.envExpansion && typeof obj[key] === "string") {
      obj[key] = _expandFromEnv(obj[key]);
    }
  }
  return obj;
}
const envExpandRx = /{{(.*?)}}/g;
function _expandFromEnv(value) {
  return value.replace(envExpandRx, (match, key) => {
    return process.env[key] || match;
  });
}

const _inlineRuntimeConfig = {
  "app": {
    "baseURL": "/",
    "buildId": "1762cd3e-738a-4133-9511-9945c551bd16",
    "buildAssetsDir": "/_nuxt/",
    "cdnURL": ""
  },
  "nitro": {
    "envPrefix": "NUXT_",
    "routeRules": {
      "/__nuxt_error": {
        "cache": false
      },
      "/sitemap.xsl": {
        "headers": {
          "Content-Type": "application/xslt+xml"
        }
      },
      "/sitemap_index.xml": {
        "swr": 600,
        "cache": {
          "varies": [
            "X-Forwarded-Host",
            "X-Forwarded-Proto",
            "Host"
          ],
          "swr": true,
          "maxAge": 600
        }
      },
      "/index-sitemap.xml": {
        "swr": 600,
        "cache": {
          "varies": [
            "X-Forwarded-Host",
            "X-Forwarded-Proto",
            "Host"
          ],
          "swr": true,
          "maxAge": 600
        }
      },
      "/en-US-sitemap.xml": {
        "swr": 600,
        "cache": {
          "varies": [
            "X-Forwarded-Host",
            "X-Forwarded-Proto",
            "Host"
          ],
          "swr": true,
          "maxAge": 600
        }
      },
      "/ar-AR-sitemap.xml": {
        "swr": 600,
        "cache": {
          "varies": [
            "X-Forwarded-Host",
            "X-Forwarded-Proto",
            "Host"
          ],
          "swr": true,
          "maxAge": 600
        }
      },
      "/_nuxt/builds/meta/**": {
        "headers": {
          "cache-control": "public, max-age=31536000, immutable"
        }
      },
      "/_nuxt/builds/**": {
        "headers": {
          "cache-control": "public, max-age=1, immutable"
        }
      },
      "/_nuxt/**": {
        "headers": {
          "cache-control": "public, max-age=31536000, immutable"
        }
      }
    }
  },
  "public": {
    "baseURL": "https://shein.aya.aait-d.com/api/client/",
    "baseGeneralURL": "https://shein.aya.aait-d.com/api/general/",
    "socketURL": "https://shein.aya.aait-d.com:4046/",
    "tokenName": "yumeii-token",
    "profileName": "yumeii-profile",
    "i18n": {
      "baseUrl": "",
      "defaultLocale": "en",
      "defaultDirection": "ltr",
      "strategy": "prefix_except_default",
      "lazy": true,
      "rootRedirect": "",
      "routesNameSeparator": "___",
      "defaultLocaleRouteNameSuffix": "default",
      "skipSettingLocaleOnNavigate": false,
      "differentDomains": false,
      "trailingSlash": false,
      "configLocales": [
        {
          "name": "EN",
          "code": "en",
          "dir": "ltr",
          "language": "en-US",
          "files": [
            "D:/Shein_Website/locales/en.json"
          ]
        },
        {
          "name": "AR",
          "code": "ar",
          "dir": "rtl",
          "language": "ar-AR",
          "files": [
            "D:/Shein_Website/locales/ar.json"
          ]
        }
      ],
      "locales": {
        "en": {
          "domain": ""
        },
        "ar": {
          "domain": ""
        }
      },
      "detectBrowserLanguage": false,
      "experimental": {
        "localeDetector": "",
        "switchLocalePathLinkSSR": false,
        "autoImportTranslationFunctions": false
      },
      "multiDomainLocales": false
    },
    "aos": {
      "disable": false,
      "startEvent": "DOMContentLoaded",
      "initClassName": "aos-init",
      "animatedClassName": "aos-animate",
      "useClassNames": false,
      "disableMutationObserver": false,
      "debounceDelay": 50,
      "throttleDelay": 60,
      "offset": 80,
      "delay": 0,
      "duration": 400,
      "easing": "ease",
      "once": true,
      "mirror": false,
      "anchorPlacement": "top-bottom"
    }
  },
  "nuxt-simple-sitemap": {
    "isI18nMapped": true,
    "sitemapName": "sitemap.xml",
    "isMultiSitemap": true,
    "excludeAppSources": [],
    "autoLastmod": false,
    "defaultSitemapsChunkSize": 1000,
    "sortEntries": true,
    "debug": false,
    "discoverImages": true,
    "isNuxtContentDocumentDriven": false,
    "xsl": "/__sitemap__/style.xsl",
    "xslTips": true,
    "xslColumns": [
      {
        "label": "URL",
        "width": "50%"
      },
      {
        "label": "Images",
        "width": "25%",
        "select": "count(image:image)"
      },
      {
        "label": "Last Updated",
        "width": "25%",
        "select": "concat(substring(sitemap:lastmod,0,11),concat(' ', substring(sitemap:lastmod,12,5)),concat(' ', substring(sitemap:lastmod,20,6)))"
      }
    ],
    "credits": true,
    "version": "4.4.0",
    "sitemaps": {
      "index": {
        "sitemapName": "index",
        "_route": "sitemap_index.xml",
        "sitemaps": [],
        "include": [],
        "exclude": []
      },
      "en-US": {
        "include": [],
        "exclude": [
          "/_nuxt/**",
          "/api/**"
        ],
        "includeAppSources": true,
        "sitemapName": "en-US",
        "_route": "en-US-sitemap.xml",
        "_hasSourceChunk": false
      },
      "ar-AR": {
        "include": [],
        "exclude": [
          "/_nuxt/**",
          "/api/**"
        ],
        "includeAppSources": true,
        "sitemapName": "ar-AR",
        "_route": "ar-AR-sitemap.xml",
        "_hasSourceChunk": false
      }
    },
    "autoI18n": {
      "differentDomains": false,
      "defaultLocale": "en",
      "locales": [
        {
          "name": "EN",
          "code": "en",
          "iso": "en-US",
          "file": "en.json",
          "dir": "ltr"
        },
        {
          "name": "AR",
          "code": "ar",
          "iso": "ar-AR",
          "file": "ar.json",
          "dir": "rtl"
        }
      ],
      "strategy": "prefix_except_default"
    }
  },
  "nuxt-site-config": {
    "stack": [
      {
        "_context": "system",
        "_priority": -15,
        "name": "Shein_Website",
        "env": "production"
      },
      {
        "_context": "package.json",
        "_priority": -10,
        "name": "al-arkan"
      }
    ],
    "version": "2.2.21",
    "debug": false
  }
};
const envOptions = {
  prefix: "NITRO_",
  altPrefix: _inlineRuntimeConfig.nitro.envPrefix ?? process.env.NITRO_ENV_PREFIX ?? "_",
  envExpansion: _inlineRuntimeConfig.nitro.envExpansion ?? process.env.NITRO_ENV_EXPANSION ?? false
};
const _sharedRuntimeConfig = _deepFreeze(
  applyEnv(klona(_inlineRuntimeConfig), envOptions)
);
function useRuntimeConfig(event) {
  if (!event) {
    return _sharedRuntimeConfig;
  }
  if (event.context.nitro.runtimeConfig) {
    return event.context.nitro.runtimeConfig;
  }
  const runtimeConfig = klona(_inlineRuntimeConfig);
  applyEnv(runtimeConfig, envOptions);
  event.context.nitro.runtimeConfig = runtimeConfig;
  return runtimeConfig;
}
const _sharedAppConfig = _deepFreeze(klona(appConfig));
function useAppConfig(event) {
  if (!event) {
    return _sharedAppConfig;
  }
  if (event.context.nitro.appConfig) {
    return event.context.nitro.appConfig;
  }
  const appConfig$1 = klona(appConfig);
  event.context.nitro.appConfig = appConfig$1;
  return appConfig$1;
}
function _deepFreeze(object) {
  const propNames = Object.getOwnPropertyNames(object);
  for (const name of propNames) {
    const value = object[name];
    if (value && typeof value === "object") {
      _deepFreeze(value);
    }
  }
  return Object.freeze(object);
}
new Proxy(/* @__PURE__ */ Object.create(null), {
  get: (_, prop) => {
    console.warn(
      "Please use `useRuntimeConfig()` instead of accessing config directly."
    );
    const runtimeConfig = useRuntimeConfig();
    if (prop in runtimeConfig) {
      return runtimeConfig[prop];
    }
    return undefined;
  }
});

function defineNitroPlugin(def) {
  return def;
}

function wrapToPromise(value) {
  if (!value || typeof value.then !== "function") {
    return Promise.resolve(value);
  }
  return value;
}
function asyncCall(function_, ...arguments_) {
  try {
    return wrapToPromise(function_(...arguments_));
  } catch (error) {
    return Promise.reject(error);
  }
}
function isPrimitive$1(value) {
  const type = typeof value;
  return value === null || type !== "object" && type !== "function";
}
function isPureObject(value) {
  const proto = Object.getPrototypeOf(value);
  return !proto || proto.isPrototypeOf(Object);
}
function stringify(value) {
  if (isPrimitive$1(value)) {
    return String(value);
  }
  if (isPureObject(value) || Array.isArray(value)) {
    return JSON.stringify(value);
  }
  if (typeof value.toJSON === "function") {
    return stringify(value.toJSON());
  }
  throw new Error("[unstorage] Cannot stringify value!");
}
const BASE64_PREFIX = "base64:";
function serializeRaw(value) {
  if (typeof value === "string") {
    return value;
  }
  return BASE64_PREFIX + base64Encode(value);
}
function deserializeRaw(value) {
  if (typeof value !== "string") {
    return value;
  }
  if (!value.startsWith(BASE64_PREFIX)) {
    return value;
  }
  return base64Decode(value.slice(BASE64_PREFIX.length));
}
function base64Decode(input) {
  if (globalThis.Buffer) {
    return Buffer.from(input, "base64");
  }
  return Uint8Array.from(
    globalThis.atob(input),
    (c) => c.codePointAt(0)
  );
}
function base64Encode(input) {
  if (globalThis.Buffer) {
    return Buffer.from(input).toString("base64");
  }
  return globalThis.btoa(String.fromCodePoint(...input));
}

const storageKeyProperties = [
  "hasItem",
  "getItem",
  "getItemRaw",
  "setItem",
  "setItemRaw",
  "removeItem",
  "getMeta",
  "setMeta",
  "removeMeta",
  "getKeys",
  "clear",
  "mount",
  "unmount"
];
function prefixStorage(storage, base) {
  base = normalizeBaseKey(base);
  if (!base) {
    return storage;
  }
  const nsStorage = { ...storage };
  for (const property of storageKeyProperties) {
    nsStorage[property] = (key = "", ...args) => (
      // @ts-ignore
      storage[property](base + key, ...args)
    );
  }
  nsStorage.getKeys = (key = "", ...arguments_) => storage.getKeys(base + key, ...arguments_).then((keys) => keys.map((key2) => key2.slice(base.length)));
  return nsStorage;
}
function normalizeKey$1(key) {
  if (!key) {
    return "";
  }
  return key.split("?")[0]?.replace(/[/\\]/g, ":").replace(/:+/g, ":").replace(/^:|:$/g, "") || "";
}
function joinKeys(...keys) {
  return normalizeKey$1(keys.join(":"));
}
function normalizeBaseKey(base) {
  base = normalizeKey$1(base);
  return base ? base + ":" : "";
}

function defineDriver$1(factory) {
  return factory;
}

const DRIVER_NAME$1 = "memory";
const memory = defineDriver$1(() => {
  const data = /* @__PURE__ */ new Map();
  return {
    name: DRIVER_NAME$1,
    getInstance: () => data,
    hasItem(key) {
      return data.has(key);
    },
    getItem(key) {
      return data.get(key) ?? null;
    },
    getItemRaw(key) {
      return data.get(key) ?? null;
    },
    setItem(key, value) {
      data.set(key, value);
    },
    setItemRaw(key, value) {
      data.set(key, value);
    },
    removeItem(key) {
      data.delete(key);
    },
    getKeys() {
      return [...data.keys()];
    },
    clear() {
      data.clear();
    },
    dispose() {
      data.clear();
    }
  };
});

function createStorage(options = {}) {
  const context = {
    mounts: { "": options.driver || memory() },
    mountpoints: [""],
    watching: false,
    watchListeners: [],
    unwatch: {}
  };
  const getMount = (key) => {
    for (const base of context.mountpoints) {
      if (key.startsWith(base)) {
        return {
          base,
          relativeKey: key.slice(base.length),
          driver: context.mounts[base]
        };
      }
    }
    return {
      base: "",
      relativeKey: key,
      driver: context.mounts[""]
    };
  };
  const getMounts = (base, includeParent) => {
    return context.mountpoints.filter(
      (mountpoint) => mountpoint.startsWith(base) || includeParent && base.startsWith(mountpoint)
    ).map((mountpoint) => ({
      relativeBase: base.length > mountpoint.length ? base.slice(mountpoint.length) : undefined,
      mountpoint,
      driver: context.mounts[mountpoint]
    }));
  };
  const onChange = (event, key) => {
    if (!context.watching) {
      return;
    }
    key = normalizeKey$1(key);
    for (const listener of context.watchListeners) {
      listener(event, key);
    }
  };
  const startWatch = async () => {
    if (context.watching) {
      return;
    }
    context.watching = true;
    for (const mountpoint in context.mounts) {
      context.unwatch[mountpoint] = await watch(
        context.mounts[mountpoint],
        onChange,
        mountpoint
      );
    }
  };
  const stopWatch = async () => {
    if (!context.watching) {
      return;
    }
    for (const mountpoint in context.unwatch) {
      await context.unwatch[mountpoint]();
    }
    context.unwatch = {};
    context.watching = false;
  };
  const runBatch = (items, commonOptions, cb) => {
    const batches = /* @__PURE__ */ new Map();
    const getBatch = (mount) => {
      let batch = batches.get(mount.base);
      if (!batch) {
        batch = {
          driver: mount.driver,
          base: mount.base,
          items: []
        };
        batches.set(mount.base, batch);
      }
      return batch;
    };
    for (const item of items) {
      const isStringItem = typeof item === "string";
      const key = normalizeKey$1(isStringItem ? item : item.key);
      const value = isStringItem ? undefined : item.value;
      const options2 = isStringItem || !item.options ? commonOptions : { ...commonOptions, ...item.options };
      const mount = getMount(key);
      getBatch(mount).items.push({
        key,
        value,
        relativeKey: mount.relativeKey,
        options: options2
      });
    }
    return Promise.all([...batches.values()].map((batch) => cb(batch))).then(
      (r) => r.flat()
    );
  };
  const storage = {
    // Item
    hasItem(key, opts = {}) {
      key = normalizeKey$1(key);
      const { relativeKey, driver } = getMount(key);
      return asyncCall(driver.hasItem, relativeKey, opts);
    },
    getItem(key, opts = {}) {
      key = normalizeKey$1(key);
      const { relativeKey, driver } = getMount(key);
      return asyncCall(driver.getItem, relativeKey, opts).then(
        (value) => destr(value)
      );
    },
    getItems(items, commonOptions = {}) {
      return runBatch(items, commonOptions, (batch) => {
        if (batch.driver.getItems) {
          return asyncCall(
            batch.driver.getItems,
            batch.items.map((item) => ({
              key: item.relativeKey,
              options: item.options
            })),
            commonOptions
          ).then(
            (r) => r.map((item) => ({
              key: joinKeys(batch.base, item.key),
              value: destr(item.value)
            }))
          );
        }
        return Promise.all(
          batch.items.map((item) => {
            return asyncCall(
              batch.driver.getItem,
              item.relativeKey,
              item.options
            ).then((value) => ({
              key: item.key,
              value: destr(value)
            }));
          })
        );
      });
    },
    getItemRaw(key, opts = {}) {
      key = normalizeKey$1(key);
      const { relativeKey, driver } = getMount(key);
      if (driver.getItemRaw) {
        return asyncCall(driver.getItemRaw, relativeKey, opts);
      }
      return asyncCall(driver.getItem, relativeKey, opts).then(
        (value) => deserializeRaw(value)
      );
    },
    async setItem(key, value, opts = {}) {
      if (value === undefined) {
        return storage.removeItem(key);
      }
      key = normalizeKey$1(key);
      const { relativeKey, driver } = getMount(key);
      if (!driver.setItem) {
        return;
      }
      await asyncCall(driver.setItem, relativeKey, stringify(value), opts);
      if (!driver.watch) {
        onChange("update", key);
      }
    },
    async setItems(items, commonOptions) {
      await runBatch(items, commonOptions, async (batch) => {
        if (batch.driver.setItems) {
          return asyncCall(
            batch.driver.setItems,
            batch.items.map((item) => ({
              key: item.relativeKey,
              value: stringify(item.value),
              options: item.options
            })),
            commonOptions
          );
        }
        if (!batch.driver.setItem) {
          return;
        }
        await Promise.all(
          batch.items.map((item) => {
            return asyncCall(
              batch.driver.setItem,
              item.relativeKey,
              stringify(item.value),
              item.options
            );
          })
        );
      });
    },
    async setItemRaw(key, value, opts = {}) {
      if (value === undefined) {
        return storage.removeItem(key, opts);
      }
      key = normalizeKey$1(key);
      const { relativeKey, driver } = getMount(key);
      if (driver.setItemRaw) {
        await asyncCall(driver.setItemRaw, relativeKey, value, opts);
      } else if (driver.setItem) {
        await asyncCall(driver.setItem, relativeKey, serializeRaw(value), opts);
      } else {
        return;
      }
      if (!driver.watch) {
        onChange("update", key);
      }
    },
    async removeItem(key, opts = {}) {
      if (typeof opts === "boolean") {
        opts = { removeMeta: opts };
      }
      key = normalizeKey$1(key);
      const { relativeKey, driver } = getMount(key);
      if (!driver.removeItem) {
        return;
      }
      await asyncCall(driver.removeItem, relativeKey, opts);
      if (opts.removeMeta || opts.removeMata) {
        await asyncCall(driver.removeItem, relativeKey + "$", opts);
      }
      if (!driver.watch) {
        onChange("remove", key);
      }
    },
    // Meta
    async getMeta(key, opts = {}) {
      if (typeof opts === "boolean") {
        opts = { nativeOnly: opts };
      }
      key = normalizeKey$1(key);
      const { relativeKey, driver } = getMount(key);
      const meta = /* @__PURE__ */ Object.create(null);
      if (driver.getMeta) {
        Object.assign(meta, await asyncCall(driver.getMeta, relativeKey, opts));
      }
      if (!opts.nativeOnly) {
        const value = await asyncCall(
          driver.getItem,
          relativeKey + "$",
          opts
        ).then((value_) => destr(value_));
        if (value && typeof value === "object") {
          if (typeof value.atime === "string") {
            value.atime = new Date(value.atime);
          }
          if (typeof value.mtime === "string") {
            value.mtime = new Date(value.mtime);
          }
          Object.assign(meta, value);
        }
      }
      return meta;
    },
    setMeta(key, value, opts = {}) {
      return this.setItem(key + "$", value, opts);
    },
    removeMeta(key, opts = {}) {
      return this.removeItem(key + "$", opts);
    },
    // Keys
    async getKeys(base, opts = {}) {
      base = normalizeBaseKey(base);
      const mounts = getMounts(base, true);
      let maskedMounts = [];
      const allKeys = [];
      for (const mount of mounts) {
        const rawKeys = await asyncCall(
          mount.driver.getKeys,
          mount.relativeBase,
          opts
        );
        for (const key of rawKeys) {
          const fullKey = mount.mountpoint + normalizeKey$1(key);
          if (!maskedMounts.some((p) => fullKey.startsWith(p))) {
            allKeys.push(fullKey);
          }
        }
        maskedMounts = [
          mount.mountpoint,
          ...maskedMounts.filter((p) => !p.startsWith(mount.mountpoint))
        ];
      }
      return base ? allKeys.filter(
        (key) => key.startsWith(base) && key[key.length - 1] !== "$"
      ) : allKeys.filter((key) => key[key.length - 1] !== "$");
    },
    // Utils
    async clear(base, opts = {}) {
      base = normalizeBaseKey(base);
      await Promise.all(
        getMounts(base, false).map(async (m) => {
          if (m.driver.clear) {
            return asyncCall(m.driver.clear, m.relativeBase, opts);
          }
          if (m.driver.removeItem) {
            const keys = await m.driver.getKeys(m.relativeBase || "", opts);
            return Promise.all(
              keys.map((key) => m.driver.removeItem(key, opts))
            );
          }
        })
      );
    },
    async dispose() {
      await Promise.all(
        Object.values(context.mounts).map((driver) => dispose(driver))
      );
    },
    async watch(callback) {
      await startWatch();
      context.watchListeners.push(callback);
      return async () => {
        context.watchListeners = context.watchListeners.filter(
          (listener) => listener !== callback
        );
        if (context.watchListeners.length === 0) {
          await stopWatch();
        }
      };
    },
    async unwatch() {
      context.watchListeners = [];
      await stopWatch();
    },
    // Mount
    mount(base, driver) {
      base = normalizeBaseKey(base);
      if (base && context.mounts[base]) {
        throw new Error(`already mounted at ${base}`);
      }
      if (base) {
        context.mountpoints.push(base);
        context.mountpoints.sort((a, b) => b.length - a.length);
      }
      context.mounts[base] = driver;
      if (context.watching) {
        Promise.resolve(watch(driver, onChange, base)).then((unwatcher) => {
          context.unwatch[base] = unwatcher;
        }).catch(console.error);
      }
      return storage;
    },
    async unmount(base, _dispose = true) {
      base = normalizeBaseKey(base);
      if (!base || !context.mounts[base]) {
        return;
      }
      if (context.watching && base in context.unwatch) {
        context.unwatch[base]?.();
        delete context.unwatch[base];
      }
      if (_dispose) {
        await dispose(context.mounts[base]);
      }
      context.mountpoints = context.mountpoints.filter((key) => key !== base);
      delete context.mounts[base];
    },
    getMount(key = "") {
      key = normalizeKey$1(key) + ":";
      const m = getMount(key);
      return {
        driver: m.driver,
        base: m.base
      };
    },
    getMounts(base = "", opts = {}) {
      base = normalizeKey$1(base);
      const mounts = getMounts(base, opts.parents);
      return mounts.map((m) => ({
        driver: m.driver,
        base: m.mountpoint
      }));
    },
    // Aliases
    keys: (base, opts = {}) => storage.getKeys(base, opts),
    get: (key, opts = {}) => storage.getItem(key, opts),
    set: (key, value, opts = {}) => storage.setItem(key, value, opts),
    has: (key, opts = {}) => storage.hasItem(key, opts),
    del: (key, opts = {}) => storage.removeItem(key, opts),
    remove: (key, opts = {}) => storage.removeItem(key, opts)
  };
  return storage;
}
function watch(driver, onChange, base) {
  return driver.watch ? driver.watch((event, key) => onChange(event, base + key)) : () => {
  };
}
async function dispose(driver) {
  if (typeof driver.dispose === "function") {
    await asyncCall(driver.dispose);
  }
}

const _assets = {

};

const normalizeKey = function normalizeKey(key) {
  if (!key) {
    return "";
  }
  return key.split("?")[0]?.replace(/[/\\]/g, ":").replace(/:+/g, ":").replace(/^:|:$/g, "") || "";
};

const assets$1 = {
  getKeys() {
    return Promise.resolve(Object.keys(_assets))
  },
  hasItem (id) {
    id = normalizeKey(id);
    return Promise.resolve(id in _assets)
  },
  getItem (id) {
    id = normalizeKey(id);
    return Promise.resolve(_assets[id] ? _assets[id].import() : null)
  },
  getMeta (id) {
    id = normalizeKey(id);
    return Promise.resolve(_assets[id] ? _assets[id].meta : {})
  }
};

function defineDriver(factory) {
  return factory;
}
function createError(driver, message, opts) {
  const err = new Error(`[unstorage] [${driver}] ${message}`, opts);
  if (Error.captureStackTrace) {
    Error.captureStackTrace(err, createError);
  }
  return err;
}
function createRequiredError(driver, name) {
  if (Array.isArray(name)) {
    return createError(
      driver,
      `Missing some of the required options ${name.map((n) => "`" + n + "`").join(", ")}`
    );
  }
  return createError(driver, `Missing required option \`${name}\`.`);
}

function ignoreNotfound(err) {
  return err.code === "ENOENT" || err.code === "EISDIR" ? null : err;
}
function ignoreExists(err) {
  return err.code === "EEXIST" ? null : err;
}
async function writeFile(path, data, encoding) {
  await ensuredir(dirname$1(path));
  return promises.writeFile(path, data, encoding);
}
function readFile(path, encoding) {
  return promises.readFile(path, encoding).catch(ignoreNotfound);
}
function unlink(path) {
  return promises.unlink(path).catch(ignoreNotfound);
}
function readdir(dir) {
  return promises.readdir(dir, { withFileTypes: true }).catch(ignoreNotfound).then((r) => r || []);
}
async function ensuredir(dir) {
  if (existsSync(dir)) {
    return;
  }
  await ensuredir(dirname$1(dir)).catch(ignoreExists);
  await promises.mkdir(dir).catch(ignoreExists);
}
async function readdirRecursive(dir, ignore) {
  if (ignore && ignore(dir)) {
    return [];
  }
  const entries = await readdir(dir);
  const files = [];
  await Promise.all(
    entries.map(async (entry) => {
      const entryPath = resolve$2(dir, entry.name);
      if (entry.isDirectory()) {
        const dirFiles = await readdirRecursive(entryPath, ignore);
        files.push(...dirFiles.map((f) => entry.name + "/" + f));
      } else {
        if (!(ignore && ignore(entry.name))) {
          files.push(entry.name);
        }
      }
    })
  );
  return files;
}
async function rmRecursive(dir) {
  const entries = await readdir(dir);
  await Promise.all(
    entries.map((entry) => {
      const entryPath = resolve$2(dir, entry.name);
      if (entry.isDirectory()) {
        return rmRecursive(entryPath).then(() => promises.rmdir(entryPath));
      } else {
        return promises.unlink(entryPath);
      }
    })
  );
}

const PATH_TRAVERSE_RE = /\.\.:|\.\.$/;
const DRIVER_NAME = "fs-lite";
const unstorage_47drivers_47fs_45lite = defineDriver((opts = {}) => {
  if (!opts.base) {
    throw createRequiredError(DRIVER_NAME, "base");
  }
  opts.base = resolve$2(opts.base);
  const r = (key) => {
    if (PATH_TRAVERSE_RE.test(key)) {
      throw createError(
        DRIVER_NAME,
        `Invalid key: ${JSON.stringify(key)}. It should not contain .. segments`
      );
    }
    const resolved = join(opts.base, key.replace(/:/g, "/"));
    return resolved;
  };
  return {
    name: DRIVER_NAME,
    options: opts,
    hasItem(key) {
      return existsSync(r(key));
    },
    getItem(key) {
      return readFile(r(key), "utf8");
    },
    getItemRaw(key) {
      return readFile(r(key));
    },
    async getMeta(key) {
      const { atime, mtime, size, birthtime, ctime } = await promises.stat(r(key)).catch(() => ({}));
      return { atime, mtime, size, birthtime, ctime };
    },
    setItem(key, value) {
      if (opts.readOnly) {
        return;
      }
      return writeFile(r(key), value, "utf8");
    },
    setItemRaw(key, value) {
      if (opts.readOnly) {
        return;
      }
      return writeFile(r(key), value);
    },
    removeItem(key) {
      if (opts.readOnly) {
        return;
      }
      return unlink(r(key));
    },
    getKeys() {
      return readdirRecursive(r("."), opts.ignore);
    },
    async clear() {
      if (opts.readOnly || opts.noClear) {
        return;
      }
      await rmRecursive(r("."));
    }
  };
});

const storage = createStorage({});

storage.mount('/assets', assets$1);

storage.mount('data', unstorage_47drivers_47fs_45lite({"driver":"fsLite","base":"D:\\Shein_Website\\.data\\kv"}));

function useStorage(base = "") {
  return base ? prefixStorage(storage, base) : storage;
}

function defaultCacheOptions() {
  return {
    name: "_",
    base: "/cache",
    swr: true,
    maxAge: 1
  };
}
function defineCachedFunction(fn, opts = {}) {
  opts = { ...defaultCacheOptions(), ...opts };
  const pending = {};
  const group = opts.group || "nitro/functions";
  const name = opts.name || fn.name || "_";
  const integrity = opts.integrity || hash([fn, opts]);
  const validate = opts.validate || ((entry) => entry.value !== undefined);
  async function get(key, resolver, shouldInvalidateCache, event) {
    const cacheKey = [opts.base, group, name, key + ".json"].filter(Boolean).join(":").replace(/:\/$/, ":index");
    let entry = await useStorage().getItem(cacheKey).catch((error) => {
      console.error(`[nitro] [cache] Cache read error.`, error);
      useNitroApp().captureError(error, { event, tags: ["cache"] });
    }) || {};
    if (typeof entry !== "object") {
      entry = {};
      const error = new Error("Malformed data read from cache.");
      console.error("[nitro] [cache]", error);
      useNitroApp().captureError(error, { event, tags: ["cache"] });
    }
    const ttl = (opts.maxAge ?? 0) * 1e3;
    if (ttl) {
      entry.expires = Date.now() + ttl;
    }
    const expired = shouldInvalidateCache || entry.integrity !== integrity || ttl && Date.now() - (entry.mtime || 0) > ttl || validate(entry) === false;
    const _resolve = async () => {
      const isPending = pending[key];
      if (!isPending) {
        if (entry.value !== undefined && (opts.staleMaxAge || 0) >= 0 && opts.swr === false) {
          entry.value = undefined;
          entry.integrity = undefined;
          entry.mtime = undefined;
          entry.expires = undefined;
        }
        pending[key] = Promise.resolve(resolver());
      }
      try {
        entry.value = await pending[key];
      } catch (error) {
        if (!isPending) {
          delete pending[key];
        }
        throw error;
      }
      if (!isPending) {
        entry.mtime = Date.now();
        entry.integrity = integrity;
        delete pending[key];
        if (validate(entry) !== false) {
          let setOpts;
          if (opts.maxAge && !opts.swr) {
            setOpts = { ttl: opts.maxAge };
          }
          const promise = useStorage().setItem(cacheKey, entry, setOpts).catch((error) => {
            console.error(`[nitro] [cache] Cache write error.`, error);
            useNitroApp().captureError(error, { event, tags: ["cache"] });
          });
          if (event?.waitUntil) {
            event.waitUntil(promise);
          }
        }
      }
    };
    const _resolvePromise = expired ? _resolve() : Promise.resolve();
    if (entry.value === undefined) {
      await _resolvePromise;
    } else if (expired && event && event.waitUntil) {
      event.waitUntil(_resolvePromise);
    }
    if (opts.swr && validate(entry) !== false) {
      _resolvePromise.catch((error) => {
        console.error(`[nitro] [cache] SWR handler error.`, error);
        useNitroApp().captureError(error, { event, tags: ["cache"] });
      });
      return entry;
    }
    return _resolvePromise.then(() => entry);
  }
  return async (...args) => {
    const shouldBypassCache = await opts.shouldBypassCache?.(...args);
    if (shouldBypassCache) {
      return fn(...args);
    }
    const key = await (opts.getKey || getKey)(...args);
    const shouldInvalidateCache = await opts.shouldInvalidateCache?.(...args);
    const entry = await get(
      key,
      () => fn(...args),
      shouldInvalidateCache,
      args[0] && isEvent(args[0]) ? args[0] : undefined
    );
    let value = entry.value;
    if (opts.transform) {
      value = await opts.transform(entry, ...args) || value;
    }
    return value;
  };
}
function cachedFunction(fn, opts = {}) {
  return defineCachedFunction(fn, opts);
}
function getKey(...args) {
  return args.length > 0 ? hash(args, {}) : "";
}
function escapeKey(key) {
  return String(key).replace(/\W/g, "");
}
function defineCachedEventHandler(handler, opts = defaultCacheOptions()) {
  const variableHeaderNames = (opts.varies || []).filter(Boolean).map((h) => h.toLowerCase()).sort();
  const _opts = {
    ...opts,
    getKey: async (event) => {
      const customKey = await opts.getKey?.(event);
      if (customKey) {
        return escapeKey(customKey);
      }
      const _path = event.node.req.originalUrl || event.node.req.url || event.path;
      let _pathname;
      try {
        _pathname = escapeKey(decodeURI(parseURL(_path).pathname)).slice(0, 16) || "index";
      } catch {
        _pathname = "-";
      }
      const _hashedPath = `${_pathname}.${hash(_path)}`;
      const _headers = variableHeaderNames.map((header) => [header, event.node.req.headers[header]]).map(([name, value]) => `${escapeKey(name)}.${hash(value)}`);
      return [_hashedPath, ..._headers].join(":");
    },
    validate: (entry) => {
      if (!entry.value) {
        return false;
      }
      if (entry.value.code >= 400) {
        return false;
      }
      if (entry.value.body === undefined) {
        return false;
      }
      if (entry.value.headers.etag === "undefined" || entry.value.headers["last-modified"] === "undefined") {
        return false;
      }
      return true;
    },
    group: opts.group || "nitro/handlers",
    integrity: opts.integrity || hash([handler, opts])
  };
  const _cachedHandler = cachedFunction(
    async (incomingEvent) => {
      const variableHeaders = {};
      for (const header of variableHeaderNames) {
        const value = incomingEvent.node.req.headers[header];
        if (value !== undefined) {
          variableHeaders[header] = value;
        }
      }
      const reqProxy = cloneWithProxy(incomingEvent.node.req, {
        headers: variableHeaders
      });
      const resHeaders = {};
      let _resSendBody;
      const resProxy = cloneWithProxy(incomingEvent.node.res, {
        statusCode: 200,
        writableEnded: false,
        writableFinished: false,
        headersSent: false,
        closed: false,
        getHeader(name) {
          return resHeaders[name];
        },
        setHeader(name, value) {
          resHeaders[name] = value;
          return this;
        },
        getHeaderNames() {
          return Object.keys(resHeaders);
        },
        hasHeader(name) {
          return name in resHeaders;
        },
        removeHeader(name) {
          delete resHeaders[name];
        },
        getHeaders() {
          return resHeaders;
        },
        end(chunk, arg2, arg3) {
          if (typeof chunk === "string") {
            _resSendBody = chunk;
          }
          if (typeof arg2 === "function") {
            arg2();
          }
          if (typeof arg3 === "function") {
            arg3();
          }
          return this;
        },
        write(chunk, arg2, arg3) {
          if (typeof chunk === "string") {
            _resSendBody = chunk;
          }
          if (typeof arg2 === "function") {
            arg2(undefined);
          }
          if (typeof arg3 === "function") {
            arg3();
          }
          return true;
        },
        writeHead(statusCode, headers2) {
          this.statusCode = statusCode;
          if (headers2) {
            if (Array.isArray(headers2) || typeof headers2 === "string") {
              throw new TypeError("Raw headers  is not supported.");
            }
            for (const header in headers2) {
              const value = headers2[header];
              if (value !== undefined) {
                this.setHeader(
                  header,
                  value
                );
              }
            }
          }
          return this;
        }
      });
      const event = createEvent(reqProxy, resProxy);
      event.fetch = (url, fetchOptions) => fetchWithEvent(event, url, fetchOptions, {
        fetch: useNitroApp().localFetch
      });
      event.$fetch = (url, fetchOptions) => fetchWithEvent(event, url, fetchOptions, {
        fetch: globalThis.$fetch
      });
      event.context = incomingEvent.context;
      event.context.cache = {
        options: _opts
      };
      const body = await handler(event) || _resSendBody;
      const headers = event.node.res.getHeaders();
      headers.etag = String(
        headers.Etag || headers.etag || `W/"${hash(body)}"`
      );
      headers["last-modified"] = String(
        headers["Last-Modified"] || headers["last-modified"] || (/* @__PURE__ */ new Date()).toUTCString()
      );
      const cacheControl = [];
      if (opts.swr) {
        if (opts.maxAge) {
          cacheControl.push(`s-maxage=${opts.maxAge}`);
        }
        if (opts.staleMaxAge) {
          cacheControl.push(`stale-while-revalidate=${opts.staleMaxAge}`);
        } else {
          cacheControl.push("stale-while-revalidate");
        }
      } else if (opts.maxAge) {
        cacheControl.push(`max-age=${opts.maxAge}`);
      }
      if (cacheControl.length > 0) {
        headers["cache-control"] = cacheControl.join(", ");
      }
      const cacheEntry = {
        code: event.node.res.statusCode,
        headers,
        body
      };
      return cacheEntry;
    },
    _opts
  );
  return defineEventHandler(async (event) => {
    if (opts.headersOnly) {
      if (handleCacheHeaders(event, { maxAge: opts.maxAge })) {
        return;
      }
      return handler(event);
    }
    const response = await _cachedHandler(
      event
    );
    if (event.node.res.headersSent || event.node.res.writableEnded) {
      return response.body;
    }
    if (handleCacheHeaders(event, {
      modifiedTime: new Date(response.headers["last-modified"]),
      etag: response.headers.etag,
      maxAge: opts.maxAge
    })) {
      return;
    }
    event.node.res.statusCode = response.code;
    for (const name in response.headers) {
      const value = response.headers[name];
      if (name === "set-cookie") {
        event.node.res.appendHeader(
          name,
          splitCookiesString(value)
        );
      } else {
        if (value !== undefined) {
          event.node.res.setHeader(name, value);
        }
      }
    }
    return response.body;
  });
}
function cloneWithProxy(obj, overrides) {
  return new Proxy(obj, {
    get(target, property, receiver) {
      if (property in overrides) {
        return overrides[property];
      }
      return Reflect.get(target, property, receiver);
    },
    set(target, property, value, receiver) {
      if (property in overrides) {
        overrides[property] = value;
        return true;
      }
      return Reflect.set(target, property, value, receiver);
    }
  });
}
const cachedEventHandler = defineCachedEventHandler;

function defineRenderHandler(render) {
  const runtimeConfig = useRuntimeConfig();
  return eventHandler(async (event) => {
    const nitroApp = useNitroApp();
    const ctx = { event, render, response: undefined };
    await nitroApp.hooks.callHook("render:before", ctx);
    if (!ctx.response) {
      if (event.path === `${runtimeConfig.app.baseURL}favicon.ico`) {
        setResponseHeader(event, "Content-Type", "image/x-icon");
        return send(
          event,
          "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7"
        );
      }
      ctx.response = await ctx.render(event);
      if (!ctx.response) {
        const _currentStatus = getResponseStatus(event);
        setResponseStatus(event, _currentStatus === 200 ? 500 : _currentStatus);
        return send(
          event,
          "No response returned from render handler: " + event.path
        );
      }
    }
    await nitroApp.hooks.callHook("render:response", ctx.response, ctx);
    if (ctx.response.headers) {
      setResponseHeaders(event, ctx.response.headers);
    }
    if (ctx.response.statusCode || ctx.response.statusMessage) {
      setResponseStatus(
        event,
        ctx.response.statusCode,
        ctx.response.statusMessage
      );
    }
    return ctx.response.body;
  });
}

const config = useRuntimeConfig();
const _routeRulesMatcher = toRouteMatcher(
  createRouter$1({ routes: config.nitro.routeRules })
);
function createRouteRulesHandler(ctx) {
  return eventHandler((event) => {
    const routeRules = getRouteRules(event);
    if (routeRules.headers) {
      setHeaders(event, routeRules.headers);
    }
    if (routeRules.redirect) {
      let target = routeRules.redirect.to;
      if (target.endsWith("/**")) {
        let targetPath = event.path;
        const strpBase = routeRules.redirect._redirectStripBase;
        if (strpBase) {
          targetPath = withoutBase(targetPath, strpBase);
        }
        target = joinURL(target.slice(0, -3), targetPath);
      } else if (event.path.includes("?")) {
        const query = getQuery$1(event.path);
        target = withQuery(target, query);
      }
      return sendRedirect(event, target, routeRules.redirect.statusCode);
    }
    if (routeRules.proxy) {
      let target = routeRules.proxy.to;
      if (target.endsWith("/**")) {
        let targetPath = event.path;
        const strpBase = routeRules.proxy._proxyStripBase;
        if (strpBase) {
          targetPath = withoutBase(targetPath, strpBase);
        }
        target = joinURL(target.slice(0, -3), targetPath);
      } else if (event.path.includes("?")) {
        const query = getQuery$1(event.path);
        target = withQuery(target, query);
      }
      return proxyRequest(event, target, {
        fetch: ctx.localFetch,
        ...routeRules.proxy
      });
    }
  });
}
function getRouteRules(event) {
  event.context._nitro = event.context._nitro || {};
  if (!event.context._nitro.routeRules) {
    event.context._nitro.routeRules = getRouteRulesForPath(
      withoutBase(event.path.split("?")[0], useRuntimeConfig().app.baseURL)
    );
  }
  return event.context._nitro.routeRules;
}
function getRouteRulesForPath(path) {
  return defu({}, ..._routeRulesMatcher.matchAll(path).reverse());
}

function createContext(opts = {}) {
  let currentInstance;
  let isSingleton = false;
  const checkConflict = (instance) => {
    if (currentInstance && currentInstance !== instance) {
      throw new Error("Context conflict");
    }
  };
  let als;
  if (opts.asyncContext) {
    const _AsyncLocalStorage = opts.AsyncLocalStorage || globalThis.AsyncLocalStorage;
    if (_AsyncLocalStorage) {
      als = new _AsyncLocalStorage();
    } else {
      console.warn("[unctx] `AsyncLocalStorage` is not provided.");
    }
  }
  const _getCurrentInstance = () => {
    if (als) {
      const instance = als.getStore();
      if (instance !== undefined) {
        return instance;
      }
    }
    return currentInstance;
  };
  return {
    use: () => {
      const _instance = _getCurrentInstance();
      if (_instance === undefined) {
        throw new Error("Context is not available");
      }
      return _instance;
    },
    tryUse: () => {
      return _getCurrentInstance();
    },
    set: (instance, replace) => {
      if (!replace) {
        checkConflict(instance);
      }
      currentInstance = instance;
      isSingleton = true;
    },
    unset: () => {
      currentInstance = undefined;
      isSingleton = false;
    },
    call: (instance, callback) => {
      checkConflict(instance);
      currentInstance = instance;
      try {
        return als ? als.run(instance, callback) : callback();
      } finally {
        if (!isSingleton) {
          currentInstance = undefined;
        }
      }
    },
    async callAsync(instance, callback) {
      currentInstance = instance;
      const onRestore = () => {
        currentInstance = instance;
      };
      const onLeave = () => currentInstance === instance ? onRestore : undefined;
      asyncHandlers.add(onLeave);
      try {
        const r = als ? als.run(instance, callback) : callback();
        if (!isSingleton) {
          currentInstance = void 0;
        }
        return await r;
      } finally {
        asyncHandlers.delete(onLeave);
      }
    }
  };
}
function createNamespace(defaultOpts = {}) {
  const contexts = {};
  return {
    get(key, opts = {}) {
      if (!contexts[key]) {
        contexts[key] = createContext({ ...defaultOpts, ...opts });
      }
      return contexts[key];
    }
  };
}
const _globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof global !== "undefined" ? global : {};
const globalKey = "__unctx__";
const defaultNamespace = _globalThis[globalKey] || (_globalThis[globalKey] = createNamespace());
const getContext = (key, opts = {}) => defaultNamespace.get(key, opts);
const asyncHandlersKey = "__unctx_async_handlers__";
const asyncHandlers = _globalThis[asyncHandlersKey] || (_globalThis[asyncHandlersKey] = /* @__PURE__ */ new Set());

function baseURL() {
  return useRuntimeConfig().app.baseURL;
}
function buildAssetsDir() {
  return useRuntimeConfig().app.buildAssetsDir;
}
function buildAssetsURL(...path) {
  return joinRelativeURL(publicAssetsURL(), buildAssetsDir(), ...path);
}
function publicAssetsURL(...path) {
  const app = useRuntimeConfig().app;
  const publicBase = app.cdnURL || app.baseURL;
  return path.length ? joinRelativeURL(publicBase, ...path) : publicBase;
}

function normalizeSiteConfig(config) {
  if (typeof config.indexable !== "undefined")
    config.indexable = String(config.indexable) !== "false";
  if (typeof config.trailingSlash !== "undefined" && !config.trailingSlash)
    config.trailingSlash = String(config.trailingSlash) !== "false";
  if (config.url && !hasProtocol(config.url, { acceptRelative: true, strict: false }))
    config.url = withHttps(config.url);
  const keys = Object.keys(config).sort((a, b) => a.localeCompare(b));
  const newConfig = {};
  for (const k of keys)
    newConfig[k] = config[k];
  return newConfig;
}
function createSiteConfigStack(options) {
  const debug = options?.debug || false;
  const stack = [];
  function push(input) {
    if (!input || typeof input !== "object" || Object.keys(input).length === 0)
      return;
    if (!input._context && debug) {
      let lastFunctionName = new Error("tmp").stack?.split("\n")[2].split(" ")[5];
      if (lastFunctionName?.includes("/"))
        lastFunctionName = "anonymous";
      input._context = lastFunctionName;
    }
    const entry = {};
    for (const k in input) {
      const val = input[k];
      if (typeof val !== "undefined" && val !== "")
        entry[k] = val;
    }
    if (Object.keys(entry).filter((k) => !k.startsWith("_")).length > 0)
      stack.push(entry);
  }
  function get(options2) {
    const siteConfig = {};
    if (options2?.debug)
      siteConfig._context = {};
    for (const o in stack.sort((a, b) => (a._priority || 0) - (b._priority || 0))) {
      for (const k in stack[o]) {
        const key = k;
        const val = options2?.resolveRefs ? toValue(stack[o][k]) : stack[o][k];
        if (!k.startsWith("_") && typeof val !== "undefined") {
          siteConfig[k] = val;
          if (options2?.debug)
            siteConfig._context[key] = stack[o]._context?.[key] || stack[o]._context || "anonymous";
        }
      }
    }
    return options2?.skipNormalize ? siteConfig : normalizeSiteConfig(siteConfig);
  }
  return {
    stack,
    push,
    get
  };
}

function envSiteConfig(env) {
  return Object.fromEntries(Object.entries(env).filter(([k]) => k.startsWith("NUXT_SITE_") || k.startsWith("NUXT_PUBLIC_SITE_")).map(([k, v]) => [
    k.replace(/^NUXT_(PUBLIC_)?SITE_/, "").split("_").map((s, i) => i === 0 ? s.toLowerCase() : s[0].toUpperCase() + s.slice(1).toLowerCase()).join(""),
    v
  ]));
}

function useNitroOrigin(e) {
  process.env.NITRO_SSL_CERT;
  process.env.NITRO_SSL_KEY;
  let host = process.env.NITRO_HOST || process.env.HOST || false;
  let port = false;
  let protocol = "https" ;
  {
    host = getRequestHost(e, { xForwardedHost: true }) || host;
    protocol = getRequestProtocol(e, { xForwardedProto: true }) || protocol;
  }
  if (typeof host === "string" && host.includes(":")) {
    port = host.split(":").pop();
    host = host.split(":")[0];
  }
  port = port ? `:${port}` : "";
  return withTrailingSlash(`${protocol}://${host}${port}`);
}

function useSiteConfig(e, _options) {
  e.context.siteConfig = e.context.siteConfig || createSiteConfigStack();
  const options = defu(_options, useRuntimeConfig(e)["nuxt-site-config"], { debug: false });
  return e.context.siteConfig.get(options);
}

function resolveSitePath(pathOrUrl, options) {
  let path = pathOrUrl;
  if (hasProtocol(pathOrUrl, { strict: false, acceptRelative: true })) {
    const parsed = parseURL(pathOrUrl);
    path = parsed.pathname;
  }
  const base = withLeadingSlash(options.base || "/");
  if (base !== "/" && path.startsWith(base)) {
    path = path.slice(base.length);
  }
  let origin = withoutTrailingSlash(options.absolute ? options.siteUrl : "");
  if (base !== "/" && origin.endsWith(base)) {
    origin = origin.slice(0, origin.indexOf(base));
  }
  const baseWithOrigin = options.withBase ? withBase(base, origin || "/") : origin;
  const resolvedUrl = withBase(path, baseWithOrigin);
  return path === "/" && !options.withBase ? withTrailingSlash(resolvedUrl) : fixSlashes(options.trailingSlash, resolvedUrl);
}
function isPathFile(path) {
  const lastSegment = path.split("/").pop();
  return !!(lastSegment || path).match(/\.[0-9a-z]+$/i)?.[0];
}
function fixSlashes(trailingSlash, pathOrUrl) {
  const $url = parseURL(pathOrUrl);
  if (isPathFile($url.pathname))
    return pathOrUrl;
  const fixedPath = trailingSlash ? withTrailingSlash($url.pathname) : withoutTrailingSlash($url.pathname);
  return `${$url.protocol ? `${$url.protocol}//` : ""}${$url.host || ""}${fixedPath}${$url.search || ""}${$url.hash || ""}`;
}

function createSitePathResolver(e, options = {}) {
  const siteConfig = useSiteConfig(e);
  const nitroOrigin = useNitroOrigin(e);
  const nuxtBase = useRuntimeConfig(e).app.baseURL || "/";
  return (path) => {
    return resolveSitePath(path, {
      ...options,
      siteUrl: options.canonical !== false || false ? siteConfig.url : nitroOrigin,
      trailingSlash: siteConfig.trailingSlash,
      base: nuxtBase
    });
  };
}

const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_$";
const unsafeChars = /[<>\b\f\n\r\t\0\u2028\u2029]/g;
const reserved = /^(?:do|if|in|for|int|let|new|try|var|byte|case|char|else|enum|goto|long|this|void|with|await|break|catch|class|const|final|float|short|super|throw|while|yield|delete|double|export|import|native|return|switch|throws|typeof|boolean|default|extends|finally|package|private|abstract|continue|debugger|function|volatile|interface|protected|transient|implements|instanceof|synchronized)$/;
const escaped = {
  "<": "\\u003C",
  ">": "\\u003E",
  "/": "\\u002F",
  "\\": "\\\\",
  "\b": "\\b",
  "\f": "\\f",
  "\n": "\\n",
  "\r": "\\r",
  "	": "\\t",
  "\0": "\\0",
  "\u2028": "\\u2028",
  "\u2029": "\\u2029"
};
const objectProtoOwnPropertyNames = Object.getOwnPropertyNames(Object.prototype).sort().join("\0");
function devalue(value) {
  const counts = /* @__PURE__ */ new Map();
  let logNum = 0;
  function log(message) {
    if (logNum < 100) {
      console.warn(message);
      logNum += 1;
    }
  }
  function walk(thing) {
    if (typeof thing === "function") {
      log(`Cannot stringify a function ${thing.name}`);
      return;
    }
    if (counts.has(thing)) {
      counts.set(thing, counts.get(thing) + 1);
      return;
    }
    counts.set(thing, 1);
    if (!isPrimitive(thing)) {
      const type = getType(thing);
      switch (type) {
        case "Number":
        case "String":
        case "Boolean":
        case "Date":
        case "RegExp":
          return;
        case "Array":
          thing.forEach(walk);
          break;
        case "Set":
        case "Map":
          Array.from(thing).forEach(walk);
          break;
        default:
          const proto = Object.getPrototypeOf(thing);
          if (proto !== Object.prototype && proto !== null && Object.getOwnPropertyNames(proto).sort().join("\0") !== objectProtoOwnPropertyNames) {
            if (typeof thing.toJSON !== "function") {
              log(`Cannot stringify arbitrary non-POJOs ${thing.constructor.name}`);
            }
          } else if (Object.getOwnPropertySymbols(thing).length > 0) {
            log(`Cannot stringify POJOs with symbolic keys ${Object.getOwnPropertySymbols(thing).map((symbol) => symbol.toString())}`);
          } else {
            Object.keys(thing).forEach((key) => walk(thing[key]));
          }
      }
    }
  }
  walk(value);
  const names = /* @__PURE__ */ new Map();
  Array.from(counts).filter((entry) => entry[1] > 1).sort((a, b) => b[1] - a[1]).forEach((entry, i) => {
    names.set(entry[0], getName(i));
  });
  function stringify(thing) {
    if (names.has(thing)) {
      return names.get(thing);
    }
    if (isPrimitive(thing)) {
      return stringifyPrimitive(thing);
    }
    const type = getType(thing);
    switch (type) {
      case "Number":
      case "String":
      case "Boolean":
        return `Object(${stringify(thing.valueOf())})`;
      case "RegExp":
        return thing.toString();
      case "Date":
        return `new Date(${thing.getTime()})`;
      case "Array":
        const members = thing.map((v, i) => i in thing ? stringify(v) : "");
        const tail = thing.length === 0 || thing.length - 1 in thing ? "" : ",";
        return `[${members.join(",")}${tail}]`;
      case "Set":
      case "Map":
        return `new ${type}([${Array.from(thing).map(stringify).join(",")}])`;
      default:
        if (thing.toJSON) {
          let json = thing.toJSON();
          if (getType(json) === "String") {
            try {
              json = JSON.parse(json);
            } catch (e) {
            }
          }
          return stringify(json);
        }
        if (Object.getPrototypeOf(thing) === null) {
          if (Object.keys(thing).length === 0) {
            return "Object.create(null)";
          }
          return `Object.create(null,{${Object.keys(thing).map((key) => `${safeKey(key)}:{writable:true,enumerable:true,value:${stringify(thing[key])}}`).join(",")}})`;
        }
        return `{${Object.keys(thing).map((key) => `${safeKey(key)}:${stringify(thing[key])}`).join(",")}}`;
    }
  }
  const str = stringify(value);
  if (names.size) {
    const params = [];
    const statements = [];
    const values = [];
    names.forEach((name, thing) => {
      params.push(name);
      if (isPrimitive(thing)) {
        values.push(stringifyPrimitive(thing));
        return;
      }
      const type = getType(thing);
      switch (type) {
        case "Number":
        case "String":
        case "Boolean":
          values.push(`Object(${stringify(thing.valueOf())})`);
          break;
        case "RegExp":
          values.push(thing.toString());
          break;
        case "Date":
          values.push(`new Date(${thing.getTime()})`);
          break;
        case "Array":
          values.push(`Array(${thing.length})`);
          thing.forEach((v, i) => {
            statements.push(`${name}[${i}]=${stringify(v)}`);
          });
          break;
        case "Set":
          values.push("new Set");
          statements.push(`${name}.${Array.from(thing).map((v) => `add(${stringify(v)})`).join(".")}`);
          break;
        case "Map":
          values.push("new Map");
          statements.push(`${name}.${Array.from(thing).map(([k, v]) => `set(${stringify(k)}, ${stringify(v)})`).join(".")}`);
          break;
        default:
          values.push(Object.getPrototypeOf(thing) === null ? "Object.create(null)" : "{}");
          Object.keys(thing).forEach((key) => {
            statements.push(`${name}${safeProp(key)}=${stringify(thing[key])}`);
          });
      }
    });
    statements.push(`return ${str}`);
    return `(function(${params.join(",")}){${statements.join(";")}}(${values.join(",")}))`;
  } else {
    return str;
  }
}
function getName(num) {
  let name = "";
  do {
    name = chars[num % chars.length] + name;
    num = ~~(num / chars.length) - 1;
  } while (num >= 0);
  return reserved.test(name) ? `${name}0` : name;
}
function isPrimitive(thing) {
  return Object(thing) !== thing;
}
function stringifyPrimitive(thing) {
  if (typeof thing === "string") {
    return stringifyString(thing);
  }
  if (thing === undefined) {
    return "void 0";
  }
  if (thing === 0 && 1 / thing < 0) {
    return "-0";
  }
  const str = String(thing);
  if (typeof thing === "number") {
    return str.replace(/^(-)?0\./, "$1.");
  }
  return str;
}
function getType(thing) {
  return Object.prototype.toString.call(thing).slice(8, -1);
}
function escapeUnsafeChar(c) {
  return escaped[c] || c;
}
function escapeUnsafeChars(str) {
  return str.replace(unsafeChars, escapeUnsafeChar);
}
function safeKey(key) {
  return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(key) ? key : escapeUnsafeChars(JSON.stringify(key));
}
function safeProp(key) {
  return /^[_$a-zA-Z][_$a-zA-Z0-9]*$/.test(key) ? `.${key}` : `[${escapeUnsafeChars(JSON.stringify(key))}]`;
}
function stringifyString(str) {
  let result = '"';
  for (let i = 0; i < str.length; i += 1) {
    const char = str.charAt(i);
    const code = char.charCodeAt(0);
    if (char === '"') {
      result += '\\"';
    } else if (char in escaped) {
      result += escaped[char];
    } else if (code >= 55296 && code <= 57343) {
      const next = str.charCodeAt(i + 1);
      if (code <= 56319 && (next >= 56320 && next <= 57343)) {
        result += char + str[++i];
      } else {
        result += `\\u${code.toString(16).toUpperCase()}`;
      }
    } else {
      result += char;
    }
  }
  result += '"';
  return result;
}

const _pNR2bBf7ch = defineNitroPlugin(async (nitroApp) => {
  nitroApp.hooks.hook("render:html", async (ctx, { event }) => {
    const routeOptions = getRouteRules(event);
    const isIsland = process.env.NUXT_COMPONENT_ISLANDS && event.path.startsWith("/__nuxt_island");
    event.path;
    const noSSR = event.context.nuxt?.noSSR || routeOptions.ssr === false && !isIsland || (false);
    if (noSSR) {
      const siteConfig = Object.fromEntries(
        Object.entries(useSiteConfig(event)).map(([k, v]) => [k, toValue(v)])
      );
      ctx.body.push(`<script>window.__NUXT_SITE_CONFIG__=${devalue(siteConfig)}<\/script>`);
    }
  });
});

const plugins = [
  _pNR2bBf7ch
];

const assets = {
  "/ar.png": {
    "type": "image/png",
    "etag": "\"29e-m7JKm6+D3F8EYMdVCQ0BhamZpL0\"",
    "mtime": "2025-02-20T09:10:24.715Z",
    "size": 670,
    "path": "../public/ar.png"
  },
  "/en.png": {
    "type": "image/png",
    "etag": "\"2eb-PVhrikQi95QBXhryEnraMugcGJI\"",
    "mtime": "2025-02-20T09:10:24.715Z",
    "size": 747,
    "path": "../public/en.png"
  },
  "/logo.svg": {
    "type": "image/svg+xml",
    "etag": "\"e7ca9-TwrKIjGLrBn/zQhJa/ED2zvKXig\"",
    "mtime": "2025-10-23T08:49:34.772Z",
    "size": 949417,
    "path": "../public/logo.svg"
  },
  "/logo2.jpg": {
    "type": "image/jpeg",
    "etag": "\"57c2-2SIIiOtfvRcAn6bcAhUXO8jmt/c\"",
    "mtime": "2025-10-23T09:49:26.431Z",
    "size": 22466,
    "path": "../public/logo2.jpg"
  },
  "/_nuxt/-3Ll3XdP.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"1117-NPZjjniTDQRBiL6xSXusGamfC5o\"",
    "mtime": "2025-11-25T15:50:41.233Z",
    "size": 4375,
    "path": "../public/_nuxt/-3Ll3XdP.js"
  },
  "/_nuxt/-lZjj20B.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"39d-KL0KbUOKADunsNTBXVTEhVuCSv0\"",
    "mtime": "2025-11-25T15:50:41.243Z",
    "size": 925,
    "path": "../public/_nuxt/-lZjj20B.js"
  },
  "/_nuxt/0JJbOJ74.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"449-0ahaAa6r7UNMiEZYo4Uc5FQOtMg\"",
    "mtime": "2025-11-25T15:50:41.213Z",
    "size": 1097,
    "path": "../public/_nuxt/0JJbOJ74.js"
  },
  "/_nuxt/0SM4VGmm.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"2a3-E0lYCh9S8O3lvpT+Bmv9b4XGC5k\"",
    "mtime": "2025-11-25T15:50:41.110Z",
    "size": 675,
    "path": "../public/_nuxt/0SM4VGmm.js"
  },
  "/_nuxt/1trend.T7UNp7Py.png": {
    "type": "image/png",
    "etag": "\"1bde0-FA58BOASJzxUXYzAKWkbk/GMZNM\"",
    "mtime": "2025-11-25T15:50:41.038Z",
    "size": 114144,
    "path": "../public/_nuxt/1trend.T7UNp7Py.png"
  },
  "/_nuxt/2dr3ICOP.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"550-zmOyRn2NbR+tesylMpLm1HvRftM\"",
    "mtime": "2025-11-25T15:50:41.270Z",
    "size": 1360,
    "path": "../public/_nuxt/2dr3ICOP.js"
  },
  "/_nuxt/2gPy_MU7.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"5e3-vm03V68iT4LXpe3oFLIsvFK8j+E\"",
    "mtime": "2025-11-25T15:50:41.263Z",
    "size": 1507,
    "path": "../public/_nuxt/2gPy_MU7.js"
  },
  "/_nuxt/4-3XWjuX.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"886-ISd17RhLVHWO+Y93mPXygoWYQXk\"",
    "mtime": "2025-11-25T15:50:41.229Z",
    "size": 2182,
    "path": "../public/_nuxt/4-3XWjuX.js"
  },
  "/_nuxt/4bPApjrm.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"699-cdWCyljkkud0MNbWiEbOhKn9fgU\"",
    "mtime": "2025-11-25T15:50:41.240Z",
    "size": 1689,
    "path": "../public/_nuxt/4bPApjrm.js"
  },
  "/_nuxt/80Off.BSWkS4LL.webp": {
    "type": "image/webp",
    "etag": "\"539c-Ajakr4ayTE3Ss/uacsOch1Tex2w\"",
    "mtime": "2025-11-25T15:50:41.038Z",
    "size": 21404,
    "path": "../public/_nuxt/80Off.BSWkS4LL.webp"
  },
  "/_nuxt/8XN_QdxZ.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"24f-xNRymfzftagxsaCqo2EfT1vIoJk\"",
    "mtime": "2025-11-25T15:50:41.265Z",
    "size": 591,
    "path": "../public/_nuxt/8XN_QdxZ.js"
  },
  "/_nuxt/a6b8uQaq.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"240-y7In3gHERdp1cJ1/wctZZlKc610\"",
    "mtime": "2025-11-25T15:50:41.150Z",
    "size": 576,
    "path": "../public/_nuxt/a6b8uQaq.js"
  },
  "/_nuxt/aLD_J8r9.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"2c0-zpVezNJFyFq6hjtOlXrrL5Mxxu8\"",
    "mtime": "2025-11-25T15:50:41.256Z",
    "size": 704,
    "path": "../public/_nuxt/aLD_J8r9.js"
  },
  "/_nuxt/app-store.zaEe8IGQ.svg": {
    "type": "image/svg+xml",
    "etag": "\"45bb-SaRNCE2xKg/XxLh6z/F8BJGyg28\"",
    "mtime": "2025-11-25T15:50:41.039Z",
    "size": 17851,
    "path": "../public/_nuxt/app-store.zaEe8IGQ.svg"
  },
  "/_nuxt/ApvtaszR.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"22a-HC/i0JQIgB3g7TZG/9RvfJqeMxw\"",
    "mtime": "2025-11-25T15:50:41.168Z",
    "size": 554,
    "path": "../public/_nuxt/ApvtaszR.js"
  },
  "/_nuxt/auth.Blnl2U_Y.css": {
    "type": "text/css; charset=utf-8",
    "etag": "\"9a-DE3cq7lg+QTKHP7JBtuXkQcecvs\"",
    "mtime": "2025-11-25T15:50:41.072Z",
    "size": 154,
    "path": "../public/_nuxt/auth.Blnl2U_Y.css"
  },
  "/_nuxt/B-A7L1EV.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"22a-TREBkdLJI3xZy5Dq7OEJc+rVGEA\"",
    "mtime": "2025-11-25T15:50:41.231Z",
    "size": 554,
    "path": "../public/_nuxt/B-A7L1EV.js"
  },
  "/_nuxt/B2EUsibC.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"236-Hu9vPTjRhnfvsXNMFA8pBfCIVrg\"",
    "mtime": "2025-11-25T15:50:41.215Z",
    "size": 566,
    "path": "../public/_nuxt/B2EUsibC.js"
  },
  "/_nuxt/B3PM4aDN.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"2ab-eQvjOAM5pt21DD7B+puEDH2oqvo\"",
    "mtime": "2025-11-25T15:50:41.196Z",
    "size": 683,
    "path": "../public/_nuxt/B3PM4aDN.js"
  },
  "/_nuxt/B4K18U3B.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"248-yfgZX7MPTLbiJVo6Ar+AxjQCPF8\"",
    "mtime": "2025-11-25T15:50:41.143Z",
    "size": 584,
    "path": "../public/_nuxt/B4K18U3B.js"
  },
  "/_nuxt/B4nmg_rR.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"1101-d0gpYw/fiEu1QJJZSHXlgbKSbBo\"",
    "mtime": "2025-11-25T15:50:41.264Z",
    "size": 4353,
    "path": "../public/_nuxt/B4nmg_rR.js"
  },
  "/_nuxt/b4x3YPP5.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"2667-Rdj8cJmZrdtnig0qQjOniS6fP4k\"",
    "mtime": "2025-11-25T15:50:41.075Z",
    "size": 9831,
    "path": "../public/_nuxt/b4x3YPP5.js"
  },
  "/_nuxt/B5gqX6Yj.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"1e4-ryHK7XK7v8zY/YeyDi7ErdvhD0E\"",
    "mtime": "2025-11-25T15:50:41.138Z",
    "size": 484,
    "path": "../public/_nuxt/B5gqX6Yj.js"
  },
  "/_nuxt/B5PAu3oy.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"164-tc9YBCH4xYWNCgqURRiqEnpKYzs\"",
    "mtime": "2025-11-25T15:50:41.240Z",
    "size": 356,
    "path": "../public/_nuxt/B5PAu3oy.js"
  },
  "/_nuxt/b6prkwdd.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"99e-uxe6oD4HRAkZ3wurLV0gmxZETJE\"",
    "mtime": "2025-11-25T15:50:41.271Z",
    "size": 2462,
    "path": "../public/_nuxt/b6prkwdd.js"
  },
  "/_nuxt/B6VC-Vp4.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"28c-rbLBaGaIi6eBt0KYdtqw2Ffal3M\"",
    "mtime": "2025-11-25T15:50:41.152Z",
    "size": 652,
    "path": "../public/_nuxt/B6VC-Vp4.js"
  },
  "/_nuxt/B7bXU_yt.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"503b-x/U7Qet2DlnLZzIFFL1aXnXkOnk\"",
    "mtime": "2025-11-25T15:50:41.115Z",
    "size": 20539,
    "path": "../public/_nuxt/B7bXU_yt.js"
  },
  "/_nuxt/B7cFp8XJ.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"52a-pr2tGgsoGAjFxZDFpuxUSkU9nd8\"",
    "mtime": "2025-11-25T15:50:41.197Z",
    "size": 1322,
    "path": "../public/_nuxt/B7cFp8XJ.js"
  },
  "/_nuxt/B957bhuK.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"bb2-wih3ei0J5KyFc58kH35cPBL9lF0\"",
    "mtime": "2025-11-25T15:50:41.271Z",
    "size": 2994,
    "path": "../public/_nuxt/B957bhuK.js"
  },
  "/_nuxt/Ba5CxzNF.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"132e-q4aRabi2hEnqydlFX0GfXXkK7Qs\"",
    "mtime": "2025-11-25T15:50:41.212Z",
    "size": 4910,
    "path": "../public/_nuxt/Ba5CxzNF.js"
  },
  "/_nuxt/Bahm_bzW.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"383-1fGk3mZYJ8XaqLd2C4ZlmPyEWIs\"",
    "mtime": "2025-11-25T15:50:41.211Z",
    "size": 899,
    "path": "../public/_nuxt/Bahm_bzW.js"
  },
  "/_nuxt/BBB1K7RO.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"2ca-s/GyHM7/+d+XfPmm0oY7pbL11m8\"",
    "mtime": "2025-11-25T15:50:41.152Z",
    "size": 714,
    "path": "../public/_nuxt/BBB1K7RO.js"
  },
  "/_nuxt/Bcumcj-e.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"3a56-kuEUthANWqQN74lFk+BA0CGlNJk\"",
    "mtime": "2025-11-25T15:50:41.088Z",
    "size": 14934,
    "path": "../public/_nuxt/Bcumcj-e.js"
  },
  "/_nuxt/BdfC77-K.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"28c-QCRmA/XGtbn60oDNOglXgvenEb4\"",
    "mtime": "2025-11-25T15:50:41.263Z",
    "size": 652,
    "path": "../public/_nuxt/BdfC77-K.js"
  },
  "/_nuxt/BdZSjx6P.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"392-9M+wjATpS3SWepfC7o2uon1OPrI\"",
    "mtime": "2025-11-25T15:50:41.243Z",
    "size": 914,
    "path": "../public/_nuxt/BdZSjx6P.js"
  },
  "/_nuxt/BEe05jCG.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"1d1-MJie487z9nHNrPC1BeoPfSZYtD0\"",
    "mtime": "2025-11-25T15:50:41.138Z",
    "size": 465,
    "path": "../public/_nuxt/BEe05jCG.js"
  },
  "/_nuxt/Bfc9Xvi8.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"257-jV8br6C+4cXUkgkxyAWlFHPBNnk\"",
    "mtime": "2025-11-25T15:50:41.240Z",
    "size": 599,
    "path": "../public/_nuxt/Bfc9Xvi8.js"
  },
  "/_nuxt/BJDueRdR.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"373-Vg4y6lPZbWasg15OtQl2zZt70oA\"",
    "mtime": "2025-11-25T15:50:41.244Z",
    "size": 883,
    "path": "../public/_nuxt/BJDueRdR.js"
  },
  "/_nuxt/BlAVPRId.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"772-k5ce10RutJBWj+pJzfZ/eR4j50k\"",
    "mtime": "2025-11-25T15:50:41.095Z",
    "size": 1906,
    "path": "../public/_nuxt/BlAVPRId.js"
  },
  "/_nuxt/BMqWfRtu.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"1c9e-61sm5due0FmRQ8lcFBfym7I33ws\"",
    "mtime": "2025-11-25T15:50:41.095Z",
    "size": 7326,
    "path": "../public/_nuxt/BMqWfRtu.js"
  },
  "/_nuxt/BmvuMl2U.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"3c-BSMY5lj8Bz+/iFoyNEd7q1rPpLY\"",
    "mtime": "2025-11-25T15:50:41.079Z",
    "size": 60,
    "path": "../public/_nuxt/BmvuMl2U.js"
  },
  "/_nuxt/BP12Pj5d.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"10d4-T8zecApSBtu5A57YDOfq+RaGv0w\"",
    "mtime": "2025-11-25T15:50:41.106Z",
    "size": 4308,
    "path": "../public/_nuxt/BP12Pj5d.js"
  },
  "/_nuxt/BPej0F5G.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"2c2-Q5i38A7Vv+otj2TKwLni2m8ViD8\"",
    "mtime": "2025-11-25T15:50:41.153Z",
    "size": 706,
    "path": "../public/_nuxt/BPej0F5G.js"
  },
  "/_nuxt/BpLFHf8F.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"360-rFAJ9yGTEigPFhwGmfrfiqr8yds\"",
    "mtime": "2025-11-25T15:50:41.154Z",
    "size": 864,
    "path": "../public/_nuxt/BpLFHf8F.js"
  },
  "/_nuxt/Bq93U2IV.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"455-LCHYbgBwxTs+BOtNT3Eoo61YcWk\"",
    "mtime": "2025-11-25T15:50:41.229Z",
    "size": 1109,
    "path": "../public/_nuxt/Bq93U2IV.js"
  },
  "/_nuxt/BrbtSOjC.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"b7a-r7m0O/d9gVRhfo1GopVqXNUY6KE\"",
    "mtime": "2025-11-25T15:50:41.264Z",
    "size": 2938,
    "path": "../public/_nuxt/BrbtSOjC.js"
  },
  "/_nuxt/breadcrumb.CIwqTr20.css": {
    "type": "text/css; charset=utf-8",
    "etag": "\"6f-oLtA7b7gThfDGQgOROwHiJHJifs\"",
    "mtime": "2025-11-25T15:50:41.071Z",
    "size": 111,
    "path": "../public/_nuxt/breadcrumb.CIwqTr20.css"
  },
  "/_nuxt/BReDe4na.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"813b-nkB/nR+fW+laW+oscYFXjMXZUQE\"",
    "mtime": "2025-11-25T15:50:41.078Z",
    "size": 33083,
    "path": "../public/_nuxt/BReDe4na.js"
  },
  "/_nuxt/BSBTX573.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"3da-8EHcCndjzfgSm6ex6ClcHEXPziw\"",
    "mtime": "2025-11-25T15:50:41.214Z",
    "size": 986,
    "path": "../public/_nuxt/BSBTX573.js"
  },
  "/_nuxt/BsBvffSE.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"146c-Ks4rqiirL6/1BNaNkNY0Ki7YipE\"",
    "mtime": "2025-11-25T15:50:41.073Z",
    "size": 5228,
    "path": "../public/_nuxt/BsBvffSE.js"
  },
  "/_nuxt/BtlEduen.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"3275-e8QWFW7SmVhpw0m3rKre8Pz+c90\"",
    "mtime": "2025-11-25T15:50:41.089Z",
    "size": 12917,
    "path": "../public/_nuxt/BtlEduen.js"
  },
  "/_nuxt/BTTCRb_o.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"8aa-6JVvuks+BqbZR5aqqNoIkCXvq1k\"",
    "mtime": "2025-11-25T15:50:41.199Z",
    "size": 2218,
    "path": "../public/_nuxt/BTTCRb_o.js"
  },
  "/_nuxt/BTTqPbnM.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"739-KZx9dXu5Wk57NqNBG/7h/dz5RaE\"",
    "mtime": "2025-11-25T15:50:41.240Z",
    "size": 1849,
    "path": "../public/_nuxt/BTTqPbnM.js"
  },
  "/_nuxt/Bu-mPGME.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"2f6-Pk+a9mbLGvANyM9VvaVL+tBQqQo\"",
    "mtime": "2025-11-25T15:50:41.244Z",
    "size": 758,
    "path": "../public/_nuxt/Bu-mPGME.js"
  },
  "/_nuxt/BU2Vj_5l.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"1c3-MR4ra6lESvLkDiun+fERCQYSJMY\"",
    "mtime": "2025-11-25T15:50:41.168Z",
    "size": 451,
    "path": "../public/_nuxt/BU2Vj_5l.js"
  },
  "/_nuxt/BuGfHzNx.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"422-Lb8QZfX168JUsFyzMT7NIj7S2U0\"",
    "mtime": "2025-11-25T15:50:41.158Z",
    "size": 1058,
    "path": "../public/_nuxt/BuGfHzNx.js"
  },
  "/_nuxt/BvtilTlN.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"268-Demnm0aJwWSjPWe2WE5jYl2I33c\"",
    "mtime": "2025-11-25T15:50:41.156Z",
    "size": 616,
    "path": "../public/_nuxt/BvtilTlN.js"
  },
  "/_nuxt/Bw_4B2XA.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"5e7-VpI0h0yUKtPMpJ7ZWHaucyDcEvw\"",
    "mtime": "2025-11-25T15:50:41.264Z",
    "size": 1511,
    "path": "../public/_nuxt/Bw_4B2XA.js"
  },
  "/_nuxt/By1KmDsQ.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"7f0-89UgwlnQaLeR70EGIZ61PoLNl9k\"",
    "mtime": "2025-11-25T15:50:41.113Z",
    "size": 2032,
    "path": "../public/_nuxt/By1KmDsQ.js"
  },
  "/_nuxt/BYikdGxP.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"665-j6siWB5x5MfbY5dMlxA7E3VaC8A\"",
    "mtime": "2025-11-25T15:50:41.212Z",
    "size": 1637,
    "path": "../public/_nuxt/BYikdGxP.js"
  },
  "/_nuxt/BYy72_sW.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"285-0b4k/81bsskkC+r/RD3DdgKWvmQ\"",
    "mtime": "2025-11-25T15:50:41.152Z",
    "size": 645,
    "path": "../public/_nuxt/BYy72_sW.js"
  },
  "/_nuxt/Bz6T5zN9.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"23d-ps/ygytNMCLVMHWAJ93hehRMf5s\"",
    "mtime": "2025-11-25T15:50:41.270Z",
    "size": 573,
    "path": "../public/_nuxt/Bz6T5zN9.js"
  },
  "/_nuxt/BZ6yeniX.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"3bb-Gc1rRsrfbEnSEJ86RWjvttLzhOI\"",
    "mtime": "2025-11-25T15:50:41.263Z",
    "size": 955,
    "path": "../public/_nuxt/BZ6yeniX.js"
  },
  "/_nuxt/BZrw3LJc.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"277-Tam3fa9685VzrV2/dm6rijkgmKI\"",
    "mtime": "2025-11-25T15:50:41.263Z",
    "size": 631,
    "path": "../public/_nuxt/BZrw3LJc.js"
  },
  "/_nuxt/C-PrhWe4.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"16c-LKam2InP1Ituwv7jWzMUVfOuas4\"",
    "mtime": "2025-11-25T15:50:41.139Z",
    "size": 364,
    "path": "../public/_nuxt/C-PrhWe4.js"
  },
  "/_nuxt/C-zn4Jdl.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"ddd-YAFIRpXiDeOBMjloeYBEHqvxmhY\"",
    "mtime": "2025-11-25T15:50:41.133Z",
    "size": 3549,
    "path": "../public/_nuxt/C-zn4Jdl.js"
  },
  "/_nuxt/C005D5nn.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"14a0-UU7fvCI2n8ZIgjdcsUABUx9ElrM\"",
    "mtime": "2025-11-25T15:50:41.212Z",
    "size": 5280,
    "path": "../public/_nuxt/C005D5nn.js"
  },
  "/_nuxt/c19X_3--.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"273-6KfbGtMa68Dy4z6UqvQbzppYdTg\"",
    "mtime": "2025-11-25T15:50:41.272Z",
    "size": 627,
    "path": "../public/_nuxt/c19X_3--.js"
  },
  "/_nuxt/C5tOdTjb.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"426-WSs1Z6EUhsVdsYq38DH4JROuM0U\"",
    "mtime": "2025-11-25T15:50:41.091Z",
    "size": 1062,
    "path": "../public/_nuxt/C5tOdTjb.js"
  },
  "/_nuxt/C6r5Yc3-.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"20f-1FgN9dbDkKI7fmzqTKCm5gNY0FM\"",
    "mtime": "2025-11-25T15:50:41.258Z",
    "size": 527,
    "path": "../public/_nuxt/C6r5Yc3-.js"
  },
  "/_nuxt/Ca1CYb1v.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"a4f-2Hqw6fnN0lTUx4YsDiHRo4FIqJg\"",
    "mtime": "2025-11-25T15:50:41.212Z",
    "size": 2639,
    "path": "../public/_nuxt/Ca1CYb1v.js"
  },
  "/_nuxt/CaA5uMV2.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"76e-wEpx+0TExBGYAkOhXUWYioRG/qQ\"",
    "mtime": "2025-11-25T15:50:41.243Z",
    "size": 1902,
    "path": "../public/_nuxt/CaA5uMV2.js"
  },
  "/_nuxt/CAAZA5ty.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"537-ZqRtLcL+86/24GvoxMzFthXm2fQ\"",
    "mtime": "2025-11-25T15:50:41.272Z",
    "size": 1335,
    "path": "../public/_nuxt/CAAZA5ty.js"
  },
  "/_nuxt/Cairo-Black.CiPMz1rI.ttf": {
    "type": "font/ttf",
    "etag": "\"171fc-Udh5Av9WsuiYf38G70no01H+ACI\"",
    "mtime": "2025-11-25T15:50:40.969Z",
    "size": 94716,
    "path": "../public/_nuxt/Cairo-Black.CiPMz1rI.ttf"
  },
  "/_nuxt/Cairo-Bold.I2ZtaFuO.ttf": {
    "type": "font/ttf",
    "etag": "\"171c0-WnsFQ8bGKEOQD11aBJ68MrVDT10\"",
    "mtime": "2025-11-25T15:50:40.970Z",
    "size": 94656,
    "path": "../public/_nuxt/Cairo-Bold.I2ZtaFuO.ttf"
  },
  "/_nuxt/Cairo-ExtraBold.DYTTxaco.ttf": {
    "type": "font/ttf",
    "etag": "\"171f8-LkiZLMT/1zM83J60qiuog8THTxo\"",
    "mtime": "2025-11-25T15:50:40.970Z",
    "size": 94712,
    "path": "../public/_nuxt/Cairo-ExtraBold.DYTTxaco.ttf"
  },
  "/_nuxt/Cairo-ExtraLight.CIOx8Y0E.ttf": {
    "type": "font/ttf",
    "etag": "\"16a48-sw3frlLGK0nLOv/WVLCXr/Xm6Ek\"",
    "mtime": "2025-11-25T15:50:40.970Z",
    "size": 92744,
    "path": "../public/_nuxt/Cairo-ExtraLight.CIOx8Y0E.ttf"
  },
  "/_nuxt/Cairo-Light.CB4yp-7N.ttf": {
    "type": "font/ttf",
    "etag": "\"16a84-WaoEnVb3D3cK+S/Yae4C9rQI5EQ\"",
    "mtime": "2025-11-25T15:50:40.971Z",
    "size": 92804,
    "path": "../public/_nuxt/Cairo-Light.CB4yp-7N.ttf"
  },
  "/_nuxt/Cairo-Medium.BS5LWzLe.ttf": {
    "type": "font/ttf",
    "etag": "\"171b8-/Y4tA2edRhtVa7TMRkgRMQwS7SQ\"",
    "mtime": "2025-11-25T15:50:40.971Z",
    "size": 94648,
    "path": "../public/_nuxt/Cairo-Medium.BS5LWzLe.ttf"
  },
  "/_nuxt/Cairo-Regular.Cpd_OyVR.ttf": {
    "type": "font/ttf",
    "etag": "\"17114-xAzWnYVNEsgYswyGZopFMFtTHF0\"",
    "mtime": "2025-11-25T15:50:40.973Z",
    "size": 94484,
    "path": "../public/_nuxt/Cairo-Regular.Cpd_OyVR.ttf"
  },
  "/_nuxt/Cairo-SemiBold.LwFphzwy.ttf": {
    "type": "font/ttf",
    "etag": "\"171e4-YuvZXH9EDgMxEYjJ7tAqrjEwRcU\"",
    "mtime": "2025-11-25T15:50:40.971Z",
    "size": 94692,
    "path": "../public/_nuxt/Cairo-SemiBold.LwFphzwy.ttf"
  },
  "/_nuxt/Cairo-VariableFont_slnt_wght.4A3BC3p8.ttf": {
    "type": "font/ttf",
    "etag": "\"564b8-ZlrjmSIsXE4s8R0Ukh30yWsBfR0\"",
    "mtime": "2025-11-25T15:50:40.971Z",
    "size": 353464,
    "path": "../public/_nuxt/Cairo-VariableFont_slnt_wght.4A3BC3p8.ttf"
  },
  "/_nuxt/CaQXg7zB.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"26bc-1huQdsx83Z1v2Aod56SS8c8CSd8\"",
    "mtime": "2025-11-25T15:50:41.076Z",
    "size": 9916,
    "path": "../public/_nuxt/CaQXg7zB.js"
  },
  "/_nuxt/CArrF1C_.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"950-9QegAeiYwCi6Met5RxtPpUG4wNQ\"",
    "mtime": "2025-11-25T15:50:41.229Z",
    "size": 2384,
    "path": "../public/_nuxt/CArrF1C_.js"
  },
  "/_nuxt/cart-empty.ChzVmTJz.png": {
    "type": "image/png",
    "etag": "\"15703-ldQ/9vv2wQeiTBsBrTt8xmC7gTg\"",
    "mtime": "2025-11-25T15:50:41.039Z",
    "size": 87811,
    "path": "../public/_nuxt/cart-empty.ChzVmTJz.png"
  },
  "/_nuxt/cart.iBHhk62p.css": {
    "type": "text/css; charset=utf-8",
    "etag": "\"20c-LFE++5ZJR9h0N9wLZ7QpqtUWjhk\"",
    "mtime": "2025-11-25T15:50:41.067Z",
    "size": 524,
    "path": "../public/_nuxt/cart.iBHhk62p.css"
  },
  "/_nuxt/CaxqCZ-o.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"fd8-fDNnHF5roWjgB15vGpAj14sLWXo\"",
    "mtime": "2025-11-25T15:50:41.264Z",
    "size": 4056,
    "path": "../public/_nuxt/CaxqCZ-o.js"
  },
  "/_nuxt/CbjEPljS.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"1eb-NNKwuNqHoNIGAgiDrvfQZSVBUuU\"",
    "mtime": "2025-11-25T15:50:41.238Z",
    "size": 491,
    "path": "../public/_nuxt/CbjEPljS.js"
  },
  "/_nuxt/CBLn8r9Q.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"6483-1Dn4UzTcHQAea7KfyN0jk80n9K4\"",
    "mtime": "2025-11-25T15:50:41.107Z",
    "size": 25731,
    "path": "../public/_nuxt/CBLn8r9Q.js"
  },
  "/_nuxt/CDr_8_OI.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"48e4-SaxWzT5rES2TYhSX9xEB4xXDY44\"",
    "mtime": "2025-11-25T15:50:41.075Z",
    "size": 18660,
    "path": "../public/_nuxt/CDr_8_OI.js"
  },
  "/_nuxt/CEd915lO.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"4a3-EoV46wEYfRVg2FUXJp0L07oPP4c\"",
    "mtime": "2025-11-25T15:50:41.231Z",
    "size": 1187,
    "path": "../public/_nuxt/CEd915lO.js"
  },
  "/_nuxt/CeRo3mHz.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"3d6-F5C0QI9dwVUkULtjC7O3NGUsZCs\"",
    "mtime": "2025-11-25T15:50:41.198Z",
    "size": 982,
    "path": "../public/_nuxt/CeRo3mHz.js"
  },
  "/_nuxt/CEXXe_fb.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"31d-JeRu2cVdfbd/91K6FFefr+RwHw0\"",
    "mtime": "2025-11-25T15:50:41.270Z",
    "size": 797,
    "path": "../public/_nuxt/CEXXe_fb.js"
  },
  "/_nuxt/CFGNYEIb.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"34809-1UzptwDQ8uBZ6TS0JbW2+73Ho2I\"",
    "mtime": "2025-11-25T15:50:41.073Z",
    "size": 215049,
    "path": "../public/_nuxt/CFGNYEIb.js"
  },
  "/_nuxt/Cg8tdazl.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"3a4-sHjmOfa2FJcNpW5rClJVT/S3tPw\"",
    "mtime": "2025-11-25T15:50:41.262Z",
    "size": 932,
    "path": "../public/_nuxt/Cg8tdazl.js"
  },
  "/_nuxt/CGIwwiGB.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"251-A1uBRviU88CISMmFJWYxRHhMgC0\"",
    "mtime": "2025-11-25T15:50:41.118Z",
    "size": 593,
    "path": "../public/_nuxt/CGIwwiGB.js"
  },
  "/_nuxt/CGjOh2Y9.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"1514-kbX3kXOfg/QPuAo0rxqs4+lfP/4\"",
    "mtime": "2025-11-25T15:50:41.089Z",
    "size": 5396,
    "path": "../public/_nuxt/CGjOh2Y9.js"
  },
  "/_nuxt/CH-uE3qH.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"b87-QXA0whI9BUCJRsWSgXTLetdoFTU\"",
    "mtime": "2025-11-25T15:50:41.091Z",
    "size": 2951,
    "path": "../public/_nuxt/CH-uE3qH.js"
  },
  "/_nuxt/CHBvqbI6.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"1179-yqdOogHY4bHTkeL6hI/Zz5RQ+6U\"",
    "mtime": "2025-11-25T15:50:41.171Z",
    "size": 4473,
    "path": "../public/_nuxt/CHBvqbI6.js"
  },
  "/_nuxt/ChEla6Lm.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"4ac-cmuEGx5hAcTVAKXD7Es3u+6J/Qs\"",
    "mtime": "2025-11-25T15:50:41.258Z",
    "size": 1196,
    "path": "../public/_nuxt/ChEla6Lm.js"
  },
  "/_nuxt/ChiPQ6Zs.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"9ed-YHqBrTv+iFOtngWwNQjj4CffkCA\"",
    "mtime": "2025-11-25T15:50:41.272Z",
    "size": 2541,
    "path": "../public/_nuxt/ChiPQ6Zs.js"
  },
  "/_nuxt/CHKBig5M.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"187-roExhNJSQFrQbFe6Rp7TfFcf0TA\"",
    "mtime": "2025-11-25T15:50:41.272Z",
    "size": 391,
    "path": "../public/_nuxt/CHKBig5M.js"
  },
  "/_nuxt/ChVxnb40.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"27c-iFKfrb1Wa+ZsqGQ9V0sEjvW2UK8\"",
    "mtime": "2025-11-25T15:50:41.152Z",
    "size": 636,
    "path": "../public/_nuxt/ChVxnb40.js"
  },
  "/_nuxt/CiMWS39q.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"6dc-N+jXil05Bxg5XYpcUtmlff2wdM0\"",
    "mtime": "2025-11-25T15:50:41.200Z",
    "size": 1756,
    "path": "../public/_nuxt/CiMWS39q.js"
  },
  "/_nuxt/CInEczii.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"363-/4gtz7sPqhfkpe0mmLqwBdb/yvQ\"",
    "mtime": "2025-11-25T15:50:41.212Z",
    "size": 867,
    "path": "../public/_nuxt/CInEczii.js"
  },
  "/_nuxt/Cj3G0mF2.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"364-xs0W4eGbhZH+oYJaZgLrCrVyMkM\"",
    "mtime": "2025-11-25T15:50:41.160Z",
    "size": 868,
    "path": "../public/_nuxt/Cj3G0mF2.js"
  },
  "/_nuxt/CjDqejJK.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"1731-fvVF5sAD0Nm6SHt18DrSg1CQioc\"",
    "mtime": "2025-11-25T15:50:41.125Z",
    "size": 5937,
    "path": "../public/_nuxt/CjDqejJK.js"
  },
  "/_nuxt/Cjua0--0.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"2b0-5usXMrxWM42weQFDie7bMvwWShg\"",
    "mtime": "2025-11-25T15:50:41.214Z",
    "size": 688,
    "path": "../public/_nuxt/Cjua0--0.js"
  },
  "/_nuxt/CjuKCPD2.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"718-CkDIjmBlZFKiuk69+flrvpshx7Q\"",
    "mtime": "2025-11-25T15:50:41.093Z",
    "size": 1816,
    "path": "../public/_nuxt/CjuKCPD2.js"
  },
  "/_nuxt/CK8zT_hn.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"200-SCr1iXi06B+FxfNB4cPdut5oo0I\"",
    "mtime": "2025-11-25T15:50:41.170Z",
    "size": 512,
    "path": "../public/_nuxt/CK8zT_hn.js"
  },
  "/_nuxt/CKOB87qZ.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"5be-z5Ol3BMVtRERPPXM7H640ClSB1A\"",
    "mtime": "2025-11-25T15:50:41.256Z",
    "size": 1470,
    "path": "../public/_nuxt/CKOB87qZ.js"
  },
  "/_nuxt/CLqT4ft_.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"df-o9rP+5WbZdu/yfDszP6NbgTL5h8\"",
    "mtime": "2025-11-25T15:50:41.120Z",
    "size": 223,
    "path": "../public/_nuxt/CLqT4ft_.js"
  },
  "/_nuxt/CMp6mtGb.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"3b6-/0YolU0tiAxuNHG49tQb/UsnC5g\"",
    "mtime": "2025-11-25T15:50:41.153Z",
    "size": 950,
    "path": "../public/_nuxt/CMp6mtGb.js"
  },
  "/_nuxt/CMQdFI8Q.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"377-x7oH/KU/tznsMPn9PGYiQ0Vufe0\"",
    "mtime": "2025-11-25T15:50:41.110Z",
    "size": 887,
    "path": "../public/_nuxt/CMQdFI8Q.js"
  },
  "/_nuxt/CndXV-wV.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"24e-QM/ZHm6DDK/XBbf2ka7FGe1gG4I\"",
    "mtime": "2025-11-25T15:50:41.171Z",
    "size": 590,
    "path": "../public/_nuxt/CndXV-wV.js"
  },
  "/_nuxt/CNFfT_IC.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"149-OTujhD+b0XJO0r1jlqIHq34Z8Yk\"",
    "mtime": "2025-11-25T15:50:41.150Z",
    "size": 329,
    "path": "../public/_nuxt/CNFfT_IC.js"
  },
  "/_nuxt/CNgXsL-A.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"23b-HxyMnlYuxdV/mF7edJaA2a0+WDM\"",
    "mtime": "2025-11-25T15:50:41.228Z",
    "size": 571,
    "path": "../public/_nuxt/CNgXsL-A.js"
  },
  "/_nuxt/CNzYF02j.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"4dd-4zm4ylDtfocUKtzuHpjpQXT3lX0\"",
    "mtime": "2025-11-25T15:50:41.155Z",
    "size": 1245,
    "path": "../public/_nuxt/CNzYF02j.js"
  },
  "/_nuxt/CO2y4Pnz.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"87f6-VJGgi7XUdyXWgmvDylm0s0i1JXQ\"",
    "mtime": "2025-11-25T15:50:41.109Z",
    "size": 34806,
    "path": "../public/_nuxt/CO2y4Pnz.js"
  },
  "/_nuxt/COxLfz42.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"403-64dTOR+vL+EA+iAJJq1MxNcw34w\"",
    "mtime": "2025-11-25T15:50:41.137Z",
    "size": 1027,
    "path": "../public/_nuxt/COxLfz42.js"
  },
  "/_nuxt/CpwOOyfN.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"40f-OuTleQu2dbe9pLS6jYz6hXaaAcg\"",
    "mtime": "2025-11-25T15:50:41.073Z",
    "size": 1039,
    "path": "../public/_nuxt/CpwOOyfN.js"
  },
  "/_nuxt/CQjYU1hB.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"282-iaBudHg9uKat+j9taqrm1mwr5qM\"",
    "mtime": "2025-11-25T15:50:41.228Z",
    "size": 642,
    "path": "../public/_nuxt/CQjYU1hB.js"
  },
  "/_nuxt/CQlSorTF.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"1040-N2OoN0aVmSQCPqtSNY4JsXGCQzw\"",
    "mtime": "2025-11-25T15:50:41.171Z",
    "size": 4160,
    "path": "../public/_nuxt/CQlSorTF.js"
  },
  "/_nuxt/Cqnma-fa.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"945-qB2ygsyJo9JFZgCYYBJ7huOjBjA\"",
    "mtime": "2025-11-25T15:50:41.114Z",
    "size": 2373,
    "path": "../public/_nuxt/Cqnma-fa.js"
  },
  "/_nuxt/CRbITvBB.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"1df3-UXz4SAwCDTRvRIXVvAlYgjvBlAs\"",
    "mtime": "2025-11-25T15:50:41.232Z",
    "size": 7667,
    "path": "../public/_nuxt/CRbITvBB.js"
  },
  "/_nuxt/CRHtvfor.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"380-XYn+0RiZvzNc8Sl4NurpXHQMI54\"",
    "mtime": "2025-11-25T15:50:41.197Z",
    "size": 896,
    "path": "../public/_nuxt/CRHtvfor.js"
  },
  "/_nuxt/CrW9zBpe.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"2ac-VamxyAzx8wWJz/g94PrAIxSYxVU\"",
    "mtime": "2025-11-25T15:50:41.229Z",
    "size": 684,
    "path": "../public/_nuxt/CrW9zBpe.js"
  },
  "/_nuxt/CRWH0Ree.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"2af-NJnXZTf50cFhrdHZ8Wogy7Xmwz0\"",
    "mtime": "2025-11-25T15:50:41.197Z",
    "size": 687,
    "path": "../public/_nuxt/CRWH0Ree.js"
  },
  "/_nuxt/CSOD-zWu.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"5cda-FjJWlqOTZcP6FzQtxBDuY4H0xtY\"",
    "mtime": "2025-11-25T15:50:41.087Z",
    "size": 23770,
    "path": "../public/_nuxt/CSOD-zWu.js"
  },
  "/_nuxt/CsTW15D8.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"493-CSAL+tPOTHt3cB3ijZJhpYKgGkM\"",
    "mtime": "2025-11-25T15:50:41.212Z",
    "size": 1171,
    "path": "../public/_nuxt/CsTW15D8.js"
  },
  "/_nuxt/CTdAryz4.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"1765-qMR9HoLgxilhW3E0rQmyzPttqaI\"",
    "mtime": "2025-11-25T15:50:41.259Z",
    "size": 5989,
    "path": "../public/_nuxt/CTdAryz4.js"
  },
  "/_nuxt/CU8DCHVL.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"c7ab-0qfUADpZgfen/moaKroWmebGieo\"",
    "mtime": "2025-11-25T15:50:41.090Z",
    "size": 51115,
    "path": "../public/_nuxt/CU8DCHVL.js"
  },
  "/_nuxt/CVLr6cJ3.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"864-t43bdbWwwJVhMm/gRF5Xg/kU+34\"",
    "mtime": "2025-11-25T15:50:41.244Z",
    "size": 2148,
    "path": "../public/_nuxt/CVLr6cJ3.js"
  },
  "/_nuxt/Cw3pCmtw.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"2c6-6gP7kEmPWYqW6QhNBpG89KTXIYQ\"",
    "mtime": "2025-11-25T15:50:41.231Z",
    "size": 710,
    "path": "../public/_nuxt/Cw3pCmtw.js"
  },
  "/_nuxt/Cw3q4nyB.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"236-PVS36bgqIfRoz0fN7hvdO+Vo0po\"",
    "mtime": "2025-11-25T15:50:41.213Z",
    "size": 566,
    "path": "../public/_nuxt/Cw3q4nyB.js"
  },
  "/_nuxt/CY4KoMjS.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"568-mGgNtC6T6myThzK2kl57l2BuqFs\"",
    "mtime": "2025-11-25T15:50:41.211Z",
    "size": 1384,
    "path": "../public/_nuxt/CY4KoMjS.js"
  },
  "/_nuxt/CYdSiMYE.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"42e-2i1ANI2IDdrrD+W388nEiO1kveY\"",
    "mtime": "2025-11-25T15:50:41.156Z",
    "size": 1070,
    "path": "../public/_nuxt/CYdSiMYE.js"
  },
  "/_nuxt/CZcH1Tfk.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"15e-hOE4LWwxj0Vpu8bHGTbN7Sa0XpY\"",
    "mtime": "2025-11-25T15:50:41.260Z",
    "size": 350,
    "path": "../public/_nuxt/CZcH1Tfk.js"
  },
  "/_nuxt/CzGv29rU.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"c3-JGhbbtI3vLDVlCu6sv17hsDu6rI\"",
    "mtime": "2025-11-25T15:50:41.135Z",
    "size": 195,
    "path": "../public/_nuxt/CzGv29rU.js"
  },
  "/_nuxt/Czu_icbf.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"508-w0d1LGwTFeBYzO5h7xsirkqVmSI\"",
    "mtime": "2025-11-25T15:50:41.135Z",
    "size": 1288,
    "path": "../public/_nuxt/Czu_icbf.js"
  },
  "/_nuxt/D--EYClD.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"2dc2-IXHEkIo4isdc1Gr3N/U4MFUYxZ4\"",
    "mtime": "2025-11-25T15:50:41.095Z",
    "size": 11714,
    "path": "../public/_nuxt/D--EYClD.js"
  },
  "/_nuxt/D0Z-bGM4.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"2ab-axoTKPeu857Rnb2ghONk91XS7jw\"",
    "mtime": "2025-11-25T15:50:41.241Z",
    "size": 683,
    "path": "../public/_nuxt/D0Z-bGM4.js"
  },
  "/_nuxt/D1c4wGDc.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"16012-gKx6A70yr2bT8v02OkApsjAHBdY\"",
    "mtime": "2025-11-25T15:50:41.094Z",
    "size": 90130,
    "path": "../public/_nuxt/D1c4wGDc.js"
  },
  "/_nuxt/D1msQ-Pw.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"2d0-Lp6iBS3l/BoIF/F+am8cIc8XvxM\"",
    "mtime": "2025-11-25T15:50:41.134Z",
    "size": 720,
    "path": "../public/_nuxt/D1msQ-Pw.js"
  },
  "/_nuxt/D25HNaTY.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"7e6-B1ZZYSM3JMwC/kiRSrPQ7GWgbr8\"",
    "mtime": "2025-11-25T15:50:41.133Z",
    "size": 2022,
    "path": "../public/_nuxt/D25HNaTY.js"
  },
  "/_nuxt/D3e0aYE6.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"21e-nqxpp3DYdF8rduTZZNV3/eGZ7qQ\"",
    "mtime": "2025-11-25T15:50:41.170Z",
    "size": 542,
    "path": "../public/_nuxt/D3e0aYE6.js"
  },
  "/_nuxt/D3Ke2OT2.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"1cff-KDk8amnwpRdyb3oPuWfKR73VfS0\"",
    "mtime": "2025-11-25T15:50:41.135Z",
    "size": 7423,
    "path": "../public/_nuxt/D3Ke2OT2.js"
  },
  "/_nuxt/D4MlBg8v.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"13ff-VI4vUV4VlbnwdGR2jaYZ1OUjuvY\"",
    "mtime": "2025-11-25T15:50:41.137Z",
    "size": 5119,
    "path": "../public/_nuxt/D4MlBg8v.js"
  },
  "/_nuxt/D5ZYIwbm.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"a284-pw4P8WN7Nya/W4QPzUx8mpmHI/E\"",
    "mtime": "2025-11-25T15:50:41.135Z",
    "size": 41604,
    "path": "../public/_nuxt/D5ZYIwbm.js"
  },
  "/_nuxt/D7HTYYYk.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"2c0-lYgFrthKLP2MIpt8LhlDJCjaJbo\"",
    "mtime": "2025-11-25T15:50:41.114Z",
    "size": 704,
    "path": "../public/_nuxt/D7HTYYYk.js"
  },
  "/_nuxt/DA4NME9e.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"8d6-PSGw3yOEelT9PEua07pu2pdmIyM\"",
    "mtime": "2025-11-25T15:50:41.155Z",
    "size": 2262,
    "path": "../public/_nuxt/DA4NME9e.js"
  },
  "/_nuxt/DaBgwMkF.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"b873-qpxAI8cBNCq4lK0oMBXpykUr+Eo\"",
    "mtime": "2025-11-25T15:50:41.135Z",
    "size": 47219,
    "path": "../public/_nuxt/DaBgwMkF.js"
  },
  "/_nuxt/DaDW4ikp.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"2dc-57CCGdZZwCYSq8XPeovImie2LKE\"",
    "mtime": "2025-11-25T15:50:41.154Z",
    "size": 732,
    "path": "../public/_nuxt/DaDW4ikp.js"
  },
  "/_nuxt/DbbZAR0S.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"78e-ovWiFmaGzgcza4rT0UwMy3BKg24\"",
    "mtime": "2025-11-25T15:50:41.229Z",
    "size": 1934,
    "path": "../public/_nuxt/DbbZAR0S.js"
  },
  "/_nuxt/DdeS3IRZ.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"21a-qZi14Vr/4uKPwUkhmJD5YVmvYts\"",
    "mtime": "2025-11-25T15:50:41.271Z",
    "size": 538,
    "path": "../public/_nuxt/DdeS3IRZ.js"
  },
  "/_nuxt/DDFIi42j.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"47a-SYRwBWZ6dT17NkPXhQ+t9jdpDmQ\"",
    "mtime": "2025-11-25T15:50:41.271Z",
    "size": 1146,
    "path": "../public/_nuxt/DDFIi42j.js"
  },
  "/_nuxt/DeagURXQ.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"188-itjtJmndm6xVILNpqIuIByIjsZ0\"",
    "mtime": "2025-11-25T15:50:41.243Z",
    "size": 392,
    "path": "../public/_nuxt/DeagURXQ.js"
  },
  "/_nuxt/DeCkFhPR.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"239-YW+3xjMM33DyIxOBfJe27IQzu9M\"",
    "mtime": "2025-11-25T15:50:41.153Z",
    "size": 569,
    "path": "../public/_nuxt/DeCkFhPR.js"
  },
  "/_nuxt/default.DWN9iSfp.css": {
    "type": "text/css; charset=utf-8",
    "etag": "\"1ee3-dXSCdPxfLCfzFimNJ8sIxcqgtDg\"",
    "mtime": "2025-11-25T15:50:41.072Z",
    "size": 7907,
    "path": "../public/_nuxt/default.DWN9iSfp.css"
  },
  "/_nuxt/Dg3YNfVh.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"270-P3wk928KXvMSs/Z6sktOs79qpcM\"",
    "mtime": "2025-11-25T15:50:41.110Z",
    "size": 624,
    "path": "../public/_nuxt/Dg3YNfVh.js"
  },
  "/_nuxt/Dg8qHuSd.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"1df1-b/E+N8k4kMEQHeoG4cXlj2mTEFQ\"",
    "mtime": "2025-11-25T15:50:41.244Z",
    "size": 7665,
    "path": "../public/_nuxt/Dg8qHuSd.js"
  },
  "/_nuxt/DgTdHVgk.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"1a1-J+L9TBb2oXT+6/yJI8viNyGx8/A\"",
    "mtime": "2025-11-25T15:50:41.228Z",
    "size": 417,
    "path": "../public/_nuxt/DgTdHVgk.js"
  },
  "/_nuxt/DGYunbW3.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"65d-nnbuYREF9lxuEhjfsJjypbjluXM\"",
    "mtime": "2025-11-25T15:50:41.200Z",
    "size": 1629,
    "path": "../public/_nuxt/DGYunbW3.js"
  },
  "/_nuxt/Dh1FvaGZ.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"4b6-Kks0+roO3nvnDjMdeSdwIJWhvGs\"",
    "mtime": "2025-11-25T15:50:41.230Z",
    "size": 1206,
    "path": "../public/_nuxt/Dh1FvaGZ.js"
  },
  "/_nuxt/DhGKdW-k.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"28f-JGjIG7HXhf5naP07/1Q46dZKNZc\"",
    "mtime": "2025-11-25T15:50:41.270Z",
    "size": 655,
    "path": "../public/_nuxt/DhGKdW-k.js"
  },
  "/_nuxt/DhO8qGxh.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"16c-NJjQUvsPO84uDLbxvVvMlIn9rVg\"",
    "mtime": "2025-11-25T15:50:41.140Z",
    "size": 364,
    "path": "../public/_nuxt/DhO8qGxh.js"
  },
  "/_nuxt/DMSerifDisplay-Italic.D1fnzAS9.ttf": {
    "type": "font/ttf",
    "etag": "\"112c0-6/o55xQp5IyzWQZiD0yYzWm+kls\"",
    "mtime": "2025-11-25T15:50:40.966Z",
    "size": 70336,
    "path": "../public/_nuxt/DMSerifDisplay-Italic.D1fnzAS9.ttf"
  },
  "/_nuxt/DMSerifDisplay-Regular.BB3xDZ4A.ttf": {
    "type": "font/ttf",
    "etag": "\"11a1c-Ulcd6WLi2PJsIEBtJADsd2dgAbI\"",
    "mtime": "2025-11-25T15:50:40.966Z",
    "size": 72220,
    "path": "../public/_nuxt/DMSerifDisplay-Regular.BB3xDZ4A.ttf"
  },
  "/_nuxt/DNmdqTCx.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"713-jOHxiVjjaz02vIv+cI4hSPmYw9E\"",
    "mtime": "2025-11-25T15:50:41.214Z",
    "size": 1811,
    "path": "../public/_nuxt/DNmdqTCx.js"
  },
  "/_nuxt/DOaGCdSn.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"3ce-X/gnncc1rl/bisNnvAFlIfb9uNQ\"",
    "mtime": "2025-11-25T15:50:41.204Z",
    "size": 974,
    "path": "../public/_nuxt/DOaGCdSn.js"
  },
  "/_nuxt/DoBlCpRp.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"327-UiGD6+uttF3KDlndE8ow67YFWck\"",
    "mtime": "2025-11-25T15:50:41.138Z",
    "size": 807,
    "path": "../public/_nuxt/DoBlCpRp.js"
  },
  "/_nuxt/DOl-gpEZ.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"360-zVSEbSE09zKAKVgAS6EX8SFDTho\"",
    "mtime": "2025-11-25T15:50:41.111Z",
    "size": 864,
    "path": "../public/_nuxt/DOl-gpEZ.js"
  },
  "/_nuxt/DoWfMgYg.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"4b6-nqJDjObZoZMj4eNRMP2D8sxZ/EE\"",
    "mtime": "2025-11-25T15:50:41.241Z",
    "size": 1206,
    "path": "../public/_nuxt/DoWfMgYg.js"
  },
  "/_nuxt/DOXjNWU3.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"35c-QXm+sLIaxHP13kGjVYS2FTcsxZs\"",
    "mtime": "2025-11-25T15:50:41.225Z",
    "size": 860,
    "path": "../public/_nuxt/DOXjNWU3.js"
  },
  "/_nuxt/DPJ2-Nti.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"4f1-txh9YhurSrjrKo0H8L5QoCzOvak\"",
    "mtime": "2025-11-25T15:50:41.117Z",
    "size": 1265,
    "path": "../public/_nuxt/DPJ2-Nti.js"
  },
  "/_nuxt/DQlSYb5b.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"a2e9-MNQUp0h8n7ZgS83F/mCaehp0ARI\"",
    "mtime": "2025-11-25T15:50:41.135Z",
    "size": 41705,
    "path": "../public/_nuxt/DQlSYb5b.js"
  },
  "/_nuxt/DqmL52Hm.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"5d73-w8tjR0lfahW/ANOAGvv/qXMFO4k\"",
    "mtime": "2025-11-25T15:50:41.099Z",
    "size": 23923,
    "path": "../public/_nuxt/DqmL52Hm.js"
  },
  "/_nuxt/DR-DkWEn.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"2c6-9PfTr7evfE1Z9yDC91oYFWhop5Y\"",
    "mtime": "2025-11-25T15:50:41.231Z",
    "size": 710,
    "path": "../public/_nuxt/DR-DkWEn.js"
  },
  "/_nuxt/DR0inLFr.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"43e-y4HyX5XZd87ljocBfqrbFsIogiY\"",
    "mtime": "2025-11-25T15:50:41.156Z",
    "size": 1086,
    "path": "../public/_nuxt/DR0inLFr.js"
  },
  "/_nuxt/Dsdr8hkY.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"a2f-bwbP+baNLqsYtLCgBj00ruRf8J8\"",
    "mtime": "2025-11-25T15:50:41.111Z",
    "size": 2607,
    "path": "../public/_nuxt/Dsdr8hkY.js"
  },
  "/_nuxt/DsXIIV_m.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"186-PIUHOcN/U2E0hw6ZwF2P34QcErg\"",
    "mtime": "2025-11-25T15:50:41.171Z",
    "size": 390,
    "path": "../public/_nuxt/DsXIIV_m.js"
  },
  "/_nuxt/DTTdInrv.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"38e-wtDbDDjmf/uiwAljS06avIDvj14\"",
    "mtime": "2025-11-25T15:50:41.239Z",
    "size": 910,
    "path": "../public/_nuxt/DTTdInrv.js"
  },
  "/_nuxt/Du6lyudM.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"8c3-aANXYqfWz/Bu+/gBiA/IVNhmZDM\"",
    "mtime": "2025-11-25T15:50:41.259Z",
    "size": 2243,
    "path": "../public/_nuxt/Du6lyudM.js"
  },
  "/_nuxt/DV4kufuV.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"d82-MLtCuwKCFGpchNEkoZ/Tn9fZMAI\"",
    "mtime": "2025-11-25T15:50:41.077Z",
    "size": 3458,
    "path": "../public/_nuxt/DV4kufuV.js"
  },
  "/_nuxt/DV4qD-zx.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"275-oGFEwALtrOPUAp35NhT4cajnYh8\"",
    "mtime": "2025-11-25T15:50:41.213Z",
    "size": 629,
    "path": "../public/_nuxt/DV4qD-zx.js"
  },
  "/_nuxt/DW4NOIWm.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"9be-5193sxViNYacdp4Qub2wO6vT2/w\"",
    "mtime": "2025-11-25T15:50:41.096Z",
    "size": 2494,
    "path": "../public/_nuxt/DW4NOIWm.js"
  },
  "/_nuxt/Dw8a-Wu3.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"9399a-aUJVVk4ig+FiM37qVoBFNBupK7Q\"",
    "mtime": "2025-11-25T15:50:41.077Z",
    "size": 604570,
    "path": "../public/_nuxt/Dw8a-Wu3.js"
  },
  "/_nuxt/DWAJZeyI.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"58d-/Tc1pvkDlbI5igAotMd8XKBKjCM\"",
    "mtime": "2025-11-25T15:50:41.272Z",
    "size": 1421,
    "path": "../public/_nuxt/DWAJZeyI.js"
  },
  "/_nuxt/DwjuP5Me.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"a2b-U2t8fH5mfrFSU2+LFkipTNt5djQ\"",
    "mtime": "2025-11-25T15:50:41.272Z",
    "size": 2603,
    "path": "../public/_nuxt/DwjuP5Me.js"
  },
  "/_nuxt/DX_zS9x2.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"2dc-3YMw886cvUaC5wyOZxDJXnr3CMM\"",
    "mtime": "2025-11-25T15:50:41.139Z",
    "size": 732,
    "path": "../public/_nuxt/DX_zS9x2.js"
  },
  "/_nuxt/DYeRhhEH.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"268-edr8BGR/nws/t9FevMk2NdjrikI\"",
    "mtime": "2025-11-25T15:50:41.240Z",
    "size": 616,
    "path": "../public/_nuxt/DYeRhhEH.js"
  },
  "/_nuxt/DyxOF5rV.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"2e3-zJXtrkoIp41zLtDw5XvyOY79pA4\"",
    "mtime": "2025-11-25T15:50:41.111Z",
    "size": 739,
    "path": "../public/_nuxt/DyxOF5rV.js"
  },
  "/_nuxt/DZRBcY2B.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"1be-SUVJoN7bdyxRzhoyEX4gBPGJO+0\"",
    "mtime": "2025-11-25T15:50:41.212Z",
    "size": 446,
    "path": "../public/_nuxt/DZRBcY2B.js"
  },
  "/_nuxt/D_O5IorA.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"915-DAC5B7S0e/BEpKAILWxrSthjeJ0\"",
    "mtime": "2025-11-25T15:50:41.213Z",
    "size": 2325,
    "path": "../public/_nuxt/D_O5IorA.js"
  },
  "/_nuxt/e9MDTErU.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"558-sAVP3tE3AudOKCaUUbogblwkczc\"",
    "mtime": "2025-11-25T15:50:41.214Z",
    "size": 1368,
    "path": "../public/_nuxt/e9MDTErU.js"
  },
  "/_nuxt/EditPhoneForm._17YXN3V.css": {
    "type": "text/css; charset=utf-8",
    "etag": "\"4d2-+1427cWcfjPOpUlINKgkCso0o6k\"",
    "mtime": "2025-11-25T15:50:41.049Z",
    "size": 1234,
    "path": "../public/_nuxt/EditPhoneForm._17YXN3V.css"
  },
  "/_nuxt/entry.DsuHfiEc.css": {
    "type": "text/css; charset=utf-8",
    "etag": "\"22db0-QXmasOL6+ZVUeIiVVV8j53rXC/w\"",
    "mtime": "2025-11-25T15:50:41.040Z",
    "size": 142768,
    "path": "../public/_nuxt/entry.DsuHfiEc.css"
  },
  "/_nuxt/eTjuj5QN.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"d90-ddDtavaLG5Zux+9sjb8sACc33bk\"",
    "mtime": "2025-11-25T15:50:41.093Z",
    "size": 3472,
    "path": "../public/_nuxt/eTjuj5QN.js"
  },
  "/_nuxt/flash-sale-1.0ul0Vm4t.png": {
    "type": "image/png",
    "etag": "\"90a12-pFVNVxw0ShrijqtiX8nsUhNZ4z4\"",
    "mtime": "2025-11-25T15:50:41.042Z",
    "size": 592402,
    "path": "../public/_nuxt/flash-sale-1.0ul0Vm4t.png"
  },
  "/_nuxt/flash-sale-2.Cu4nAzfy.png": {
    "type": "image/png",
    "etag": "\"70a19-84btGHjhVJnGsm0C/GOJX3lRouI\"",
    "mtime": "2025-11-25T15:50:41.024Z",
    "size": 461337,
    "path": "../public/_nuxt/flash-sale-2.Cu4nAzfy.png"
  },
  "/_nuxt/flash-sale-3.DIxzJLlH.png": {
    "type": "image/png",
    "etag": "\"50bae-uAgzp0FAaE9EkPBxaXPJ8ESty+k\"",
    "mtime": "2025-11-25T15:50:41.024Z",
    "size": 330670,
    "path": "../public/_nuxt/flash-sale-3.DIxzJLlH.png"
  },
  "/_nuxt/flash-sale.b0UA2zki.png": {
    "type": "image/png",
    "etag": "\"11c80f-BCPf9Ia7cPtlP3hj6siOP3vw3SQ\"",
    "mtime": "2025-11-25T15:50:41.052Z",
    "size": 1165327,
    "path": "../public/_nuxt/flash-sale.b0UA2zki.png"
  },
  "/_nuxt/flashsale-bg.CbEknVXT.png": {
    "type": "image/png",
    "etag": "\"28c8a-1Vv2FI17+88RHYjRXZ+Z1LDXmnw\"",
    "mtime": "2025-11-25T15:50:41.038Z",
    "size": 167050,
    "path": "../public/_nuxt/flashsale-bg.CbEknVXT.png"
  },
  "/_nuxt/footer-bg.CD_vUQKs.png": {
    "type": "image/png",
    "etag": "\"2bdf4-SBjRiqahCT5ZF78fu+1OdcXn8F8\"",
    "mtime": "2025-11-25T15:50:40.980Z",
    "size": 179700,
    "path": "../public/_nuxt/footer-bg.CD_vUQKs.png"
  },
  "/_nuxt/gKC931_s.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"25a-1VAjkxynFhkHm5r6gnXM7hnDk1s\"",
    "mtime": "2025-11-25T15:50:41.172Z",
    "size": 602,
    "path": "../public/_nuxt/gKC931_s.js"
  },
  "/_nuxt/gm1aD37P.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"3e05-vAqtFaSHUWVp7cw3W29MwTKSSsk\"",
    "mtime": "2025-11-25T15:50:41.135Z",
    "size": 15877,
    "path": "../public/_nuxt/gm1aD37P.js"
  },
  "/_nuxt/google-play.DF2u7CLq.svg": {
    "type": "image/svg+xml",
    "etag": "\"27ab-pgNQHRGwqGrDzwLo3w1B0VCtr5g\"",
    "mtime": "2025-11-25T15:50:41.038Z",
    "size": 10155,
    "path": "../public/_nuxt/google-play.DF2u7CLq.svg"
  },
  "/_nuxt/gq0H8cKy.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"317-CeR7cr9DSPgj7BzdFDEh+kqQTT4\"",
    "mtime": "2025-11-25T15:50:41.200Z",
    "size": 791,
    "path": "../public/_nuxt/gq0H8cKy.js"
  },
  "/_nuxt/hdiN-7gC.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"b07-udgSs9qVO53M07nrBi0ZueW/y1I\"",
    "mtime": "2025-11-25T15:50:41.093Z",
    "size": 2823,
    "path": "../public/_nuxt/hdiN-7gC.js"
  },
  "/_nuxt/h_s3yGin.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"a72-wF2mT2lU6Rhcp5BF4ts1+Q/QZ7Q\"",
    "mtime": "2025-11-25T15:50:41.271Z",
    "size": 2674,
    "path": "../public/_nuxt/h_s3yGin.js"
  },
  "/_nuxt/IAc2majH.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"223-s7ww4afuiqeSrgHwRHEb/4zeEp4\"",
    "mtime": "2025-11-25T15:50:41.172Z",
    "size": 547,
    "path": "../public/_nuxt/IAc2majH.js"
  },
  "/_nuxt/IFDkMvDM.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"217-9n65b1472qd/HRPBuOKlksDvWZ4\"",
    "mtime": "2025-11-25T15:50:41.116Z",
    "size": 535,
    "path": "../public/_nuxt/IFDkMvDM.js"
  },
  "/_nuxt/index.BcyF2eDm.css": {
    "type": "text/css; charset=utf-8",
    "etag": "\"39b-vFhuiEf8Y7poJa2pLG8dHevsVO4\"",
    "mtime": "2025-11-25T15:50:41.067Z",
    "size": 923,
    "path": "../public/_nuxt/index.BcyF2eDm.css"
  },
  "/_nuxt/index.DvOT2kzv.css": {
    "type": "text/css; charset=utf-8",
    "etag": "\"1fe-HNpuAPQH72jn613/am280OfeH68\"",
    "mtime": "2025-11-25T15:50:41.071Z",
    "size": 510,
    "path": "../public/_nuxt/index.DvOT2kzv.css"
  },
  "/_nuxt/index.uA3I5TBR.css": {
    "type": "text/css; charset=utf-8",
    "etag": "\"cc-PF0VPvhHUMIexQsFKP47RHMLMpI\"",
    "mtime": "2025-11-25T15:50:41.042Z",
    "size": 204,
    "path": "../public/_nuxt/index.uA3I5TBR.css"
  },
  "/_nuxt/IvsSv6Lj.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"1bbb-2ciIepGYo37ELP7bbUDw/tEFaIk\"",
    "mtime": "2025-11-25T15:50:41.089Z",
    "size": 7099,
    "path": "../public/_nuxt/IvsSv6Lj.js"
  },
  "/_nuxt/iwpbA7PY.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"6a4-35iZzPjjXQt7MsvOgIFklpVp5M0\"",
    "mtime": "2025-11-25T15:50:41.270Z",
    "size": 1700,
    "path": "../public/_nuxt/iwpbA7PY.js"
  },
  "/_nuxt/iz2BGEQH.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"417-WLG577k6AU2CG58FvQNYx46hYVg\"",
    "mtime": "2025-11-25T15:50:41.232Z",
    "size": 1047,
    "path": "../public/_nuxt/iz2BGEQH.js"
  },
  "/_nuxt/JdrkEO5h.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"1f5-i3eAbqVMcWgL1rfBMolzYEGHqy8\"",
    "mtime": "2025-11-25T15:50:41.119Z",
    "size": 501,
    "path": "../public/_nuxt/JdrkEO5h.js"
  },
  "/_nuxt/jmMJliCr.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"22ec-Ys4wiV/3idQkkgXRXccJYYbfY2M\"",
    "mtime": "2025-11-25T15:50:41.075Z",
    "size": 8940,
    "path": "../public/_nuxt/jmMJliCr.js"
  },
  "/_nuxt/KD2Ok_n9.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"1b83-/ReA7t4OSg8x9MMrCxYyMU37gzg\"",
    "mtime": "2025-11-25T15:50:41.106Z",
    "size": 7043,
    "path": "../public/_nuxt/KD2Ok_n9.js"
  },
  "/_nuxt/login-bg-2.CsTTPFNZ.png": {
    "type": "image/png",
    "etag": "\"82969-LQiAKJQbyFkWTLMfiNMUcjNG9+U\"",
    "mtime": "2025-11-25T15:50:41.042Z",
    "size": 534889,
    "path": "../public/_nuxt/login-bg-2.CsTTPFNZ.png"
  },
  "/_nuxt/login-bg.BXwYJeU8.png": {
    "type": "image/png",
    "etag": "\"e13c9-JJ5eyWdQi2HmDH9jz8kjSz4U+o4\"",
    "mtime": "2025-11-25T15:50:41.043Z",
    "size": 922569,
    "path": "../public/_nuxt/login-bg.BXwYJeU8.png"
  },
  "/_nuxt/logo-dark.DHTckJKs.svg": {
    "type": "image/svg+xml",
    "etag": "\"e7ca9-rDkL9FRf5kprci3pADk8szuFtd0\"",
    "mtime": "2025-11-25T15:50:41.046Z",
    "size": 949417,
    "path": "../public/_nuxt/logo-dark.DHTckJKs.svg"
  },
  "/_nuxt/logo.CnwTxVTo.css": {
    "type": "text/css; charset=utf-8",
    "etag": "\"12c-EgV8V112kiVhjboI/DzwoGIm6iM\"",
    "mtime": "2025-11-25T15:50:41.072Z",
    "size": 300,
    "path": "../public/_nuxt/logo.CnwTxVTo.css"
  },
  "/_nuxt/logo.WoLDsXun.svg": {
    "type": "image/svg+xml",
    "etag": "\"e7ca9-TwrKIjGLrBn/zQhJa/ED2zvKXig\"",
    "mtime": "2025-11-25T15:50:41.042Z",
    "size": 949417,
    "path": "../public/_nuxt/logo.WoLDsXun.svg"
  },
  "/_nuxt/lQIVW4fc.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"498-YOOa4zm9ygErwZ2O92THGEpH2Yw\"",
    "mtime": "2025-11-25T15:50:41.155Z",
    "size": 1176,
    "path": "../public/_nuxt/lQIVW4fc.js"
  },
  "/_nuxt/m3aqLvNt.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"3d6-mFSneCNwrI5Bf4/g5x1+TXlRVlU\"",
    "mtime": "2025-11-25T15:50:41.259Z",
    "size": 982,
    "path": "../public/_nuxt/m3aqLvNt.js"
  },
  "/_nuxt/Montserrat-Black.BS-yoS0_.ttf": {
    "type": "font/ttf",
    "etag": "\"53d00-6k/rFvPYyz8cvI46evc4jMAc4y4\"",
    "mtime": "2025-11-25T15:50:40.945Z",
    "size": 343296,
    "path": "../public/_nuxt/Montserrat-Black.BS-yoS0_.ttf"
  },
  "/_nuxt/Montserrat-Bold.BSrD1I5P.ttf": {
    "type": "font/ttf",
    "etag": "\"51fac-x9kHcir0+4RauX1RW7QU8pZR8AA\"",
    "mtime": "2025-11-25T15:50:40.958Z",
    "size": 335788,
    "path": "../public/_nuxt/Montserrat-Bold.BSrD1I5P.ttf"
  },
  "/_nuxt/Montserrat-ExtraBold.DnlpJ974.ttf": {
    "type": "font/ttf",
    "etag": "\"53ff4-Siy+56ereass8MEgyWI4TcJAsjc\"",
    "mtime": "2025-11-25T15:50:40.958Z",
    "size": 344052,
    "path": "../public/_nuxt/Montserrat-ExtraBold.DnlpJ974.ttf"
  },
  "/_nuxt/Montserrat-ExtraLight.fStl-XCH.ttf": {
    "type": "font/ttf",
    "etag": "\"50af8-wZhiCv28jru2jqK3H/q5GIA31gI\"",
    "mtime": "2025-11-25T15:50:40.958Z",
    "size": 330488,
    "path": "../public/_nuxt/Montserrat-ExtraLight.fStl-XCH.ttf"
  },
  "/_nuxt/Montserrat-Light.Cbfxly1I.ttf": {
    "type": "font/ttf",
    "etag": "\"50c88-HbiHinZUIItsVUAvb/cX4DoxLh4\"",
    "mtime": "2025-11-25T15:50:40.968Z",
    "size": 330888,
    "path": "../public/_nuxt/Montserrat-Light.Cbfxly1I.ttf"
  },
  "/_nuxt/Montserrat-Medium.CpRznguy.ttf": {
    "type": "font/ttf",
    "etag": "\"50c78-RlbkBBnahqX+xHPqjn/A7+8YPwU\"",
    "mtime": "2025-11-25T15:50:40.967Z",
    "size": 330872,
    "path": "../public/_nuxt/Montserrat-Medium.CpRznguy.ttf"
  },
  "/_nuxt/Montserrat-Regular.Cw3fqWkz.ttf": {
    "type": "font/ttf",
    "etag": "\"50cc4-HIEZs47vGRSk+9n2z97fGYRFq5c\"",
    "mtime": "2025-11-25T15:50:40.970Z",
    "size": 330948,
    "path": "../public/_nuxt/Montserrat-Regular.Cw3fqWkz.ttf"
  },
  "/_nuxt/Montserrat-SemiBold.Cyv6qdWd.ttf": {
    "type": "font/ttf",
    "etag": "\"518a4-1JHJ0K9h+u9ZyoB3N7VgFw9Uf1s\"",
    "mtime": "2025-11-25T15:50:40.971Z",
    "size": 333988,
    "path": "../public/_nuxt/Montserrat-SemiBold.Cyv6qdWd.ttf"
  },
  "/_nuxt/Montserrat-Thin.CLa9vnJU.ttf": {
    "type": "font/ttf",
    "etag": "\"50888-RHg4ZCJYuV6KYd8XcBiflizAdBs\"",
    "mtime": "2025-11-25T15:50:40.970Z",
    "size": 329864,
    "path": "../public/_nuxt/Montserrat-Thin.CLa9vnJU.ttf"
  },
  "/_nuxt/mqjJGHgV.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"8bf-6EGro1kdOdUDG4OENI2xMUO9QR4\"",
    "mtime": "2025-11-25T15:50:41.133Z",
    "size": 2239,
    "path": "../public/_nuxt/mqjJGHgV.js"
  },
  "/_nuxt/NqEsyZDc.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"43f-JsPXNEIUcgx/5k4IQT2mtmKkYiI\"",
    "mtime": "2025-11-25T15:50:41.213Z",
    "size": 1087,
    "path": "../public/_nuxt/NqEsyZDc.js"
  },
  "/_nuxt/P2Lu1KH-.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"c91-yZRNkMr5QrUvC3+RZ2l7vd2F1hQ\"",
    "mtime": "2025-11-25T15:50:41.271Z",
    "size": 3217,
    "path": "../public/_nuxt/P2Lu1KH-.js"
  },
  "/_nuxt/qufJNU_I.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"50d-NAuE/Ce71GT9FSN5X62ZhqaTCgU\"",
    "mtime": "2025-11-25T15:50:41.155Z",
    "size": 1293,
    "path": "../public/_nuxt/qufJNU_I.js"
  },
  "/_nuxt/RJHEP9Cl.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"35a-vuRhs7l1EkRUX3Z6OsJDkXZd4+U\"",
    "mtime": "2025-11-25T15:50:41.089Z",
    "size": 858,
    "path": "../public/_nuxt/RJHEP9Cl.js"
  },
  "/_nuxt/rjjGmZAH.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"2c6-rWolw8M+axG2wlhY6MHB3XzaGCE\"",
    "mtime": "2025-11-25T15:50:41.077Z",
    "size": 710,
    "path": "../public/_nuxt/rjjGmZAH.js"
  },
  "/_nuxt/RR_aQbBn.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"2db-0254FSiTkHKyT/mKOMcoAXb8gZo\"",
    "mtime": "2025-11-25T15:50:41.247Z",
    "size": 731,
    "path": "../public/_nuxt/RR_aQbBn.js"
  },
  "/_nuxt/ruOlp7Vt.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"53c-UmD26kB0NtORpAqi2FdUwlgNvzc\"",
    "mtime": "2025-11-25T15:50:41.242Z",
    "size": 1340,
    "path": "../public/_nuxt/ruOlp7Vt.js"
  },
  "/_nuxt/saudi-arabia.Vm2LMp2Z.png": {
    "type": "image/png",
    "etag": "\"3283-2n14RQQzF249GDL8axSi1FRskbo\"",
    "mtime": "2025-11-25T15:50:41.039Z",
    "size": 12931,
    "path": "../public/_nuxt/saudi-arabia.Vm2LMp2Z.png"
  },
  "/_nuxt/SCh4yAAb.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"449-V2lux/YdSVvRRkn0opMlbwZ3AXs\"",
    "mtime": "2025-11-25T15:50:41.272Z",
    "size": 1097,
    "path": "../public/_nuxt/SCh4yAAb.js"
  },
  "/_nuxt/SjaTgYNJ.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"4f4-ZlNm2qEHaWdyCGxMbBaGLzJcnw8\"",
    "mtime": "2025-11-25T15:50:41.231Z",
    "size": 1268,
    "path": "../public/_nuxt/SjaTgYNJ.js"
  },
  "/_nuxt/success.ByW5HO0f.gif": {
    "type": "image/gif",
    "etag": "\"5ca9a-CwgopoksckpVe0roHea8oZABnM8\"",
    "mtime": "2025-11-25T15:50:41.039Z",
    "size": 379546,
    "path": "../public/_nuxt/success.ByW5HO0f.gif"
  },
  "/_nuxt/swiper-vue.BCiLj-cK.css": {
    "type": "text/css; charset=utf-8",
    "etag": "\"4592-FeDQYoha2psry8bJStDfRn26CkM\"",
    "mtime": "2025-11-25T15:50:41.040Z",
    "size": 17810,
    "path": "../public/_nuxt/swiper-vue.BCiLj-cK.css"
  },
  "/_nuxt/tL81ZjHw.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"1f2-FQ/6+uJGMxKksM1PxdTAvpnITio\"",
    "mtime": "2025-11-25T15:50:41.240Z",
    "size": 498,
    "path": "../public/_nuxt/tL81ZjHw.js"
  },
  "/_nuxt/TQ9-YT3-.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"191-v1izA17EAIa5fkEMlSWB6IpanRg\"",
    "mtime": "2025-11-25T15:50:41.258Z",
    "size": 401,
    "path": "../public/_nuxt/TQ9-YT3-.js"
  },
  "/_nuxt/W9cN62YZ.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"5d7-Wu16ZhRCt8b4YU+xww6W4QKmTGc\"",
    "mtime": "2025-11-25T15:50:41.230Z",
    "size": 1495,
    "path": "../public/_nuxt/W9cN62YZ.js"
  },
  "/_nuxt/wI7Orf5t.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"2c3-xkUmDRLR9yxjrLwpHCfB+97cBvc\"",
    "mtime": "2025-11-25T15:50:41.226Z",
    "size": 707,
    "path": "../public/_nuxt/wI7Orf5t.js"
  },
  "/_nuxt/WlgQ98RY.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"380f-9x0pCY1tC79D2QwKX9g2Sp3ovyU\"",
    "mtime": "2025-11-25T15:50:41.090Z",
    "size": 14351,
    "path": "../public/_nuxt/WlgQ98RY.js"
  },
  "/_nuxt/XlzAqXzj.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"23c-VWhYda135is66N5Aw9+z4vpQ/jY\"",
    "mtime": "2025-11-25T15:50:41.272Z",
    "size": 572,
    "path": "../public/_nuxt/XlzAqXzj.js"
  },
  "/_nuxt/xSla9Exo.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"27d-vLFKkGe17JjB/Ubi8u6+gjPKoiw\"",
    "mtime": "2025-11-25T15:50:41.259Z",
    "size": 637,
    "path": "../public/_nuxt/xSla9Exo.js"
  },
  "/_nuxt/YBBZ6mho.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"cfd-zPje37pcJriyIxdW4w1/BDG0mr0\"",
    "mtime": "2025-11-25T15:50:41.087Z",
    "size": 3325,
    "path": "../public/_nuxt/YBBZ6mho.js"
  },
  "/_nuxt/zgPTdVES.js": {
    "type": "text/javascript; charset=utf-8",
    "etag": "\"234-+U+upBFRlafFMRgf/BOz0wRAfYc\"",
    "mtime": "2025-11-25T15:50:41.212Z",
    "size": 564,
    "path": "../public/_nuxt/zgPTdVES.js"
  },
  "/_nuxt/_slug_.CoBvCMW8.css": {
    "type": "text/css; charset=utf-8",
    "etag": "\"1f3-Of3Cc/KXwTwCX2mCJeCHE9bKuKo\"",
    "mtime": "2025-11-25T15:50:41.071Z",
    "size": 499,
    "path": "../public/_nuxt/_slug_.CoBvCMW8.css"
  },
  "/_nuxt/builds/latest.json": {
    "type": "application/json",
    "etag": "\"47-YaZOF9j6fGwizlr8kIZsC/7OQnE\"",
    "mtime": "2025-11-25T15:51:08.880Z",
    "size": 71,
    "path": "../public/_nuxt/builds/latest.json"
  },
  "/_nuxt/builds/meta/1762cd3e-738a-4133-9511-9945c551bd16.json": {
    "type": "application/json",
    "etag": "\"8b-+Tyhb9ikUrxFbFbjLc8ZwsePg3s\"",
    "mtime": "2025-11-25T15:51:08.881Z",
    "size": 139,
    "path": "../public/_nuxt/builds/meta/1762cd3e-738a-4133-9511-9945c551bd16.json"
  }
};

const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
function normalizeWindowsPath(input = "") {
  if (!input) {
    return input;
  }
  return input.replace(/\\/g, "/").replace(_DRIVE_LETTER_START_RE, (r) => r.toUpperCase());
}
const _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
const _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
function cwd() {
  if (typeof process !== "undefined" && typeof process.cwd === "function") {
    return process.cwd().replace(/\\/g, "/");
  }
  return "/";
}
const resolve$1 = function(...arguments_) {
  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
  let resolvedPath = "";
  let resolvedAbsolute = false;
  for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
    const path = index >= 0 ? arguments_[index] : cwd();
    if (!path || path.length === 0) {
      continue;
    }
    resolvedPath = `${path}/${resolvedPath}`;
    resolvedAbsolute = isAbsolute(path);
  }
  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
    return `/${resolvedPath}`;
  }
  return resolvedPath.length > 0 ? resolvedPath : ".";
};
function normalizeString(path, allowAboveRoot) {
  let res = "";
  let lastSegmentLength = 0;
  let lastSlash = -1;
  let dots = 0;
  let char = null;
  for (let index = 0; index <= path.length; ++index) {
    if (index < path.length) {
      char = path[index];
    } else if (char === "/") {
      break;
    } else {
      char = "/";
    }
    if (char === "/") {
      if (lastSlash === index - 1 || dots === 1) ; else if (dots === 2) {
        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
          if (res.length > 2) {
            const lastSlashIndex = res.lastIndexOf("/");
            if (lastSlashIndex === -1) {
              res = "";
              lastSegmentLength = 0;
            } else {
              res = res.slice(0, lastSlashIndex);
              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
            }
            lastSlash = index;
            dots = 0;
            continue;
          } else if (res.length > 0) {
            res = "";
            lastSegmentLength = 0;
            lastSlash = index;
            dots = 0;
            continue;
          }
        }
        if (allowAboveRoot) {
          res += res.length > 0 ? "/.." : "..";
          lastSegmentLength = 2;
        }
      } else {
        if (res.length > 0) {
          res += `/${path.slice(lastSlash + 1, index)}`;
        } else {
          res = path.slice(lastSlash + 1, index);
        }
        lastSegmentLength = index - lastSlash - 1;
      }
      lastSlash = index;
      dots = 0;
    } else if (char === "." && dots !== -1) {
      ++dots;
    } else {
      dots = -1;
    }
  }
  return res;
}
const isAbsolute = function(p) {
  return _IS_ABSOLUTE_RE.test(p);
};
const dirname = function(p) {
  const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
  if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) {
    segments[0] += "/";
  }
  return segments.join("/") || (isAbsolute(p) ? "/" : ".");
};

function readAsset (id) {
  const serverDir = dirname(fileURLToPath(globalThis._importMeta_.url));
  return promises.readFile(resolve$1(serverDir, assets[id].path))
}

const publicAssetBases = {"/_nuxt/builds/meta/":{"maxAge":31536000},"/_nuxt/builds/":{"maxAge":1},"/_nuxt/":{"maxAge":31536000}};

function isPublicAssetURL(id = '') {
  if (assets[id]) {
    return true
  }
  for (const base in publicAssetBases) {
    if (id.startsWith(base)) { return true }
  }
  return false
}

function getAsset (id) {
  return assets[id]
}

const METHODS = /* @__PURE__ */ new Set(["HEAD", "GET"]);
const EncodingMap = { gzip: ".gz", br: ".br" };
const _xAXova = eventHandler((event) => {
  if (event.method && !METHODS.has(event.method)) {
    return;
  }
  let id = decodePath(
    withLeadingSlash(withoutTrailingSlash(parseURL(event.path).pathname))
  );
  let asset;
  const encodingHeader = String(
    getRequestHeader(event, "accept-encoding") || ""
  );
  const encodings = [
    ...encodingHeader.split(",").map((e) => EncodingMap[e.trim()]).filter(Boolean).sort(),
    ""
  ];
  if (encodings.length > 1) {
    appendResponseHeader(event, "Vary", "Accept-Encoding");
  }
  for (const encoding of encodings) {
    for (const _id of [id + encoding, joinURL(id, "index.html" + encoding)]) {
      const _asset = getAsset(_id);
      if (_asset) {
        asset = _asset;
        id = _id;
        break;
      }
    }
  }
  if (!asset) {
    if (isPublicAssetURL(id)) {
      removeResponseHeader(event, "Cache-Control");
      throw createError$1({
        statusMessage: "Cannot find static asset " + id,
        statusCode: 404
      });
    }
    return;
  }
  const ifNotMatch = getRequestHeader(event, "if-none-match") === asset.etag;
  if (ifNotMatch) {
    setResponseStatus(event, 304, "Not Modified");
    return "";
  }
  const ifModifiedSinceH = getRequestHeader(event, "if-modified-since");
  const mtimeDate = new Date(asset.mtime);
  if (ifModifiedSinceH && asset.mtime && new Date(ifModifiedSinceH) >= mtimeDate) {
    setResponseStatus(event, 304, "Not Modified");
    return "";
  }
  if (asset.type && !getResponseHeader(event, "Content-Type")) {
    setResponseHeader(event, "Content-Type", asset.type);
  }
  if (asset.etag && !getResponseHeader(event, "ETag")) {
    setResponseHeader(event, "ETag", asset.etag);
  }
  if (asset.mtime && !getResponseHeader(event, "Last-Modified")) {
    setResponseHeader(event, "Last-Modified", mtimeDate.toUTCString());
  }
  if (asset.encoding && !getResponseHeader(event, "Content-Encoding")) {
    setResponseHeader(event, "Content-Encoding", asset.encoding);
  }
  if (asset.size > 0 && !getResponseHeader(event, "Content-Length")) {
    setResponseHeader(event, "Content-Length", asset.size);
  }
  return readAsset(id);
});

const _7oSkxq = defineEventHandler(async (e) => {
  if (e.context.siteConfig)
    return;
  const runtimeConfig = useRuntimeConfig(e);
  const config = runtimeConfig["nuxt-site-config"];
  const nitroApp = useNitroApp();
  const siteConfig = createSiteConfigStack({
    debug: config.debug
  });
  const appConfig = useAppConfig(e);
  const nitroOrigin = useNitroOrigin(e);
  e.context.siteConfigNitroOrigin = nitroOrigin;
  {
    siteConfig.push({
      _context: "nitro:init",
      _priority: -4,
      url: nitroOrigin
    });
  }
  siteConfig.push({
    _context: "runtimeEnv",
    _priority: 0,
    ...runtimeConfig.site || {},
    ...runtimeConfig.public.site || {},
    // @ts-expect-error untyped
    ...envSiteConfig(globalThis._importMeta_.env)
    // just in-case, shouldn't be needed
  });
  const buildStack = config.stack || [];
  buildStack.forEach((c) => siteConfig.push(c));
  if (appConfig.site) {
    siteConfig.push({
      _priority: -2,
      _context: "app:config",
      ...appConfig.site
    });
  }
  if (e.context._nitro.routeRules.site) {
    siteConfig.push({
      _context: "route-rules",
      ...e.context._nitro.routeRules.site
    });
  }
  const ctx = { siteConfig, event: e };
  await nitroApp.hooks.callHook("site-config:init", ctx);
  e.context.siteConfig = ctx.siteConfig;
});

const merger = createDefu((obj, key, value) => {
  if (Array.isArray(obj[key]) && Array.isArray(value))
    obj[key] = Array.from(/* @__PURE__ */ new Set([...obj[key], ...value]));
  return obj[key];
});
function mergeOnKey(arr, key) {
  const res = {};
  arr.forEach((item) => {
    const k = item[key];
    res[k] = merger(item, res[k] || {});
  });
  return Object.values(res);
}
function splitForLocales(path, locales) {
  const prefix = withLeadingSlash(path).split("/")[1];
  if (locales.includes(prefix))
    return [prefix, path.replace(`/${prefix}`, "")];
  return [null, path];
}

function resolve(s, resolvers) {
  if (typeof s === "undefined")
    return s;
  s = typeof s === "string" ? s : s.toString();
  if (hasProtocol(s, { acceptRelative: true, strict: false }))
    return resolvers.fixSlashes(s);
  return resolvers.canonicalUrlResolver(s);
}
function normaliseSitemapUrls(data, resolvers) {
  const entries = data.map((e) => typeof e === "string" ? { loc: e } : e).map((e) => {
    e = { ...e };
    if (e.url) {
      e.loc = e.url;
      delete e.url;
    }
    e.loc = fixSlashes(false, e.loc);
    return e;
  }).filter(Boolean);
  function normaliseEntry(e) {
    if (e.lastmod) {
      const date = normaliseDate(e.lastmod);
      if (date)
        e.lastmod = date;
      else
        delete e.lastmod;
    }
    if (!e.lastmod)
      delete e.lastmod;
    e.loc = resolve(e.loc, resolvers);
    if (e.alternatives) {
      e.alternatives = mergeOnKey(e.alternatives.map((e2) => {
        const a = { ...e2 };
        if (typeof a.href === "string")
          a.href = resolve(a.href, resolvers);
        else if (typeof a.href === "object" && a.href)
          a.href = resolve(a.href.href, resolvers);
        return a;
      }), "hreflang");
    }
    if (e.images) {
      e.images = mergeOnKey(e.images.map((i) => {
        i = { ...i };
        i.loc = resolve(i.loc, resolvers);
        return i;
      }), "loc");
    }
    if (e.videos) {
      e.videos = e.videos.map((v) => {
        v = { ...v };
        if (v.content_loc)
          v.content_loc = resolve(v.content_loc, resolvers);
        return v;
      });
    }
    return e;
  }
  return mergeOnKey(
    entries.map(normaliseEntry).map((e) => ({ ...e, _key: `${e._sitemap || ""}${e.loc}` })),
    "_key"
  );
}
function normaliseDate(d) {
  if (typeof d === "string") {
    d = d.replace("Z", "");
    d = d.replace(/\.\d+$/, "");
    if (d.match(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$/) || d.match(/^\d{4}-\d{2}-\d{2}$/))
      return d;
    d = new Date(d);
    if (Number.isNaN(d.getTime()))
      return false;
  }
  const z = (n) => `0${n}`.slice(-2);
  return `${d.getUTCFullYear()}-${z(d.getUTCMonth() + 1)}-${z(d.getUTCDate())}T${z(d.getUTCHours())}:${z(d.getUTCMinutes())}:${z(d.getUTCSeconds())}+00:00`;
}

async function fetchDataSource(input) {
  const context = typeof input.context === "string" ? { name: input.context } : input.context || { name: "fetch" };
  context.tips = context.tips || [];
  const url = typeof input.fetch === "string" ? input.fetch : input.fetch[0];
  const options = typeof input.fetch === "string" ? {} : input.fetch[1];
  const start = Date.now();
  const timeout = options.timeout || 5e3;
  const timeoutController = new AbortController();
  const abortRequestTimeout = setTimeout(() => timeoutController.abort(), timeout);
  let isHtmlResponse = false;
  try {
    const urls = await globalThis.$fetch(url, {
      responseType: "json",
      signal: timeoutController.signal,
      headers: {
        Accept: "application/json"
      },
      // @ts-expect-error untyped
      onResponse({ response }) {
        if (typeof response._data === "string" && response._data.startsWith("<!DOCTYPE html>"))
          isHtmlResponse = true;
      }
    });
    const timeTakenMs = Date.now() - start;
    if (isHtmlResponse) {
      context.tips.push("This is usually because the URL isn't correct or is throwing an error. Please check the URL");
      return {
        ...input,
        context,
        urls: [],
        timeTakenMs,
        error: "Received HTML response instead of JSON"
      };
    }
    return {
      ...input,
      context,
      timeTakenMs,
      urls
    };
  } catch (_err) {
    const error = _err;
    if (error.message.includes("This operation was aborted"))
      context.tips.push("The request has taken too long. Make sure app sources respond within 5 seconds or adjust the timeout fetch option.");
    else
      context.tips.push(`Response returned a status of ${error.response?.status || "unknown"}.`);
    console.error("[nuxt-simple-sitemap] Failed to fetch source.", { url, error });
    return {
      ...input,
      context,
      urls: [],
      error: error.message
    };
  } finally {
    abortRequestTimeout && clearTimeout(abortRequestTimeout);
  }
}
function globalSitemapSources() {
  return import('../virtual/global-sources.mjs').then((m) => m.sources);
}
function childSitemapSources(definition) {
  return definition?._hasSourceChunk ? import('../virtual/child-sources.mjs').then((m) => m.sources[definition.sitemapName] || []) : Promise.resolve([]);
}
async function resolveSitemapSources(sources) {
  return (await Promise.all(
    sources.map((source) => {
      if (typeof source === "object" && "urls" in source) {
        return {
          timeTakenMs: 0,
          ...source,
          urls: source.urls
        };
      }
      if (source.fetch)
        return fetchDataSource(source);
      return {
        ...source,
        error: "Invalid source"
      };
    })
  )).flat();
}

function normaliseI18nSources(sources, { autoI18n, isI18nMapped }) {
  if (autoI18n && isI18nMapped) {
    return sources.map((s) => {
      const urls = (s.urls || []).map((_url) => {
        const url = typeof _url === "string" ? { loc: _url } : _url;
        url.loc = url.loc || url.url;
        url.loc = withLeadingSlash(url.loc);
        return url;
      });
      s.urls = urls.map((url) => {
        if (url._sitemap || url._i18nTransform)
          return url;
        if (url.loc) {
          const match = splitForLocales(url.loc, autoI18n.locales.map((l) => l.code));
          const localeCode = match[0] || autoI18n.defaultLocale;
          const pathWithoutPrefix = match[1];
          const locale = autoI18n.locales.find((e) => e.code === localeCode);
          if (locale) {
            if (!url.alternatives) {
              const alternatives = urls.map((u) => {
                if (u._sitemap || u._i18nTransform)
                  return false;
                if (u?.loc) {
                  const [_localeCode, _pathWithoutPrefix] = splitForLocales(u.loc, autoI18n.locales.map((l) => l.code));
                  if (pathWithoutPrefix === _pathWithoutPrefix) {
                    const entries = [];
                    if (_localeCode === autoI18n.defaultLocale) {
                      entries.push({
                        href: u.loc,
                        hreflang: "x-default"
                      });
                    }
                    entries.push({
                      href: u.loc,
                      hreflang: _localeCode || autoI18n.defaultLocale
                    });
                    return entries;
                  }
                }
                return false;
              }).flat().filter(Boolean);
              if (alternatives.length)
                url.alternatives = alternatives;
            }
            return {
              _sitemap: locale.iso || locale.code,
              ...url
            };
          }
        }
        return url;
      });
      return s;
    });
  }
  return sources;
}
function applyI18nEnhancements(_urls, options) {
  const { autoI18n } = options;
  return _urls.map((e) => {
    if (!e._i18nTransform)
      return e;
    delete e._i18nTransform;
    const path = withLeadingSlash(parseURL(e.loc).pathname);
    const match = splitForLocales(path, autoI18n.locales.map((l) => l.code));
    let pathWithoutLocale = path;
    if (match[0]) {
      pathWithoutLocale = match[1] || "/";
      match[0];
    }
    if (autoI18n.differentDomains) {
      return {
        // will force it to pass filter
        _sitemap: options.sitemapName,
        ...e,
        alternatives: [
          {
            // apply default locale domain
            ...autoI18n.locales.find((l) => [l.code, l.iso].includes(autoI18n.defaultLocale)),
            code: "x-default"
          },
          ...autoI18n.locales.filter((l) => !!l.domain)
        ].map((locale2) => {
          return {
            hreflang: locale2.iso || locale2.code,
            href: joinURL(withHttps(locale2.domain), pathWithoutLocale)
          };
        })
      };
    }
    return autoI18n.locales.map((l) => {
      let loc = joinURL(`/${l.code}`, pathWithoutLocale);
      if (autoI18n.differentDomains || ["prefix_and_default", "prefix_except_default"].includes(autoI18n.strategy) && l.code === autoI18n.defaultLocale)
        loc = pathWithoutLocale;
      return {
        _sitemap: options.isI18nMapped ? l.iso || l.code : undefined,
        ...e,
        loc,
        alternatives: [{ code: "x-default" }, ...autoI18n.locales].map((locale2) => {
          const code = locale2.code === "x-default" ? autoI18n.defaultLocale : locale2.code;
          const isDefault = locale2.code === "x-default" || locale2.code === autoI18n.defaultLocale;
          let href = "";
          if (autoI18n.strategy === "prefix") {
            href = joinURL("/", code, pathWithoutLocale);
          } else if (["prefix_and_default", "prefix_except_default"].includes(autoI18n.strategy)) {
            if (isDefault) {
              href = pathWithoutLocale;
            } else {
              href = joinURL("/", code, pathWithoutLocale);
            }
          }
          const hreflang = locale2.iso || locale2.code;
          return {
            hreflang,
            href
          };
        })
      };
    });
  }).flat();
}

function createFilter(options = {}) {
  const include = options.include || [];
  const exclude = options.exclude || [];
  if (include.length === 0 && exclude.length === 0)
    return () => true;
  return function(path) {
    for (const v of [{ rules: exclude, result: false }, { rules: include, result: true }]) {
      const regexRules = v.rules.filter((r) => r instanceof RegExp);
      if (regexRules.some((r) => r.test(path)))
        return v.result;
      const stringRules = v.rules.filter((r) => typeof r === "string");
      if (stringRules.length > 0) {
        const routes = {};
        for (const r of stringRules) {
          if (r === path)
            return v.result;
          routes[r] = true;
        }
        const routeRulesMatcher = toRouteMatcher(createRouter$1({ routes, strictTrailingSlash: false }));
        if (routeRulesMatcher.matchAll(path).length > 0)
          return Boolean(v.result);
      }
    }
    return include.length === 0;
  };
}
function filterSitemapUrls(_urls, options) {
  const urlFilter = createFilter({
    include: options.include,
    exclude: options.exclude
  });
  return _urls.filter((e) => {
    let path = e.loc;
    try {
      path = parseURL(e.loc).pathname;
    } catch {
      return false;
    }
    if (!urlFilter(path))
      return false;
    if (options.isMultiSitemap && e._sitemap && options.sitemapName)
      return e._sitemap === options.sitemapName;
    return true;
  });
}

function sortSitemapUrls(urls) {
  return urls.sort(
    (a, b) => {
      const aLoc = typeof a === "string" ? a : a.loc;
      const bLoc = typeof b === "string" ? b : b.loc;
      return aLoc.localeCompare(bLoc, undefined, { numeric: true });
    }
  ).sort((a, b) => {
    const aLoc = (typeof a === "string" ? a : a.loc) || "";
    const bLoc = (typeof b === "string" ? b : b.loc) || "";
    const aSegments = aLoc.split("/").length;
    const bSegments = bLoc.split("/").length;
    if (aSegments > bSegments)
      return 1;
    if (aSegments < bSegments)
      return -1;
    return 0;
  });
}

const StringifiedRegExpPattern = /\/(.*?)\/([gimsuy]*)$/;
function normalizeRuntimeFilters(input) {
  return (input || []).map((rule) => {
    if (rule instanceof RegExp || typeof rule === "string")
      return rule;
    const match = rule.regex.match(StringifiedRegExpPattern);
    if (match)
      return new RegExp(match[1], match[2]);
    return false;
  }).filter(Boolean);
}
function useSimpleSitemapRuntimeConfig() {
  const clone = JSON.parse(JSON.stringify(useRuntimeConfig()["nuxt-simple-sitemap"]));
  for (const k in clone.sitemaps) {
    const sitemap = clone.sitemaps[k];
    sitemap.include = normalizeRuntimeFilters(sitemap.include);
    sitemap.exclude = normalizeRuntimeFilters(sitemap.exclude);
    clone.sitemaps[k] = sitemap;
  }
  return Object.freeze(clone);
}

function resolveKey(k) {
  switch (k) {
    case "images":
      return "image";
    case "videos":
      return "video";
    case "news":
      return "news";
    default:
      return k;
  }
}
function handleObject(key, obj) {
  return [
    `        <${key}:${key}>`,
    ...Object.entries(obj).map(([sk, sv]) => {
      if (key === "video" && Array.isArray(sv)) {
        return sv.map((v) => {
          if (typeof v === "string") {
            return [
              `            `,
              `<${key}:${sk}>`,
              escapeValueForXml(v),
              `</${key}:${sk}>`
            ].join("");
          }
          const attributes = Object.entries(v).filter(([ssk]) => ssk !== sk).map(([ssk, ssv]) => `${ssk}="${escapeValueForXml(ssv)}"`).join(" ");
          return [
            `            <${key}:${sk} ${attributes}>`,
            // value is the same sk
            v[sk],
            `</${key}:${sk}>`
          ].join("");
        }).join("\n");
      }
      if (typeof sv === "object") {
        if (key === "video") {
          const attributes = Object.entries(sv).filter(([ssk]) => ssk !== sk).map(([ssk, ssv]) => `${ssk}="${escapeValueForXml(ssv)}"`).join(" ");
          return [
            `            <${key}:${sk} ${attributes}>`,
            // value is the same sk
            sv[sk],
            `</${key}:${sk}>`
          ].join("");
        }
        return [
          `            <${key}:${sk}>`,
          ...Object.entries(sv).map(([ssk, ssv]) => `                <${key}:${ssk}>${escapeValueForXml(ssv)}</${key}:${ssk}>`),
          `            </${key}:${sk}>`
        ].join("\n");
      }
      return `            <${key}:${sk}>${escapeValueForXml(sv)}</${key}:${sk}>`;
    }),
    `        </${key}:${key}>`
  ].join("\n");
}
function handleArray(key, arr) {
  if (arr.length === 0)
    return false;
  key = resolveKey(key);
  if (key === "alternatives") {
    return arr.map((obj) => [
      `        <xhtml:link rel="alternate" ${Object.entries(obj).map(([sk, sv]) => `${sk}="${escapeValueForXml(sv)}"`).join(" ")} />`
    ].join("\n")).join("\n");
  }
  return arr.map((obj) => handleObject(key, obj)).join("\n");
}
function handleEntry(k, e) {
  return Array.isArray(e[k]) ? handleArray(k, e[k]) : typeof e[k] === "object" ? handleObject(k, e[k]) : `        <${k}>${escapeValueForXml(e[k])}</${k}>`;
}
function wrapSitemapXml(input, resolvers, wrapSitemapXmlOptions) {
  const xsl = wrapSitemapXmlOptions.xsl ? resolvers.relativeBaseUrlResolver(wrapSitemapXmlOptions.xsl) : false;
  const credits = wrapSitemapXmlOptions.credits;
  input.unshift(`<?xml version="1.0" encoding="UTF-8"?>${xsl ? `<?xml-stylesheet type="text/xsl" href="${xsl}"?>` : ""}`);
  if (credits)
    input.push(`<!-- XML Sitemap generated by Nuxt Simple Sitemap v${wrapSitemapXmlOptions.version} -->`);
  return input.join("\n");
}
function escapeValueForXml(value) {
  if (value === true || value === false)
    return value ? "yes" : "no";
  return String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
}

async function buildSitemapIndex(resolvers) {
  const {
    sitemaps,
    // enhancing
    autoLastmod,
    // chunking
    defaultSitemapsChunkSize,
    autoI18n,
    isI18nMapped,
    sortEntries,
    // xls
    version,
    xsl,
    credits
  } = useSimpleSitemapRuntimeConfig();
  if (!sitemaps)
    throw new Error("Attempting to build a sitemap index without required `sitemaps` configuration.");
  function maybeSort(urls) {
    return sortEntries ? sortSitemapUrls(urls) : urls;
  }
  const isChunking = typeof sitemaps.chunks !== "undefined";
  const chunks = {};
  if (isChunking) {
    const sitemap = sitemaps.chunks;
    const sources = await resolveSitemapSources(await globalSitemapSources());
    const normalisedUrls = normaliseSitemapUrls(sources.map((e) => e.urls).flat(), resolvers);
    let enhancedUrls = normalisedUrls.map((e) => defu(e, sitemap.defaults));
    if (autoI18n?.locales)
      enhancedUrls = applyI18nEnhancements(enhancedUrls, { isI18nMapped, autoI18n, sitemapName: sitemap.sitemapName });
    const filteredUrls = filterSitemapUrls(enhancedUrls, { ...sitemap, autoI18n, isMultiSitemap: true });
    const sortedUrls = maybeSort(filteredUrls);
    sortedUrls.forEach((url, i) => {
      const chunkIndex = Math.floor(i / defaultSitemapsChunkSize);
      chunks[chunkIndex] = chunks[chunkIndex] || { urls: [] };
      chunks[chunkIndex].urls.push(url);
    });
  } else {
    for (const sitemap in sitemaps) {
      if (sitemap !== "index") {
        chunks[sitemap] = chunks[sitemap] || { urls: [] };
      }
    }
  }
  const entries = [];
  for (const name in chunks) {
    const sitemap = chunks[name];
    const entry = {
      sitemap: resolvers.canonicalUrlResolver(`${name}-sitemap.xml`)
    };
    let lastmod = sitemap.urls.filter((a) => !!a?.lastmod).map((a) => typeof a.lastmod === "string" ? new Date(a.lastmod) : a.lastmod).sort((a, b) => (b?.getTime() || 0) - (a?.getTime() || 0))?.[0];
    if (!lastmod && autoLastmod)
      lastmod = /* @__PURE__ */ new Date();
    if (lastmod)
      entry.lastmod = normaliseDate(lastmod);
    entries.push(entry);
  }
  if (sitemaps.index)
    entries.push(...sitemaps.index.sitemaps);
  const sitemapXml = entries.map((e) => [
    "    <sitemap>",
    `        <loc>${escapeValueForXml(e.sitemap)}</loc>`,
    // lastmod is optional
    e.lastmod ? `        <lastmod>${escapeValueForXml(e.lastmod)}</lastmod>` : false,
    "    </sitemap>"
  ].filter(Boolean).join("\n")).join("\n");
  return wrapSitemapXml([
    '<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
    sitemapXml,
    "</sitemapindex>"
  ], resolvers, { version, xsl, credits });
}

const _yKnW0K = defineEventHandler(async (e) => {
  const canonicalQuery = getQuery(e).canonical;
  const isShowingCanonical = typeof canonicalQuery !== "undefined" && canonicalQuery !== "false";
  let sitemap = await buildSitemapIndex({
    event: e,
    canonicalUrlResolver: createSitePathResolver(e, { canonical: isShowingCanonical || true, absolute: true, withBase: true }),
    relativeBaseUrlResolver: createSitePathResolver(e, { absolute: false, withBase: true })
  });
  const nitro = useNitroApp();
  const ctx = { sitemap, sitemapName: "sitemap" };
  await nitro.hooks.callHook("sitemap:output", ctx);
  sitemap = ctx.sitemap;
  setHeader(e, "Content-Type", "text/xml; charset=UTF-8");
  setHeader(e, "Cache-Control", "max-age=600, must-revalidate");
  return sitemap;
});

function withoutQuery(path) {
  return path.split("?")[0];
}
function createNitroRouteRuleMatcher() {
  const { nitro, app } = useRuntimeConfig();
  const _routeRulesMatcher = toRouteMatcher(
    createRouter$1({
      routes: Object.fromEntries(
        Object.entries(nitro?.routeRules || {}).map(([path, rules]) => [withoutTrailingSlash(path), rules])
      )
    })
  );
  return (path) => {
    return defu({}, ..._routeRulesMatcher.matchAll(
      // radix3 does not support trailing slashes
      withoutBase(withoutTrailingSlash(withoutQuery(path)), app.baseURL)
    ).reverse());
  };
}

async function buildSitemap(sitemap, resolvers) {
  const {
    sitemaps,
    // enhancing
    autoLastmod,
    autoI18n,
    isI18nMapped,
    isMultiSitemap,
    // sorting
    sortEntries,
    // chunking
    defaultSitemapsChunkSize,
    // xls
    version,
    xsl,
    credits
  } = useSimpleSitemapRuntimeConfig();
  const isChunking = typeof sitemaps.chunks !== "undefined" && !Number.isNaN(Number(sitemap.sitemapName));
  function maybeSort(urls2) {
    return sortEntries ? sortSitemapUrls(urls2) : urls2;
  }
  function maybeSlice(urls2) {
    if (isChunking && defaultSitemapsChunkSize) {
      const chunk = Number(sitemap.sitemapName);
      return urls2.slice(chunk * defaultSitemapsChunkSize, (chunk + 1) * defaultSitemapsChunkSize);
    }
    return urls2;
  }
  if (autoI18n?.differentDomains) {
    const domain = autoI18n.locales.find((e) => [e.iso, e.code].includes(sitemap.sitemapName))?.domain;
    if (domain) {
      const _tester = resolvers.canonicalUrlResolver;
      resolvers.canonicalUrlResolver = (path) => resolveSitePath(path, {
        absolute: true,
        withBase: false,
        siteUrl: withHttps(domain),
        trailingSlash: !_tester("/test/").endsWith("/"),
        base: "/"
      });
    }
  }
  const sources = sitemap.includeAppSources ? await globalSitemapSources() : [];
  sources.push(...await childSitemapSources(sitemap));
  let resolvedSources = await resolveSitemapSources(sources);
  if (autoI18n)
    resolvedSources = normaliseI18nSources(resolvedSources, { autoI18n, isI18nMapped });
  const normalisedUrls = normaliseSitemapUrls(resolvedSources.map((e) => e.urls).flat(), resolvers);
  ({ ...sitemap.defaults || {} });
  const routeRuleMatcher = createNitroRouteRuleMatcher();
  let enhancedUrls = normalisedUrls.map((e) => defu(e, sitemap.defaults)).map((e) => {
    const path = parseURL(e.loc).pathname;
    let routeRules = routeRuleMatcher(path);
    if (autoI18n?.locales && autoI18n?.strategy !== "no_prefix") {
      const match = splitForLocales(path, autoI18n.locales.map((l) => l.code));
      const pathWithoutPrefix = match[1];
      if (pathWithoutPrefix && pathWithoutPrefix !== path)
        routeRules = defu(routeRules, routeRuleMatcher(pathWithoutPrefix));
    }
    if (routeRules.sitemap === false)
      return false;
    if (typeof routeRules.index !== "undefined" && !routeRules.index)
      return false;
    const hasRobotsDisabled = Object.entries(routeRules.headers || {}).some(([name, value]) => name.toLowerCase() === "x-robots-tag" && value.toLowerCase() === "noindex");
    if (routeRules.redirect || hasRobotsDisabled)
      return false;
    return routeRules.sitemap ? defu(e, routeRules.sitemap) : e;
  }).filter(Boolean);
  if (autoI18n?.locales)
    enhancedUrls = applyI18nEnhancements(enhancedUrls, { isI18nMapped, autoI18n, sitemapName: sitemap.sitemapName });
  const filteredUrls = filterSitemapUrls(enhancedUrls, { event: resolvers.event, isMultiSitemap, autoI18n, ...sitemap });
  const sortedUrls = maybeSort(filteredUrls);
  const slicedUrls = maybeSlice(sortedUrls);
  const nitro = useNitroApp();
  const ctx = {
    urls: slicedUrls,
    sitemapName: sitemap.sitemapName
  };
  await nitro.hooks.callHook("sitemap:resolved", ctx);
  const urls = maybeSort(normaliseSitemapUrls(ctx.urls, resolvers));
  const urlset = urls.map((e) => {
    const keys = Object.keys(e).filter((k) => !k.startsWith("_"));
    return [
      "    <url>",
      keys.map((k) => handleEntry(k, e)).filter(Boolean).join("\n"),
      "    </url>"
    ].join("\n");
  });
  return wrapSitemapXml([
    '<urlset xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:video="http://www.google.com/schemas/sitemap-video/1.1" xmlns:xhtml="http://www.w3.org/1999/xhtml" xmlns:image="http://www.google.com/schemas/sitemap-image/1.1" xmlns:news="http://www.google.com/schemas/sitemap-news/0.9" xsi:schemaLocation="http://www.sitemaps.org/schemas/sitemap/0.9 http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd http://www.google.com/schemas/sitemap-image/1.1 http://www.google.com/schemas/sitemap-image/1.1/sitemap-image.xsd" xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
    urlset.join("\n"),
    "</urlset>"
  ], resolvers, { version, xsl, credits });
}

function useNitroUrlResolvers(e) {
  const canonicalQuery = getQuery(e).canonical;
  const isShowingCanonical = typeof canonicalQuery !== "undefined" && canonicalQuery !== "false";
  const siteConfig = useSiteConfig(e);
  return {
    event: e,
    fixSlashes: (path) => fixSlashes(siteConfig.trailingSlash, path),
    // we need these as they depend on the nitro event
    canonicalUrlResolver: createSitePathResolver(e, {
      canonical: isShowingCanonical || true,
      absolute: true,
      withBase: true
    }),
    relativeBaseUrlResolver: createSitePathResolver(e, { absolute: false, withBase: true })
  };
}
async function createSitemap(e, definition) {
  const { sitemapName } = definition;
  const nitro = useNitroApp();
  let sitemap = await (definition.sitemapName === "index" ? buildSitemapIndex(useNitroUrlResolvers(e)) : buildSitemap(definition, useNitroUrlResolvers(e)));
  const ctx = { sitemap, sitemapName };
  await nitro.hooks.callHook("sitemap:output", ctx);
  sitemap = ctx.sitemap;
  setHeader(e, "Content-Type", "text/xml; charset=UTF-8");
  setHeader(e, "Cache-Control", "max-age=600, must-revalidate");
  e.context._isSitemap = true;
  return sitemap;
}

const _bratbR = defineEventHandler(async (e) => {
  const path = parseURL(e.path).pathname;
  if (!path.endsWith("-sitemap.xml"))
    return;
  const { sitemaps } = useSimpleSitemapRuntimeConfig();
  const sitemapName = path.replace("-sitemap.xml", "").replace("/", "");
  const isChunking = typeof sitemaps.chunks !== "undefined" && !Number.isNaN(Number(sitemapName));
  if (!(sitemapName in sitemaps) && !isChunking) {
    return createError$1({
      statusCode: 404,
      message: `Sitemap "${sitemapName}" not found.`
    });
  }
  return createSitemap(e, isChunking ? {
    ...sitemaps.chunks,
    sitemapName
  } : sitemaps[sitemapName]);
});

const _vl3dG5 = defineEventHandler(async (e) => {
  setHeader(e, "Content-Type", "application/xslt+xml");
  setHeader(e, "Cache-Control", "max-age=600, must-revalidate");
  const fixPath = createSitePathResolver(e, { absolute: false, withBase: true });
  const { sitemapName: fallbackSitemapName, version, xslColumns, xslTips } = useSimpleSitemapRuntimeConfig();
  const { name: siteName, url: siteUrl } = useSiteConfig(e);
  const referrer = getHeader(e, "Referer") || "/";
  const isNotIndexButHasIndex = referrer !== fixPath("/sitemap.xml") && parseURL(referrer).pathname.endsWith("-sitemap.xml");
  const sitemapName = parseURL(referrer).pathname.split("/").pop()?.split("-sitemap")[0] || fallbackSitemapName;
  const title = `${siteName}${sitemapName !== "sitemap.xml" ? ` - ${sitemapName === "sitemap_index.xml" ? "index" : sitemapName}` : ""}`.replace(/&/g, "&amp;");
  const canonicalQuery = getQuery$1(referrer).canonical;
  const isShowingCanonical = typeof canonicalQuery !== "undefined" && canonicalQuery !== "false";
  const conditionalTips = [
    'You are looking at a <a href="https://developer.mozilla.org/en-US/docs/Web/XSLT/Transforming_XML_with_XSLT/An_Overview" style="color: #398465" target="_blank">XML stylesheet</a>. Read the <a href="https://nuxtseo.com/sitemap/guides/customising-ui" style="color: #398465" target="_blank">docs</a> to learn how to customize it. View the page source to see the raw XML.',
    `URLs missing? Check Nuxt Devtools Sitemap tab (or the <a href="${withQuery("/__sitemap__/debug.json", { sitemap: sitemapName })}" style="color: #398465" target="_blank">debug endpoint</a>).`
  ];
  if (!isShowingCanonical) {
    const canonicalPreviewUrl = withQuery(referrer, { canonical: "" });
    conditionalTips.push(`Your canonical site URL is <strong>${siteUrl}</strong>.`);
    conditionalTips.push(`You can preview your canonical sitemap by visiting <a href="${canonicalPreviewUrl}" style="color: #398465; white-space: nowrap;">${fixPath(canonicalPreviewUrl)}?canonical</a>`);
  } else {
    conditionalTips.push(`You are viewing the canonical sitemap. You can switch to using the request origin: <a href="${fixPath(referrer)}" style="color: #398465; white-space: nowrap ">${fixPath(referrer)}</a>`);
  }
  let columns = [...xslColumns];
  if (!columns.length) {
    columns = [
      { label: "URL", width: "50%" },
      { label: "Images", width: "25%", select: "count(image:image)" },
      { label: "Last Updated", width: "25%", select: "concat(substring(sitemap:lastmod,0,11),concat(' ', substring(sitemap:lastmod,12,5)),concat(' ', substring(sitemap:lastmod,20,6)))" }
    ];
  }
  return `<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="2.0"
                xmlns:html="http://www.w3.org/TR/REC-html40"
                xmlns:image="http://www.google.com/schemas/sitemap-image/1.1"
                xmlns:sitemap="http://www.sitemaps.org/schemas/sitemap/0.9"
                xmlns:xhtml="http://www.w3.org/1999/xhtml"
                xmlns:news="http://www.google.com/schemas/sitemap-news/0.9"
                xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:output method="html" version="1.0" encoding="UTF-8" indent="yes"/>
  <xsl:template match="/">
    <html xmlns="http://www.w3.org/1999/xhtml">
      <head>
        <title>XML Sitemap</title>
        <meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
        <style type="text/css">
          body {
            font-family: Inter, Helvetica, Arial, sans-serif;
            font-size: 14px;
            color: #333;
          }

          table {
            border: none;
            border-collapse: collapse;
          }

          .bg-yellow-200 {
            background-color: #fef9c3;
          }

          .p-5 {
            padding: 1.25rem;
          }

          .rounded {
            border-radius: 4px;
            }

          .shadow {
            box-shadow: 0 1px 2px 0 rgba(0, 0, 0, 0.05);
          }

          #sitemap tr:nth-child(odd) td {
            background-color: #f8f8f8 !important;
          }

          #sitemap tbody tr:hover td {
            background-color: #fff;
          }

          #sitemap tbody tr:hover td, #sitemap tbody tr:hover td a {
            color: #000;
          }

          .expl a {
            color: #398465
            font-weight: 600;
          }

          .expl a:visited {
            color: #398465
          }

          a {
            color: #000;
            text-decoration: none;
          }

          a:visited {
            color: #777;
          }

          a:hover {
            text-decoration: underline;
          }

          td {
            font-size: 12px;
          }

          .text-2xl {
            font-size: 2rem;
            font-weight: 600;
            line-height: 1.25;
          }

          th {
            text-align: left;
            padding-right: 30px;
            font-size: 12px;
          }

          thead th {
            border-bottom: 1px solid #000;
          }
          .fixed { position: fixed; }
          .right-2 { right: 2rem; }
          .top-2 { top: 2rem; }
          .w-30 { width: 30rem; }
          p { margin: 0; }
          li { padding-bottom: 0.5rem; line-height: 1.5; }
          h1 { margin: 0; }
          .mb-5 { margin-bottom: 1.25rem; }
          .mb-3 { margin-bottom: 0.75rem; }
        </style>
      </head>
      <body>
        <div style="grid-template-columns: 1fr 1fr; display: grid; margin: 3rem;">
            <div>
             <div id="content">
          <h1 class="text-2xl mb-3">XML Sitemap</h1>
          <h2>${title}</h2>
          ${isNotIndexButHasIndex ? `<p style="font-size: 12px; margin-bottom: 1rem;"><a href="${fixPath("/sitemap_index.xml")}">${fixPath("/sitemap_index.xml")}</a></p>` : ""}
          <xsl:if test="count(sitemap:sitemapindex/sitemap:sitemap) &gt; 0">
            <p class="expl" style="margin-bottom: 1rem;">
              This XML Sitemap Index file contains
              <xsl:value-of select="count(sitemap:sitemapindex/sitemap:sitemap)"/> sitemaps.
            </p>
            <table id="sitemap" cellpadding="3">
              <thead>
                <tr>
                  <th width="75%">Sitemap</th>
                  <th width="25%">Last Modified</th>
                </tr>
              </thead>
              <tbody>
                <xsl:for-each select="sitemap:sitemapindex/sitemap:sitemap">
                  <xsl:variable name="sitemapURL">
                    <xsl:value-of select="sitemap:loc"/>
                  </xsl:variable>
                  <tr>
                    <td>
                      <a href="{$sitemapURL}">
                        <xsl:value-of select="sitemap:loc"/>
                      </a>
                    </td>
                    <td>
                      <xsl:value-of
                        select="concat(substring(sitemap:lastmod,0,11),concat(' ', substring(sitemap:lastmod,12,5)),concat(' ', substring(sitemap:lastmod,20,6)))"/>
                    </td>
                  </tr>
                </xsl:for-each>
              </tbody>
            </table>
          </xsl:if>
          <xsl:if test="count(sitemap:sitemapindex/sitemap:sitemap) &lt; 1">
            <p class="expl" style="margin-bottom: 1rem;">
              This XML Sitemap contains
              <xsl:value-of select="count(sitemap:urlset/sitemap:url)"/> URLs.
            </p>
            <table id="sitemap" cellpadding="3">
              <thead>
                <tr>
                  ${columns.map((c) => `<th width="${c.width}">${c.label}</th>`).join("\n")}
                </tr>
              </thead>
              <tbody>
                <xsl:variable name="lower" select="'abcdefghijklmnopqrstuvwxyz'"/>
                <xsl:variable name="upper" select="'ABCDEFGHIJKLMNOPQRSTUVWXYZ'"/>
                <xsl:for-each select="sitemap:urlset/sitemap:url">
                  <tr>
                    <td>
                      <xsl:variable name="itemURL">
                        <xsl:value-of select="sitemap:loc"/>
                      </xsl:variable>
                      <a href="{$itemURL}">
                        <xsl:value-of select="sitemap:loc"/>
                      </a>
                    </td>
                    ${columns.filter((c) => c.label !== "URL").map((c) => `<td>
<xsl:value-of select="${c.select}"/>
</td>`).join("\n")}
                  </tr>
                </xsl:for-each>
              </tbody>
            </table>
          </xsl:if>
        </div>
        </div>
                    ${""}
        </div>
      </body>
    </html>
  </xsl:template>
</xsl:stylesheet>
`;
});

const _NuOAlJ = defineEventHandler(async (e) => {
  const { sitemaps } = useSimpleSitemapRuntimeConfig();
  if ("index" in sitemaps) {
    return sendRedirect(e, withBase("/sitemap_index.xml", useRuntimeConfig().app.baseURL), 301);
  }
  return createSitemap(e, Object.values(sitemaps)[0]);
});

const _lazy_OJnuRy = () => import('../routes/renderer.mjs');

const handlers = [
  { route: '', handler: _xAXova, lazy: false, middleware: true, method: undefined },
  { route: '/__nuxt_error', handler: _lazy_OJnuRy, lazy: true, middleware: false, method: undefined },
  { route: '', handler: _7oSkxq, lazy: false, middleware: true, method: undefined },
  { route: '/sitemap_index.xml', handler: _yKnW0K, lazy: false, middleware: false, method: undefined },
  { route: '/en-US-sitemap.xml', handler: _bratbR, lazy: false, middleware: false, method: undefined },
  { route: '/ar-AR-sitemap.xml', handler: _bratbR, lazy: false, middleware: false, method: undefined },
  { route: '/__sitemap__/style.xsl', handler: _vl3dG5, lazy: false, middleware: false, method: undefined },
  { route: '/sitemap.xml', handler: _NuOAlJ, lazy: false, middleware: false, method: undefined },
  { route: '/index-sitemap.xml', handler: _lazy_OJnuRy, lazy: true, middleware: false, method: undefined },
  { route: '/**', handler: _lazy_OJnuRy, lazy: true, middleware: false, method: undefined }
];

function createNitroApp() {
  const config = useRuntimeConfig();
  const hooks = createHooks();
  const captureError = (error, context = {}) => {
    const promise = hooks.callHookParallel("error", error, context).catch((error_) => {
      console.error("Error while capturing another error", error_);
    });
    if (context.event && isEvent(context.event)) {
      const errors = context.event.context.nitro?.errors;
      if (errors) {
        errors.push({ error, context });
      }
      if (context.event.waitUntil) {
        context.event.waitUntil(promise);
      }
    }
  };
  const h3App = createApp({
    debug: destr(false),
    onError: (error, event) => {
      captureError(error, { event, tags: ["request"] });
      return errorHandler(error, event);
    },
    onRequest: async (event) => {
      await nitroApp.hooks.callHook("request", event).catch((error) => {
        captureError(error, { event, tags: ["request"] });
      });
    },
    onBeforeResponse: async (event, response) => {
      await nitroApp.hooks.callHook("beforeResponse", event, response).catch((error) => {
        captureError(error, { event, tags: ["request", "response"] });
      });
    },
    onAfterResponse: async (event, response) => {
      await nitroApp.hooks.callHook("afterResponse", event, response).catch((error) => {
        captureError(error, { event, tags: ["request", "response"] });
      });
    }
  });
  const router = createRouter({
    preemptive: true
  });
  const localCall = createCall(toNodeListener(h3App));
  const _localFetch = createFetch(localCall, globalThis.fetch);
  const localFetch = (input, init) => _localFetch(input, init).then(
    (response) => normalizeFetchResponse(response)
  );
  const $fetch = createFetch$1({
    fetch: localFetch,
    Headers: Headers$1,
    defaults: { baseURL: config.app.baseURL }
  });
  globalThis.$fetch = $fetch;
  h3App.use(createRouteRulesHandler({ localFetch }));
  h3App.use(
    eventHandler((event) => {
      event.context.nitro = event.context.nitro || { errors: [] };
      const envContext = event.node.req?.__unenv__;
      if (envContext) {
        Object.assign(event.context, envContext);
      }
      event.fetch = (req, init) => fetchWithEvent(event, req, init, { fetch: localFetch });
      event.$fetch = (req, init) => fetchWithEvent(event, req, init, {
        fetch: $fetch
      });
      event.waitUntil = (promise) => {
        if (!event.context.nitro._waitUntilPromises) {
          event.context.nitro._waitUntilPromises = [];
        }
        event.context.nitro._waitUntilPromises.push(promise);
        if (envContext?.waitUntil) {
          envContext.waitUntil(promise);
        }
      };
      event.captureError = (error, context) => {
        captureError(error, { event, ...context });
      };
    })
  );
  for (const h of handlers) {
    let handler = h.lazy ? lazyEventHandler(h.handler) : h.handler;
    if (h.middleware || !h.route) {
      const middlewareBase = (config.app.baseURL + (h.route || "/")).replace(
        /\/+/g,
        "/"
      );
      h3App.use(middlewareBase, handler);
    } else {
      const routeRules = getRouteRulesForPath(
        h.route.replace(/:\w+|\*\*/g, "_")
      );
      if (routeRules.cache) {
        handler = cachedEventHandler(handler, {
          group: "nitro/routes",
          ...routeRules.cache
        });
      }
      router.use(h.route, handler, h.method);
    }
  }
  h3App.use(config.app.baseURL, router.handler);
  const app = {
    hooks,
    h3App,
    router,
    localCall,
    localFetch,
    captureError
  };
  return app;
}
function runNitroPlugins(nitroApp2) {
  for (const plugin of plugins) {
    try {
      plugin(nitroApp2);
    } catch (error) {
      nitroApp2.captureError(error, { tags: ["plugin"] });
      throw error;
    }
  }
}
const nitroApp = createNitroApp();
function useNitroApp() {
  return nitroApp;
}
runNitroPlugins(nitroApp);

const debug = (...args) => {
};
function GracefulShutdown(server, opts) {
  opts = opts || {};
  const options = Object.assign(
    {
      signals: "SIGINT SIGTERM",
      timeout: 3e4,
      development: false,
      forceExit: true,
      onShutdown: (signal) => Promise.resolve(signal),
      preShutdown: (signal) => Promise.resolve(signal)
    },
    opts
  );
  let isShuttingDown = false;
  const connections = {};
  let connectionCounter = 0;
  const secureConnections = {};
  let secureConnectionCounter = 0;
  let failed = false;
  let finalRun = false;
  function onceFactory() {
    let called = false;
    return (emitter, events, callback) => {
      function call() {
        if (!called) {
          called = true;
          return Reflect.apply(callback, this, arguments);
        }
      }
      for (const e of events) {
        emitter.on(e, call);
      }
    };
  }
  const signals = options.signals.split(" ").map((s) => s.trim()).filter((s) => s.length > 0);
  const once = onceFactory();
  once(process, signals, (signal) => {
    shutdown(signal).then(() => {
      if (options.forceExit) {
        process.exit(failed ? 1 : 0);
      }
    }).catch((error) => {
      process.exit(1);
    });
  });
  function isFunction(functionToCheck) {
    const getType = Object.prototype.toString.call(functionToCheck);
    return /^\[object\s([A-Za-z]+)?Function]$/.test(getType);
  }
  function destroy(socket, force = false) {
    if (socket._isIdle && isShuttingDown || force) {
      socket.destroy();
      if (socket.server instanceof http.Server) {
        delete connections[socket._connectionId];
      } else {
        delete secureConnections[socket._connectionId];
      }
    }
  }
  function destroyAllConnections(force = false) {
    for (const key of Object.keys(connections)) {
      const socket = connections[key];
      const serverResponse = socket._httpMessage;
      if (serverResponse && !force) {
        if (!serverResponse.headersSent) {
          serverResponse.setHeader("connection", "close");
        }
      } else {
        destroy(socket);
      }
    }
    for (const key of Object.keys(secureConnections)) {
      const socket = secureConnections[key];
      const serverResponse = socket._httpMessage;
      if (serverResponse && !force) {
        if (!serverResponse.headersSent) {
          serverResponse.setHeader("connection", "close");
        }
      } else {
        destroy(socket);
      }
    }
  }
  server.on("request", (req, res) => {
    req.socket._isIdle = false;
    if (isShuttingDown && !res.headersSent) {
      res.setHeader("connection", "close");
    }
    res.on("finish", () => {
      req.socket._isIdle = true;
      destroy(req.socket);
    });
  });
  server.on("connection", (socket) => {
    if (isShuttingDown) {
      socket.destroy();
    } else {
      const id = connectionCounter++;
      socket._isIdle = true;
      socket._connectionId = id;
      connections[id] = socket;
      socket.once("close", () => {
        delete connections[socket._connectionId];
      });
    }
  });
  server.on("secureConnection", (socket) => {
    if (isShuttingDown) {
      socket.destroy();
    } else {
      const id = secureConnectionCounter++;
      socket._isIdle = true;
      socket._connectionId = id;
      secureConnections[id] = socket;
      socket.once("close", () => {
        delete secureConnections[socket._connectionId];
      });
    }
  });
  process.on("close", () => {
  });
  function shutdown(sig) {
    function cleanupHttp() {
      destroyAllConnections();
      return new Promise((resolve, reject) => {
        server.close((err) => {
          if (err) {
            return reject(err);
          }
          return resolve(true);
        });
      });
    }
    if (options.development) {
      return process.exit(0);
    }
    function finalHandler() {
      if (!finalRun) {
        finalRun = true;
        if (options.finally && isFunction(options.finally)) {
          options.finally();
        }
      }
      return Promise.resolve();
    }
    function waitForReadyToShutDown(totalNumInterval) {
      if (totalNumInterval === 0) {
        debug(
          `Could not close connections in time (${options.timeout}ms), will forcefully shut down`
        );
        return Promise.resolve(true);
      }
      const allConnectionsClosed = Object.keys(connections).length === 0 && Object.keys(secureConnections).length === 0;
      if (allConnectionsClosed) {
        return Promise.resolve(false);
      }
      return new Promise((resolve) => {
        setTimeout(() => {
          resolve(waitForReadyToShutDown(totalNumInterval - 1));
        }, 250);
      });
    }
    if (isShuttingDown) {
      return Promise.resolve();
    }
    return options.preShutdown(sig).then(() => {
      isShuttingDown = true;
      cleanupHttp();
    }).then(() => {
      const pollIterations = options.timeout ? Math.round(options.timeout / 250) : 0;
      return waitForReadyToShutDown(pollIterations);
    }).then((force) => {
      if (force) {
        destroyAllConnections(force);
      }
      return options.onShutdown(sig);
    }).then(finalHandler).catch((error) => {
      const errString = typeof error === "string" ? error : JSON.stringify(error);
      failed = true;
      throw errString;
    });
  }
  function shutdownManual() {
    return shutdown("manual");
  }
  return shutdownManual;
}

function getGracefulShutdownConfig() {
  return {
    disabled: !!process.env.NITRO_SHUTDOWN_DISABLED,
    signals: (process.env.NITRO_SHUTDOWN_SIGNALS || "SIGTERM SIGINT").split(" ").map((s) => s.trim()),
    timeout: Number.parseInt(process.env.NITRO_SHUTDOWN_TIMEOUT || "", 10) || 3e4,
    forceExit: !process.env.NITRO_SHUTDOWN_NO_FORCE_EXIT
  };
}
function setupGracefulShutdown(listener, nitroApp) {
  const shutdownConfig = getGracefulShutdownConfig();
  if (shutdownConfig.disabled) {
    return;
  }
  GracefulShutdown(listener, {
    signals: shutdownConfig.signals.join(" "),
    timeout: shutdownConfig.timeout,
    forceExit: shutdownConfig.forceExit,
    onShutdown: async () => {
      await new Promise((resolve) => {
        const timeout = setTimeout(() => {
          console.warn("Graceful shutdown timeout, force exiting...");
          resolve();
        }, shutdownConfig.timeout);
        nitroApp.hooks.callHook("close").catch((error) => {
          console.error(error);
        }).finally(() => {
          clearTimeout(timeout);
          resolve();
        });
      });
    }
  });
}

export { $fetch as $, createHooks as A, sanitizeStatusCode as B, getRequestHeaders as C, trapUnhandledNodeErrors as a, useNitroApp as b, defineRenderHandler as c, destr as d, buildAssetsURL as e, createError$1 as f, getQuery as g, getRouteRules as h, getResponseStatus as i, getResponseStatusText as j, baseURL as k, parse as l, getRequestHeader as m, klona as n, defu as o, publicAssetsURL as p, getContext as q, isEqual as r, setupGracefulShutdown as s, toNodeListener as t, useRuntimeConfig as u, setCookie as v, getCookie as w, deleteCookie as x, toRouteMatcher as y, createRouter$1 as z };
//# sourceMappingURL=nitro.mjs.map
