@ynput/ayon-frontend-shared 0.2.28 → 0.2.30

package/dist/node_modules/@ungap/structured-clone/esm/deserialize.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deserialize.cjs.js","sources":["../../../../../../node_modules/@ungap/structured-clone/esm/deserialize.js"],"sourcesContent":["import {\n  VOID, PRIMITIVE,\n  ARRAY, OBJECT,\n  DATE, REGEXP, MAP, SET,\n  ERROR, BIGINT\n} from './types.js';\n\nconst env = typeof self === 'object' ? self : globalThis;\n\nconst deserializer = ($, _) => {\n  const as = (out, index) => {\n    $.set(index, out);\n    return out;\n  };\n\n  const unpair = index => {\n    if ($.has(index))\n      return $.get(index);\n\n    const [type, value] = _[index];\n    switch (type) {\n      case PRIMITIVE:\n      case VOID:\n        return as(value, index);\n      case ARRAY: {\n        const arr = as([], index);\n        for (const index of value)\n          arr.push(unpair(index));\n        return arr;\n      }\n      case OBJECT: {\n        const object = as({}, index);\n        for (const [key, index] of value)\n          object[unpair(key)] = unpair(index);\n        return object;\n      }\n      case DATE:\n        return as(new Date(value), index);\n      case REGEXP: {\n        const {source, flags} = value;\n        return as(new RegExp(source, flags), index);\n      }\n      case MAP: {\n        const map = as(new Map, index);\n        for (const [key, index] of value)\n          map.set(unpair(key), unpair(index));\n        return map;\n      }\n      case SET: {\n        const set = as(new Set, index);\n        for (const index of value)\n          set.add(unpair(index));\n        return set;\n      }\n      case ERROR: {\n        const {name, message} = value;\n        return as(new env[name](message), index);\n      }\n      case BIGINT:\n        return as(BigInt(value), index);\n      case 'BigInt':\n        return as(Object(BigInt(value)), index);\n      case 'ArrayBuffer':\n        return as(new Uint8Array(value).buffer, value);\n      case 'DataView': {\n        const { buffer } = new Uint8Array(value);\n        return as(new DataView(buffer), value);\n      }\n    }\n    return as(new env[type](value), index);\n  };\n\n  return unpair;\n};\n\n/**\n * @typedef {Array<string,any>} Record a type representation\n */\n\n/**\n * Returns a deserialized value from a serialized array of Records.\n * @param {Record[]} serialized a previously serialized value.\n * @returns {any}\n */\nexport const deserialize = serialized => deserializer(new Map, serialized)(0);\n"],"names":["env","deserializer","$","_","as","out","index","unpair","type","value","PRIMITIVE","VOID","ARRAY","arr","OBJECT","object","key","DATE","REGEXP","source","flags","MAP","map","SET","set","ERROR","name","message","BIGINT","buffer","deserialize","serialized"],"mappings":"kHAOMA,EAAM,OAAO,MAAS,SAAW,KAAO,WAExCC,EAAe,CAACC,EAAGC,IAAM,CAC7B,MAAMC,EAAK,CAACC,EAAKC,KACfJ,EAAE,IAAII,EAAOD,CAAG,EACTA,GAGHE,EAASD,GAAS,CACtB,GAAIJ,EAAE,IAAII,CAAK,EACb,OAAOJ,EAAE,IAAII,CAAK,EAEpB,KAAM,CAACE,EAAMC,CAAK,EAAIN,EAAEG,CAAK,EAC7B,OAAQE,EAAI,CACV,KAAKE,EAAS,UACd,KAAKC,EAAI,KACP,OAAOP,EAAGK,EAAOH,CAAK,EACxB,KAAKM,QAAO,CACV,MAAMC,EAAMT,EAAG,CAAE,EAAEE,CAAK,EACxB,UAAWA,KAASG,EAClBI,EAAI,KAAKN,EAAOD,CAAK,CAAC,EACxB,OAAOO,CACf,CACM,KAAKC,SAAQ,CACX,MAAMC,EAASX,EAAG,CAAE,EAAEE,CAAK,EAC3B,SAAW,CAACU,EAAKV,CAAK,IAAKG,EACzBM,EAAOR,EAAOS,CAAG,CAAC,EAAIT,EAAOD,CAAK,EACpC,OAAOS,CACf,CACM,KAAKE,EAAI,KACP,OAAOb,EAAG,IAAI,KAAKK,CAAK,EAAGH,CAAK,EAClC,KAAKY,SAAQ,CACX,KAAM,CAAC,OAAAC,EAAQ,MAAAC,CAAK,EAAIX,EACxB,OAAOL,EAAG,IAAI,OAAOe,EAAQC,CAAK,EAAGd,CAAK,CAClD,CACM,KAAKe,MAAK,CACR,MAAMC,EAAMlB,EAAG,IAAI,IAAKE,CAAK,EAC7B,SAAW,CAACU,EAAKV,CAAK,IAAKG,EACzBa,EAAI,IAAIf,EAAOS,CAAG,EAAGT,EAAOD,CAAK,CAAC,EACpC,OAAOgB,CACf,CACM,KAAKC,MAAK,CACR,MAAMC,EAAMpB,EAAG,IAAI,IAAKE,CAAK,EAC7B,UAAWA,KAASG,EAClBe,EAAI,IAAIjB,EAAOD,CAAK,CAAC,EACvB,OAAOkB,CACf,CACM,KAAKC,QAAO,CACV,KAAM,CAAC,KAAAC,EAAM,QAAAC,CAAO,EAAIlB,EACxB,OAAOL,EAAG,IAAIJ,EAAI0B,CAAI,EAAEC,CAAO,EAAGrB,CAAK,CAC/C,CACM,KAAKsB,EAAM,OACT,OAAOxB,EAAG,OAAOK,CAAK,EAAGH,CAAK,EAChC,IAAK,SACH,OAAOF,EAAG,OAAO,OAAOK,CAAK,CAAC,EAAGH,CAAK,EACxC,IAAK,cACH,OAAOF,EAAG,IAAI,WAAWK,CAAK,EAAE,OAAQA,CAAK,EAC/C,IAAK,WAAY,CACf,KAAM,CAAE,OAAAoB,CAAM,EAAK,IAAI,WAAWpB,CAAK,EACvC,OAAOL,EAAG,IAAI,SAASyB,CAAM,EAAGpB,CAAK,CAC7C,CACA,CACI,OAAOL,EAAG,IAAIJ,EAAIQ,CAAI,EAAEC,CAAK,EAAGH,CAAK,CACtC,EAED,OAAOC,CACT,EAWauB,EAAcC,GAAc9B,EAAa,IAAI,IAAK8B,CAAU,EAAE,CAAC","x_google_ignoreList":[0]}

package/dist/node_modules/@ungap/structured-clone/esm/deserialize.es.js

@@ -0,0 +1,63 @@
+import { BIGINT as p, ERROR as I, SET as g, MAP as l, REGEXP as E, DATE as R, OBJECT as i, ARRAY as y, VOID as A, PRIMITIVE as b } from "./types.es.js";
+const f = typeof self == "object" ? self : globalThis, B = (c, w) => {
+  const s = (e, o) => (c.set(o, e), e), a = (e) => {
+    if (c.has(e))
+      return c.get(e);
+    const [o, t] = w[e];
+    switch (o) {
+      case b:
+      case A:
+        return s(t, e);
+      case y: {
+        const r = s([], e);
+        for (const n of t)
+          r.push(a(n));
+        return r;
+      }
+      case i: {
+        const r = s({}, e);
+        for (const [n, u] of t)
+          r[a(n)] = a(u);
+        return r;
+      }
+      case R:
+        return s(new Date(t), e);
+      case E: {
+        const { source: r, flags: n } = t;
+        return s(new RegExp(r, n), e);
+      }
+      case l: {
+        const r = s(/* @__PURE__ */ new Map(), e);
+        for (const [n, u] of t)
+          r.set(a(n), a(u));
+        return r;
+      }
+      case g: {
+        const r = s(/* @__PURE__ */ new Set(), e);
+        for (const n of t)
+          r.add(a(n));
+        return r;
+      }
+      case I: {
+        const { name: r, message: n } = t;
+        return s(new f[r](n), e);
+      }
+      case p:
+        return s(BigInt(t), e);
+      case "BigInt":
+        return s(Object(BigInt(t)), e);
+      case "ArrayBuffer":
+        return s(new Uint8Array(t).buffer, t);
+      case "DataView": {
+        const { buffer: r } = new Uint8Array(t);
+        return s(new DataView(r), t);
+      }
+    }
+    return s(new f[o](t), e);
+  };
+  return a;
+}, m = (c) => B(/* @__PURE__ */ new Map(), c)(0);
+export {
+  m as deserialize
+};
+//# sourceMappingURL=deserialize.es.js.map

