@qredence/fleet 0.7.2 → 0.7.3

package/dist/web/server/chunk-3L5VHELG.js

@@ -0,0 +1,993 @@
+import {
+  characterEntitiesLegacy
+} from "./chunk-MPHREEUA.js";
+import {
+  decodeNamedCharacterReference
+} from "./chunk-O5FZJ7AQ.js";
+import {
+  h
+} from "./chunk-CJ534HFW.js";
+
+// node_modules/.pnpm/character-reference-invalid@2.0.1/node_modules/character-reference-invalid/index.js
+var characterReferenceInvalid = {
+  0: "\uFFFD",
+  128: "\u20AC",
+  130: "\u201A",
+  131: "\u0192",
+  132: "\u201E",
+  133: "\u2026",
+  134: "\u2020",
+  135: "\u2021",
+  136: "\u02C6",
+  137: "\u2030",
+  138: "\u0160",
+  139: "\u2039",
+  140: "\u0152",
+  142: "\u017D",
+  145: "\u2018",
+  146: "\u2019",
+  147: "\u201C",
+  148: "\u201D",
+  149: "\u2022",
+  150: "\u2013",
+  151: "\u2014",
+  152: "\u02DC",
+  153: "\u2122",
+  154: "\u0161",
+  155: "\u203A",
+  156: "\u0153",
+  158: "\u017E",
+  159: "\u0178"
+};
+
+// node_modules/.pnpm/is-decimal@2.0.1/node_modules/is-decimal/index.js
+function isDecimal(character) {
+  const code = typeof character === "string" ? character.charCodeAt(0) : character;
+  return code >= 48 && code <= 57;
+}
+
+// node_modules/.pnpm/is-hexadecimal@2.0.1/node_modules/is-hexadecimal/index.js
+function isHexadecimal(character) {
+  const code = typeof character === "string" ? character.charCodeAt(0) : character;
+  return code >= 97 && code <= 102 || code >= 65 && code <= 70 || code >= 48 && code <= 57;
+}
+
+// node_modules/.pnpm/is-alphabetical@2.0.1/node_modules/is-alphabetical/index.js
+function isAlphabetical(character) {
+  const code = typeof character === "string" ? character.charCodeAt(0) : character;
+  return code >= 97 && code <= 122 || code >= 65 && code <= 90;
+}
+
+// node_modules/.pnpm/is-alphanumerical@2.0.1/node_modules/is-alphanumerical/index.js
+function isAlphanumerical(character) {
+  return isAlphabetical(character) || isDecimal(character);
+}
+
+// node_modules/.pnpm/parse-entities@4.0.2/node_modules/parse-entities/lib/index.js
+var messages = [
+  "",
+  /* 1: Non terminated (named) */
+  "Named character references must be terminated by a semicolon",
+  /* 2: Non terminated (numeric) */
+  "Numeric character references must be terminated by a semicolon",
+  /* 3: Empty (named) */
+  "Named character references cannot be empty",
+  /* 4: Empty (numeric) */
+  "Numeric character references cannot be empty",
+  /* 5: Unknown (named) */
+  "Named character references must be known",
+  /* 6: Disallowed (numeric) */
+  "Numeric character references cannot be disallowed",
+  /* 7: Prohibited (numeric) */
+  "Numeric character references cannot be outside the permissible Unicode range"
+];
+function parseEntities(value, options) {
+  const settings = options || {};
+  const additional = typeof settings.additional === "string" ? settings.additional.charCodeAt(0) : settings.additional;
+  const result = [];
+  let index = 0;
+  let lines = -1;
+  let queue = "";
+  let point;
+  let indent;
+  if (settings.position) {
+    if ("start" in settings.position || "indent" in settings.position) {
+      indent = settings.position.indent;
+      point = settings.position.start;
+    } else {
+      point = settings.position;
+    }
+  }
+  let line = (point ? point.line : 0) || 1;
+  let column = (point ? point.column : 0) || 1;
+  let previous = now();
+  let character;
+  index--;
+  while (++index <= value.length) {
+    if (character === 10) {
+      column = (indent ? indent[lines] : 0) || 1;
+    }
+    character = value.charCodeAt(index);
+    if (character === 38) {
+      const following = value.charCodeAt(index + 1);
+      if (following === 9 || following === 10 || following === 12 || following === 32 || following === 38 || following === 60 || Number.isNaN(following) || additional && following === additional) {
+        queue += String.fromCharCode(character);
+        column++;
+        continue;
+      }
+      const start = index + 1;
+      let begin = start;
+      let end = start;
+      let type;
+      if (following === 35) {
+        end = ++begin;
+        const following2 = value.charCodeAt(end);
+        if (following2 === 88 || following2 === 120) {
+          type = "hexadecimal";
+          end = ++begin;
+        } else {
+          type = "decimal";
+        }
+      } else {
+        type = "named";
+      }
+      let characterReferenceCharacters = "";
+      let characterReference = "";
+      let characters = "";
+      const test = type === "named" ? isAlphanumerical : type === "decimal" ? isDecimal : isHexadecimal;
+      end--;
+      while (++end <= value.length) {
+        const following2 = value.charCodeAt(end);
+        if (!test(following2)) {
+          break;
+        }
+        characters += String.fromCharCode(following2);
+        if (type === "named" && characterEntitiesLegacy.includes(characters)) {
+          characterReferenceCharacters = characters;
+          characterReference = decodeNamedCharacterReference(characters);
+        }
+      }
+      let terminated = value.charCodeAt(end) === 59;
+      if (terminated) {
+        end++;
+        const namedReference = type === "named" ? decodeNamedCharacterReference(characters) : false;
+        if (namedReference) {
+          characterReferenceCharacters = characters;
+          characterReference = namedReference;
+        }
+      }
+      let diff = 1 + end - start;
+      let reference = "";
+      if (!terminated && settings.nonTerminated === false) {
+      } else if (!characters) {
+        if (type !== "named") {
+          warning(4, diff);
+        }
+      } else if (type === "named") {
+        if (terminated && !characterReference) {
+          warning(5, 1);
+        } else {
+          if (characterReferenceCharacters !== characters) {
+            end = begin + characterReferenceCharacters.length;
+            diff = 1 + end - begin;
+            terminated = false;
+          }
+          if (!terminated) {
+            const reason = characterReferenceCharacters ? 1 : 3;
+            if (settings.attribute) {
+              const following2 = value.charCodeAt(end);
+              if (following2 === 61) {
+                warning(reason, diff);
+                characterReference = "";
+              } else if (isAlphanumerical(following2)) {
+                characterReference = "";
+              } else {
+                warning(reason, diff);
+              }
+            } else {
+              warning(reason, diff);
+            }
+          }
+        }
+        reference = characterReference;
+      } else {
+        if (!terminated) {
+          warning(2, diff);
+        }
+        let referenceCode = Number.parseInt(
+          characters,
+          type === "hexadecimal" ? 16 : 10
+        );
+        if (prohibited(referenceCode)) {
+          warning(7, diff);
+          reference = String.fromCharCode(
+            65533
+            /* `�` */
+          );
+        } else if (referenceCode in characterReferenceInvalid) {
+          warning(6, diff);
+          reference = characterReferenceInvalid[referenceCode];
+        } else {
+          let output = "";
+          if (disallowed(referenceCode)) {
+            warning(6, diff);
+          }
+          if (referenceCode > 65535) {
+            referenceCode -= 65536;
+            output += String.fromCharCode(
+              referenceCode >>> (10 & 1023) | 55296
+            );
+            referenceCode = 56320 | referenceCode & 1023;
+          }
+          reference = output + String.fromCharCode(referenceCode);
+        }
+      }
+      if (reference) {
+        flush();
+        previous = now();
+        index = end - 1;
+        column += end - start + 1;
+        result.push(reference);
+        const next = now();
+        next.offset++;
+        if (settings.reference) {
+          settings.reference.call(
+            settings.referenceContext || void 0,
+            reference,
+            { start: previous, end: next },
+            value.slice(start - 1, end)
+          );
+        }
+        previous = next;
+      } else {
+        characters = value.slice(start - 1, end);
+        queue += characters;
+        column += characters.length;
+        index = end - 1;
+      }
+    } else {
+      if (character === 10) {
+        line++;
+        lines++;
+        column = 0;
+      }
+      if (Number.isNaN(character)) {
+        flush();
+      } else {
+        queue += String.fromCharCode(character);
+        column++;
+      }
+    }
+  }
+  return result.join("");
+  function now() {
+    return {
+      line,
+      column,
+      offset: index + ((point ? point.offset : 0) || 0)
+    };
+  }
+  function warning(code, offset) {
+    let position;
+    if (settings.warning) {
+      position = now();
+      position.column += offset;
+      position.offset += offset;
+      settings.warning.call(
+        settings.warningContext || void 0,
+        messages[code],
+        position,
+        code
+      );
+    }
+  }
+  function flush() {
+    if (queue) {
+      result.push(queue);
+      if (settings.text) {
+        settings.text.call(settings.textContext || void 0, queue, {
+          start: previous,
+          end: now()
+        });
+      }
+      queue = "";
+    }
+  }
+}
+function prohibited(code) {
+  return code >= 55296 && code <= 57343 || code > 1114111;
+}
+function disallowed(code) {
+  return code >= 1 && code <= 8 || code === 11 || code >= 13 && code <= 31 || code >= 127 && code <= 159 || code >= 64976 && code <= 65007 || (code & 65535) === 65535 || (code & 65535) === 65534;
+}
+
+// node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lib/prism-core.js
+var uniqueId = 0;
+var plainTextGrammar = {};
+var _ = {
+  /**
+   * 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(o) {
+      return Object.prototype.toString.call(o).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(obj) {
+      if (!obj["__id"]) {
+        Object.defineProperty(obj, "__id", { value: ++uniqueId });
+      }
+      return obj["__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 deepClone(o, visited) {
+      visited = visited || {};
+      var clone;
+      var id;
+      switch (_.util.type(o)) {
+        case "Object":
+          id = _.util.objId(o);
+          if (visited[id]) {
+            return visited[id];
+          }
+          clone = /** @type {Record<string, any>} */
+          {};
+          visited[id] = clone;
+          for (var key in o) {
+            if (o.hasOwnProperty(key)) {
+              clone[key] = deepClone(o[key], visited);
+            }
+          }
+          return (
+            /** @type {any} */
+            clone
+          );
+        case "Array":
+          id = _.util.objId(o);
+          if (visited[id]) {
+            return visited[id];
+          }
+          clone = [];
+          visited[id] = clone;
+          /** @type {any} */
+          o.forEach(
+            function(v, i) {
+              clone[i] = deepClone(v, visited);
+            }
+          );
+          return (
+            /** @type {any} */
+            clone
+          );
+        default:
+          return o;
+      }
+    }
+  },
+  /**
+   * 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: plainTextGrammar,
+    plaintext: plainTextGrammar,
+    text: plainTextGrammar,
+    txt: plainTextGrammar,
+    /**
+     * 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(id, redef) {
+      var lang = _.util.clone(_.languages[id]);
+      for (var key in redef) {
+        lang[key] = redef[key];
+      }
+      return lang;
+    },
+    /**
+     * 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(inside, before, insert, root) {
+      root = root || /** @type {any} */
+      _.languages;
+      var grammar = root[inside];
+      var ret = {};
+      for (var token in grammar) {
+        if (grammar.hasOwnProperty(token)) {
+          if (token == before) {
+            for (var newToken in insert) {
+              if (insert.hasOwnProperty(newToken)) {
+                ret[newToken] = insert[newToken];
+              }
+            }
+          }
+          if (!insert.hasOwnProperty(token)) {
+            ret[token] = grammar[token];
+          }
+        }
+      }
+      var old = root[inside];
+      root[inside] = ret;
+      _.languages.DFS(_.languages, function(key, value) {
+        if (value === old && key != inside) {
+          this[key] = ret;
+        }
+      });
+      return ret;
+    },
+    // Traverse a language definition with Depth First Search
+    DFS: function DFS(o, callback, type, visited) {
+      visited = visited || {};
+      var objId = _.util.objId;
+      for (var i in o) {
+        if (o.hasOwnProperty(i)) {
+          callback.call(o, i, o[i], type || i);
+          var property = o[i];
+          var propertyType = _.util.type(property);
+          if (propertyType === "Object" && !visited[objId(property)]) {
+            visited[objId(property)] = true;
+            DFS(property, callback, null, visited);
+          } else if (propertyType === "Array" && !visited[objId(property)]) {
+            visited[objId(property)] = true;
+            DFS(property, callback, i, visited);
+          }
+        }
+      }
+    }
+  },
+  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(text, grammar, language) {
+    var env = {
+      code: text,
+      grammar,
+      language
+    };
+    _.hooks.run("before-tokenize", env);
+    if (!env.grammar) {
+      throw new Error('The language "' + env.language + '" has no grammar.');
+    }
+    env.tokens = _.tokenize(env.code, env.grammar);
+    _.hooks.run("after-tokenize", env);
+    return Token.stringify(_.util.encode(env.tokens), env.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(text, grammar) {
+    var rest = grammar.rest;
+    if (rest) {
+      for (var token in rest) {
+        grammar[token] = rest[token];
+      }
+      delete grammar.rest;
+    }
+    var tokenList = new LinkedList();
+    addAfter(tokenList, tokenList.head, text);
+    matchGrammar(text, tokenList, grammar, tokenList.head, 0);
+    return toArray(tokenList);
+  },
+  /**
+   * @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(name, callback) {
+      var hooks = _.hooks.all;
+      hooks[name] = hooks[name] || [];
+      hooks[name].push(callback);
+    },
+    /**
+     * 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(name, env) {
+      var callbacks = _.hooks.all[name];
+      if (!callbacks || !callbacks.length) {
+        return;
+      }
+      for (var i = 0, callback; callback = callbacks[i++]; ) {
+        callback(env);
+      }
+    }
+  },
+  Token
+};
+function Token(type, content, alias2, matchedStr) {
+  this.type = type;
+  this.content = content;
+  this.alias = alias2;
+  this.length = (matchedStr || "").length | 0;
+}
+function matchPattern(pattern, pos, text, lookbehind) {
+  pattern.lastIndex = pos;
+  var match = pattern.exec(text);
+  if (match && lookbehind && match[1]) {
+    var lookbehindLength = match[1].length;
+    match.index += lookbehindLength;
+    match[0] = match[0].slice(lookbehindLength);
+  }
+  return match;
+}
+function matchGrammar(text, tokenList, grammar, startNode, startPos, rematch) {
+  for (var token in grammar) {
+    if (!grammar.hasOwnProperty(token) || !grammar[token]) {
+      continue;
+    }
+    var patterns = grammar[token];
+    patterns = Array.isArray(patterns) ? patterns : [patterns];
+    for (var j = 0; j < patterns.length; ++j) {
+      if (rematch && rematch.cause == token + "," + j) {
+        return;
+      }
+      var patternObj = patterns[j];
+      var inside = patternObj.inside;
+      var lookbehind = !!patternObj.lookbehind;
+      var greedy = !!patternObj.greedy;
+      var alias2 = patternObj.alias;
+      if (greedy && !patternObj.pattern.global) {
+        var flags = patternObj.pattern.toString().match(/[imsuy]*$/)[0];
+        patternObj.pattern = RegExp(patternObj.pattern.source, flags + "g");
+      }
+      var pattern = patternObj.pattern || patternObj;
+      for (var currentNode = startNode.next, pos = startPos; currentNode !== tokenList.tail; pos += currentNode.value.length, currentNode = currentNode.next) {
+        if (rematch && pos >= rematch.reach) {
+          break;
+        }
+        var str = currentNode.value;
+        if (tokenList.length > text.length) {
+          return;
+        }
+        if (str instanceof Token) {
+          continue;
+        }
+        var removeCount = 1;
+        var match;
+        if (greedy) {
+          match = matchPattern(pattern, pos, text, lookbehind);
+          if (!match || match.index >= text.length) {
+            break;
+          }
+          var from = match.index;
+          var to = match.index + match[0].length;
+          var p = pos;
+          p += currentNode.value.length;
+          while (from >= p) {
+            currentNode = currentNode.next;
+            p += currentNode.value.length;
+          }
+          p -= currentNode.value.length;
+          pos = p;
+          if (currentNode.value instanceof Token) {
+            continue;
+          }
+          for (var k = currentNode; k !== tokenList.tail && (p < to || typeof k.value === "string"); k = k.next) {
+            removeCount++;
+            p += k.value.length;
+          }
+          removeCount--;
+          str = text.slice(pos, p);
+          match.index -= pos;
+        } else {
+          match = matchPattern(pattern, 0, str, lookbehind);
+          if (!match) {
+            continue;
+          }
+        }
+        var from = match.index;
+        var matchStr = match[0];
+        var before = str.slice(0, from);
+        var after = str.slice(from + matchStr.length);
+        var reach = pos + str.length;
+        if (rematch && reach > rematch.reach) {
+          rematch.reach = reach;
+        }
+        var removeFrom = currentNode.prev;
+        if (before) {
+          removeFrom = addAfter(tokenList, removeFrom, before);
+          pos += before.length;
+        }
+        removeRange(tokenList, removeFrom, removeCount);
+        var wrapped = new Token(
+          token,
+          inside ? _.tokenize(matchStr, inside) : matchStr,
+          alias2,
+          matchStr
+        );
+        currentNode = addAfter(tokenList, removeFrom, wrapped);
+        if (after) {
+          addAfter(tokenList, currentNode, after);
+        }
+        if (removeCount > 1) {
+          var nestedRematch = {
+            cause: token + "," + j,
+            reach
+          };
+          matchGrammar(
+            text,
+            tokenList,
+            grammar,
+            currentNode.prev,
+            pos,
+            nestedRematch
+          );
+          if (rematch && nestedRematch.reach > rematch.reach) {
+            rematch.reach = nestedRematch.reach;
+          }
+        }
+      }
+    }
+  }
+}
+function LinkedList() {
+  var head = { value: null, prev: null, next: null };
+  var tail = { value: null, prev: head, next: null };
+  head.next = tail;
+  this.head = head;
+  this.tail = tail;
+  this.length = 0;
+}
+function addAfter(list, node, value) {
+  var next = node.next;
+  var newNode = { value, prev: node, next };
+  node.next = newNode;
+  next.prev = newNode;
+  list.length++;
+  return newNode;
+}
+function removeRange(list, node, count) {
+  var next = node.next;
+  for (var i = 0; i < count && next !== list.tail; i++) {
+    next = next.next;
+  }
+  node.next = next;
+  next.prev = node;
+  list.length -= i;
+}
+function toArray(list) {
+  var array = [];
+  var node = list.head.next;
+  while (node !== list.tail) {
+    array.push(node.value);
+    node = node.next;
+  }
+  return array;
+}
+var Prism = _;
+
+// node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lib/core.js
+function Refractor() {
+}
+Refractor.prototype = Prism;
+var refractor = new Refractor();
+refractor.highlight = highlight;
+refractor.register = register;
+refractor.alias = alias;
+refractor.registered = registered;
+refractor.listLanguages = listLanguages;
+refractor.util.encode = encode;
+refractor.Token.stringify = stringify;
+function highlight(value, language) {
+  if (typeof value !== "string") {
+    throw new TypeError("Expected `string` for `value`, got `" + value + "`");
+  }
+  let grammar;
+  let name;
+  if (language && typeof language === "object") {
+    grammar = language;
+  } else {
+    name = language;
+    if (typeof name !== "string") {
+      throw new TypeError("Expected `string` for `name`, got `" + name + "`");
+    }
+    if (Object.hasOwn(refractor.languages, name)) {
+      grammar = refractor.languages[name];
+    } else {
+      throw new Error("Unknown language: `" + name + "` is not registered");
+    }
+  }
+  return {
+    type: "root",
+    // @ts-expect-error: we hacked Prism to accept and return the things we want.
+    children: Prism.highlight.call(refractor, value, grammar, name)
+  };
+}
+function register(syntax) {
+  if (typeof syntax !== "function" || !syntax.displayName) {
+    throw new Error("Expected `function` for `syntax`, got `" + syntax + "`");
+  }
+  if (!Object.hasOwn(refractor.languages, syntax.displayName)) {
+    syntax(refractor);
+  }
+}
+function alias(language, alias2) {
+  const languages = refractor.languages;
+  let map = {};
+  if (typeof language === "string") {
+    if (alias2) {
+      map[language] = alias2;
+    }
+  } else {
+    map = language;
+  }
+  let key;
+  for (key in map) {
+    if (Object.hasOwn(map, key)) {
+      const value = map[key];
+      const list = typeof value === "string" ? [value] : value;
+      let index = -1;
+      while (++index < list.length) {
+        languages[list[index]] = languages[key];
+      }
+    }
+  }
+}
+function registered(aliasOrLanguage) {
+  if (typeof aliasOrLanguage !== "string") {
+    throw new TypeError(
+      "Expected `string` for `aliasOrLanguage`, got `" + aliasOrLanguage + "`"
+    );
+  }
+  return Object.hasOwn(refractor.languages, aliasOrLanguage);
+}
+function listLanguages() {
+  const languages = refractor.languages;
+  const list = [];
+  let language;
+  for (language in languages) {
+    if (Object.hasOwn(languages, language) && typeof languages[language] === "object") {
+      list.push(language);
+    }
+  }
+  return list;
+}
+function stringify(value, language) {
+  if (typeof value === "string") {
+    return { type: "text", value };
+  }
+  if (Array.isArray(value)) {
+    const result = [];
+    let index = -1;
+    while (++index < value.length) {
+      if (value[index] !== null && value[index] !== void 0 && value[index] !== "") {
+        result.push(
+          /** @type {Element | Text} */
+          stringify(value[index], language)
+        );
+      }
+    }
+    return result;
+  }
+  const env = {
+    attributes: {},
+    classes: ["token", value.type],
+    content: stringify(value.content, language),
+    language,
+    tag: "span",
+    type: value.type
+  };
+  if (value.alias) {
+    env.classes.push(
+      ...typeof value.alias === "string" ? [value.alias] : value.alias
+    );
+  }
+  refractor.hooks.run("wrap", env);
+  return h(
+    env.tag + "." + env.classes.join("."),
+    attributes(env.attributes),
+    env.content
+  );
+}
+function encode(tokens) {
+  return tokens;
+}
+function attributes(record) {
+  let key;
+  for (key in record) {
+    if (Object.hasOwn(record, key)) {
+      record[key] = parseEntities(record[key]);
+    }
+  }
+  return record;
+}
+
+export {
+  refractor
+};