@epilot/zenith-react 0.1.0-next.0

package/dist/vendor/.bun/refractor@5.0.0/vendor/refractor/lib/prism-core.js

@@ -0,0 +1,431 @@
+var R = 0, D = {}, v = {
+  /**
+   * A namespace for utility methods.
+   *
+   * All function in this namespace that are not explicitly marked as _public_ are for __internal use only__ and may
+   * change or disappear at any time.
+   *
+   * @namespace
+   * @memberof Prism
+   */
+  util: {
+    /**
+     * Returns the name of the type of the given value.
+     *
+     * @param {any} o
+     * @returns {string}
+     * @example
+     * type(null)      === 'Null'
+     * type(undefined) === 'Undefined'
+     * type(123)       === 'Number'
+     * type('foo')     === 'String'
+     * type(true)      === 'Boolean'
+     * type([1, 2])    === 'Array'
+     * type({})        === 'Object'
+     * type(String)    === 'Function'
+     * type(/abc+/)    === 'RegExp'
+     */
+    type: function(l) {
+      return Object.prototype.toString.call(l).slice(8, -1);
+    },
+    /**
+     * Returns a unique number for the given object. Later calls will still return the same number.
+     *
+     * @param {Object} obj
+     * @returns {number}
+     */
+    objId: function(l) {
+      return l.__id || Object.defineProperty(l, "__id", { value: ++R }), l.__id;
+    },
+    /**
+     * Creates a deep clone of the given object.
+     *
+     * The main intended use of this function is to clone language definitions.
+     *
+     * @param {T} o
+     * @param {Record<number, any>} [visited]
+     * @returns {T}
+     * @template T
+     */
+    clone: function l(n, a) {
+      a = a || {};
+      var r, u;
+      switch (v.util.type(n)) {
+        case "Object":
+          if (u = v.util.objId(n), a[u])
+            return a[u];
+          r = /** @type {Record<string, any>} */
+          {}, a[u] = r;
+          for (var i in n)
+            n.hasOwnProperty(i) && (r[i] = l(n[i], a));
+          return (
+            /** @type {any} */
+            r
+          );
+        case "Array":
+          return u = v.util.objId(n), a[u] ? a[u] : (r = [], a[u] = r, /** @type {any} */
+          n.forEach(
+            function(f, e) {
+              r[e] = l(f, a);
+            }
+          ), /** @type {any} */
+          r);
+        default:
+          return n;
+      }
+    }
+  },
+  /**
+   * This namespace contains all currently loaded languages and the some helper functions to create and modify languages.
+   *
+   * @namespace
+   * @memberof Prism
+   * @public
+   */
+  languages: {
+    /**
+     * The grammar for plain, unformatted text.
+     */
+    plain: D,
+    plaintext: D,
+    text: D,
+    txt: D,
+    /**
+     * Creates a deep copy of the language with the given id and appends the given tokens.
+     *
+     * If a token in `redef` also appears in the copied language, then the existing token in the copied language
+     * will be overwritten at its original position.
+     *
+     * ## Best practices
+     *
+     * Since the position of overwriting tokens (token in `redef` that overwrite tokens in the copied language)
+     * doesn't matter, they can technically be in any order. However, this can be confusing to others that trying to
+     * understand the language definition because, normally, the order of tokens matters in Prism grammars.
+     *
+     * Therefore, it is encouraged to order overwriting tokens according to the positions of the overwritten tokens.
+     * Furthermore, all non-overwriting tokens should be placed after the overwriting ones.
+     *
+     * @param {string} id The id of the language to extend. This has to be a key in `Prism.languages`.
+     * @param {Grammar} redef The new tokens to append.
+     * @returns {Grammar} The new language created.
+     * @public
+     * @example
+     * Prism.languages['css-with-colors'] = Prism.languages.extend('css', {
+     *     // Prism.languages.css already has a 'comment' token, so this token will overwrite CSS' 'comment' token
+     *     // at its original position
+     *     'comment': { ... },
+     *     // CSS doesn't have a 'color' token, so this token will be appended
+     *     'color': /\b(?:red|green|blue)\b/
+     * });
+     */
+    extend: function(l, n) {
+      var a = v.util.clone(v.languages[l]);
+      for (var r in n)
+        a[r] = n[r];
+      return a;
+    },
+    /**
+     * Inserts tokens _before_ another token in a language definition or any other grammar.
+     *
+     * ## Usage
+     *
+     * This helper method makes it easy to modify existing languages. For example, the CSS language definition
+     * not only defines CSS highlighting for CSS documents, but also needs to define highlighting for CSS embedded
+     * in HTML through `<style>` elements. To do this, it needs to modify `Prism.languages.markup` and add the
+     * appropriate tokens. However, `Prism.languages.markup` is a regular JavaScript object literal, so if you do
+     * this:
+     *
+     * ```js
+     * Prism.languages.markup.style = {
+     *     // token
+     * };
+     * ```
+     *
+     * then the `style` token will be added (and processed) at the end. `insertBefore` allows you to insert tokens
+     * before existing tokens. For the CSS example above, you would use it like this:
+     *
+     * ```js
+     * Prism.languages.insertBefore('markup', 'cdata', {
+     *     'style': {
+     *         // token
+     *     }
+     * });
+     * ```
+     *
+     * ## Special cases
+     *
+     * If the grammars of `inside` and `insert` have tokens with the same name, the tokens in `inside`'s grammar
+     * will be ignored.
+     *
+     * This behavior can be used to insert tokens after `before`:
+     *
+     * ```js
+     * Prism.languages.insertBefore('markup', 'comment', {
+     *     'comment': Prism.languages.markup.comment,
+     *     // tokens after 'comment'
+     * });
+     * ```
+     *
+     * ## Limitations
+     *
+     * The main problem `insertBefore` has to solve is iteration order. Since ES2015, the iteration order for object
+     * properties is guaranteed to be the insertion order (except for integer keys) but some browsers behave
+     * differently when keys are deleted and re-inserted. So `insertBefore` can't be implemented by temporarily
+     * deleting properties which is necessary to insert at arbitrary positions.
+     *
+     * To solve this problem, `insertBefore` doesn't actually insert the given tokens into the target object.
+     * Instead, it will create a new object and replace all references to the target object with the new one. This
+     * can be done without temporarily deleting properties, so the iteration order is well-defined.
+     *
+     * However, only references that can be reached from `Prism.languages` or `insert` will be replaced. I.e. if
+     * you hold the target object in a variable, then the value of the variable will not change.
+     *
+     * ```js
+     * var oldMarkup = Prism.languages.markup;
+     * var newMarkup = Prism.languages.insertBefore('markup', 'comment', { ... });
+     *
+     * assert(oldMarkup !== Prism.languages.markup);
+     * assert(newMarkup === Prism.languages.markup);
+     * ```
+     *
+     * @param {string} inside The property of `root` (e.g. a language id in `Prism.languages`) that contains the
+     * object to be modified.
+     * @param {string} before The key to insert before.
+     * @param {Grammar} insert An object containing the key-value pairs to be inserted.
+     * @param {Object<string, any>} [root] The object containing `inside`, i.e. the object that contains the
+     * object to be modified.
+     *
+     * Defaults to `Prism.languages`.
+     * @returns {Grammar} The new grammar object.
+     * @public
+     */
+    insertBefore: function(l, n, a, r) {
+      r = r || /** @type {any} */
+      v.languages;
+      var u = r[l], i = {};
+      for (var f in u)
+        if (u.hasOwnProperty(f)) {
+          if (f == n)
+            for (var e in a)
+              a.hasOwnProperty(e) && (i[e] = a[e]);
+          a.hasOwnProperty(f) || (i[f] = u[f]);
+        }
+      var x = r[l];
+      return r[l] = i, v.languages.DFS(v.languages, function(h, o) {
+        o === x && h != l && (this[h] = i);
+      }), i;
+    },
+    // Traverse a language definition with Depth First Search
+    DFS: function l(n, a, r, u) {
+      u = u || {};
+      var i = v.util.objId;
+      for (var f in n)
+        if (n.hasOwnProperty(f)) {
+          a.call(n, f, n[f], r || f);
+          var e = n[f], x = v.util.type(e);
+          x === "Object" && !u[i(e)] ? (u[i(e)] = !0, l(e, a, null, u)) : x === "Array" && !u[i(e)] && (u[i(e)] = !0, l(e, a, f, u));
+        }
+    }
+  },
+  plugins: {},
+  /**
+   * Low-level function, only use if you know what you’re doing. It accepts a string of text as input
+   * and the language definitions to use, and returns a string with the HTML produced.
+   *
+   * The following hooks will be run:
+   * 1. `before-tokenize`
+   * 2. `after-tokenize`
+   * 3. `wrap`: On each {@link Token}.
+   *
+   * @param {string} text A string with the code to be highlighted.
+   * @param {Grammar} grammar An object containing the tokens to use.
+   *
+   * Usually a language definition like `Prism.languages.markup`.
+   * @param {string} language The name of the language definition passed to `grammar`.
+   * @returns {string} The highlighted HTML.
+   * @memberof Prism
+   * @public
+   * @example
+   * Prism.highlight('var foo = true;', Prism.languages.javascript, 'javascript');
+   */
+  highlight: function(l, n, a) {
+    var r = {
+      code: l,
+      grammar: n,
+      language: a
+    };
+    if (v.hooks.run("before-tokenize", r), !r.grammar)
+      throw new Error('The language "' + r.language + '" has no grammar.');
+    return r.tokens = v.tokenize(r.code, r.grammar), v.hooks.run("after-tokenize", r), P.stringify(v.util.encode(r.tokens), r.language);
+  },
+  /**
+   * This is the heart of Prism, and the most low-level function you can use. It accepts a string of text as input
+   * and the language definitions to use, and returns an array with the tokenized code.
+   *
+   * When the language definition includes nested tokens, the function is called recursively on each of these tokens.
+   *
+   * This method could be useful in other contexts as well, as a very crude parser.
+   *
+   * @param {string} text A string with the code to be highlighted.
+   * @param {Grammar} grammar An object containing the tokens to use.
+   *
+   * Usually a language definition like `Prism.languages.markup`.
+   * @returns {TokenStream} An array of strings and tokens, a token stream.
+   * @memberof Prism
+   * @public
+   * @example
+   * let code = `var foo = 0;`;
+   * let tokens = Prism.tokenize(code, Prism.languages.javascript);
+   * tokens.forEach(token => {
+   *     if (token instanceof Prism.Token && token.type === 'number') {
+   *         console.log(`Found numeric literal: ${token.content}`);
+   *     }
+   * });
+   */
+  tokenize: function(l, n) {
+    var a = n.rest;
+    if (a) {
+      for (var r in a)
+        n[r] = a[r];
+      delete n.rest;
+    }
+    var u = new U();
+    return E(u, u.head, l), H(l, u, n, u.head, 0), W(u);
+  },
+  /**
+   * @namespace
+   * @memberof Prism
+   * @public
+   */
+  hooks: {
+    all: {},
+    /**
+     * Adds the given callback to the list of callbacks for the given hook.
+     *
+     * The callback will be invoked when the hook it is registered for is run.
+     * Hooks are usually directly run by a highlight function but you can also run hooks yourself.
+     *
+     * One callback function can be registered to multiple hooks and the same hook multiple times.
+     *
+     * @param {string} name The name of the hook.
+     * @param {HookCallback} callback The callback function which is given environment variables.
+     * @public
+     */
+    add: function(l, n) {
+      var a = v.hooks.all;
+      a[l] = a[l] || [], a[l].push(n);
+    },
+    /**
+     * Runs a hook invoking all registered callbacks with the given environment variables.
+     *
+     * Callbacks will be invoked synchronously and in the order in which they were registered.
+     *
+     * @param {string} name The name of the hook.
+     * @param {Object<string, any>} env The environment variables of the hook passed to all callbacks registered.
+     * @public
+     */
+    run: function(l, n) {
+      var a = v.hooks.all[l];
+      if (!(!a || !a.length))
+        for (var r = 0, u; u = a[r++]; )
+          u(n);
+    }
+  },
+  Token: P
+};
+function P(l, n, a, r) {
+  this.type = l, this.content = n, this.alias = a, this.length = (r || "").length | 0;
+}
+function F(l, n, a, r) {
+  l.lastIndex = n;
+  var u = l.exec(a);
+  if (u && r && u[1]) {
+    var i = u[1].length;
+    u.index += i, u[0] = u[0].slice(i);
+  }
+  return u;
+}
+function H(l, n, a, r, u, i) {
+  for (var f in a)
+    if (!(!a.hasOwnProperty(f) || !a[f])) {
+      var e = a[f];
+      e = Array.isArray(e) ? e : [e];
+      for (var x = 0; x < e.length; ++x) {
+        if (i && i.cause == f + "," + x)
+          return;
+        var h = e[x], o = h.inside, B = !!h.lookbehind, O = !!h.greedy, J = h.alias;
+        if (O && !h.pattern.global) {
+          var K = h.pattern.toString().match(/[imsuy]*$/)[0];
+          h.pattern = RegExp(h.pattern.source, K + "g");
+        }
+        for (var T = h.pattern || h, g = r.next, c = u; g !== n.tail && !(i && c >= i.reach); c += g.value.length, g = g.next) {
+          var s = g.value;
+          if (n.length > l.length)
+            return;
+          if (!(s instanceof P)) {
+            var I = 1, t;
+            if (O) {
+              if (t = F(T, c, l, B), !t || t.index >= l.length)
+                break;
+              var _ = t.index, M = t.index + t[0].length, w = c;
+              for (w += g.value.length; _ >= w; )
+                g = g.next, w += g.value.length;
+              if (w -= g.value.length, c = w, g.value instanceof P)
+                continue;
+              for (var y = g; y !== n.tail && (w < M || typeof y.value == "string"); y = y.next)
+                I++, w += y.value.length;
+              I--, s = l.slice(c, w), t.index -= c;
+            } else if (t = F(T, 0, s, B), !t)
+              continue;
+            var _ = t.index, A = t[0], G = s.slice(0, _), $ = s.slice(_ + A.length), S = c + s.length;
+            i && S > i.reach && (i.reach = S);
+            var z = g.prev;
+            G && (z = E(n, z, G), c += G.length), V(n, z, I);
+            var Q = new P(
+              f,
+              o ? v.tokenize(A, o) : A,
+              J,
+              A
+            );
+            if (g = E(n, z, Q), $ && E(n, g, $), I > 1) {
+              var q = {
+                cause: f + "," + x,
+                reach: S
+              };
+              H(
+                l,
+                n,
+                a,
+                g.prev,
+                c,
+                q
+              ), i && q.reach > i.reach && (i.reach = q.reach);
+            }
+          }
+        }
+      }
+    }
+}
+function U() {
+  var l = { value: null, prev: null, next: null }, n = { value: null, prev: l, next: null };
+  l.next = n, this.head = l, this.tail = n, this.length = 0;
+}
+function E(l, n, a) {
+  var r = n.next, u = { value: a, prev: n, next: r };
+  return n.next = u, r.prev = u, l.length++, u;
+}
+function V(l, n, a) {
+  for (var r = n.next, u = 0; u < a && r !== l.tail; u++)
+    r = r.next;
+  n.next = r, r.prev = n, l.length -= u;
+}
+function W(l) {
+  for (var n = [], a = l.head.next; a !== l.tail; )
+    n.push(a.value), a = a.next;
+  return n;
+}
+const X = v;
+export {
+  X as Prism
+};
+//# sourceMappingURL=prism-core.js.map