package/dist/node_modules/@ungap/structured-clone/esm/deserialize.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deserialize.es.js","sources":["../../../../../../node_modules/@ungap/structured-clone/esm/deserialize.js"],"sourcesContent":["import {\n  VOID, PRIMITIVE,\n  ARRAY, OBJECT,\n  DATE, REGEXP, MAP, SET,\n  ERROR, BIGINT\n} from './types.js';\n\nconst env = typeof self === 'object' ? self : globalThis;\n\nconst deserializer = ($, _) => {\n  const as = (out, index) => {\n    $.set(index, out);\n    return out;\n  };\n\n  const unpair = index => {\n    if ($.has(index))\n      return $.get(index);\n\n    const [type, value] = _[index];\n    switch (type) {\n      case PRIMITIVE:\n      case VOID:\n        return as(value, index);\n      case ARRAY: {\n        const arr = as([], index);\n        for (const index of value)\n          arr.push(unpair(index));\n        return arr;\n      }\n      case OBJECT: {\n        const object = as({}, index);\n        for (const [key, index] of value)\n          object[unpair(key)] = unpair(index);\n        return object;\n      }\n      case DATE:\n        return as(new Date(value), index);\n      case REGEXP: {\n        const {source, flags} = value;\n        return as(new RegExp(source, flags), index);\n      }\n      case MAP: {\n        const map = as(new Map, index);\n        for (const [key, index] of value)\n          map.set(unpair(key), unpair(index));\n        return map;\n      }\n      case SET: {\n        const set = as(new Set, index);\n        for (const index of value)\n          set.add(unpair(index));\n        return set;\n      }\n      case ERROR: {\n        const {name, message} = value;\n        return as(new env[name](message), index);\n      }\n      case BIGINT:\n        return as(BigInt(value), index);\n      case 'BigInt':\n        return as(Object(BigInt(value)), index);\n      case 'ArrayBuffer':\n        return as(new Uint8Array(value).buffer, value);\n      case 'DataView': {\n        const { buffer } = new Uint8Array(value);\n        return as(new DataView(buffer), value);\n      }\n    }\n    return as(new env[type](value), index);\n  };\n\n  return unpair;\n};\n\n/**\n * @typedef {Array<string,any>} Record a type representation\n */\n\n/**\n * Returns a deserialized value from a serialized array of Records.\n * @param {Record[]} serialized a previously serialized value.\n * @returns {any}\n */\nexport const deserialize = serialized => deserializer(new Map, serialized)(0);\n"],"names":["env","deserializer","$","_","as","out","index","unpair","type","value","PRIMITIVE","VOID","ARRAY","arr","OBJECT","object","key","DATE","REGEXP","source","flags","MAP","map","SET","set","ERROR","name","message","BIGINT","buffer","deserialize","serialized"],"mappings":";AAOA,MAAMA,IAAM,OAAO,QAAS,WAAW,OAAO,YAExCC,IAAe,CAACC,GAAGC,MAAM;AAC7B,QAAMC,IAAK,CAACC,GAAKC,OACfJ,EAAE,IAAII,GAAOD,CAAG,GACTA,IAGHE,IAAS,CAAAD,MAAS;AACtB,QAAIJ,EAAE,IAAII,CAAK;AACb,aAAOJ,EAAE,IAAII,CAAK;AAEpB,UAAM,CAACE,GAAMC,CAAK,IAAIN,EAAEG,CAAK;AAC7B,YAAQE,GAAI;AAAA,MACV,KAAKE;AAAA,MACL,KAAKC;AACH,eAAOP,EAAGK,GAAOH,CAAK;AAAA,MACxB,KAAKM,GAAO;AACV,cAAMC,IAAMT,EAAG,CAAE,GAAEE,CAAK;AACxB,mBAAWA,KAASG;AAClB,UAAAI,EAAI,KAAKN,EAAOD,CAAK,CAAC;AACxB,eAAOO;AAAA,MACf;AAAA,MACM,KAAKC,GAAQ;AACX,cAAMC,IAASX,EAAG,CAAE,GAAEE,CAAK;AAC3B,mBAAW,CAACU,GAAKV,CAAK,KAAKG;AACzB,UAAAM,EAAOR,EAAOS,CAAG,CAAC,IAAIT,EAAOD,CAAK;AACpC,eAAOS;AAAA,MACf;AAAA,MACM,KAAKE;AACH,eAAOb,EAAG,IAAI,KAAKK,CAAK,GAAGH,CAAK;AAAA,MAClC,KAAKY,GAAQ;AACX,cAAM,EAAC,QAAAC,GAAQ,OAAAC,EAAK,IAAIX;AACxB,eAAOL,EAAG,IAAI,OAAOe,GAAQC,CAAK,GAAGd,CAAK;AAAA,MAClD;AAAA,MACM,KAAKe,GAAK;AACR,cAAMC,IAAMlB,EAAG,oBAAI,OAAKE,CAAK;AAC7B,mBAAW,CAACU,GAAKV,CAAK,KAAKG;AACzB,UAAAa,EAAI,IAAIf,EAAOS,CAAG,GAAGT,EAAOD,CAAK,CAAC;AACpC,eAAOgB;AAAA,MACf;AAAA,MACM,KAAKC,GAAK;AACR,cAAMC,IAAMpB,EAAG,oBAAI,OAAKE,CAAK;AAC7B,mBAAWA,KAASG;AAClB,UAAAe,EAAI,IAAIjB,EAAOD,CAAK,CAAC;AACvB,eAAOkB;AAAA,MACf;AAAA,MACM,KAAKC,GAAO;AACV,cAAM,EAAC,MAAAC,GAAM,SAAAC,EAAO,IAAIlB;AACxB,eAAOL,EAAG,IAAIJ,EAAI0B,CAAI,EAAEC,CAAO,GAAGrB,CAAK;AAAA,MAC/C;AAAA,MACM,KAAKsB;AACH,eAAOxB,EAAG,OAAOK,CAAK,GAAGH,CAAK;AAAA,MAChC,KAAK;AACH,eAAOF,EAAG,OAAO,OAAOK,CAAK,CAAC,GAAGH,CAAK;AAAA,MACxC,KAAK;AACH,eAAOF,EAAG,IAAI,WAAWK,CAAK,EAAE,QAAQA,CAAK;AAAA,MAC/C,KAAK,YAAY;AACf,cAAM,EAAE,QAAAoB,EAAM,IAAK,IAAI,WAAWpB,CAAK;AACvC,eAAOL,EAAG,IAAI,SAASyB,CAAM,GAAGpB,CAAK;AAAA,MAC7C;AAAA,IACA;AACI,WAAOL,EAAG,IAAIJ,EAAIQ,CAAI,EAAEC,CAAK,GAAGH,CAAK;AAAA,EACtC;AAED,SAAOC;AACT,GAWauB,IAAc,CAAAC,MAAc9B,EAAa,oBAAI,OAAK8B,CAAU,EAAE,CAAC;","x_google_ignoreList":[0]}

package/dist/node_modules/@ungap/structured-clone/esm/index.cjs.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:"Module"}});const r=require("./deserialize.cjs.js"),l=require("./serialize.cjs.js"),s=typeof structuredClone=="function"?(i,e)=>e&&("json"in e||"lossy"in e)?r.deserialize(l.serialize(i,e)):structuredClone(i):(i,e)=>r.deserialize(l.serialize(i,e));exports.deserialize=r.deserialize;exports.serialize=l.serialize;exports.default=s;
+//# sourceMappingURL=index.cjs.js.map

package/dist/node_modules/@ungap/structured-clone/esm/index.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs.js","sources":["../../../../../../node_modules/@ungap/structured-clone/esm/index.js"],"sourcesContent":["import {deserialize} from './deserialize.js';\nimport {serialize} from './serialize.js';\n\n/**\n * @typedef {Array<string,any>} Record a type representation\n */\n\n/**\n * Returns an array of serialized Records.\n * @param {any} any a serializable value.\n * @param {{transfer?: any[], json?: boolean, lossy?: boolean}?} options an object with\n * a transfer option (ignored when polyfilled) and/or non standard fields that\n * fallback to the polyfill if present.\n * @returns {Record[]}\n */\nexport default typeof structuredClone === \"function\" ?\n  /* c8 ignore start */\n  (any, options) => (\n    options && ('json' in options || 'lossy' in options) ?\n      deserialize(serialize(any, options)) : structuredClone(any)\n  ) :\n  (any, options) => deserialize(serialize(any, options));\n  /* c8 ignore stop */\n\nexport {deserialize, serialize};\n"],"names":["structuredClone$1","any","options","deserialize","serialize"],"mappings":"oLAeeA,EAAA,OAAO,iBAAoB,WAExC,CAACC,EAAKC,IACJA,IAAY,SAAUA,GAAW,UAAWA,GAC1CC,EAAW,YAACC,EAAS,UAACH,EAAKC,CAAO,CAAC,EAAI,gBAAgBD,CAAG,EAE9D,CAACA,EAAKC,IAAYC,EAAAA,YAAYC,EAAAA,UAAUH,EAAKC,CAAO,CAAC","x_google_ignoreList":[0]}

package/dist/node_modules/@ungap/structured-clone/esm/index.es.js

@@ -0,0 +1,12 @@
+import { deserialize as t } from "./deserialize.es.js";
+import { serialize as u } from "./serialize.es.js";
+const s = typeof structuredClone == "function" ? (
+  /* c8 ignore start */
+  (r, e) => e && ("json" in e || "lossy" in e) ? t(u(r, e)) : structuredClone(r)
+) : (r, e) => t(u(r, e));
+export {
+  s as default,
+  t as deserialize,
+  u as serialize
+};
+//# sourceMappingURL=index.es.js.map

package/dist/node_modules/@ungap/structured-clone/esm/index.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es.js","sources":["../../../../../../node_modules/@ungap/structured-clone/esm/index.js"],"sourcesContent":["import {deserialize} from './deserialize.js';\nimport {serialize} from './serialize.js';\n\n/**\n * @typedef {Array<string,any>} Record a type representation\n */\n\n/**\n * Returns an array of serialized Records.\n * @param {any} any a serializable value.\n * @param {{transfer?: any[], json?: boolean, lossy?: boolean}?} options an object with\n * a transfer option (ignored when polyfilled) and/or non standard fields that\n * fallback to the polyfill if present.\n * @returns {Record[]}\n */\nexport default typeof structuredClone === \"function\" ?\n  /* c8 ignore start */\n  (any, options) => (\n    options && ('json' in options || 'lossy' in options) ?\n      deserialize(serialize(any, options)) : structuredClone(any)\n  ) :\n  (any, options) => deserialize(serialize(any, options));\n  /* c8 ignore stop */\n\nexport {deserialize, serialize};\n"],"names":["structuredClone$1","any","options","deserialize","serialize"],"mappings":";;AAeA,MAAeA,IAAA,OAAO,mBAAoB;AAAA;AAAA,EAExC,CAACC,GAAKC,MACJA,MAAY,UAAUA,KAAW,WAAWA,KAC1CC,EAAYC,EAAUH,GAAKC,CAAO,CAAC,IAAI,gBAAgBD,CAAG;AAAA,IAE9D,CAACA,GAAKC,MAAYC,EAAYC,EAAUH,GAAKC,CAAO,CAAC;","x_google_ignoreList":[0]}

package/dist/node_modules/@ungap/structured-clone/esm/serialize.cjs.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=require("./types.cjs.js"),p="",{toString:g}={},{keys:I}=Object,A=o=>{const a=typeof o;if(a!=="object"||!o)return[t.PRIMITIVE,a];const c=g.call(o).slice(8,-1);switch(c){case"Array":return[t.ARRAY,p];case"Object":return[t.OBJECT,p];case"Date":return[t.DATE,p];case"RegExp":return[t.REGEXP,p];case"Map":return[t.MAP,p];case"Set":return[t.SET,p];case"DataView":return[t.ARRAY,c]}return c.includes("Array")?[t.ARRAY,c]:c.includes("Error")?[t.ERROR,c]:[t.OBJECT,c]},u=([o,a])=>o===t.PRIMITIVE&&(a==="function"||a==="symbol"),b=(o,a,c,R)=>{const i=(r,f)=>{const s=R.push(r)-1;return c.set(f,s),s},E=r=>{if(c.has(r))return c.get(r);let[f,s]=A(r);switch(f){case t.PRIMITIVE:{let n=r;switch(s){case"bigint":f=t.BIGINT,n=r.toString();break;case"function":case"symbol":if(o)throw new TypeError("unable to serialize "+s);n=null;break;case"undefined":return i([t.VOID],r)}return i([f,n],r)}case t.ARRAY:{if(s){let e=r;return s==="DataView"?e=new Uint8Array(r.buffer):s==="ArrayBuffer"&&(e=new Uint8Array(r)),i([s,[...e]],r)}const n=[],y=i([f,n],r);for(const e of r)n.push(E(e));return y}case t.OBJECT:{if(s)switch(s){case"BigInt":return i([s,r.toString()],r);case"Boolean":case"Number":case"String":return i([s,r.valueOf()],r)}if(a&&"toJSON"in r)return E(r.toJSON());const n=[],y=i([f,n],r);for(const e of I(r))(o||!u(A(r[e])))&&n.push([E(e),E(r[e])]);return y}case t.DATE:return i([f,r.toISOString()],r);case t.REGEXP:{const{source:n,flags:y}=r;return i([f,{source:n,flags:y}],r)}case t.MAP:{const n=[],y=i([f,n],r);for(const[e,S]of r)(o||!(u(A(e))||u(A(S))))&&n.push([E(e),E(S)]);return y}case t.SET:{const n=[],y=i([f,n],r);for(const e of r)(o||!u(A(e)))&&n.push(E(e));return y}}const{message:T}=r;return i([f,{name:s,message:T}],r)};return E},d=(o,{json:a,lossy:c}={})=>{const R=[];return b(!(a||c),!!a,new Map,R)(o),R};exports.serialize=d;
+//# sourceMappingURL=serialize.cjs.js.map

package/dist/node_modules/@ungap/structured-clone/esm/serialize.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize.cjs.js","sources":["../../../../../../node_modules/@ungap/structured-clone/esm/serialize.js"],"sourcesContent":["import {\n  VOID, PRIMITIVE,\n  ARRAY, OBJECT,\n  DATE, REGEXP, MAP, SET,\n  ERROR, BIGINT\n} from './types.js';\n\nconst EMPTY = '';\n\nconst {toString} = {};\nconst {keys} = Object;\n\nconst typeOf = value => {\n  const type = typeof value;\n  if (type !== 'object' || !value)\n    return [PRIMITIVE, type];\n\n  const asString = toString.call(value).slice(8, -1);\n  switch (asString) {\n    case 'Array':\n      return [ARRAY, EMPTY];\n    case 'Object':\n      return [OBJECT, EMPTY];\n    case 'Date':\n      return [DATE, EMPTY];\n    case 'RegExp':\n      return [REGEXP, EMPTY];\n    case 'Map':\n      return [MAP, EMPTY];\n    case 'Set':\n      return [SET, EMPTY];\n    case 'DataView':\n      return [ARRAY, asString];\n  }\n\n  if (asString.includes('Array'))\n    return [ARRAY, asString];\n\n  if (asString.includes('Error'))\n    return [ERROR, asString];\n\n  return [OBJECT, asString];\n};\n\nconst shouldSkip = ([TYPE, type]) => (\n  TYPE === PRIMITIVE &&\n  (type === 'function' || type === 'symbol')\n);\n\nconst serializer = (strict, json, $, _) => {\n\n  const as = (out, value) => {\n    const index = _.push(out) - 1;\n    $.set(value, index);\n    return index;\n  };\n\n  const pair = value => {\n    if ($.has(value))\n      return $.get(value);\n\n    let [TYPE, type] = typeOf(value);\n    switch (TYPE) {\n      case PRIMITIVE: {\n        let entry = value;\n        switch (type) {\n          case 'bigint':\n            TYPE = BIGINT;\n            entry = value.toString();\n            break;\n          case 'function':\n          case 'symbol':\n            if (strict)\n              throw new TypeError('unable to serialize ' + type);\n            entry = null;\n            break;\n          case 'undefined':\n            return as([VOID], value);\n        }\n        return as([TYPE, entry], value);\n      }\n      case ARRAY: {\n        if (type) {\n          let spread = value;\n          if (type === 'DataView') {\n            spread = new Uint8Array(value.buffer);\n          }\n          else if (type === 'ArrayBuffer') {\n            spread = new Uint8Array(value);\n          }\n          return as([type, [...spread]], value);\n        }\n\n        const arr = [];\n        const index = as([TYPE, arr], value);\n        for (const entry of value)\n          arr.push(pair(entry));\n        return index;\n      }\n      case OBJECT: {\n        if (type) {\n          switch (type) {\n            case 'BigInt':\n              return as([type, value.toString()], value);\n            case 'Boolean':\n            case 'Number':\n            case 'String':\n              return as([type, value.valueOf()], value);\n          }\n        }\n\n        if (json && ('toJSON' in value))\n          return pair(value.toJSON());\n\n        const entries = [];\n        const index = as([TYPE, entries], value);\n        for (const key of keys(value)) {\n          if (strict || !shouldSkip(typeOf(value[key])))\n            entries.push([pair(key), pair(value[key])]);\n        }\n        return index;\n      }\n      case DATE:\n        return as([TYPE, value.toISOString()], value);\n      case REGEXP: {\n        const {source, flags} = value;\n        return as([TYPE, {source, flags}], value);\n      }\n      case MAP: {\n        const entries = [];\n        const index = as([TYPE, entries], value);\n        for (const [key, entry] of value) {\n          if (strict || !(shouldSkip(typeOf(key)) || shouldSkip(typeOf(entry))))\n            entries.push([pair(key), pair(entry)]);\n        }\n        return index;\n      }\n      case SET: {\n        const entries = [];\n        const index = as([TYPE, entries], value);\n        for (const entry of value) {\n          if (strict || !shouldSkip(typeOf(entry)))\n            entries.push(pair(entry));\n        }\n        return index;\n      }\n    }\n\n    const {message} = value;\n    return as([TYPE, {name: type, message}], value);\n  };\n\n  return pair;\n};\n\n/**\n * @typedef {Array<string,any>} Record a type representation\n */\n\n/**\n * Returns an array of serialized Records.\n * @param {any} value a serializable value.\n * @param {{json?: boolean, lossy?: boolean}?} options an object with a `lossy` or `json` property that,\n *  if `true`, will not throw errors on incompatible types, and behave more\n *  like JSON stringify would behave. Symbol and Function will be discarded.\n * @returns {Record[]}\n */\n export const serialize = (value, {json, lossy} = {}) => {\n  const _ = [];\n  return serializer(!(json || lossy), !!json, new Map, _)(value), _;\n};\n"],"names":["EMPTY","toString","keys","typeOf","value","type","PRIMITIVE","asString","ARRAY","OBJECT","DATE","REGEXP","MAP","SET","ERROR","shouldSkip","TYPE","serializer","strict","json","$","_","as","out","index","pair","entry","BIGINT","VOID","spread","arr","entries","key","source","flags","message","serialize","lossy"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/@ungap/structured-clone/esm/serialize.es.js

@@ -0,0 +1,107 @@
+import { SET as w, MAP as O, REGEXP as A, DATE as I, OBJECT as S, ARRAY as E, PRIMITIVE as b, BIGINT as T, ERROR as m, VOID as x } from "./types.es.js";
+const p = "", { toString: k } = {}, { keys: B } = Object, g = (c) => {
+  const f = typeof c;
+  if (f !== "object" || !c)
+    return [b, f];
+  const s = k.call(c).slice(8, -1);
+  switch (s) {
+    case "Array":
+      return [E, p];
+    case "Object":
+      return [S, p];
+    case "Date":
+      return [I, p];
+    case "RegExp":
+      return [A, p];
+    case "Map":
+      return [O, p];
+    case "Set":
+      return [w, p];
+    case "DataView":
+      return [E, s];
+  }
+  return s.includes("Array") ? [E, s] : s.includes("Error") ? [m, s] : [S, s];
+}, u = ([c, f]) => c === b && (f === "function" || f === "symbol"), D = (c, f, s, h) => {
+  const o = (r, i) => {
+    const e = h.push(r) - 1;
+    return s.set(i, e), e;
+  }, y = (r) => {
+    if (s.has(r))
+      return s.get(r);
+    let [i, e] = g(r);
+    switch (i) {
+      case b: {
+        let t = r;
+        switch (e) {
+          case "bigint":
+            i = T, t = r.toString();
+            break;
+          case "function":
+          case "symbol":
+            if (c)
+              throw new TypeError("unable to serialize " + e);
+            t = null;
+            break;
+          case "undefined":
+            return o([x], r);
+        }
+        return o([i, t], r);
+      }
+      case E: {
+        if (e) {
+          let n = r;
+          return e === "DataView" ? n = new Uint8Array(r.buffer) : e === "ArrayBuffer" && (n = new Uint8Array(r)), o([e, [...n]], r);
+        }
+        const t = [], a = o([i, t], r);
+        for (const n of r)
+          t.push(y(n));
+        return a;
+      }
+      case S: {
+        if (e)
+          switch (e) {
+            case "BigInt":
+              return o([e, r.toString()], r);
+            case "Boolean":
+            case "Number":
+            case "String":
+              return o([e, r.valueOf()], r);
+          }
+        if (f && "toJSON" in r)
+          return y(r.toJSON());
+        const t = [], a = o([i, t], r);
+        for (const n of B(r))
+          (c || !u(g(r[n]))) && t.push([y(n), y(r[n])]);
+        return a;
+      }
+      case I:
+        return o([i, r.toISOString()], r);
+      case A: {
+        const { source: t, flags: a } = r;
+        return o([i, { source: t, flags: a }], r);
+      }
+      case O: {
+        const t = [], a = o([i, t], r);
+        for (const [n, d] of r)
+          (c || !(u(g(n)) || u(g(d)))) && t.push([y(n), y(d)]);
+        return a;
+      }
+      case w: {
+        const t = [], a = o([i, t], r);
+        for (const n of r)
+          (c || !u(g(n))) && t.push(y(n));
+        return a;
+      }
+    }
+    const { message: R } = r;
+    return o([i, { name: e, message: R }], r);
+  };
+  return y;
+}, P = (c, { json: f, lossy: s } = {}) => {
+  const h = [];
+  return D(!(f || s), !!f, /* @__PURE__ */ new Map(), h)(c), h;
+};
+export {
+  P as serialize
+};
+//# sourceMappingURL=serialize.es.js.map