package/dist/vendor/.bun/refractor@5.0.0/vendor/refractor/lib/prism-core.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prism-core.js","sources":["../../../../../../../../../node_modules/.bun/refractor@5.0.0/node_modules/refractor/lib/prism-core.js"],"sourcesContent":["// @ts-nocheck\n\n// This is a slimmed down version of `prism-core.js`, to remove globals,\n// document, workers, `util.encode`, `Token.stringify`\n\n// Private helper vars\nvar lang = /(?:^|\\s)lang(?:uage)?-([\\w-]+)(?=\\s|$)/i\nvar uniqueId = 0\n\n// The grammar object for plaintext\nvar plainTextGrammar = {}\n\nvar _ = {\n  /**\n   * A namespace for utility methods.\n   *\n   * All function in this namespace that are not explicitly marked as _public_ are for __internal use only__ and may\n   * change or disappear at any time.\n   *\n   * @namespace\n   * @memberof Prism\n   */\n  util: {\n    /**\n     * Returns the name of the type of the given value.\n     *\n     * @param {any} o\n     * @returns {string}\n     * @example\n     * type(null)      === 'Null'\n     * type(undefined) === 'Undefined'\n     * type(123)       === 'Number'\n     * type('foo')     === 'String'\n     * type(true)      === 'Boolean'\n     * type([1, 2])    === 'Array'\n     * type({})        === 'Object'\n     * type(String)    === 'Function'\n     * type(/abc+/)    === 'RegExp'\n     */\n    type: function (o) {\n      return Object.prototype.toString.call(o).slice(8, -1)\n    },\n\n    /**\n     * Returns a unique number for the given object. Later calls will still return the same number.\n     *\n     * @param {Object} obj\n     * @returns {number}\n     */\n    objId: function (obj) {\n      if (!obj['__id']) {\n        Object.defineProperty(obj, '__id', {value: ++uniqueId})\n      }\n      return obj['__id']\n    },\n\n    /**\n     * Creates a deep clone of the given object.\n     *\n     * The main intended use of this function is to clone language definitions.\n     *\n     * @param {T} o\n     * @param {Record<number, any>} [visited]\n     * @returns {T}\n     * @template T\n     */\n    clone: function deepClone(o, visited) {\n      visited = visited || {}\n\n      var clone\n      var id\n      switch (_.util.type(o)) {\n        case 'Object':\n          id = _.util.objId(o)\n          if (visited[id]) {\n            return visited[id]\n          }\n          clone = /** @type {Record<string, any>} */ ({})\n          visited[id] = clone\n\n          for (var key in o) {\n            if (o.hasOwnProperty(key)) {\n              clone[key] = deepClone(o[key], visited)\n            }\n          }\n\n          return /** @type {any} */ (clone)\n\n        case 'Array':\n          id = _.util.objId(o)\n          if (visited[id]) {\n            return visited[id]\n          }\n          clone = []\n          visited[id] = clone\n\n          ;/** @type {Array} */ (/** @type {any} */ (o)).forEach(\n            function (v, i) {\n              clone[i] = deepClone(v, visited)\n            }\n          )\n\n          return /** @type {any} */ (clone)\n\n        default:\n          return o\n      }\n    }\n  },\n\n  /**\n   * This namespace contains all currently loaded languages and the some helper functions to create and modify languages.\n   *\n   * @namespace\n   * @memberof Prism\n   * @public\n   */\n  languages: {\n    /**\n     * The grammar for plain, unformatted text.\n     */\n    plain: plainTextGrammar,\n    plaintext: plainTextGrammar,\n    text: plainTextGrammar,\n    txt: plainTextGrammar,\n\n    /**\n     * Creates a deep copy of the language with the given id and appends the given tokens.\n     *\n     * If a token in `redef` also appears in the copied language, then the existing token in the copied language\n     * will be overwritten at its original position.\n     *\n     * ## Best practices\n     *\n     * Since the position of overwriting tokens (token in `redef` that overwrite tokens in the copied language)\n     * doesn't matter, they can technically be in any order. However, this can be confusing to others that trying to\n     * understand the language definition because, normally, the order of tokens matters in Prism grammars.\n     *\n     * Therefore, it is encouraged to order overwriting tokens according to the positions of the overwritten tokens.\n     * Furthermore, all non-overwriting tokens should be placed after the overwriting ones.\n     *\n     * @param {string} id The id of the language to extend. This has to be a key in `Prism.languages`.\n     * @param {Grammar} redef The new tokens to append.\n     * @returns {Grammar} The new language created.\n     * @public\n     * @example\n     * Prism.languages['css-with-colors'] = Prism.languages.extend('css', {\n     *     // Prism.languages.css already has a 'comment' token, so this token will overwrite CSS' 'comment' token\n     *     // at its original position\n     *     'comment': { ... },\n     *     // CSS doesn't have a 'color' token, so this token will be appended\n     *     'color': /\\b(?:red|green|blue)\\b/\n     * });\n     */\n    extend: function (id, redef) {\n      var lang = _.util.clone(_.languages[id])\n\n      for (var key in redef) {\n        lang[key] = redef[key]\n      }\n\n      return lang\n    },\n\n    /**\n     * Inserts tokens _before_ another token in a language definition or any other grammar.\n     *\n     * ## Usage\n     *\n     * This helper method makes it easy to modify existing languages. For example, the CSS language definition\n     * not only defines CSS highlighting for CSS documents, but also needs to define highlighting for CSS embedded\n     * in HTML through `<style>` elements. To do this, it needs to modify `Prism.languages.markup` and add the\n     * appropriate tokens. However, `Prism.languages.markup` is a regular JavaScript object literal, so if you do\n     * this:\n     *\n     * ```js\n     * Prism.languages.markup.style = {\n     *     // token\n     * };\n     * ```\n     *\n     * then the `style` token will be added (and processed) at the end. `insertBefore` allows you to insert tokens\n     * before existing tokens. For the CSS example above, you would use it like this:\n     *\n     * ```js\n     * Prism.languages.insertBefore('markup', 'cdata', {\n     *     'style': {\n     *         // token\n     *     }\n     * });\n     * ```\n     *\n     * ## Special cases\n     *\n     * If the grammars of `inside` and `insert` have tokens with the same name, the tokens in `inside`'s grammar\n     * will be ignored.\n     *\n     * This behavior can be used to insert tokens after `before`:\n     *\n     * ```js\n     * Prism.languages.insertBefore('markup', 'comment', {\n     *     'comment': Prism.languages.markup.comment,\n     *     // tokens after 'comment'\n     * });\n     * ```\n     *\n     * ## Limitations\n     *\n     * The main problem `insertBefore` has to solve is iteration order. Since ES2015, the iteration order for object\n     * properties is guaranteed to be the insertion order (except for integer keys) but some browsers behave\n     * differently when keys are deleted and re-inserted. So `insertBefore` can't be implemented by temporarily\n     * deleting properties which is necessary to insert at arbitrary positions.\n     *\n     * To solve this problem, `insertBefore` doesn't actually insert the given tokens into the target object.\n     * Instead, it will create a new object and replace all references to the target object with the new one. This\n     * can be done without temporarily deleting properties, so the iteration order is well-defined.\n     *\n     * However, only references that can be reached from `Prism.languages` or `insert` will be replaced. I.e. if\n     * you hold the target object in a variable, then the value of the variable will not change.\n     *\n     * ```js\n     * var oldMarkup = Prism.languages.markup;\n     * var newMarkup = Prism.languages.insertBefore('markup', 'comment', { ... });\n     *\n     * assert(oldMarkup !== Prism.languages.markup);\n     * assert(newMarkup === Prism.languages.markup);\n     * ```\n     *\n     * @param {string} inside The property of `root` (e.g. a language id in `Prism.languages`) that contains the\n     * object to be modified.\n     * @param {string} before The key to insert before.\n     * @param {Grammar} insert An object containing the key-value pairs to be inserted.\n     * @param {Object<string, any>} [root] The object containing `inside`, i.e. the object that contains the\n     * object to be modified.\n     *\n     * Defaults to `Prism.languages`.\n     * @returns {Grammar} The new grammar object.\n     * @public\n     */\n    insertBefore: function (inside, before, insert, root) {\n      root = root || /** @type {any} */ (_.languages)\n      var grammar = root[inside]\n      /** @type {Grammar} */\n      var ret = {}\n\n      for (var token in grammar) {\n        if (grammar.hasOwnProperty(token)) {\n          if (token == before) {\n            for (var newToken in insert) {\n              if (insert.hasOwnProperty(newToken)) {\n                ret[newToken] = insert[newToken]\n              }\n            }\n          }\n\n          // Do not insert token which also occur in insert. See #1525\n          if (!insert.hasOwnProperty(token)) {\n            ret[token] = grammar[token]\n          }\n        }\n      }\n\n      var old = root[inside]\n      root[inside] = ret\n\n      // Update references in other language definitions\n      _.languages.DFS(_.languages, function (key, value) {\n        if (value === old && key != inside) {\n          this[key] = ret\n        }\n      })\n\n      return ret\n    },\n\n    // Traverse a language definition with Depth First Search\n    DFS: function DFS(o, callback, type, visited) {\n      visited = visited || {}\n\n      var objId = _.util.objId\n\n      for (var i in o) {\n        if (o.hasOwnProperty(i)) {\n          callback.call(o, i, o[i], type || i)\n\n          var property = o[i]\n          var propertyType = _.util.type(property)\n\n          if (propertyType === 'Object' && !visited[objId(property)]) {\n            visited[objId(property)] = true\n            DFS(property, callback, null, visited)\n          } else if (propertyType === 'Array' && !visited[objId(property)]) {\n            visited[objId(property)] = true\n            DFS(property, callback, i, visited)\n          }\n        }\n      }\n    }\n  },\n\n  plugins: {},\n\n  /**\n   * Low-level function, only use if you know what you’re doing. It accepts a string of text as input\n   * and the language definitions to use, and returns a string with the HTML produced.\n   *\n   * The following hooks will be run:\n   * 1. `before-tokenize`\n   * 2. `after-tokenize`\n   * 3. `wrap`: On each {@link Token}.\n   *\n   * @param {string} text A string with the code to be highlighted.\n   * @param {Grammar} grammar An object containing the tokens to use.\n   *\n   * Usually a language definition like `Prism.languages.markup`.\n   * @param {string} language The name of the language definition passed to `grammar`.\n   * @returns {string} The highlighted HTML.\n   * @memberof Prism\n   * @public\n   * @example\n   * Prism.highlight('var foo = true;', Prism.languages.javascript, 'javascript');\n   */\n  highlight: function (text, grammar, language) {\n    var env = {\n      code: text,\n      grammar: grammar,\n      language: language\n    }\n    _.hooks.run('before-tokenize', env)\n    if (!env.grammar) {\n      throw new Error('The language \"' + env.language + '\" has no grammar.')\n    }\n    env.tokens = _.tokenize(env.code, env.grammar)\n    _.hooks.run('after-tokenize', env)\n    return Token.stringify(_.util.encode(env.tokens), env.language)\n  },\n\n  /**\n   * This is the heart of Prism, and the most low-level function you can use. It accepts a string of text as input\n   * and the language definitions to use, and returns an array with the tokenized code.\n   *\n   * When the language definition includes nested tokens, the function is called recursively on each of these tokens.\n   *\n   * This method could be useful in other contexts as well, as a very crude parser.\n   *\n   * @param {string} text A string with the code to be highlighted.\n   * @param {Grammar} grammar An object containing the tokens to use.\n   *\n   * Usually a language definition like `Prism.languages.markup`.\n   * @returns {TokenStream} An array of strings and tokens, a token stream.\n   * @memberof Prism\n   * @public\n   * @example\n   * let code = `var foo = 0;`;\n   * let tokens = Prism.tokenize(code, Prism.languages.javascript);\n   * tokens.forEach(token => {\n   *     if (token instanceof Prism.Token && token.type === 'number') {\n   *         console.log(`Found numeric literal: ${token.content}`);\n   *     }\n   * });\n   */\n  tokenize: function (text, grammar) {\n    var rest = grammar.rest\n    if (rest) {\n      for (var token in rest) {\n        grammar[token] = rest[token]\n      }\n\n      delete grammar.rest\n    }\n\n    var tokenList = new LinkedList()\n    addAfter(tokenList, tokenList.head, text)\n\n    matchGrammar(text, tokenList, grammar, tokenList.head, 0)\n\n    return toArray(tokenList)\n  },\n\n  /**\n   * @namespace\n   * @memberof Prism\n   * @public\n   */\n  hooks: {\n    all: {},\n\n    /**\n     * Adds the given callback to the list of callbacks for the given hook.\n     *\n     * The callback will be invoked when the hook it is registered for is run.\n     * Hooks are usually directly run by a highlight function but you can also run hooks yourself.\n     *\n     * One callback function can be registered to multiple hooks and the same hook multiple times.\n     *\n     * @param {string} name The name of the hook.\n     * @param {HookCallback} callback The callback function which is given environment variables.\n     * @public\n     */\n    add: function (name, callback) {\n      var hooks = _.hooks.all\n\n      hooks[name] = hooks[name] || []\n\n      hooks[name].push(callback)\n    },\n\n    /**\n     * Runs a hook invoking all registered callbacks with the given environment variables.\n     *\n     * Callbacks will be invoked synchronously and in the order in which they were registered.\n     *\n     * @param {string} name The name of the hook.\n     * @param {Object<string, any>} env The environment variables of the hook passed to all callbacks registered.\n     * @public\n     */\n    run: function (name, env) {\n      var callbacks = _.hooks.all[name]\n\n      if (!callbacks || !callbacks.length) {\n        return\n      }\n\n      for (var i = 0, callback; (callback = callbacks[i++]); ) {\n        callback(env)\n      }\n    }\n  },\n\n  Token: Token\n}\n\n// Typescript note:\n// The following can be used to import the Token type in JSDoc:\n//\n//   @typedef {InstanceType<import(\"./prism-core\")[\"Token\"]>} Token\n\n/**\n * Creates a new token.\n *\n * @param {string} type See {@link Token#type type}\n * @param {string | TokenStream} content See {@link Token#content content}\n * @param {string|string[]} [alias] The alias(es) of the token.\n * @param {string} [matchedStr=\"\"] A copy of the full string this token was created from.\n * @class\n * @global\n * @public\n */\nfunction Token(type, content, alias, matchedStr) {\n  /**\n   * The type of the token.\n   *\n   * This is usually the key of a pattern in a {@link Grammar}.\n   *\n   * @type {string}\n   * @see GrammarToken\n   * @public\n   */\n  this.type = type\n  /**\n   * The strings or tokens contained by this token.\n   *\n   * This will be a token stream if the pattern matched also defined an `inside` grammar.\n   *\n   * @type {string | TokenStream}\n   * @public\n   */\n  this.content = content\n  /**\n   * The alias(es) of the token.\n   *\n   * @type {string|string[]}\n   * @see GrammarToken\n   * @public\n   */\n  this.alias = alias\n  // Copy of the full string this token was created from\n  this.length = (matchedStr || '').length | 0\n}\n\n/**\n * A token stream is an array of strings and {@link Token Token} objects.\n *\n * Token streams have to fulfill a few properties that are assumed by most functions (mostly internal ones) that process\n * them.\n *\n * 1. No adjacent strings.\n * 2. No empty strings.\n *\n *    The only exception here is the token stream that only contains the empty string and nothing else.\n *\n * @typedef {Array<string | Token>} TokenStream\n * @global\n * @public\n */\n\n/**\n * @param {RegExp} pattern\n * @param {number} pos\n * @param {string} text\n * @param {boolean} lookbehind\n * @returns {RegExpExecArray | null}\n */\nfunction matchPattern(pattern, pos, text, lookbehind) {\n  pattern.lastIndex = pos\n  var match = pattern.exec(text)\n  if (match && lookbehind && match[1]) {\n    // change the match to remove the text matched by the Prism lookbehind group\n    var lookbehindLength = match[1].length\n    match.index += lookbehindLength\n    match[0] = match[0].slice(lookbehindLength)\n  }\n  return match\n}\n\n/**\n * @param {string} text\n * @param {LinkedList<string | Token>} tokenList\n * @param {any} grammar\n * @param {LinkedListNode<string | Token>} startNode\n * @param {number} startPos\n * @param {RematchOptions} [rematch]\n * @returns {void}\n * @private\n *\n * @typedef RematchOptions\n * @property {string} cause\n * @property {number} reach\n */\nfunction matchGrammar(text, tokenList, grammar, startNode, startPos, rematch) {\n  for (var token in grammar) {\n    if (!grammar.hasOwnProperty(token) || !grammar[token]) {\n      continue\n    }\n\n    var patterns = grammar[token]\n    patterns = Array.isArray(patterns) ? patterns : [patterns]\n\n    for (var j = 0; j < patterns.length; ++j) {\n      if (rematch && rematch.cause == token + ',' + j) {\n        return\n      }\n\n      var patternObj = patterns[j]\n      var inside = patternObj.inside\n      var lookbehind = !!patternObj.lookbehind\n      var greedy = !!patternObj.greedy\n      var alias = patternObj.alias\n\n      if (greedy && !patternObj.pattern.global) {\n        // Without the global flag, lastIndex won't work\n        var flags = patternObj.pattern.toString().match(/[imsuy]*$/)[0]\n        patternObj.pattern = RegExp(patternObj.pattern.source, flags + 'g')\n      }\n\n      /** @type {RegExp} */\n      var pattern = patternObj.pattern || patternObj\n\n      for (\n        // iterate the token list and keep track of the current token/string position\n        var currentNode = startNode.next, pos = startPos;\n        currentNode !== tokenList.tail;\n        pos += currentNode.value.length, currentNode = currentNode.next\n      ) {\n        if (rematch && pos >= rematch.reach) {\n          break\n        }\n\n        var str = currentNode.value\n\n        if (tokenList.length > text.length) {\n          // Something went terribly wrong, ABORT, ABORT!\n          return\n        }\n\n        if (str instanceof Token) {\n          continue\n        }\n\n        var removeCount = 1 // this is the to parameter of removeBetween\n        var match\n\n        if (greedy) {\n          match = matchPattern(pattern, pos, text, lookbehind)\n          if (!match || match.index >= text.length) {\n            break\n          }\n\n          var from = match.index\n          var to = match.index + match[0].length\n          var p = pos\n\n          // find the node that contains the match\n          p += currentNode.value.length\n          while (from >= p) {\n            currentNode = currentNode.next\n            p += currentNode.value.length\n          }\n          // adjust pos (and p)\n          p -= currentNode.value.length\n          pos = p\n\n          // the current node is a Token, then the match starts inside another Token, which is invalid\n          if (currentNode.value instanceof Token) {\n            continue\n          }\n\n          // find the last node which is affected by this match\n          for (\n            var k = currentNode;\n            k !== tokenList.tail && (p < to || typeof k.value === 'string');\n            k = k.next\n          ) {\n            removeCount++\n            p += k.value.length\n          }\n          removeCount--\n\n          // replace with the new match\n          str = text.slice(pos, p)\n          match.index -= pos\n        } else {\n          match = matchPattern(pattern, 0, str, lookbehind)\n          if (!match) {\n            continue\n          }\n        }\n\n        // eslint-disable-next-line no-redeclare\n        var from = match.index\n        var matchStr = match[0]\n        var before = str.slice(0, from)\n        var after = str.slice(from + matchStr.length)\n\n        var reach = pos + str.length\n        if (rematch && reach > rematch.reach) {\n          rematch.reach = reach\n        }\n\n        var removeFrom = currentNode.prev\n\n        if (before) {\n          removeFrom = addAfter(tokenList, removeFrom, before)\n          pos += before.length\n        }\n\n        removeRange(tokenList, removeFrom, removeCount)\n\n        var wrapped = new Token(\n          token,\n          inside ? _.tokenize(matchStr, inside) : matchStr,\n          alias,\n          matchStr\n        )\n        currentNode = addAfter(tokenList, removeFrom, wrapped)\n\n        if (after) {\n          addAfter(tokenList, currentNode, after)\n        }\n\n        if (removeCount > 1) {\n          // at least one Token object was removed, so we have to do some rematching\n          // this can only happen if the current pattern is greedy\n\n          /** @type {RematchOptions} */\n          var nestedRematch = {\n            cause: token + ',' + j,\n            reach: reach\n          }\n          matchGrammar(\n            text,\n            tokenList,\n            grammar,\n            currentNode.prev,\n            pos,\n            nestedRematch\n          )\n\n          // the reach might have been extended because of the rematching\n          if (rematch && nestedRematch.reach > rematch.reach) {\n            rematch.reach = nestedRematch.reach\n          }\n        }\n      }\n    }\n  }\n}\n\n/**\n * @typedef LinkedListNode\n * @property {T} value\n * @property {LinkedListNode<T> | null} prev The previous node.\n * @property {LinkedListNode<T> | null} next The next node.\n * @template T\n * @private\n */\n\n/**\n * @template T\n * @private\n */\nfunction LinkedList() {\n  /** @type {LinkedListNode<T>} */\n  var head = {value: null, prev: null, next: null}\n  /** @type {LinkedListNode<T>} */\n  var tail = {value: null, prev: head, next: null}\n  head.next = tail\n\n  /** @type {LinkedListNode<T>} */\n  this.head = head\n  /** @type {LinkedListNode<T>} */\n  this.tail = tail\n  this.length = 0\n}\n\n/**\n * Adds a new node with the given value to the list.\n *\n * @param {LinkedList<T>} list\n * @param {LinkedListNode<T>} node\n * @param {T} value\n * @returns {LinkedListNode<T>} The added node.\n * @template T\n */\nfunction addAfter(list, node, value) {\n  // assumes that node != list.tail && values.length >= 0\n  var next = node.next\n\n  var newNode = {value: value, prev: node, next: next}\n  node.next = newNode\n  next.prev = newNode\n  list.length++\n\n  return newNode\n}\n/**\n * Removes `count` nodes after the given node. The given node will not be removed.\n *\n * @param {LinkedList<T>} list\n * @param {LinkedListNode<T>} node\n * @param {number} count\n * @template T\n */\nfunction removeRange(list, node, count) {\n  var next = node.next\n  for (var i = 0; i < count && next !== list.tail; i++) {\n    next = next.next\n  }\n  node.next = next\n  next.prev = node\n  list.length -= i\n}\n/**\n * @param {LinkedList<T>} list\n * @returns {T[]}\n * @template T\n */\nfunction toArray(list) {\n  var array = []\n  var node = list.head.next\n  while (node !== list.tail) {\n    array.push(node.value)\n    node = node.next\n  }\n  return array\n}\n\nexport const Prism = _\n"],"names":["uniqueId","plainTextGrammar","_","o","obj","deepClone","visited","clone","id","key","v","i","redef","lang","inside","before","insert","root","grammar","ret","token","newToken","old","value","DFS","callback","type","objId","property","propertyType","text","language","env","Token","rest","tokenList","LinkedList","addAfter","matchGrammar","toArray","name","hooks","callbacks","content","alias","matchedStr","matchPattern","pattern","pos","lookbehind","match","lookbehindLength","startNode","startPos","rematch","patterns","j","patternObj","greedy","flags","currentNode","str","removeCount","from","to","p","k","matchStr","after","reach","removeFrom","removeRange","wrapped","nestedRematch","head","tail","list","node","next","newNode","count","array","Prism"],"mappings":"AAOA,IAAIA,IAAW,GAGXC,IAAmB,CAAA,GAEnBC,IAAI;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAUN,MAAM;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAiBJ,MAAM,SAAUC,GAAG;AACjB,aAAO,OAAO,UAAU,SAAS,KAAKA,CAAC,EAAE,MAAM,GAAG,EAAE;AAAA,IACtD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAQA,OAAO,SAAUC,GAAK;AACpB,aAAKA,EAAI,QACP,OAAO,eAAeA,GAAK,QAAQ,EAAC,OAAO,EAAEJ,EAAQ,CAAC,GAEjDI,EAAI;AAAA,IACb;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAYA,OAAO,SAASC,EAAUF,GAAGG,GAAS;AACpC,MAAAA,IAAUA,KAAW,CAAA;AAErB,UAAIC,GACAC;AACJ,cAAQN,EAAE,KAAK,KAAKC,CAAC,GAAC;AAAA,QACpB,KAAK;AAEH,cADAK,IAAKN,EAAE,KAAK,MAAMC,CAAC,GACfG,EAAQE,CAAE;AACZ,mBAAOF,EAAQE,CAAE;AAEnB,UAAAD;AAAA,UAA4C,CAAA,GAC5CD,EAAQE,CAAE,IAAID;AAEd,mBAASE,KAAON;AACd,YAAIA,EAAE,eAAeM,CAAG,MACtBF,EAAME,CAAG,IAAIJ,EAAUF,EAAEM,CAAG,GAAGH,CAAO;AAI1C;AAAA;AAAA,YAA2BC;AAAA;AAAA,QAE7B,KAAK;AAEH,iBADAC,IAAKN,EAAE,KAAK,MAAMC,CAAC,GACfG,EAAQE,CAAE,IACLF,EAAQE,CAAE,KAEnBD,IAAQ,CAAA,GACRD,EAAQE,CAAE,IAAID;AAAA,UAE6BJ,EAAI;AAAA,YAC7C,SAAUO,GAAGC,GAAG;AACd,cAAAJ,EAAMI,CAAC,IAAIN,EAAUK,GAAGJ,CAAO;AAAA,YACjC;AAAA,UACZ;AAAA,UAEqCC;AAAA,QAE7B;AACE,iBAAOJ;AAAA,MACjB;AAAA,IACI;AAAA,EACJ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASE,WAAW;AAAA;AAAA;AAAA;AAAA,IAIT,OAAOF;AAAA,IACP,WAAWA;AAAA,IACX,MAAMA;AAAA,IACN,KAAKA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IA8BL,QAAQ,SAAUO,GAAII,GAAO;AAC3B,UAAIC,IAAOX,EAAE,KAAK,MAAMA,EAAE,UAAUM,CAAE,CAAC;AAEvC,eAASC,KAAOG;AACd,QAAAC,EAAKJ,CAAG,IAAIG,EAAMH,CAAG;AAGvB,aAAOI;AAAA,IACT;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IA6EA,cAAc,SAAUC,GAAQC,GAAQC,GAAQC,GAAM;AACpD,MAAAA,IAAOA;AAAA,MAA4Bf,EAAE;AACrC,UAAIgB,IAAUD,EAAKH,CAAM,GAErBK,IAAM,CAAA;AAEV,eAASC,KAASF;AAChB,YAAIA,EAAQ,eAAeE,CAAK,GAAG;AACjC,cAAIA,KAASL;AACX,qBAASM,KAAYL;AACnB,cAAIA,EAAO,eAAeK,CAAQ,MAChCF,EAAIE,CAAQ,IAAIL,EAAOK,CAAQ;AAMrC,UAAKL,EAAO,eAAeI,CAAK,MAC9BD,EAAIC,CAAK,IAAIF,EAAQE,CAAK;AAAA,QAE9B;AAGF,UAAIE,IAAML,EAAKH,CAAM;AACrB,aAAAG,EAAKH,CAAM,IAAIK,GAGfjB,EAAE,UAAU,IAAIA,EAAE,WAAW,SAAUO,GAAKc,GAAO;AACjD,QAAIA,MAAUD,KAAOb,KAAOK,MAC1B,KAAKL,CAAG,IAAIU;AAAA,MAEhB,CAAC,GAEMA;AAAA,IACT;AAAA;AAAA,IAGA,KAAK,SAASK,EAAIrB,GAAGsB,GAAUC,GAAMpB,GAAS;AAC5C,MAAAA,IAAUA,KAAW,CAAA;AAErB,UAAIqB,IAAQzB,EAAE,KAAK;AAEnB,eAASS,KAAKR;AACZ,YAAIA,EAAE,eAAeQ,CAAC,GAAG;AACvB,UAAAc,EAAS,KAAKtB,GAAGQ,GAAGR,EAAEQ,CAAC,GAAGe,KAAQf,CAAC;AAEnC,cAAIiB,IAAWzB,EAAEQ,CAAC,GACdkB,IAAe3B,EAAE,KAAK,KAAK0B,CAAQ;AAEvC,UAAIC,MAAiB,YAAY,CAACvB,EAAQqB,EAAMC,CAAQ,CAAC,KACvDtB,EAAQqB,EAAMC,CAAQ,CAAC,IAAI,IAC3BJ,EAAII,GAAUH,GAAU,MAAMnB,CAAO,KAC5BuB,MAAiB,WAAW,CAACvB,EAAQqB,EAAMC,CAAQ,CAAC,MAC7DtB,EAAQqB,EAAMC,CAAQ,CAAC,IAAI,IAC3BJ,EAAII,GAAUH,GAAUd,GAAGL,CAAO;AAAA,QAEtC;AAAA,IAEJ;AAAA,EACJ;AAAA,EAEE,SAAS,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAsBT,WAAW,SAAUwB,GAAMZ,GAASa,GAAU;AAC5C,QAAIC,IAAM;AAAA,MACR,MAAMF;AAAA,MACN,SAASZ;AAAA,MACT,UAAUa;AAAA,IAChB;AAEI,QADA7B,EAAE,MAAM,IAAI,mBAAmB8B,CAAG,GAC9B,CAACA,EAAI;AACP,YAAM,IAAI,MAAM,mBAAmBA,EAAI,WAAW,mBAAmB;AAEvE,WAAAA,EAAI,SAAS9B,EAAE,SAAS8B,EAAI,MAAMA,EAAI,OAAO,GAC7C9B,EAAE,MAAM,IAAI,kBAAkB8B,CAAG,GAC1BC,EAAM,UAAU/B,EAAE,KAAK,OAAO8B,EAAI,MAAM,GAAGA,EAAI,QAAQ;AAAA,EAChE;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EA0BA,UAAU,SAAUF,GAAMZ,GAAS;AACjC,QAAIgB,IAAOhB,EAAQ;AACnB,QAAIgB,GAAM;AACR,eAASd,KAASc;AAChB,QAAAhB,EAAQE,CAAK,IAAIc,EAAKd,CAAK;AAG7B,aAAOF,EAAQ;AAAA,IACjB;AAEA,QAAIiB,IAAY,IAAIC,EAAU;AAC9B,WAAAC,EAASF,GAAWA,EAAU,MAAML,CAAI,GAExCQ,EAAaR,GAAMK,GAAWjB,GAASiB,EAAU,MAAM,CAAC,GAEjDI,EAAQJ,CAAS;AAAA,EAC1B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOA,OAAO;AAAA,IACL,KAAK,CAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAcL,KAAK,SAAUK,GAAMf,GAAU;AAC7B,UAAIgB,IAAQvC,EAAE,MAAM;AAEpB,MAAAuC,EAAMD,CAAI,IAAIC,EAAMD,CAAI,KAAK,CAAA,GAE7BC,EAAMD,CAAI,EAAE,KAAKf,CAAQ;AAAA,IAC3B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAWA,KAAK,SAAUe,GAAMR,GAAK;AACxB,UAAIU,IAAYxC,EAAE,MAAM,IAAIsC,CAAI;AAEhC,UAAI,GAACE,KAAa,CAACA,EAAU;AAI7B,iBAAS/B,IAAI,GAAGc,GAAWA,IAAWiB,EAAU/B,GAAG;AACjD,UAAAc,EAASO,CAAG;AAAA,IAEhB;AAAA,EACJ;AAAA,EAEE,OAAOC;AACT;AAkBA,SAASA,EAAMP,GAAMiB,GAASC,GAAOC,GAAY;AAU/C,OAAK,OAAOnB,GASZ,KAAK,UAAUiB,GAQf,KAAK,QAAQC,GAEb,KAAK,UAAUC,KAAc,IAAI,SAAS;AAC5C;AAyBA,SAASC,EAAaC,GAASC,GAAKlB,GAAMmB,GAAY;AACpD,EAAAF,EAAQ,YAAYC;AACpB,MAAIE,IAAQH,EAAQ,KAAKjB,CAAI;AAC7B,MAAIoB,KAASD,KAAcC,EAAM,CAAC,GAAG;AAEnC,QAAIC,IAAmBD,EAAM,CAAC,EAAE;AAChC,IAAAA,EAAM,SAASC,GACfD,EAAM,CAAC,IAAIA,EAAM,CAAC,EAAE,MAAMC,CAAgB;AAAA,EAC5C;AACA,SAAOD;AACT;AAgBA,SAASZ,EAAaR,GAAMK,GAAWjB,GAASkC,GAAWC,GAAUC,GAAS;AAC5E,WAASlC,KAASF;AAChB,QAAI,GAACA,EAAQ,eAAeE,CAAK,KAAK,CAACF,EAAQE,CAAK,IAIpD;AAAA,UAAImC,IAAWrC,EAAQE,CAAK;AAC5B,MAAAmC,IAAW,MAAM,QAAQA,CAAQ,IAAIA,IAAW,CAACA,CAAQ;AAEzD,eAASC,IAAI,GAAGA,IAAID,EAAS,QAAQ,EAAEC,GAAG;AACxC,YAAIF,KAAWA,EAAQ,SAASlC,IAAQ,MAAMoC;AAC5C;AAGF,YAAIC,IAAaF,EAASC,CAAC,GACvB1C,IAAS2C,EAAW,QACpBR,IAAa,CAAC,CAACQ,EAAW,YAC1BC,IAAS,CAAC,CAACD,EAAW,QACtBb,IAAQa,EAAW;AAEvB,YAAIC,KAAU,CAACD,EAAW,QAAQ,QAAQ;AAExC,cAAIE,IAAQF,EAAW,QAAQ,SAAQ,EAAG,MAAM,WAAW,EAAE,CAAC;AAC9D,UAAAA,EAAW,UAAU,OAAOA,EAAW,QAAQ,QAAQE,IAAQ,GAAG;AAAA,QACpE;AAKA,iBAFIZ,IAAUU,EAAW,WAAWA,GAI9BG,IAAcR,EAAU,MAAMJ,IAAMK,GACxCO,MAAgBzB,EAAU,QAGtB,EAAAmB,KAAWN,KAAOM,EAAQ,QAF9BN,KAAOY,EAAY,MAAM,QAAQA,IAAcA,EAAY,MAC3D;AAKA,cAAIC,IAAMD,EAAY;AAEtB,cAAIzB,EAAU,SAASL,EAAK;AAE1B;AAGF,cAAI,EAAA+B,aAAe5B,IAInB;AAAA,gBAAI6B,IAAc,GACdZ;AAEJ,gBAAIQ,GAAQ;AAEV,kBADAR,IAAQJ,EAAaC,GAASC,GAAKlB,GAAMmB,CAAU,GAC/C,CAACC,KAASA,EAAM,SAASpB,EAAK;AAChC;AAGF,kBAAIiC,IAAOb,EAAM,OACbc,IAAKd,EAAM,QAAQA,EAAM,CAAC,EAAE,QAC5Be,IAAIjB;AAIR,mBADAiB,KAAKL,EAAY,MAAM,QAChBG,KAAQE;AACb,gBAAAL,IAAcA,EAAY,MAC1BK,KAAKL,EAAY,MAAM;AAOzB,kBAJAK,KAAKL,EAAY,MAAM,QACvBZ,IAAMiB,GAGFL,EAAY,iBAAiB3B;AAC/B;AAIF,uBACMiC,IAAIN,GACRM,MAAM/B,EAAU,SAAS8B,IAAID,KAAM,OAAOE,EAAE,SAAU,WACtDA,IAAIA,EAAE;AAEN,gBAAAJ,KACAG,KAAKC,EAAE,MAAM;AAEf,cAAAJ,KAGAD,IAAM/B,EAAK,MAAMkB,GAAKiB,CAAC,GACvBf,EAAM,SAASF;AAAA,YACjB,WACEE,IAAQJ,EAAaC,GAAS,GAAGc,GAAKZ,CAAU,GAC5C,CAACC;AACH;AAKJ,gBAAIa,IAAOb,EAAM,OACbiB,IAAWjB,EAAM,CAAC,GAClBnC,IAAS8C,EAAI,MAAM,GAAGE,CAAI,GAC1BK,IAAQP,EAAI,MAAME,IAAOI,EAAS,MAAM,GAExCE,IAAQrB,IAAMa,EAAI;AACtB,YAAIP,KAAWe,IAAQf,EAAQ,UAC7BA,EAAQ,QAAQe;AAGlB,gBAAIC,IAAaV,EAAY;AAE7B,YAAI7C,MACFuD,IAAajC,EAASF,GAAWmC,GAAYvD,CAAM,GACnDiC,KAAOjC,EAAO,SAGhBwD,EAAYpC,GAAWmC,GAAYR,CAAW;AAE9C,gBAAIU,IAAU,IAAIvC;AAAA,cAChBb;AAAA,cACAN,IAASZ,EAAE,SAASiE,GAAUrD,CAAM,IAAIqD;AAAA,cACxCvB;AAAA,cACAuB;AAAA,YACV;AAOQ,gBANAP,IAAcvB,EAASF,GAAWmC,GAAYE,CAAO,GAEjDJ,KACF/B,EAASF,GAAWyB,GAAaQ,CAAK,GAGpCN,IAAc,GAAG;AAKnB,kBAAIW,IAAgB;AAAA,gBAClB,OAAOrD,IAAQ,MAAMoC;AAAA,gBACrB,OAAOa;AAAA,cACnB;AACU,cAAA/B;AAAA,gBACER;AAAA,gBACAK;AAAA,gBACAjB;AAAA,gBACA0C,EAAY;AAAA,gBACZZ;AAAA,gBACAyB;AAAA,cACZ,GAGcnB,KAAWmB,EAAc,QAAQnB,EAAQ,UAC3CA,EAAQ,QAAQmB,EAAc;AAAA,YAElC;AAAA;AAAA,QACF;AAAA,MACF;AAAA;AAEJ;AAeA,SAASrC,IAAa;AAEpB,MAAIsC,IAAO,EAAC,OAAO,MAAM,MAAM,MAAM,MAAM,KAAI,GAE3CC,IAAO,EAAC,OAAO,MAAM,MAAMD,GAAM,MAAM,KAAI;AAC/C,EAAAA,EAAK,OAAOC,GAGZ,KAAK,OAAOD,GAEZ,KAAK,OAAOC,GACZ,KAAK,SAAS;AAChB;AAWA,SAAStC,EAASuC,GAAMC,GAAMtD,GAAO;AAEnC,MAAIuD,IAAOD,EAAK,MAEZE,IAAU,EAAC,OAAOxD,GAAO,MAAMsD,GAAM,MAAMC,EAAI;AACnD,SAAAD,EAAK,OAAOE,GACZD,EAAK,OAAOC,GACZH,EAAK,UAEEG;AACT;AASA,SAASR,EAAYK,GAAMC,GAAMG,GAAO;AAEtC,WADIF,IAAOD,EAAK,MACPlE,IAAI,GAAGA,IAAIqE,KAASF,MAASF,EAAK,MAAMjE;AAC/C,IAAAmE,IAAOA,EAAK;AAEd,EAAAD,EAAK,OAAOC,GACZA,EAAK,OAAOD,GACZD,EAAK,UAAUjE;AACjB;AAMA,SAAS4B,EAAQqC,GAAM;AAGrB,WAFIK,IAAQ,CAAA,GACRJ,IAAOD,EAAK,KAAK,MACdC,MAASD,EAAK;AACnB,IAAAK,EAAM,KAAKJ,EAAK,KAAK,GACrBA,IAAOA,EAAK;AAEd,SAAOI;AACT;AAEY,MAACC,IAAQhF;","x_google_ignoreList":[0]}