package/dist/node_modules/@ungap/structured-clone/esm/serialize.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize.es.js","sources":["../../../../../../node_modules/@ungap/structured-clone/esm/serialize.js"],"sourcesContent":["import {\n  VOID, PRIMITIVE,\n  ARRAY, OBJECT,\n  DATE, REGEXP, MAP, SET,\n  ERROR, BIGINT\n} from './types.js';\n\nconst EMPTY = '';\n\nconst {toString} = {};\nconst {keys} = Object;\n\nconst typeOf = value => {\n  const type = typeof value;\n  if (type !== 'object' || !value)\n    return [PRIMITIVE, type];\n\n  const asString = toString.call(value).slice(8, -1);\n  switch (asString) {\n    case 'Array':\n      return [ARRAY, EMPTY];\n    case 'Object':\n      return [OBJECT, EMPTY];\n    case 'Date':\n      return [DATE, EMPTY];\n    case 'RegExp':\n      return [REGEXP, EMPTY];\n    case 'Map':\n      return [MAP, EMPTY];\n    case 'Set':\n      return [SET, EMPTY];\n    case 'DataView':\n      return [ARRAY, asString];\n  }\n\n  if (asString.includes('Array'))\n    return [ARRAY, asString];\n\n  if (asString.includes('Error'))\n    return [ERROR, asString];\n\n  return [OBJECT, asString];\n};\n\nconst shouldSkip = ([TYPE, type]) => (\n  TYPE === PRIMITIVE &&\n  (type === 'function' || type === 'symbol')\n);\n\nconst serializer = (strict, json, $, _) => {\n\n  const as = (out, value) => {\n    const index = _.push(out) - 1;\n    $.set(value, index);\n    return index;\n  };\n\n  const pair = value => {\n    if ($.has(value))\n      return $.get(value);\n\n    let [TYPE, type] = typeOf(value);\n    switch (TYPE) {\n      case PRIMITIVE: {\n        let entry = value;\n        switch (type) {\n          case 'bigint':\n            TYPE = BIGINT;\n            entry = value.toString();\n            break;\n          case 'function':\n          case 'symbol':\n            if (strict)\n              throw new TypeError('unable to serialize ' + type);\n            entry = null;\n            break;\n          case 'undefined':\n            return as([VOID], value);\n        }\n        return as([TYPE, entry], value);\n      }\n      case ARRAY: {\n        if (type) {\n          let spread = value;\n          if (type === 'DataView') {\n            spread = new Uint8Array(value.buffer);\n          }\n          else if (type === 'ArrayBuffer') {\n            spread = new Uint8Array(value);\n          }\n          return as([type, [...spread]], value);\n        }\n\n        const arr = [];\n        const index = as([TYPE, arr], value);\n        for (const entry of value)\n          arr.push(pair(entry));\n        return index;\n      }\n      case OBJECT: {\n        if (type) {\n          switch (type) {\n            case 'BigInt':\n              return as([type, value.toString()], value);\n            case 'Boolean':\n            case 'Number':\n            case 'String':\n              return as([type, value.valueOf()], value);\n          }\n        }\n\n        if (json && ('toJSON' in value))\n          return pair(value.toJSON());\n\n        const entries = [];\n        const index = as([TYPE, entries], value);\n        for (const key of keys(value)) {\n          if (strict || !shouldSkip(typeOf(value[key])))\n            entries.push([pair(key), pair(value[key])]);\n        }\n        return index;\n      }\n      case DATE:\n        return as([TYPE, value.toISOString()], value);\n      case REGEXP: {\n        const {source, flags} = value;\n        return as([TYPE, {source, flags}], value);\n      }\n      case MAP: {\n        const entries = [];\n        const index = as([TYPE, entries], value);\n        for (const [key, entry] of value) {\n          if (strict || !(shouldSkip(typeOf(key)) || shouldSkip(typeOf(entry))))\n            entries.push([pair(key), pair(entry)]);\n        }\n        return index;\n      }\n      case SET: {\n        const entries = [];\n        const index = as([TYPE, entries], value);\n        for (const entry of value) {\n          if (strict || !shouldSkip(typeOf(entry)))\n            entries.push(pair(entry));\n        }\n        return index;\n      }\n    }\n\n    const {message} = value;\n    return as([TYPE, {name: type, message}], value);\n  };\n\n  return pair;\n};\n\n/**\n * @typedef {Array<string,any>} Record a type representation\n */\n\n/**\n * Returns an array of serialized Records.\n * @param {any} value a serializable value.\n * @param {{json?: boolean, lossy?: boolean}?} options an object with a `lossy` or `json` property that,\n *  if `true`, will not throw errors on incompatible types, and behave more\n *  like JSON stringify would behave. Symbol and Function will be discarded.\n * @returns {Record[]}\n */\n export const serialize = (value, {json, lossy} = {}) => {\n  const _ = [];\n  return serializer(!(json || lossy), !!json, new Map, _)(value), _;\n};\n"],"names":["EMPTY","toString","keys","typeOf","value","type","PRIMITIVE","asString","ARRAY","OBJECT","DATE","REGEXP","MAP","SET","ERROR","shouldSkip","TYPE","serializer","strict","json","$","_","as","out","index","pair","entry","BIGINT","VOID","spread","arr","entries","key","source","flags","message","serialize","lossy"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/@ungap/structured-clone/esm/types.cjs.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=-1,o=0,E=1,R=2,c=3,n=4,s=5,I=6,T=7,A=8;exports.ARRAY=E;exports.BIGINT=A;exports.DATE=c;exports.ERROR=T;exports.MAP=s;exports.OBJECT=R;exports.PRIMITIVE=o;exports.REGEXP=n;exports.SET=I;exports.VOID=t;
+//# sourceMappingURL=types.cjs.js.map

package/dist/node_modules/@ungap/structured-clone/esm/types.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.cjs.js","sources":["../../../../../../node_modules/@ungap/structured-clone/esm/types.js"],"sourcesContent":["export const VOID       = -1;\nexport const PRIMITIVE  = 0;\nexport const ARRAY      = 1;\nexport const OBJECT     = 2;\nexport const DATE       = 3;\nexport const REGEXP     = 4;\nexport const MAP        = 5;\nexport const SET        = 6;\nexport const ERROR      = 7;\nexport const BIGINT     = 8;\n// export const SYMBOL = 9;\n"],"names":["VOID","PRIMITIVE","ARRAY","OBJECT","DATE","REGEXP","MAP","SET","ERROR","BIGINT"],"mappings":"gFAAY,MAACA,EAAa,GACbC,EAAa,EACbC,EAAa,EACbC,EAAa,EACbC,EAAa,EACbC,EAAa,EACbC,EAAa,EACbC,EAAa,EACbC,EAAa,EACbC,EAAa","x_google_ignoreList":[0]}

package/dist/node_modules/@ungap/structured-clone/esm/types.es.js

@@ -0,0 +1,14 @@
+const o = -1, t = 0, c = 1, n = 2, s = 3, E = 4, R = 5, I = 6, T = 7, A = 8;
+export {
+  c as ARRAY,
+  A as BIGINT,
+  s as DATE,
+  T as ERROR,
+  R as MAP,
+  n as OBJECT,
+  t as PRIMITIVE,
+  E as REGEXP,
+  I as SET,
+  o as VOID
+};
+//# sourceMappingURL=types.es.js.map

package/dist/node_modules/@ungap/structured-clone/esm/types.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.es.js","sources":["../../../../../../node_modules/@ungap/structured-clone/esm/types.js"],"sourcesContent":["export const VOID       = -1;\nexport const PRIMITIVE  = 0;\nexport const ARRAY      = 1;\nexport const OBJECT     = 2;\nexport const DATE       = 3;\nexport const REGEXP     = 4;\nexport const MAP        = 5;\nexport const SET        = 6;\nexport const ERROR      = 7;\nexport const BIGINT     = 8;\n// export const SYMBOL = 9;\n"],"names":["VOID","PRIMITIVE","ARRAY","OBJECT","DATE","REGEXP","MAP","SET","ERROR","BIGINT"],"mappings":"AAAY,MAACA,IAAa,IACbC,IAAa,GACbC,IAAa,GACbC,IAAa,GACbC,IAAa,GACbC,IAAa,GACbC,IAAa,GACbC,IAAa,GACbC,IAAa,GACbC,IAAa;","x_google_ignoreList":[0]}

package/dist/node_modules/devlop/lib/default.cjs.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});function e(){}exports.ok=e;
+//# sourceMappingURL=default.cjs.js.map

package/dist/node_modules/devlop/lib/default.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"default.cjs.js","sources":["../../../../../node_modules/devlop/lib/default.js"],"sourcesContent":["export function deprecate(fn) {\n  return fn\n}\n\nexport function equal() {}\n\nexport function ok() {}\n\nexport function unreachable() {}\n"],"names":["ok"],"mappings":"gFAMO,SAASA,GAAK,CAAA","x_google_ignoreList":[0]}