package/dist/vendor/.bun/rifm@0.12.1_62547eec5a2188e3/vendor/rifm/dist/rifm.esm.js

@@ -0,0 +1,87 @@
+import { useReducer as N, useRef as V, useLayoutEffect as x, useEffect as R } from "react";
+const A = (r) => {
+  const [, E] = N((e) => e + 1, 0), l = V(null), {
+    replace: i,
+    append: g
+  } = r, f = i ? i(r.format(r.value)) : r.format(r.value), m = V(!1), k = (e) => {
+    if (process.env.NODE_ENV !== "production") {
+      if (e.target.type === "number") {
+        console.error("Rifm does not support input type=number, use type=tel instead.");
+        return;
+      }
+      if (e.target.type === "date") {
+        console.error("Rifm does not support input type=date.");
+        return;
+      }
+    }
+    const t = e.target.value;
+    if (l.current = [
+      t,
+      // eventValue
+      e.target,
+      // input
+      t.length > f.length,
+      // isSizeIncreaseOperation
+      m.current,
+      // isDeleleteButtonDown
+      f === r.format(t)
+      // isNoOperation
+    ], process.env.NODE_ENV !== "production") {
+      const o = r.format(t);
+      t !== o && t.toLowerCase() === o.toLowerCase() && console.warn("Case enforcement does not work with format. Please use replace={value => value.toLowerCase()} instead");
+    }
+    E();
+  };
+  return (process.env.NODE_ENV === "production" || typeof window < "u") && x(() => {
+    if (l.current == null) return;
+    let [
+      e,
+      t,
+      o,
+      y,
+      // No operation means that value itself hasn't been changed, BTW cursor, selection etc can be changed
+      v
+    ] = l.current;
+    l.current = null;
+    const p = y && v, D = e.slice(t.selectionStart).search(r.accept || /\d/g), L = D !== -1 ? D : 0, c = (n) => (n.match(r.accept || /\d/g) || []).join(""), h = c(e.substr(0, t.selectionStart)), S = (n) => {
+      let s = 0, u = 0;
+      for (let d = 0; d !== h.length; ++d) {
+        let O = n.indexOf(h[d], s) + 1, w = c(n).indexOf(h[d], u) + 1;
+        w - u > 1 && (O = s, w = u), u = Math.max(w, u), s = Math.max(s, O);
+      }
+      return s;
+    };
+    if (r.mask === !0 && o && !v) {
+      let n = S(e);
+      const s = c(e.substr(n))[0];
+      n = e.indexOf(s, n), e = `${e.substr(0, n)}${e.substr(n + 1)}`;
+    }
+    let a = r.format(e);
+    g != null && // cursor at the end
+    t.selectionStart === e.length && !v && (o ? a = g(a) : c(a.slice(-1)) === "" && (a = a.slice(0, -1)));
+    const C = i ? i(a) : a;
+    return f === C ? E() : r.onChange(C), () => {
+      let n = S(a);
+      if (r.mask != null && (o || y && !p))
+        for (; a[n] && c(a[n]) === ""; )
+          n += 1;
+      t.selectionStart = t.selectionEnd = n + (p ? 1 + L : 0);
+    };
+  }), R(() => {
+    const e = (o) => {
+      o.code === "Delete" && (m.current = !0);
+    }, t = (o) => {
+      o.code === "Delete" && (m.current = !1);
+    };
+    return document.addEventListener("keydown", e), document.addEventListener("keyup", t), () => {
+      document.removeEventListener("keydown", e), document.removeEventListener("keyup", t);
+    };
+  }, []), {
+    value: l.current != null ? l.current[0] : f,
+    onChange: k
+  };
+};
+export {
+  A as useRifm
+};
+//# sourceMappingURL=rifm.esm.js.map