package/dist/node_modules/devlop/lib/default.es.js

@@ -0,0 +1,6 @@
+function o() {
+}
+export {
+  o as ok
+};
+//# sourceMappingURL=default.es.js.map

package/dist/node_modules/devlop/lib/default.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"default.es.js","sources":["../../../../../node_modules/devlop/lib/default.js"],"sourcesContent":["export function deprecate(fn) {\n  return fn\n}\n\nexport function equal() {}\n\nexport function ok() {}\n\nexport function unreachable() {}\n"],"names":["ok"],"mappings":"AAMO,SAASA,IAAK;AAAA;","x_google_ignoreList":[0]}

package/dist/node_modules/entities/dist/esm/decode-codepoint.cjs.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const t=new Map([[0,65533],[128,8364],[130,8218],[131,402],[132,8222],[133,8230],[134,8224],[135,8225],[136,710],[137,8240],[138,352],[139,8249],[140,338],[142,381],[145,8216],[146,8217],[147,8220],[148,8221],[149,8226],[150,8211],[151,8212],[152,732],[153,8482],[154,353],[155,8250],[156,339],[158,382],[159,376]]);function a(e){var r;return e>=55296&&e<=57343||e>1114111?65533:(r=t.get(e))!==null&&r!==void 0?r:e}exports.replaceCodePoint=a;
+//# sourceMappingURL=decode-codepoint.cjs.js.map

package/dist/node_modules/entities/dist/esm/decode-codepoint.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode-codepoint.cjs.js","sources":["../../../../../../node_modules/entities/dist/esm/decode-codepoint.js"],"sourcesContent":["// Adapted from https://github.com/mathiasbynens/he/blob/36afe179392226cf1b6ccdb16ebbb7a5a844d93a/src/he.js#L106-L134\nvar _a;\nconst decodeMap = new Map([\n    [0, 65533],\n    // C1 Unicode control character reference replacements\n    [128, 8364],\n    [130, 8218],\n    [131, 402],\n    [132, 8222],\n    [133, 8230],\n    [134, 8224],\n    [135, 8225],\n    [136, 710],\n    [137, 8240],\n    [138, 352],\n    [139, 8249],\n    [140, 338],\n    [142, 381],\n    [145, 8216],\n    [146, 8217],\n    [147, 8220],\n    [148, 8221],\n    [149, 8226],\n    [150, 8211],\n    [151, 8212],\n    [152, 732],\n    [153, 8482],\n    [154, 353],\n    [155, 8250],\n    [156, 339],\n    [158, 382],\n    [159, 376],\n]);\n/**\n * Polyfill for `String.fromCodePoint`. It is used to create a string from a Unicode code point.\n */\nexport const fromCodePoint = \n// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition, n/no-unsupported-features/es-builtins\n(_a = String.fromCodePoint) !== null && _a !== void 0 ? _a : function (codePoint) {\n    let output = \"\";\n    if (codePoint > 65535) {\n        codePoint -= 65536;\n        output += String.fromCharCode(((codePoint >>> 10) & 1023) | 55296);\n        codePoint = 56320 | (codePoint & 1023);\n    }\n    output += String.fromCharCode(codePoint);\n    return output;\n};\n/**\n * Replace the given code point with a replacement character if it is a\n * surrogate or is outside the valid range. Otherwise return the code\n * point unchanged.\n */\nexport function replaceCodePoint(codePoint) {\n    var _a;\n    if ((codePoint >= 55296 && codePoint <= 57343) ||\n        codePoint > 1114111) {\n        return 65533;\n    }\n    return (_a = decodeMap.get(codePoint)) !== null && _a !== void 0 ? _a : codePoint;\n}\n/**\n * Replace the code point if relevant, then convert it to a string.\n *\n * @deprecated Use `fromCodePoint(replaceCodePoint(codePoint))` instead.\n * @param codePoint The code point to decode.\n * @returns The decoded code point.\n */\nexport function decodeCodePoint(codePoint) {\n    return fromCodePoint(replaceCodePoint(codePoint));\n}\n//# sourceMappingURL=decode-codepoint.js.map"],"names":["decodeMap","replaceCodePoint","codePoint","_a"],"mappings":"gFAEA,MAAMA,EAAY,IAAI,IAAI,CACtB,CAAC,EAAG,KAAK,EAET,CAAC,IAAK,IAAI,EACV,CAAC,IAAK,IAAI,EACV,CAAC,IAAK,GAAG,EACT,CAAC,IAAK,IAAI,EACV,CAAC,IAAK,IAAI,EACV,CAAC,IAAK,IAAI,EACV,CAAC,IAAK,IAAI,EACV,CAAC,IAAK,GAAG,EACT,CAAC,IAAK,IAAI,EACV,CAAC,IAAK,GAAG,EACT,CAAC,IAAK,IAAI,EACV,CAAC,IAAK,GAAG,EACT,CAAC,IAAK,GAAG,EACT,CAAC,IAAK,IAAI,EACV,CAAC,IAAK,IAAI,EACV,CAAC,IAAK,IAAI,EACV,CAAC,IAAK,IAAI,EACV,CAAC,IAAK,IAAI,EACV,CAAC,IAAK,IAAI,EACV,CAAC,IAAK,IAAI,EACV,CAAC,IAAK,GAAG,EACT,CAAC,IAAK,IAAI,EACV,CAAC,IAAK,GAAG,EACT,CAAC,IAAK,IAAI,EACV,CAAC,IAAK,GAAG,EACT,CAAC,IAAK,GAAG,EACT,CAAC,IAAK,GAAG,CACb,CAAC,EAqBM,SAASC,EAAiBC,EAAW,CACxC,IAAIC,EACJ,OAAKD,GAAa,OAASA,GAAa,OACpCA,EAAY,QACL,OAEHC,EAAKH,EAAU,IAAIE,CAAS,KAAO,MAAQC,IAAO,OAASA,EAAKD,CAC5E","x_google_ignoreList":[0]}

package/dist/node_modules/entities/dist/esm/decode-codepoint.es.js

@@ -0,0 +1,39 @@
+const a = /* @__PURE__ */ new Map([
+  [0, 65533],
+  // C1 Unicode control character reference replacements
+  [128, 8364],
+  [130, 8218],
+  [131, 402],
+  [132, 8222],
+  [133, 8230],
+  [134, 8224],
+  [135, 8225],
+  [136, 710],
+  [137, 8240],
+  [138, 352],
+  [139, 8249],
+  [140, 338],
+  [142, 381],
+  [145, 8216],
+  [146, 8217],
+  [147, 8220],
+  [148, 8221],
+  [149, 8226],
+  [150, 8211],
+  [151, 8212],
+  [152, 732],
+  [153, 8482],
+  [154, 353],
+  [155, 8250],
+  [156, 339],
+  [158, 382],
+  [159, 376]
+]);
+function n(r) {
+  var e;
+  return r >= 55296 && r <= 57343 || r > 1114111 ? 65533 : (e = a.get(r)) !== null && e !== void 0 ? e : r;
+}
+export {
+  n as replaceCodePoint
+};
+//# sourceMappingURL=decode-codepoint.es.js.map

package/dist/node_modules/entities/dist/esm/decode-codepoint.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode-codepoint.es.js","sources":["../../../../../../node_modules/entities/dist/esm/decode-codepoint.js"],"sourcesContent":["// Adapted from https://github.com/mathiasbynens/he/blob/36afe179392226cf1b6ccdb16ebbb7a5a844d93a/src/he.js#L106-L134\nvar _a;\nconst decodeMap = new Map([\n    [0, 65533],\n    // C1 Unicode control character reference replacements\n    [128, 8364],\n    [130, 8218],\n    [131, 402],\n    [132, 8222],\n    [133, 8230],\n    [134, 8224],\n    [135, 8225],\n    [136, 710],\n    [137, 8240],\n    [138, 352],\n    [139, 8249],\n    [140, 338],\n    [142, 381],\n    [145, 8216],\n    [146, 8217],\n    [147, 8220],\n    [148, 8221],\n    [149, 8226],\n    [150, 8211],\n    [151, 8212],\n    [152, 732],\n    [153, 8482],\n    [154, 353],\n    [155, 8250],\n    [156, 339],\n    [158, 382],\n    [159, 376],\n]);\n/**\n * Polyfill for `String.fromCodePoint`. It is used to create a string from a Unicode code point.\n */\nexport const fromCodePoint = \n// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition, n/no-unsupported-features/es-builtins\n(_a = String.fromCodePoint) !== null && _a !== void 0 ? _a : function (codePoint) {\n    let output = \"\";\n    if (codePoint > 65535) {\n        codePoint -= 65536;\n        output += String.fromCharCode(((codePoint >>> 10) & 1023) | 55296);\n        codePoint = 56320 | (codePoint & 1023);\n    }\n    output += String.fromCharCode(codePoint);\n    return output;\n};\n/**\n * Replace the given code point with a replacement character if it is a\n * surrogate or is outside the valid range. Otherwise return the code\n * point unchanged.\n */\nexport function replaceCodePoint(codePoint) {\n    var _a;\n    if ((codePoint >= 55296 && codePoint <= 57343) ||\n        codePoint > 1114111) {\n        return 65533;\n    }\n    return (_a = decodeMap.get(codePoint)) !== null && _a !== void 0 ? _a : codePoint;\n}\n/**\n * Replace the code point if relevant, then convert it to a string.\n *\n * @deprecated Use `fromCodePoint(replaceCodePoint(codePoint))` instead.\n * @param codePoint The code point to decode.\n * @returns The decoded code point.\n */\nexport function decodeCodePoint(codePoint) {\n    return fromCodePoint(replaceCodePoint(codePoint));\n}\n//# sourceMappingURL=decode-codepoint.js.map"],"names":["decodeMap","replaceCodePoint","codePoint","_a"],"mappings":"AAEA,MAAMA,IAAY,oBAAI,IAAI;AAAA,EACtB,CAAC,GAAG,KAAK;AAAA;AAAA,EAET,CAAC,KAAK,IAAI;AAAA,EACV,CAAC,KAAK,IAAI;AAAA,EACV,CAAC,KAAK,GAAG;AAAA,EACT,CAAC,KAAK,IAAI;AAAA,EACV,CAAC,KAAK,IAAI;AAAA,EACV,CAAC,KAAK,IAAI;AAAA,EACV,CAAC,KAAK,IAAI;AAAA,EACV,CAAC,KAAK,GAAG;AAAA,EACT,CAAC,KAAK,IAAI;AAAA,EACV,CAAC,KAAK,GAAG;AAAA,EACT,CAAC,KAAK,IAAI;AAAA,EACV,CAAC,KAAK,GAAG;AAAA,EACT,CAAC,KAAK,GAAG;AAAA,EACT,CAAC,KAAK,IAAI;AAAA,EACV,CAAC,KAAK,IAAI;AAAA,EACV,CAAC,KAAK,IAAI;AAAA,EACV,CAAC,KAAK,IAAI;AAAA,EACV,CAAC,KAAK,IAAI;AAAA,EACV,CAAC,KAAK,IAAI;AAAA,EACV,CAAC,KAAK,IAAI;AAAA,EACV,CAAC,KAAK,GAAG;AAAA,EACT,CAAC,KAAK,IAAI;AAAA,EACV,CAAC,KAAK,GAAG;AAAA,EACT,CAAC,KAAK,IAAI;AAAA,EACV,CAAC,KAAK,GAAG;AAAA,EACT,CAAC,KAAK,GAAG;AAAA,EACT,CAAC,KAAK,GAAG;AACb,CAAC;AAqBM,SAASC,EAAiBC,GAAW;AACxC,MAAIC;AACJ,SAAKD,KAAa,SAASA,KAAa,SACpCA,IAAY,UACL,SAEHC,IAAKH,EAAU,IAAIE,CAAS,OAAO,QAAQC,MAAO,SAASA,IAAKD;AAC5E;","x_google_ignoreList":[0]}

package/dist/node_modules/entities/dist/esm/decode.cjs.js

@@ -0,0 +1,2 @@
+"use strict";Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const d=require("./decode-codepoint.cjs.js");var c;(function(t){t[t.NUM=35]="NUM",t[t.SEMI=59]="SEMI",t[t.EQUALS=61]="EQUALS",t[t.ZERO=48]="ZERO",t[t.NINE=57]="NINE",t[t.LOWER_A=97]="LOWER_A",t[t.LOWER_F=102]="LOWER_F",t[t.LOWER_X=120]="LOWER_X",t[t.LOWER_Z=122]="LOWER_Z",t[t.UPPER_A=65]="UPPER_A",t[t.UPPER_F=70]="UPPER_F",t[t.UPPER_Z=90]="UPPER_Z"})(c||(c={}));const o=32;exports.BinTrieFlags=void 0;(function(t){t[t.VALUE_LENGTH=49152]="VALUE_LENGTH",t[t.BRANCH_LENGTH=16256]="BRANCH_LENGTH",t[t.JUMP_TABLE=127]="JUMP_TABLE"})(exports.BinTrieFlags||(exports.BinTrieFlags={}));function E(t){return t>=c.ZERO&&t<=c.NINE}function R(t){return t>=c.UPPER_A&&t<=c.UPPER_F||t>=c.LOWER_A&&t<=c.LOWER_F}function _(t){return t>=c.UPPER_A&&t<=c.UPPER_Z||t>=c.LOWER_A&&t<=c.LOWER_Z||E(t)}function L(t){return t===c.EQUALS||_(t)}var n;(function(t){t[t.EntityStart=0]="EntityStart",t[t.NumericStart=1]="NumericStart",t[t.NumericDecimal=2]="NumericDecimal",t[t.NumericHex=3]="NumericHex",t[t.NamedEntity=4]="NamedEntity"})(n||(n={}));exports.DecodingMode=void 0;(function(t){t[t.Legacy=0]="Legacy",t[t.Strict=1]="Strict",t[t.Attribute=2]="Attribute"})(exports.DecodingMode||(exports.DecodingMode={}));class A{constructor(e,i,r){this.decodeTree=e,this.emitCodePoint=i,this.errors=r,this.state=n.EntityStart,this.consumed=1,this.result=0,this.treeIndex=0,this.excess=1,this.decodeMode=exports.DecodingMode.Strict}startEntity(e){this.decodeMode=e,this.state=n.EntityStart,this.result=0,this.treeIndex=0,this.excess=1,this.consumed=1}write(e,i){switch(this.state){case n.EntityStart:return e.charCodeAt(i)===c.NUM?(this.state=n.NumericStart,this.consumed+=1,this.stateNumericStart(e,i+1)):(this.state=n.NamedEntity,this.stateNamedEntity(e,i));case n.NumericStart:return this.stateNumericStart(e,i);case n.NumericDecimal:return this.stateNumericDecimal(e,i);case n.NumericHex:return this.stateNumericHex(e,i);case n.NamedEntity:return this.stateNamedEntity(e,i)}}stateNumericStart(e,i){return i>=e.length?-1:(e.charCodeAt(i)|o)===c.LOWER_X?(this.state=n.NumericHex,this.consumed+=1,this.stateNumericHex(e,i+1)):(this.state=n.NumericDecimal,this.stateNumericDecimal(e,i))}addToNumericResult(e,i,r,s){if(i!==r){const u=r-i;this.result=this.result*Math.pow(s,u)+Number.parseInt(e.substr(i,u),s),this.consumed+=u}}stateNumericHex(e,i){const r=i;for(;i<e.length;){const s=e.charCodeAt(i);if(E(s)||R(s))i+=1;else return this.addToNumericResult(e,r,i,16),this.emitNumericEntity(s,3)}return this.addToNumericResult(e,r,i,16),-1}stateNumericDecimal(e,i){const r=i;for(;i<e.length;){const s=e.charCodeAt(i);if(E(s))i+=1;else return this.addToNumericResult(e,r,i,10),this.emitNumericEntity(s,2)}return this.addToNumericResult(e,r,i,10),-1}emitNumericEntity(e,i){var r;if(this.consumed<=i)return(r=this.errors)===null||r===void 0||r.absenceOfDigitsInNumericCharacterReference(this.consumed),0;if(e===c.SEMI)this.consumed+=1;else if(this.decodeMode===exports.DecodingMode.Strict)return 0;return this.emitCodePoint(d.replaceCodePoint(this.result),this.consumed),this.errors&&(e!==c.SEMI&&this.errors.missingSemicolonAfterCharacterReference(),this.errors.validateNumericCharacterReference(this.result)),this.consumed}stateNamedEntity(e,i){const{decodeTree:r}=this;let s=r[this.treeIndex],u=(s&exports.BinTrieFlags.VALUE_LENGTH)>>14;for(;i<e.length;i++,this.excess++){const m=e.charCodeAt(i);if(this.treeIndex=l(r,s,this.treeIndex+Math.max(1,u),m),this.treeIndex<0)return this.result===0||this.decodeMode===exports.DecodingMode.Attribute&&(u===0||L(m))?0:this.emitNotTerminatedNamedEntity();if(s=r[this.treeIndex],u=(s&exports.BinTrieFlags.VALUE_LENGTH)>>14,u!==0){if(m===c.SEMI)return this.emitNamedEntityData(this.treeIndex,u,this.consumed+this.excess);this.decodeMode!==exports.DecodingMode.Strict&&(this.result=this.treeIndex,this.consumed+=this.excess,this.excess=0)}}return-1}emitNotTerminatedNamedEntity(){var e;const{result:i,decodeTree:r}=this,s=(r[i]&exports.BinTrieFlags.VALUE_LENGTH)>>14;return this.emitNamedEntityData(i,s,this.consumed),(e=this.errors)===null||e===void 0||e.missingSemicolonAfterCharacterReference(),this.consumed}emitNamedEntityData(e,i,r){const{decodeTree:s}=this;return this.emitCodePoint(i===1?s[e]&~exports.BinTrieFlags.VALUE_LENGTH:s[e+1],r),i===3&&this.emitCodePoint(s[e+2],r),r}end(){var e;switch(this.state){case n.NamedEntity:return this.result!==0&&(this.decodeMode!==exports.DecodingMode.Attribute||this.result===this.treeIndex)?this.emitNotTerminatedNamedEntity():0;case n.NumericDecimal:return this.emitNumericEntity(0,2);case n.NumericHex:return this.emitNumericEntity(0,3);case n.NumericStart:return(e=this.errors)===null||e===void 0||e.absenceOfDigitsInNumericCharacterReference(this.consumed),0;case n.EntityStart:return 0}}}function l(t,e,i,r){const s=(e&exports.BinTrieFlags.BRANCH_LENGTH)>>7,u=e&exports.BinTrieFlags.JUMP_TABLE;if(s===0)return u!==0&&r===u?i:-1;if(u){const a=r-u;return a<0||a>=s?-1:t[i+a]-1}let m=i,h=m+s-1;for(;m<=h;){const a=m+h>>>1,N=t[a];if(N<r)m=a+1;else if(N>r)h=a-1;else return t[a+s]}return-1}exports.replaceCodePoint=d.replaceCodePoint;exports.EntityDecoder=A;exports.determineBranch=l;
+//# sourceMappingURL=decode.cjs.js.map