package/dist/vendor/.bun/rifm@0.12.1_62547eec5a2188e3/vendor/rifm/dist/rifm.esm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rifm.esm.js","sources":["../../../../../../../../../node_modules/.bun/rifm@0.12.1+62547eec5a2188e3/node_modules/rifm/dist/rifm.esm.js"],"sourcesContent":["import { useReducer, useRef, useLayoutEffect, useEffect } from 'react';\n\nconst useRifm = props => {\n  const [, refresh] = useReducer(c => c + 1, 0);\n  const valueRef = useRef(null);\n  const {\n    replace,\n    append\n  } = props;\n  const userValue = replace ? replace(props.format(props.value)) : props.format(props.value); // state of delete button see comments below about inputType support\n\n  const isDeleleteButtonDownRef = useRef(false);\n\n  const onChange = evt => {\n    if (process.env.NODE_ENV !== 'production') {\n      if (evt.target.type === 'number') {\n        console.error('Rifm does not support input type=number, use type=tel instead.');\n        return;\n      }\n\n      if (evt.target.type === 'date') {\n        console.error('Rifm does not support input type=date.');\n        return;\n      }\n    }\n\n    const eventValue = evt.target.value;\n    valueRef.current = [eventValue, // eventValue\n    evt.target, // input\n    eventValue.length > userValue.length, // isSizeIncreaseOperation\n    isDeleleteButtonDownRef.current, // isDeleleteButtonDown\n    userValue === props.format(eventValue) // isNoOperation\n    ];\n\n    if (process.env.NODE_ENV !== 'production') {\n      const formattedEventValue = props.format(eventValue);\n\n      if (eventValue !== formattedEventValue && eventValue.toLowerCase() === formattedEventValue.toLowerCase()) {\n        console.warn('Case enforcement does not work with format. Please use replace={value => value.toLowerCase()} instead');\n      }\n    } // The main trick is to update underlying input with non formatted value (= eventValue)\n    // that allows us to calculate right cursor position after formatting (see getCursorPosition)\n    // then we format new value and call props.onChange with masked/formatted value\n    // and finally we are able to set cursor position into right place\n\n\n    refresh();\n  }; // React prints warn on server in non production mode about useLayoutEffect usage\n  // in both cases it's noop\n\n\n  if (process.env.NODE_ENV === 'production' || typeof window !== 'undefined') {\n    useLayoutEffect(() => {\n      if (valueRef.current == null) return;\n      let [eventValue, input, isSizeIncreaseOperation, isDeleleteButtonDown, // No operation means that value itself hasn't been changed, BTW cursor, selection etc can be changed\n      isNoOperation] = valueRef.current;\n      valueRef.current = null; // this usually occurs on deleting special symbols like ' here 123'123.00\n      // in case of isDeleleteButtonDown cursor should move differently vs backspace\n\n      const deleteWasNoOp = isDeleleteButtonDown && isNoOperation;\n      const valueAfterSelectionStart = eventValue.slice(input.selectionStart);\n      const acceptedCharIndexAfterDelete = valueAfterSelectionStart.search(props.accept || /\\d/g);\n      const charsToSkipAfterDelete = acceptedCharIndexAfterDelete !== -1 ? acceptedCharIndexAfterDelete : 0; // Create string from only accepted symbols\n\n      const clean = str => (str.match(props.accept || /\\d/g) || []).join('');\n\n      const valueBeforeSelectionStart = clean(eventValue.substr(0, input.selectionStart)); // trying to find cursor position in formatted value having knowledge about valueBeforeSelectionStart\n      // This works because we assume that format doesn't change the order of accepted symbols.\n      // Imagine we have formatter which adds ' symbol between numbers, and by default we refuse all non numeric symbols\n      // for example we had input = 1'2|'4 (| means cursor position) then user entered '3' symbol\n      // inputValue = 1'23'|4 so valueBeforeSelectionStart = 123 and formatted value = 1'2'3'4\n      // calling getCursorPosition(\"1'2'3'4\") will give us position after 3, 1'2'3|'4\n      // so for formatting just this function to determine cursor position after formatting is enough\n      // with masking we need to do some additional checks see `mask` below\n\n      const getCursorPosition = val => {\n        let start = 0;\n        let cleanPos = 0;\n\n        for (let i = 0; i !== valueBeforeSelectionStart.length; ++i) {\n          let newPos = val.indexOf(valueBeforeSelectionStart[i], start) + 1;\n          let newCleanPos = clean(val).indexOf(valueBeforeSelectionStart[i], cleanPos) + 1; // this skips position change if accepted symbols order was broken\n          // For example fixes edge case with fixed point numbers:\n          // You have '0|.00', then press 1, it becomes 01|.00 and after format 1.00, this breaks our assumption\n          // that order of accepted symbols is not changed after format,\n          // so here we don't update start position if other accepted symbols was inbetween current and new position\n\n          if (newCleanPos - cleanPos > 1) {\n            newPos = start;\n            newCleanPos = cleanPos;\n          }\n\n          cleanPos = Math.max(newCleanPos, cleanPos);\n          start = Math.max(start, newPos);\n        }\n\n        return start;\n      }; // Masking part, for masks if size of mask is above some value\n      // we need to replace symbols instead of do nothing as like in format\n\n\n      if (props.mask === true && isSizeIncreaseOperation && !isNoOperation) {\n        let start = getCursorPosition(eventValue);\n        const c = clean(eventValue.substr(start))[0];\n        start = eventValue.indexOf(c, start);\n        eventValue = `${eventValue.substr(0, start)}${eventValue.substr(start + 1)}`;\n      }\n\n      let formattedValue = props.format(eventValue);\n\n      if (append != null && // cursor at the end\n      input.selectionStart === eventValue.length && !isNoOperation) {\n        if (isSizeIncreaseOperation) {\n          formattedValue = append(formattedValue);\n        } else {\n          // If after delete last char is special character and we use append\n          // delete it too\n          // was: \"12-3|\" backspace pressed, then should be \"12|\"\n          if (clean(formattedValue.slice(-1)) === '') {\n            formattedValue = formattedValue.slice(0, -1);\n          }\n        }\n      }\n\n      const replacedValue = replace ? replace(formattedValue) : formattedValue;\n\n      if (userValue === replacedValue) {\n        // if nothing changed for formatted value, just refresh so userValue will be used at render\n        refresh();\n      } else {\n        props.onChange(replacedValue);\n      }\n\n      return () => {\n        let start = getCursorPosition(formattedValue); // Visually improves working with masked values,\n        // like cursor jumping over refused symbols\n        // as an example date mask: was \"5|1-24-3\" then user pressed \"6\"\n        // it becomes \"56-|12-43\" with this code, and \"56|-12-43\" without\n\n        if (props.mask != null && (isSizeIncreaseOperation || isDeleleteButtonDown && !deleteWasNoOp)) {\n          while (formattedValue[start] && clean(formattedValue[start]) === '') {\n            start += 1;\n          }\n        }\n\n        input.selectionStart = input.selectionEnd = start + (deleteWasNoOp ? 1 + charsToSkipAfterDelete : 0);\n      };\n    });\n  }\n\n  useEffect(() => {\n    // until https://developer.mozilla.org/en-US/docs/Web/API/InputEvent/inputType will be supported\n    // by all major browsers (now supported by: +chrome, +safari, ?edge, !firefox)\n    // there is no way I found to distinguish in onChange\n    // backspace or delete was called in some situations\n    // firefox track https://bugzilla.mozilla.org/show_bug.cgi?id=1447239\n    const handleKeyDown = evt => {\n      if (evt.code === 'Delete') {\n        isDeleleteButtonDownRef.current = true;\n      }\n    };\n\n    const handleKeyUp = evt => {\n      if (evt.code === 'Delete') {\n        isDeleleteButtonDownRef.current = false;\n      }\n    };\n\n    document.addEventListener('keydown', handleKeyDown);\n    document.addEventListener('keyup', handleKeyUp);\n    return () => {\n      document.removeEventListener('keydown', handleKeyDown);\n      document.removeEventListener('keyup', handleKeyUp);\n    };\n  }, []);\n  return {\n    value: valueRef.current != null ? valueRef.current[0] : userValue,\n    onChange\n  };\n};\nconst Rifm = props => {\n  const renderProps = useRifm(props);\n  return props.children(renderProps);\n};\n\nexport { Rifm, useRifm };\n"],"names":["useRifm","props","refresh","useReducer","c","valueRef","useRef","replace","append","userValue","isDeleleteButtonDownRef","onChange","evt","eventValue","formattedEventValue","useLayoutEffect","input","isSizeIncreaseOperation","isDeleleteButtonDown","isNoOperation","deleteWasNoOp","acceptedCharIndexAfterDelete","charsToSkipAfterDelete","clean","str","valueBeforeSelectionStart","getCursorPosition","val","start","cleanPos","i","newPos","newCleanPos","formattedValue","replacedValue","useEffect","handleKeyDown","handleKeyUp"],"mappings":"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","x_google_ignoreList":[0]}