package/dist/node_modules/entities/dist/esm/decode.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode.cjs.js","sources":["../../../../../../node_modules/entities/dist/esm/decode.js"],"sourcesContent":["import { htmlDecodeTree } from \"./generated/decode-data-html.js\";\nimport { xmlDecodeTree } from \"./generated/decode-data-xml.js\";\nimport { replaceCodePoint, fromCodePoint } from \"./decode-codepoint.js\";\nvar CharCodes;\n(function (CharCodes) {\n    CharCodes[CharCodes[\"NUM\"] = 35] = \"NUM\";\n    CharCodes[CharCodes[\"SEMI\"] = 59] = \"SEMI\";\n    CharCodes[CharCodes[\"EQUALS\"] = 61] = \"EQUALS\";\n    CharCodes[CharCodes[\"ZERO\"] = 48] = \"ZERO\";\n    CharCodes[CharCodes[\"NINE\"] = 57] = \"NINE\";\n    CharCodes[CharCodes[\"LOWER_A\"] = 97] = \"LOWER_A\";\n    CharCodes[CharCodes[\"LOWER_F\"] = 102] = \"LOWER_F\";\n    CharCodes[CharCodes[\"LOWER_X\"] = 120] = \"LOWER_X\";\n    CharCodes[CharCodes[\"LOWER_Z\"] = 122] = \"LOWER_Z\";\n    CharCodes[CharCodes[\"UPPER_A\"] = 65] = \"UPPER_A\";\n    CharCodes[CharCodes[\"UPPER_F\"] = 70] = \"UPPER_F\";\n    CharCodes[CharCodes[\"UPPER_Z\"] = 90] = \"UPPER_Z\";\n})(CharCodes || (CharCodes = {}));\n/** Bit that needs to be set to convert an upper case ASCII character to lower case */\nconst TO_LOWER_BIT = 32;\nexport var BinTrieFlags;\n(function (BinTrieFlags) {\n    BinTrieFlags[BinTrieFlags[\"VALUE_LENGTH\"] = 49152] = \"VALUE_LENGTH\";\n    BinTrieFlags[BinTrieFlags[\"BRANCH_LENGTH\"] = 16256] = \"BRANCH_LENGTH\";\n    BinTrieFlags[BinTrieFlags[\"JUMP_TABLE\"] = 127] = \"JUMP_TABLE\";\n})(BinTrieFlags || (BinTrieFlags = {}));\nfunction isNumber(code) {\n    return code >= CharCodes.ZERO && code <= CharCodes.NINE;\n}\nfunction isHexadecimalCharacter(code) {\n    return ((code >= CharCodes.UPPER_A && code <= CharCodes.UPPER_F) ||\n        (code >= CharCodes.LOWER_A && code <= CharCodes.LOWER_F));\n}\nfunction isAsciiAlphaNumeric(code) {\n    return ((code >= CharCodes.UPPER_A && code <= CharCodes.UPPER_Z) ||\n        (code >= CharCodes.LOWER_A && code <= CharCodes.LOWER_Z) ||\n        isNumber(code));\n}\n/**\n * Checks if the given character is a valid end character for an entity in an attribute.\n *\n * Attribute values that aren't terminated properly aren't parsed, and shouldn't lead to a parser error.\n * See the example in https://html.spec.whatwg.org/multipage/parsing.html#named-character-reference-state\n */\nfunction isEntityInAttributeInvalidEnd(code) {\n    return code === CharCodes.EQUALS || isAsciiAlphaNumeric(code);\n}\nvar EntityDecoderState;\n(function (EntityDecoderState) {\n    EntityDecoderState[EntityDecoderState[\"EntityStart\"] = 0] = \"EntityStart\";\n    EntityDecoderState[EntityDecoderState[\"NumericStart\"] = 1] = \"NumericStart\";\n    EntityDecoderState[EntityDecoderState[\"NumericDecimal\"] = 2] = \"NumericDecimal\";\n    EntityDecoderState[EntityDecoderState[\"NumericHex\"] = 3] = \"NumericHex\";\n    EntityDecoderState[EntityDecoderState[\"NamedEntity\"] = 4] = \"NamedEntity\";\n})(EntityDecoderState || (EntityDecoderState = {}));\nexport var DecodingMode;\n(function (DecodingMode) {\n    /** Entities in text nodes that can end with any character. */\n    DecodingMode[DecodingMode[\"Legacy\"] = 0] = \"Legacy\";\n    /** Only allow entities terminated with a semicolon. */\n    DecodingMode[DecodingMode[\"Strict\"] = 1] = \"Strict\";\n    /** Entities in attributes have limitations on ending characters. */\n    DecodingMode[DecodingMode[\"Attribute\"] = 2] = \"Attribute\";\n})(DecodingMode || (DecodingMode = {}));\n/**\n * Token decoder with support of writing partial entities.\n */\nexport class EntityDecoder {\n    constructor(\n    /** The tree used to decode entities. */\n    decodeTree, \n    /**\n     * The function that is called when a codepoint is decoded.\n     *\n     * For multi-byte named entities, this will be called multiple times,\n     * with the second codepoint, and the same `consumed` value.\n     *\n     * @param codepoint The decoded codepoint.\n     * @param consumed The number of bytes consumed by the decoder.\n     */\n    emitCodePoint, \n    /** An object that is used to produce errors. */\n    errors) {\n        this.decodeTree = decodeTree;\n        this.emitCodePoint = emitCodePoint;\n        this.errors = errors;\n        /** The current state of the decoder. */\n        this.state = EntityDecoderState.EntityStart;\n        /** Characters that were consumed while parsing an entity. */\n        this.consumed = 1;\n        /**\n         * The result of the entity.\n         *\n         * Either the result index of a numeric entity, or the codepoint of a\n         * numeric entity.\n         */\n        this.result = 0;\n        /** The current index in the decode tree. */\n        this.treeIndex = 0;\n        /** The number of characters that were consumed in excess. */\n        this.excess = 1;\n        /** The mode in which the decoder is operating. */\n        this.decodeMode = DecodingMode.Strict;\n    }\n    /** Resets the instance to make it reusable. */\n    startEntity(decodeMode) {\n        this.decodeMode = decodeMode;\n        this.state = EntityDecoderState.EntityStart;\n        this.result = 0;\n        this.treeIndex = 0;\n        this.excess = 1;\n        this.consumed = 1;\n    }\n    /**\n     * Write an entity to the decoder. This can be called multiple times with partial entities.\n     * If the entity is incomplete, the decoder will return -1.\n     *\n     * Mirrors the implementation of `getDecoder`, but with the ability to stop decoding if the\n     * entity is incomplete, and resume when the next string is written.\n     *\n     * @param input The string containing the entity (or a continuation of the entity).\n     * @param offset The offset at which the entity begins. Should be 0 if this is not the first call.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    write(input, offset) {\n        switch (this.state) {\n            case EntityDecoderState.EntityStart: {\n                if (input.charCodeAt(offset) === CharCodes.NUM) {\n                    this.state = EntityDecoderState.NumericStart;\n                    this.consumed += 1;\n                    return this.stateNumericStart(input, offset + 1);\n                }\n                this.state = EntityDecoderState.NamedEntity;\n                return this.stateNamedEntity(input, offset);\n            }\n            case EntityDecoderState.NumericStart: {\n                return this.stateNumericStart(input, offset);\n            }\n            case EntityDecoderState.NumericDecimal: {\n                return this.stateNumericDecimal(input, offset);\n            }\n            case EntityDecoderState.NumericHex: {\n                return this.stateNumericHex(input, offset);\n            }\n            case EntityDecoderState.NamedEntity: {\n                return this.stateNamedEntity(input, offset);\n            }\n        }\n    }\n    /**\n     * Switches between the numeric decimal and hexadecimal states.\n     *\n     * Equivalent to the `Numeric character reference state` in the HTML spec.\n     *\n     * @param input The string containing the entity (or a continuation of the entity).\n     * @param offset The current offset.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    stateNumericStart(input, offset) {\n        if (offset >= input.length) {\n            return -1;\n        }\n        if ((input.charCodeAt(offset) | TO_LOWER_BIT) === CharCodes.LOWER_X) {\n            this.state = EntityDecoderState.NumericHex;\n            this.consumed += 1;\n            return this.stateNumericHex(input, offset + 1);\n        }\n        this.state = EntityDecoderState.NumericDecimal;\n        return this.stateNumericDecimal(input, offset);\n    }\n    addToNumericResult(input, start, end, base) {\n        if (start !== end) {\n            const digitCount = end - start;\n            this.result =\n                this.result * Math.pow(base, digitCount) +\n                    Number.parseInt(input.substr(start, digitCount), base);\n            this.consumed += digitCount;\n        }\n    }\n    /**\n     * Parses a hexadecimal numeric entity.\n     *\n     * Equivalent to the `Hexademical character reference state` in the HTML spec.\n     *\n     * @param input The string containing the entity (or a continuation of the entity).\n     * @param offset The current offset.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    stateNumericHex(input, offset) {\n        const startIndex = offset;\n        while (offset < input.length) {\n            const char = input.charCodeAt(offset);\n            if (isNumber(char) || isHexadecimalCharacter(char)) {\n                offset += 1;\n            }\n            else {\n                this.addToNumericResult(input, startIndex, offset, 16);\n                return this.emitNumericEntity(char, 3);\n            }\n        }\n        this.addToNumericResult(input, startIndex, offset, 16);\n        return -1;\n    }\n    /**\n     * Parses a decimal numeric entity.\n     *\n     * Equivalent to the `Decimal character reference state` in the HTML spec.\n     *\n     * @param input The string containing the entity (or a continuation of the entity).\n     * @param offset The current offset.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    stateNumericDecimal(input, offset) {\n        const startIndex = offset;\n        while (offset < input.length) {\n            const char = input.charCodeAt(offset);\n            if (isNumber(char)) {\n                offset += 1;\n            }\n            else {\n                this.addToNumericResult(input, startIndex, offset, 10);\n                return this.emitNumericEntity(char, 2);\n            }\n        }\n        this.addToNumericResult(input, startIndex, offset, 10);\n        return -1;\n    }\n    /**\n     * Validate and emit a numeric entity.\n     *\n     * Implements the logic from the `Hexademical character reference start\n     * state` and `Numeric character reference end state` in the HTML spec.\n     *\n     * @param lastCp The last code point of the entity. Used to see if the\n     *               entity was terminated with a semicolon.\n     * @param expectedLength The minimum number of characters that should be\n     *                       consumed. Used to validate that at least one digit\n     *                       was consumed.\n     * @returns The number of characters that were consumed.\n     */\n    emitNumericEntity(lastCp, expectedLength) {\n        var _a;\n        // Ensure we consumed at least one digit.\n        if (this.consumed <= expectedLength) {\n            (_a = this.errors) === null || _a === void 0 ? void 0 : _a.absenceOfDigitsInNumericCharacterReference(this.consumed);\n            return 0;\n        }\n        // Figure out if this is a legit end of the entity\n        if (lastCp === CharCodes.SEMI) {\n            this.consumed += 1;\n        }\n        else if (this.decodeMode === DecodingMode.Strict) {\n            return 0;\n        }\n        this.emitCodePoint(replaceCodePoint(this.result), this.consumed);\n        if (this.errors) {\n            if (lastCp !== CharCodes.SEMI) {\n                this.errors.missingSemicolonAfterCharacterReference();\n            }\n            this.errors.validateNumericCharacterReference(this.result);\n        }\n        return this.consumed;\n    }\n    /**\n     * Parses a named entity.\n     *\n     * Equivalent to the `Named character reference state` in the HTML spec.\n     *\n     * @param input The string containing the entity (or a continuation of the entity).\n     * @param offset The current offset.\n     * @returns The number of characters that were consumed, or -1 if the entity is incomplete.\n     */\n    stateNamedEntity(input, offset) {\n        const { decodeTree } = this;\n        let current = decodeTree[this.treeIndex];\n        // The mask is the number of bytes of the value, including the current byte.\n        let valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;\n        for (; offset < input.length; offset++, this.excess++) {\n            const char = input.charCodeAt(offset);\n            this.treeIndex = determineBranch(decodeTree, current, this.treeIndex + Math.max(1, valueLength), char);\n            if (this.treeIndex < 0) {\n                return this.result === 0 ||\n                    // If we are parsing an attribute\n                    (this.decodeMode === DecodingMode.Attribute &&\n                        // We shouldn't have consumed any characters after the entity,\n                        (valueLength === 0 ||\n                            // And there should be no invalid characters.\n                            isEntityInAttributeInvalidEnd(char)))\n                    ? 0\n                    : this.emitNotTerminatedNamedEntity();\n            }\n            current = decodeTree[this.treeIndex];\n            valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;\n            // If the branch is a value, store it and continue\n            if (valueLength !== 0) {\n                // If the entity is terminated by a semicolon, we are done.\n                if (char === CharCodes.SEMI) {\n                    return this.emitNamedEntityData(this.treeIndex, valueLength, this.consumed + this.excess);\n                }\n                // If we encounter a non-terminated (legacy) entity while parsing strictly, then ignore it.\n                if (this.decodeMode !== DecodingMode.Strict) {\n                    this.result = this.treeIndex;\n                    this.consumed += this.excess;\n                    this.excess = 0;\n                }\n            }\n        }\n        return -1;\n    }\n    /**\n     * Emit a named entity that was not terminated with a semicolon.\n     *\n     * @returns The number of characters consumed.\n     */\n    emitNotTerminatedNamedEntity() {\n        var _a;\n        const { result, decodeTree } = this;\n        const valueLength = (decodeTree[result] & BinTrieFlags.VALUE_LENGTH) >> 14;\n        this.emitNamedEntityData(result, valueLength, this.consumed);\n        (_a = this.errors) === null || _a === void 0 ? void 0 : _a.missingSemicolonAfterCharacterReference();\n        return this.consumed;\n    }\n    /**\n     * Emit a named entity.\n     *\n     * @param result The index of the entity in the decode tree.\n     * @param valueLength The number of bytes in the entity.\n     * @param consumed The number of characters consumed.\n     *\n     * @returns The number of characters consumed.\n     */\n    emitNamedEntityData(result, valueLength, consumed) {\n        const { decodeTree } = this;\n        this.emitCodePoint(valueLength === 1\n            ? decodeTree[result] & ~BinTrieFlags.VALUE_LENGTH\n            : decodeTree[result + 1], consumed);\n        if (valueLength === 3) {\n            // For multi-byte values, we need to emit the second byte.\n            this.emitCodePoint(decodeTree[result + 2], consumed);\n        }\n        return consumed;\n    }\n    /**\n     * Signal to the parser that the end of the input was reached.\n     *\n     * Remaining data will be emitted and relevant errors will be produced.\n     *\n     * @returns The number of characters consumed.\n     */\n    end() {\n        var _a;\n        switch (this.state) {\n            case EntityDecoderState.NamedEntity: {\n                // Emit a named entity if we have one.\n                return this.result !== 0 &&\n                    (this.decodeMode !== DecodingMode.Attribute ||\n                        this.result === this.treeIndex)\n                    ? this.emitNotTerminatedNamedEntity()\n                    : 0;\n            }\n            // Otherwise, emit a numeric entity if we have one.\n            case EntityDecoderState.NumericDecimal: {\n                return this.emitNumericEntity(0, 2);\n            }\n            case EntityDecoderState.NumericHex: {\n                return this.emitNumericEntity(0, 3);\n            }\n            case EntityDecoderState.NumericStart: {\n                (_a = this.errors) === null || _a === void 0 ? void 0 : _a.absenceOfDigitsInNumericCharacterReference(this.consumed);\n                return 0;\n            }\n            case EntityDecoderState.EntityStart: {\n                // Return 0 if we have no entity.\n                return 0;\n            }\n        }\n    }\n}\n/**\n * Creates a function that decodes entities in a string.\n *\n * @param decodeTree The decode tree.\n * @returns A function that decodes entities in a string.\n */\nfunction getDecoder(decodeTree) {\n    let returnValue = \"\";\n    const decoder = new EntityDecoder(decodeTree, (data) => (returnValue += fromCodePoint(data)));\n    return function decodeWithTrie(input, decodeMode) {\n        let lastIndex = 0;\n        let offset = 0;\n        while ((offset = input.indexOf(\"&\", offset)) >= 0) {\n            returnValue += input.slice(lastIndex, offset);\n            decoder.startEntity(decodeMode);\n            const length = decoder.write(input, \n            // Skip the \"&\"\n            offset + 1);\n            if (length < 0) {\n                lastIndex = offset + decoder.end();\n                break;\n            }\n            lastIndex = offset + length;\n            // If `length` is 0, skip the current `&` and continue.\n            offset = length === 0 ? lastIndex + 1 : lastIndex;\n        }\n        const result = returnValue + input.slice(lastIndex);\n        // Make sure we don't keep a reference to the final string.\n        returnValue = \"\";\n        return result;\n    };\n}\n/**\n * Determines the branch of the current node that is taken given the current\n * character. This function is used to traverse the trie.\n *\n * @param decodeTree The trie.\n * @param current The current node.\n * @param nodeIdx The index right after the current node and its value.\n * @param char The current character.\n * @returns The index of the next node, or -1 if no branch is taken.\n */\nexport function determineBranch(decodeTree, current, nodeIndex, char) {\n    const branchCount = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;\n    const jumpOffset = current & BinTrieFlags.JUMP_TABLE;\n    // Case 1: Single branch encoded in jump offset\n    if (branchCount === 0) {\n        return jumpOffset !== 0 && char === jumpOffset ? nodeIndex : -1;\n    }\n    // Case 2: Multiple branches encoded in jump table\n    if (jumpOffset) {\n        const value = char - jumpOffset;\n        return value < 0 || value >= branchCount\n            ? -1\n            : decodeTree[nodeIndex + value] - 1;\n    }\n    // Case 3: Multiple branches encoded in dictionary\n    // Binary search for the character.\n    let lo = nodeIndex;\n    let hi = lo + branchCount - 1;\n    while (lo <= hi) {\n        const mid = (lo + hi) >>> 1;\n        const midValue = decodeTree[mid];\n        if (midValue < char) {\n            lo = mid + 1;\n        }\n        else if (midValue > char) {\n            hi = mid - 1;\n        }\n        else {\n            return decodeTree[mid + branchCount];\n        }\n    }\n    return -1;\n}\nconst htmlDecoder = /* #__PURE__ */ getDecoder(htmlDecodeTree);\nconst xmlDecoder = /* #__PURE__ */ getDecoder(xmlDecodeTree);\n/**\n * Decodes an HTML string.\n *\n * @param htmlString The string to decode.\n * @param mode The decoding mode.\n * @returns The decoded string.\n */\nexport function decodeHTML(htmlString, mode = DecodingMode.Legacy) {\n    return htmlDecoder(htmlString, mode);\n}\n/**\n * Decodes an HTML string in an attribute.\n *\n * @param htmlAttribute The string to decode.\n * @returns The decoded string.\n */\nexport function decodeHTMLAttribute(htmlAttribute) {\n    return htmlDecoder(htmlAttribute, DecodingMode.Attribute);\n}\n/**\n * Decodes an HTML string, requiring all entities to be terminated by a semicolon.\n *\n * @param htmlString The string to decode.\n * @returns The decoded string.\n */\nexport function decodeHTMLStrict(htmlString) {\n    return htmlDecoder(htmlString, DecodingMode.Strict);\n}\n/**\n * Decodes an XML string, requiring all entities to be terminated by a semicolon.\n *\n * @param xmlString The string to decode.\n * @returns The decoded string.\n */\nexport function decodeXML(xmlString) {\n    return xmlDecoder(xmlString, DecodingMode.Strict);\n}\n// Re-export for use by eg. htmlparser2\nexport { htmlDecodeTree } from \"./generated/decode-data-html.js\";\nexport { xmlDecodeTree } from \"./generated/decode-data-xml.js\";\nexport { decodeCodePoint, replaceCodePoint, fromCodePoint, } from \"./decode-codepoint.js\";\n//# sourceMappingURL=decode.js.map"],"names":["CharCodes","TO_LOWER_BIT","BinTrieFlags","isNumber","code","isHexadecimalCharacter","isAsciiAlphaNumeric","isEntityInAttributeInvalidEnd","EntityDecoderState","DecodingMode","EntityDecoder","decodeTree","emitCodePoint","errors","decodeMode","input","offset","start","end","base","digitCount","startIndex","char","lastCp","expectedLength","_a","replaceCodePoint","current","valueLength","determineBranch","result","consumed","nodeIndex","branchCount","jumpOffset","value","lo","hi","mid","midValue"],"mappings":"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","x_google_ignoreList":[0]}