@epilot/zenith-react 0.1.0-next.0

package/dist/vendor/.bun/refractor@5.0.0/vendor/refractor/lang/markdown.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown.js","sources":["../../../../../../../../../node_modules/.bun/refractor@5.0.0/node_modules/refractor/lang/markdown.js"],"sourcesContent":["// @ts-nocheck\n/**\n * @import {Refractor} from '../lib/core.js'\n */\nimport refractorMarkup from './markup.js'\nmarkdown.displayName = 'markdown'\nmarkdown.aliases = ['md']\n\n/** @param {Refractor} Prism */\nexport default function markdown(Prism) {\n  Prism.register(refractorMarkup)\n  ;(function (Prism) {\n    // Allow only one line break\n    var inner = /(?:\\\\.|[^\\\\\\n\\r]|(?:\\n|\\r\\n?)(?![\\r\\n]))/.source\n\n    /**\n     * This function is intended for the creation of the bold or italic pattern.\n     *\n     * This also adds a lookbehind group to the given pattern to ensure that the pattern is not backslash-escaped.\n     *\n     * _Note:_ Keep in mind that this adds a capturing group.\n     *\n     * @param {string} pattern\n     * @returns {RegExp}\n     */\n    function createInline(pattern) {\n      pattern = pattern.replace(/<inner>/g, function () {\n        return inner\n      })\n      return RegExp(/((?:^|[^\\\\])(?:\\\\{2})*)/.source + '(?:' + pattern + ')')\n    }\n    var tableCell = /(?:\\\\.|``(?:[^`\\r\\n]|`(?!`))+``|`[^`\\r\\n]+`|[^\\\\|\\r\\n`])+/\n      .source\n    var tableRow =\n      /\\|?__(?:\\|__)+\\|?(?:(?:\\n|\\r\\n?)|(?![\\s\\S]))/.source.replace(\n        /__/g,\n        function () {\n          return tableCell\n        }\n      )\n    var tableLine =\n      /\\|?[ \\t]*:?-{3,}:?[ \\t]*(?:\\|[ \\t]*:?-{3,}:?[ \\t]*)+\\|?(?:\\n|\\r\\n?)/\n        .source\n    Prism.languages.markdown = Prism.languages.extend('markup', {})\n    Prism.languages.insertBefore('markdown', 'prolog', {\n      'front-matter-block': {\n        pattern: /(^(?:\\s*[\\r\\n])?)---(?!.)[\\s\\S]*?[\\r\\n]---(?!.)/,\n        lookbehind: true,\n        greedy: true,\n        inside: {\n          punctuation: /^---|---$/,\n          'front-matter': {\n            pattern: /\\S+(?:\\s+\\S+)*/,\n            alias: ['yaml', 'language-yaml'],\n            inside: Prism.languages.yaml\n          }\n        }\n      },\n      blockquote: {\n        // > ...\n        pattern: /^>(?:[\\t ]*>)*/m,\n        alias: 'punctuation'\n      },\n      table: {\n        pattern: RegExp(\n          '^' + tableRow + tableLine + '(?:' + tableRow + ')*',\n          'm'\n        ),\n        inside: {\n          'table-data-rows': {\n            pattern: RegExp(\n              '^(' + tableRow + tableLine + ')(?:' + tableRow + ')*$'\n            ),\n            lookbehind: true,\n            inside: {\n              'table-data': {\n                pattern: RegExp(tableCell),\n                inside: Prism.languages.markdown\n              },\n              punctuation: /\\|/\n            }\n          },\n          'table-line': {\n            pattern: RegExp('^(' + tableRow + ')' + tableLine + '$'),\n            lookbehind: true,\n            inside: {\n              punctuation: /\\||:?-{3,}:?/\n            }\n          },\n          'table-header-row': {\n            pattern: RegExp('^' + tableRow + '$'),\n            inside: {\n              'table-header': {\n                pattern: RegExp(tableCell),\n                alias: 'important',\n                inside: Prism.languages.markdown\n              },\n              punctuation: /\\|/\n            }\n          }\n        }\n      },\n      code: [\n        {\n          // Prefixed by 4 spaces or 1 tab and preceded by an empty line\n          pattern:\n            /((?:^|\\n)[ \\t]*\\n|(?:^|\\r\\n?)[ \\t]*\\r\\n?)(?: {4}|\\t).+(?:(?:\\n|\\r\\n?)(?: {4}|\\t).+)*/,\n          lookbehind: true,\n          alias: 'keyword'\n        },\n        {\n          // ```optional language\n          // code block\n          // ```\n          pattern: /^```[\\s\\S]*?^```$/m,\n          greedy: true,\n          inside: {\n            'code-block': {\n              pattern: /^(```.*(?:\\n|\\r\\n?))[\\s\\S]+?(?=(?:\\n|\\r\\n?)^```$)/m,\n              lookbehind: true\n            },\n            'code-language': {\n              pattern: /^(```).+/,\n              lookbehind: true\n            },\n            punctuation: /```/\n          }\n        }\n      ],\n      title: [\n        {\n          // title 1\n          // =======\n\n          // title 2\n          // -------\n          pattern: /\\S.*(?:\\n|\\r\\n?)(?:==+|--+)(?=[ \\t]*$)/m,\n          alias: 'important',\n          inside: {\n            punctuation: /==+$|--+$/\n          }\n        },\n        {\n          // # title 1\n          // ###### title 6\n          pattern: /(^\\s*)#.+/m,\n          lookbehind: true,\n          alias: 'important',\n          inside: {\n            punctuation: /^#+|#+$/\n          }\n        }\n      ],\n      hr: {\n        // ***\n        // ---\n        // * * *\n        // -----------\n        pattern: /(^\\s*)([*-])(?:[\\t ]*\\2){2,}(?=\\s*$)/m,\n        lookbehind: true,\n        alias: 'punctuation'\n      },\n      list: {\n        // * item\n        // + item\n        // - item\n        // 1. item\n        pattern: /(^\\s*)(?:[*+-]|\\d+\\.)(?=[\\t ].)/m,\n        lookbehind: true,\n        alias: 'punctuation'\n      },\n      'url-reference': {\n        // [id]: http://example.com \"Optional title\"\n        // [id]: http://example.com 'Optional title'\n        // [id]: http://example.com (Optional title)\n        // [id]: <http://example.com> \"Optional title\"\n        pattern:\n          /!?\\[[^\\]]+\\]:[\\t ]+(?:\\S+|<(?:\\\\.|[^>\\\\])+>)(?:[\\t ]+(?:\"(?:\\\\.|[^\"\\\\])*\"|'(?:\\\\.|[^'\\\\])*'|\\((?:\\\\.|[^)\\\\])*\\)))?/,\n        inside: {\n          variable: {\n            pattern: /^(!?\\[)[^\\]]+/,\n            lookbehind: true\n          },\n          string:\n            /(?:\"(?:\\\\.|[^\"\\\\])*\"|'(?:\\\\.|[^'\\\\])*'|\\((?:\\\\.|[^)\\\\])*\\))$/,\n          punctuation: /^[\\[\\]!:]|[<>]/\n        },\n        alias: 'url'\n      },\n      bold: {\n        // **strong**\n        // __strong__\n\n        // allow one nested instance of italic text using the same delimiter\n        pattern: createInline(\n          /\\b__(?:(?!_)<inner>|_(?:(?!_)<inner>)+_)+__\\b|\\*\\*(?:(?!\\*)<inner>|\\*(?:(?!\\*)<inner>)+\\*)+\\*\\*/\n            .source\n        ),\n        lookbehind: true,\n        greedy: true,\n        inside: {\n          content: {\n            pattern: /(^..)[\\s\\S]+(?=..$)/,\n            lookbehind: true,\n            inside: {} // see below\n          },\n          punctuation: /\\*\\*|__/\n        }\n      },\n      italic: {\n        // *em*\n        // _em_\n\n        // allow one nested instance of bold text using the same delimiter\n        pattern: createInline(\n          /\\b_(?:(?!_)<inner>|__(?:(?!_)<inner>)+__)+_\\b|\\*(?:(?!\\*)<inner>|\\*\\*(?:(?!\\*)<inner>)+\\*\\*)+\\*/\n            .source\n        ),\n        lookbehind: true,\n        greedy: true,\n        inside: {\n          content: {\n            pattern: /(^.)[\\s\\S]+(?=.$)/,\n            lookbehind: true,\n            inside: {} // see below\n          },\n          punctuation: /[*_]/\n        }\n      },\n      strike: {\n        // ~~strike through~~\n        // ~strike~\n        // eslint-disable-next-line regexp/strict\n        pattern: createInline(/(~~?)(?:(?!~)<inner>)+\\2/.source),\n        lookbehind: true,\n        greedy: true,\n        inside: {\n          content: {\n            pattern: /(^~~?)[\\s\\S]+(?=\\1$)/,\n            lookbehind: true,\n            inside: {} // see below\n          },\n          punctuation: /~~?/\n        }\n      },\n      'code-snippet': {\n        // `code`\n        // ``code``\n        pattern:\n          /(^|[^\\\\`])(?:``[^`\\r\\n]+(?:`[^`\\r\\n]+)*``(?!`)|`[^`\\r\\n]+`(?!`))/,\n        lookbehind: true,\n        greedy: true,\n        alias: ['code', 'keyword']\n      },\n      url: {\n        // [example](http://example.com \"Optional title\")\n        // [example][id]\n        // [example] [id]\n        pattern: createInline(\n          /!?\\[(?:(?!\\])<inner>)+\\](?:\\([^\\s)]+(?:[\\t ]+\"(?:\\\\.|[^\"\\\\])*\")?\\)|[ \\t]?\\[(?:(?!\\])<inner>)+\\])/\n            .source\n        ),\n        lookbehind: true,\n        greedy: true,\n        inside: {\n          operator: /^!/,\n          content: {\n            pattern: /(^\\[)[^\\]]+(?=\\])/,\n            lookbehind: true,\n            inside: {} // see below\n          },\n          variable: {\n            pattern: /(^\\][ \\t]?\\[)[^\\]]+(?=\\]$)/,\n            lookbehind: true\n          },\n          url: {\n            pattern: /(^\\]\\()[^\\s)]+/,\n            lookbehind: true\n          },\n          string: {\n            pattern: /(^[ \\t]+)\"(?:\\\\.|[^\"\\\\])*\"(?=\\)$)/,\n            lookbehind: true\n          }\n        }\n      }\n    })\n    ;['url', 'bold', 'italic', 'strike'].forEach(function (token) {\n      ;['url', 'bold', 'italic', 'strike', 'code-snippet'].forEach(\n        function (inside) {\n          if (token !== inside) {\n            Prism.languages.markdown[token].inside.content.inside[inside] =\n              Prism.languages.markdown[inside]\n          }\n        }\n      )\n    })\n    Prism.hooks.add('after-tokenize', function (env) {\n      if (env.language !== 'markdown' && env.language !== 'md') {\n        return\n      }\n      function walkTokens(tokens) {\n        if (!tokens || typeof tokens === 'string') {\n          return\n        }\n        for (var i = 0, l = tokens.length; i < l; i++) {\n          var token = tokens[i]\n          if (token.type !== 'code') {\n            walkTokens(token.content)\n            continue\n          }\n\n          /*\n           * Add the correct `language-xxxx` class to this code block. Keep in mind that the `code-language` token\n           * is optional. But the grammar is defined so that there is only one case we have to handle:\n           *\n           * token.content = [\n           *     <span class=\"punctuation\">```</span>,\n           *     <span class=\"code-language\">xxxx</span>,\n           *     '\\n', // exactly one new lines (\\r or \\n or \\r\\n)\n           *     <span class=\"code-block\">...</span>,\n           *     '\\n', // exactly one new lines again\n           *     <span class=\"punctuation\">```</span>\n           * ];\n           */\n\n          var codeLang = token.content[1]\n          var codeBlock = token.content[3]\n          if (\n            codeLang &&\n            codeBlock &&\n            codeLang.type === 'code-language' &&\n            codeBlock.type === 'code-block' &&\n            typeof codeLang.content === 'string'\n          ) {\n            // this might be a language that Prism does not support\n\n            // do some replacements to support C++, C#, and F#\n            var lang = codeLang.content\n              .replace(/\\b#/g, 'sharp')\n              .replace(/\\b\\+\\+/g, 'pp')\n            // only use the first word\n            lang = (/[a-z][\\w-]*/i.exec(lang) || [''])[0].toLowerCase()\n            var alias = 'language-' + lang\n\n            // add alias\n            if (!codeBlock.alias) {\n              codeBlock.alias = [alias]\n            } else if (typeof codeBlock.alias === 'string') {\n              codeBlock.alias = [codeBlock.alias, alias]\n            } else {\n              codeBlock.alias.push(alias)\n            }\n          }\n        }\n      }\n      walkTokens(env.tokens)\n    })\n    Prism.hooks.add('wrap', function (env) {\n      if (env.type !== 'code-block') {\n        return\n      }\n      var codeLang = ''\n      for (var i = 0, l = env.classes.length; i < l; i++) {\n        var cls = env.classes[i]\n        var match = /language-(.+)/.exec(cls)\n        if (match) {\n          codeLang = match[1]\n          break\n        }\n      }\n      var grammar = Prism.languages[codeLang]\n      if (!grammar) {\n        if (codeLang && codeLang !== 'none' && Prism.plugins.autoloader) {\n          var id =\n            'md-' +\n            new Date().valueOf() +\n            '-' +\n            Math.floor(Math.random() * 1e16)\n          env.attributes['id'] = id\n          Prism.plugins.autoloader.loadLanguages(codeLang, function () {\n            var ele = document.getElementById(id)\n            if (ele) {\n              ele.innerHTML = Prism.highlight(\n                ele.textContent,\n                Prism.languages[codeLang],\n                codeLang\n              )\n            }\n          })\n        }\n      } else {\n        env.content = Prism.highlight(env.content.value, grammar, codeLang)\n      }\n    })\n    var tagPattern = RegExp(Prism.languages.markup.tag.pattern.source, 'gi')\n\n    /**\n     * A list of known entity names.\n     *\n     * This will always be incomplete to save space. The current list is the one used by lowdash's unescape function.\n     *\n     * @see {@link https://github.com/lodash/lodash/blob/2da024c3b4f9947a48517639de7560457cd4ec6c/unescape.js#L2}\n     */\n    var KNOWN_ENTITY_NAMES = {\n      amp: '&',\n      lt: '<',\n      gt: '>',\n      quot: '\"'\n    }\n\n    // IE 11 doesn't support `String.fromCodePoint`\n    var fromCodePoint = String.fromCodePoint || String.fromCharCode\n\n    /**\n     * Returns the text content of a given HTML source code string.\n     *\n     * @param {string} html\n     * @returns {string}\n     */\n    function textContent(html) {\n      // remove all tags\n      var text = html.replace(tagPattern, '')\n\n      // decode known entities\n      text = text.replace(/&(\\w{1,8}|#x?[\\da-f]{1,8});/gi, function (m, code) {\n        code = code.toLowerCase()\n        if (code[0] === '#') {\n          var value\n          if (code[1] === 'x') {\n            value = parseInt(code.slice(2), 16)\n          } else {\n            value = Number(code.slice(1))\n          }\n          return fromCodePoint(value)\n        } else {\n          var known = KNOWN_ENTITY_NAMES[code]\n          if (known) {\n            return known\n          }\n\n          // unable to decode\n          return m\n        }\n      })\n      return text\n    }\n    Prism.languages.md = Prism.languages.markdown\n  })(Prism)\n}\n"],"names":["markdown","Prism","refractorMarkup","inner","createInline","pattern","tableCell","tableRow","tableLine","token","inside","env","walkTokens","tokens","i","l","codeLang","codeBlock","lang","alias","cls","match","grammar","id","ele"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/vendor/.bun/refractor@5.0.0/vendor/refractor/lang/markup.js

@@ -0,0 +1,175 @@
+l.displayName = "markup";
+l.aliases = ["atom", "html", "mathml", "rss", "ssml", "svg", "xml"];
+function l(e) {
+  e.languages.markup = {
+    comment: {
+      pattern: /<!--(?:(?!<!--)[\s\S])*?-->/,
+      greedy: !0
+    },
+    prolog: {
+      pattern: /<\?[\s\S]+?\?>/,
+      greedy: !0
+    },
+    doctype: {
+      // https://www.w3.org/TR/xml/#NT-doctypedecl
+      pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i,
+      greedy: !0,
+      inside: {
+        "internal-subset": {
+          pattern: /(^[^\[]*\[)[\s\S]+(?=\]>$)/,
+          lookbehind: !0,
+          greedy: !0,
+          inside: null
+          // see below
+        },
+        string: {
+          pattern: /"[^"]*"|'[^']*'/,
+          greedy: !0
+        },
+        punctuation: /^<!|>$|[[\]]/,
+        "doctype-tag": /^DOCTYPE/i,
+        name: /[^\s<>'"]+/
+      }
+    },
+    cdata: {
+      pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+      greedy: !0
+    },
+    tag: {
+      pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/,
+      greedy: !0,
+      inside: {
+        tag: {
+          pattern: /^<\/?[^\s>\/]+/,
+          inside: {
+            punctuation: /^<\/?/,
+            namespace: /^[^\s>\/:]+:/
+          }
+        },
+        "special-attr": [],
+        "attr-value": {
+          pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
+          inside: {
+            punctuation: [
+              {
+                pattern: /^=/,
+                alias: "attr-equals"
+              },
+              {
+                pattern: /^(\s*)["']|["']$/,
+                lookbehind: !0
+              }
+            ]
+          }
+        },
+        punctuation: /\/?>/,
+        "attr-name": {
+          pattern: /[^\s>\/]+/,
+          inside: {
+            namespace: /^[^\s>\/:]+:/
+          }
+        }
+      }
+    },
+    entity: [
+      {
+        pattern: /&[\da-z]{1,8};/i,
+        alias: "named-entity"
+      },
+      /&#x?[\da-f]{1,8};/i
+    ]
+  }, e.languages.markup.tag.inside["attr-value"].inside.entity = e.languages.markup.entity, e.languages.markup.doctype.inside["internal-subset"].inside = e.languages.markup, e.hooks.add("wrap", function(a) {
+    a.type === "entity" && (a.attributes.title = a.content.value.replace(/&amp;/, "&"));
+  }), Object.defineProperty(e.languages.markup.tag, "addInlined", {
+    /**
+     * Adds an inlined language to markup.
+     *
+     * An example of an inlined language is CSS with `<style>` tags.
+     *
+     * @param {string} tagName The name of the tag that contains the inlined language. This name will be treated as
+     * case insensitive.
+     * @param {string} lang The language key.
+     * @example
+     * addInlined('style', 'css');
+     */
+    value: function(t, n) {
+      var u = {};
+      u["language-" + n] = {
+        pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
+        lookbehind: !0,
+        inside: e.languages[n]
+      }, u.cdata = /^<!\[CDATA\[|\]\]>$/i;
+      var s = {
+        "included-cdata": {
+          pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
+          inside: u
+        }
+      };
+      s["language-" + n] = {
+        pattern: /[\s\S]+/,
+        inside: e.languages[n]
+      };
+      var g = {};
+      g[t] = {
+        pattern: RegExp(
+          /(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(
+            /__/g,
+            function() {
+              return t;
+            }
+          ),
+          "i"
+        ),
+        lookbehind: !0,
+        greedy: !0,
+        inside: s
+      }, e.languages.insertBefore("markup", "cdata", g);
+    }
+  }), Object.defineProperty(e.languages.markup.tag, "addAttribute", {
+    /**
+     * Adds an pattern to highlight languages embedded in HTML attributes.
+     *
+     * An example of an inlined language is CSS with `style` attributes.
+     *
+     * @param {string} attrName The name of the tag that contains the inlined language. This name will be treated as
+     * case insensitive.
+     * @param {string} lang The language key.
+     * @example
+     * addAttribute('style', 'css');
+     */
+    value: function(a, t) {
+      e.languages.markup.tag.inside["special-attr"].push({
+        pattern: RegExp(
+          /(^|["'\s])/.source + "(?:" + a + ")" + /\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))/.source,
+          "i"
+        ),
+        lookbehind: !0,
+        inside: {
+          "attr-name": /^[^\s=]+/,
+          "attr-value": {
+            pattern: /=[\s\S]+/,
+            inside: {
+              value: {
+                pattern: /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/,
+                lookbehind: !0,
+                alias: [t, "language-" + t],
+                inside: e.languages[t]
+              },
+              punctuation: [
+                {
+                  pattern: /^=/,
+                  alias: "attr-equals"
+                },
+                /"|'/
+              ]
+            }
+          }
+        }
+      });
+    }
+  }), e.languages.html = e.languages.markup, e.languages.mathml = e.languages.markup, e.languages.svg = e.languages.markup, e.languages.xml = e.languages.extend("markup", {}), e.languages.ssml = e.languages.xml, e.languages.atom = e.languages.xml, e.languages.rss = e.languages.xml;
+}
+export {
+  l as default
+};
+//# sourceMappingURL=markup.js.map

package/dist/vendor/.bun/refractor@5.0.0/vendor/refractor/lang/markup.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"markup.js","sources":["../../../../../../../../../node_modules/.bun/refractor@5.0.0/node_modules/refractor/lang/markup.js"],"sourcesContent":["// @ts-nocheck\n/**\n * @import {Refractor} from '../lib/core.js'\n */\nmarkup.displayName = 'markup'\nmarkup.aliases = ['atom', 'html', 'mathml', 'rss', 'ssml', 'svg', 'xml']\n\n/** @param {Refractor} Prism */\nexport default function markup(Prism) {\n  Prism.languages.markup = {\n    comment: {\n      pattern: /<!--(?:(?!<!--)[\\s\\S])*?-->/,\n      greedy: true\n    },\n    prolog: {\n      pattern: /<\\?[\\s\\S]+?\\?>/,\n      greedy: true\n    },\n    doctype: {\n      // https://www.w3.org/TR/xml/#NT-doctypedecl\n      pattern:\n        /<!DOCTYPE(?:[^>\"'[\\]]|\"[^\"]*\"|'[^']*')+(?:\\[(?:[^<\"'\\]]|\"[^\"]*\"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\\]\\s*)?>/i,\n      greedy: true,\n      inside: {\n        'internal-subset': {\n          pattern: /(^[^\\[]*\\[)[\\s\\S]+(?=\\]>$)/,\n          lookbehind: true,\n          greedy: true,\n          inside: null // see below\n        },\n        string: {\n          pattern: /\"[^\"]*\"|'[^']*'/,\n          greedy: true\n        },\n        punctuation: /^<!|>$|[[\\]]/,\n        'doctype-tag': /^DOCTYPE/i,\n        name: /[^\\s<>'\"]+/\n      }\n    },\n    cdata: {\n      pattern: /<!\\[CDATA\\[[\\s\\S]*?\\]\\]>/i,\n      greedy: true\n    },\n    tag: {\n      pattern:\n        /<\\/?(?!\\d)[^\\s>\\/=$<%]+(?:\\s(?:\\s*[^\\s>\\/=]+(?:\\s*=\\s*(?:\"[^\"]*\"|'[^']*'|[^\\s'\">=]+(?=[\\s>]))|(?=[\\s/>])))+)?\\s*\\/?>/,\n      greedy: true,\n      inside: {\n        tag: {\n          pattern: /^<\\/?[^\\s>\\/]+/,\n          inside: {\n            punctuation: /^<\\/?/,\n            namespace: /^[^\\s>\\/:]+:/\n          }\n        },\n        'special-attr': [],\n        'attr-value': {\n          pattern: /=\\s*(?:\"[^\"]*\"|'[^']*'|[^\\s'\">=]+)/,\n          inside: {\n            punctuation: [\n              {\n                pattern: /^=/,\n                alias: 'attr-equals'\n              },\n              {\n                pattern: /^(\\s*)[\"']|[\"']$/,\n                lookbehind: true\n              }\n            ]\n          }\n        },\n        punctuation: /\\/?>/,\n        'attr-name': {\n          pattern: /[^\\s>\\/]+/,\n          inside: {\n            namespace: /^[^\\s>\\/:]+:/\n          }\n        }\n      }\n    },\n    entity: [\n      {\n        pattern: /&[\\da-z]{1,8};/i,\n        alias: 'named-entity'\n      },\n      /&#x?[\\da-f]{1,8};/i\n    ]\n  }\n  Prism.languages.markup['tag'].inside['attr-value'].inside['entity'] =\n    Prism.languages.markup['entity']\n  Prism.languages.markup['doctype'].inside['internal-subset'].inside =\n    Prism.languages.markup\n\n  // Plugin to make entity title show the real entity, idea by Roman Komarov\n  Prism.hooks.add('wrap', function (env) {\n    if (env.type === 'entity') {\n      env.attributes['title'] = env.content.value.replace(/&amp;/, '&')\n    }\n  })\n  Object.defineProperty(Prism.languages.markup.tag, 'addInlined', {\n    /**\n     * Adds an inlined language to markup.\n     *\n     * An example of an inlined language is CSS with `<style>` tags.\n     *\n     * @param {string} tagName The name of the tag that contains the inlined language. This name will be treated as\n     * case insensitive.\n     * @param {string} lang The language key.\n     * @example\n     * addInlined('style', 'css');\n     */\n    value: function addInlined(tagName, lang) {\n      var includedCdataInside = {}\n      includedCdataInside['language-' + lang] = {\n        pattern: /(^<!\\[CDATA\\[)[\\s\\S]+?(?=\\]\\]>$)/i,\n        lookbehind: true,\n        inside: Prism.languages[lang]\n      }\n      includedCdataInside['cdata'] = /^<!\\[CDATA\\[|\\]\\]>$/i\n      var inside = {\n        'included-cdata': {\n          pattern: /<!\\[CDATA\\[[\\s\\S]*?\\]\\]>/i,\n          inside: includedCdataInside\n        }\n      }\n      inside['language-' + lang] = {\n        pattern: /[\\s\\S]+/,\n        inside: Prism.languages[lang]\n      }\n      var def = {}\n      def[tagName] = {\n        pattern: RegExp(\n          /(<__[^>]*>)(?:<!\\[CDATA\\[(?:[^\\]]|\\](?!\\]>))*\\]\\]>|(?!<!\\[CDATA\\[)[\\s\\S])*?(?=<\\/__>)/.source.replace(\n            /__/g,\n            function () {\n              return tagName\n            }\n          ),\n          'i'\n        ),\n        lookbehind: true,\n        greedy: true,\n        inside: inside\n      }\n      Prism.languages.insertBefore('markup', 'cdata', def)\n    }\n  })\n  Object.defineProperty(Prism.languages.markup.tag, 'addAttribute', {\n    /**\n     * Adds an pattern to highlight languages embedded in HTML attributes.\n     *\n     * An example of an inlined language is CSS with `style` attributes.\n     *\n     * @param {string} attrName The name of the tag that contains the inlined language. This name will be treated as\n     * case insensitive.\n     * @param {string} lang The language key.\n     * @example\n     * addAttribute('style', 'css');\n     */\n    value: function (attrName, lang) {\n      Prism.languages.markup.tag.inside['special-attr'].push({\n        pattern: RegExp(\n          /(^|[\"'\\s])/.source +\n            '(?:' +\n            attrName +\n            ')' +\n            /\\s*=\\s*(?:\"[^\"]*\"|'[^']*'|[^\\s'\">=]+(?=[\\s>]))/.source,\n          'i'\n        ),\n        lookbehind: true,\n        inside: {\n          'attr-name': /^[^\\s=]+/,\n          'attr-value': {\n            pattern: /=[\\s\\S]+/,\n            inside: {\n              value: {\n                pattern: /(^=\\s*([\"']|(?![\"'])))\\S[\\s\\S]*(?=\\2$)/,\n                lookbehind: true,\n                alias: [lang, 'language-' + lang],\n                inside: Prism.languages[lang]\n              },\n              punctuation: [\n                {\n                  pattern: /^=/,\n                  alias: 'attr-equals'\n                },\n                /\"|'/\n              ]\n            }\n          }\n        }\n      })\n    }\n  })\n  Prism.languages.html = Prism.languages.markup\n  Prism.languages.mathml = Prism.languages.markup\n  Prism.languages.svg = Prism.languages.markup\n  Prism.languages.xml = Prism.languages.extend('markup', {})\n  Prism.languages.ssml = Prism.languages.xml\n  Prism.languages.atom = Prism.languages.xml\n  Prism.languages.rss = Prism.languages.xml\n}\n"],"names":["markup","Prism","env","tagName","lang","includedCdataInside","inside","def","attrName"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/vendor/.bun/refractor@5.0.0/vendor/refractor/lang/tsx.js

@@ -0,0 +1,19 @@
+import l from "./jsx.js";
+import p from "./typescript.js";
+g.displayName = "tsx";
+g.aliases = [];
+function g(a) {
+  a.register(l), a.register(p), (function(e) {
+    var s = e.util.clone(e.languages.typescript);
+    e.languages.tsx = e.languages.extend("jsx", s), delete e.languages.tsx.parameter, delete e.languages.tsx["literal-property"];
+    var t = e.languages.tsx.tag;
+    t.pattern = RegExp(
+      /(^|[^\w$]|(?=<\/))/.source + "(?:" + t.pattern.source + ")",
+      t.pattern.flags
+    ), t.lookbehind = !0;
+  })(a);
+}
+export {
+  g as default
+};
+//# sourceMappingURL=tsx.js.map

package/dist/vendor/.bun/refractor@5.0.0/vendor/refractor/lang/tsx.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tsx.js","sources":["../../../../../../../../../node_modules/.bun/refractor@5.0.0/node_modules/refractor/lang/tsx.js"],"sourcesContent":["// @ts-nocheck\n/**\n * @import {Refractor} from '../lib/core.js'\n */\nimport refractorJsx from './jsx.js'\nimport refractorTypescript from './typescript.js'\ntsx.displayName = 'tsx'\ntsx.aliases = []\n\n/** @param {Refractor} Prism */\nexport default function tsx(Prism) {\n  Prism.register(refractorJsx)\n  Prism.register(refractorTypescript)\n  ;(function (Prism) {\n    var typescript = Prism.util.clone(Prism.languages.typescript)\n    Prism.languages.tsx = Prism.languages.extend('jsx', typescript)\n\n    // doesn't work with TS because TS is too complex\n    delete Prism.languages.tsx['parameter']\n    delete Prism.languages.tsx['literal-property']\n\n    // This will prevent collisions between TSX tags and TS generic types.\n    // Idea by https://github.com/karlhorky\n    // Discussion: https://github.com/PrismJS/prism/issues/2594#issuecomment-710666928\n    var tag = Prism.languages.tsx.tag\n    tag.pattern = RegExp(\n      /(^|[^\\w$]|(?=<\\/))/.source + '(?:' + tag.pattern.source + ')',\n      tag.pattern.flags\n    )\n    tag.lookbehind = true\n  })(Prism)\n}\n"],"names":["tsx","Prism","refractorJsx","refractorTypescript","typescript","tag"],"mappings":";;AAMAA,EAAI,cAAc;AAClBA,EAAI,UAAU,CAAA;AAGC,SAASA,EAAIC,GAAO;AACjC,EAAAA,EAAM,SAASC,CAAY,GAC3BD,EAAM,SAASE,CAAmB,IAChC,SAAUF,GAAO;AACjB,QAAIG,IAAaH,EAAM,KAAK,MAAMA,EAAM,UAAU,UAAU;AAC5D,IAAAA,EAAM,UAAU,MAAMA,EAAM,UAAU,OAAO,OAAOG,CAAU,GAG9D,OAAOH,EAAM,UAAU,IAAI,WAC3B,OAAOA,EAAM,UAAU,IAAI,kBAAkB;AAK7C,QAAII,IAAMJ,EAAM,UAAU,IAAI;AAC9B,IAAAI,EAAI,UAAU;AAAA,MACZ,qBAAqB,SAAS,QAAQA,EAAI,QAAQ,SAAS;AAAA,MAC3DA,EAAI,QAAQ;AAAA,IAClB,GACIA,EAAI,aAAa;AAAA,EACnB,GAAGJ,CAAK;AACV;","x_google_ignoreList":[0]}

package/dist/vendor/.bun/refractor@5.0.0/vendor/refractor/lang/typescript.js

@@ -0,0 +1,54 @@
+import s from "./javascript.js";
+n.displayName = "typescript";
+n.aliases = ["ts"];
+function n(a) {
+  a.register(s), (function(e) {
+    e.languages.typescript = e.languages.extend("javascript", {
+      "class-name": {
+        pattern: /(\b(?:class|extends|implements|instanceof|interface|new|type)\s+)(?!keyof\b)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?:\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>)?/,
+        lookbehind: !0,
+        greedy: !0,
+        inside: null
+        // see below
+      },
+      builtin: /\b(?:Array|Function|Promise|any|boolean|console|never|number|string|symbol|unknown)\b/
+    }), e.languages.typescript.keyword.push(
+      /\b(?:abstract|declare|is|keyof|readonly|require)\b/,
+      // keywords that have to be followed by an identifier
+      /\b(?:asserts|infer|interface|module|namespace|type)\b(?=\s*(?:[{_$a-zA-Z\xA0-\uFFFF]|$))/,
+      // This is for `import type *, {}`
+      /\btype\b(?=\s*(?:[\{*]|$))/
+    ), delete e.languages.typescript.parameter, delete e.languages.typescript["literal-property"];
+    var t = e.languages.extend("typescript", {});
+    delete t["class-name"], e.languages.typescript["class-name"].inside = t, e.languages.insertBefore("typescript", "function", {
+      decorator: {
+        pattern: /@[$\w\xA0-\uFFFF]+/,
+        inside: {
+          at: {
+            pattern: /^@/,
+            alias: "operator"
+          },
+          function: /^[\s\S]+/
+        }
+      },
+      "generic-function": {
+        // e.g. foo<T extends "bar" | "baz">( ...
+        pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>(?=\s*\()/,
+        greedy: !0,
+        inside: {
+          function: /^#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/,
+          generic: {
+            pattern: /<[\s\S]+/,
+            // everything after the first <
+            alias: "class-name",
+            inside: t
+          }
+        }
+      }
+    }), e.languages.ts = e.languages.typescript;
+  })(a);
+}
+export {
+  n as default
+};
+//# sourceMappingURL=typescript.js.map

package/dist/vendor/.bun/refractor@5.0.0/vendor/refractor/lang/typescript.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescript.js","sources":["../../../../../../../../../node_modules/.bun/refractor@5.0.0/node_modules/refractor/lang/typescript.js"],"sourcesContent":["// @ts-nocheck\n/**\n * @import {Refractor} from '../lib/core.js'\n */\nimport refractorJavascript from './javascript.js'\ntypescript.displayName = 'typescript'\ntypescript.aliases = ['ts']\n\n/** @param {Refractor} Prism */\nexport default function typescript(Prism) {\n  Prism.register(refractorJavascript)\n  ;(function (Prism) {\n    Prism.languages.typescript = Prism.languages.extend('javascript', {\n      'class-name': {\n        pattern:\n          /(\\b(?:class|extends|implements|instanceof|interface|new|type)\\s+)(?!keyof\\b)(?!\\s)[_$a-zA-Z\\xA0-\\uFFFF](?:(?!\\s)[$\\w\\xA0-\\uFFFF])*(?:\\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>)?/,\n        lookbehind: true,\n        greedy: true,\n        inside: null // see below\n      },\n      builtin:\n        /\\b(?:Array|Function|Promise|any|boolean|console|never|number|string|symbol|unknown)\\b/\n    })\n\n    // The keywords TypeScript adds to JavaScript\n    Prism.languages.typescript.keyword.push(\n      /\\b(?:abstract|declare|is|keyof|readonly|require)\\b/,\n      // keywords that have to be followed by an identifier\n      /\\b(?:asserts|infer|interface|module|namespace|type)\\b(?=\\s*(?:[{_$a-zA-Z\\xA0-\\uFFFF]|$))/,\n      // This is for `import type *, {}`\n      /\\btype\\b(?=\\s*(?:[\\{*]|$))/\n    )\n\n    // doesn't work with TS because TS is too complex\n    delete Prism.languages.typescript['parameter']\n    delete Prism.languages.typescript['literal-property']\n\n    // a version of typescript specifically for highlighting types\n    var typeInside = Prism.languages.extend('typescript', {})\n    delete typeInside['class-name']\n    Prism.languages.typescript['class-name'].inside = typeInside\n    Prism.languages.insertBefore('typescript', 'function', {\n      decorator: {\n        pattern: /@[$\\w\\xA0-\\uFFFF]+/,\n        inside: {\n          at: {\n            pattern: /^@/,\n            alias: 'operator'\n          },\n          function: /^[\\s\\S]+/\n        }\n      },\n      'generic-function': {\n        // e.g. foo<T extends \"bar\" | \"baz\">( ...\n        pattern:\n          /#?(?!\\s)[_$a-zA-Z\\xA0-\\uFFFF](?:(?!\\s)[$\\w\\xA0-\\uFFFF])*\\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>(?=\\s*\\()/,\n        greedy: true,\n        inside: {\n          function: /^#?(?!\\s)[_$a-zA-Z\\xA0-\\uFFFF](?:(?!\\s)[$\\w\\xA0-\\uFFFF])*/,\n          generic: {\n            pattern: /<[\\s\\S]+/,\n            // everything after the first <\n            alias: 'class-name',\n            inside: typeInside\n          }\n        }\n      }\n    })\n    Prism.languages.ts = Prism.languages.typescript\n  })(Prism)\n}\n"],"names":["typescript","Prism","refractorJavascript","typeInside"],"mappings":";AAKAA,EAAW,cAAc;AACzBA,EAAW,UAAU,CAAC,IAAI;AAGX,SAASA,EAAWC,GAAO;AACxC,EAAAA,EAAM,SAASC,CAAmB,IAChC,SAAUD,GAAO;AACjB,IAAAA,EAAM,UAAU,aAAaA,EAAM,UAAU,OAAO,cAAc;AAAA,MAChE,cAAc;AAAA,QACZ,SACE;AAAA,QACF,YAAY;AAAA,QACZ,QAAQ;AAAA,QACR,QAAQ;AAAA;AAAA,MAChB;AAAA,MACM,SACE;AAAA,IACR,CAAK,GAGDA,EAAM,UAAU,WAAW,QAAQ;AAAA,MACjC;AAAA;AAAA,MAEA;AAAA;AAAA,MAEA;AAAA,IACN,GAGI,OAAOA,EAAM,UAAU,WAAW,WAClC,OAAOA,EAAM,UAAU,WAAW,kBAAkB;AAGpD,QAAIE,IAAaF,EAAM,UAAU,OAAO,cAAc,CAAA,CAAE;AACxD,WAAOE,EAAW,YAAY,GAC9BF,EAAM,UAAU,WAAW,YAAY,EAAE,SAASE,GAClDF,EAAM,UAAU,aAAa,cAAc,YAAY;AAAA,MACrD,WAAW;AAAA,QACT,SAAS;AAAA,QACT,QAAQ;AAAA,UACN,IAAI;AAAA,YACF,SAAS;AAAA,YACT,OAAO;AAAA,UACnB;AAAA,UACU,UAAU;AAAA,QACpB;AAAA,MACA;AAAA,MACM,oBAAoB;AAAA;AAAA,QAElB,SACE;AAAA,QACF,QAAQ;AAAA,QACR,QAAQ;AAAA,UACN,UAAU;AAAA,UACV,SAAS;AAAA,YACP,SAAS;AAAA;AAAA,YAET,OAAO;AAAA,YACP,QAAQE;AAAA,UACpB;AAAA,QACA;AAAA,MACA;AAAA,IACA,CAAK,GACDF,EAAM,UAAU,KAAKA,EAAM,UAAU;AAAA,EACvC,GAAGA,CAAK;AACV;","x_google_ignoreList":[0]}

package/dist/vendor/.bun/refractor@5.0.0/vendor/refractor/lang/yaml.js

@@ -0,0 +1,89 @@
+d.displayName = "yaml";
+d.aliases = ["yml"];
+function d(l) {
+  (function(r) {
+    var t = /[*&][^\s[\]{},]+/, n = /!(?:<[\w\-%#;/?:@&=+$,.!~*'()[\]]+>|(?:[a-zA-Z\d-]*!)?[\w\-%#;/?:@&=+$.~*'()]+)?/, a = "(?:" + n.source + "(?:[ 	]+" + t.source + ")?|" + t.source + "(?:[ 	]+" + n.source + ")?)", i = /(?:[^\s\x00-\x08\x0e-\x1f!"#%&'*,\-:>?@[\]`{|}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]|[?:-]<PLAIN>)(?:[ \t]*(?:(?![#:])<PLAIN>|:<PLAIN>))*/.source.replace(
+      /<PLAIN>/g,
+      function() {
+        return /[^\s\x00-\x08\x0e-\x1f,[\]{}\x7f-\x84\x86-\x9f\ud800-\udfff\ufffe\uffff]/.source;
+      }
+    ), o = /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'/.source;
+    function e(p, u) {
+      u = (u || "").replace(/m/g, "") + "m";
+      var s = /([:\-,[{]\s*(?:\s<<prop>>[ \t]+)?)(?:<<value>>)(?=[ \t]*(?:$|,|\]|\}|(?:[\r\n]\s*)?#))/.source.replace(/<<prop>>/g, function() {
+        return a;
+      }).replace(/<<value>>/g, function() {
+        return p;
+      });
+      return RegExp(s, u);
+    }
+    r.languages.yaml = {
+      scalar: {
+        pattern: RegExp(
+          /([\-:]\s*(?:\s<<prop>>[ \t]+)?[|>])[ \t]*(?:((?:\r?\n|\r)[ \t]+)\S[^\r\n]*(?:\2[^\r\n]+)*)/.source.replace(
+            /<<prop>>/g,
+            function() {
+              return a;
+            }
+          )
+        ),
+        lookbehind: !0,
+        alias: "string"
+      },
+      comment: /#.*/,
+      key: {
+        pattern: RegExp(
+          /((?:^|[:\-,[{\r\n?])[ \t]*(?:<<prop>>[ \t]+)?)<<key>>(?=\s*:\s)/.source.replace(/<<prop>>/g, function() {
+            return a;
+          }).replace(/<<key>>/g, function() {
+            return "(?:" + i + "|" + o + ")";
+          })
+        ),
+        lookbehind: !0,
+        greedy: !0,
+        alias: "atrule"
+      },
+      directive: {
+        pattern: /(^[ \t]*)%.+/m,
+        lookbehind: !0,
+        alias: "important"
+      },
+      datetime: {
+        pattern: e(
+          /\d{4}-\d\d?-\d\d?(?:[tT]|[ \t]+)\d\d?:\d{2}:\d{2}(?:\.\d*)?(?:[ \t]*(?:Z|[-+]\d\d?(?::\d{2})?))?|\d{4}-\d{2}-\d{2}|\d\d?:\d{2}(?::\d{2}(?:\.\d*)?)?/.source
+        ),
+        lookbehind: !0,
+        alias: "number"
+      },
+      boolean: {
+        pattern: e(/false|true/.source, "i"),
+        lookbehind: !0,
+        alias: "important"
+      },
+      null: {
+        pattern: e(/null|~/.source, "i"),
+        lookbehind: !0,
+        alias: "important"
+      },
+      string: {
+        pattern: e(o),
+        lookbehind: !0,
+        greedy: !0
+      },
+      number: {
+        pattern: e(
+          /[+-]?(?:0x[\da-f]+|0o[0-7]+|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?|\.inf|\.nan)/.source,
+          "i"
+        ),
+        lookbehind: !0
+      },
+      tag: n,
+      important: t,
+      punctuation: /---|[:[\]{}\-,|>?]|\.\.\./
+    }, r.languages.yml = r.languages.yaml;
+  })(l);
+}
+export {
+  d as default
+};
+//# sourceMappingURL=yaml.js.map

package/dist/vendor/.bun/refractor@5.0.0/vendor/refractor/lang/yaml.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"yaml.js","sources":["../../../../../../../../../node_modules/.bun/refractor@5.0.0/node_modules/refractor/lang/yaml.js"],"sourcesContent":["// @ts-nocheck\n/**\n * @import {Refractor} from '../lib/core.js'\n */\nyaml.displayName = 'yaml'\nyaml.aliases = ['yml']\n\n/** @param {Refractor} Prism */\nexport default function yaml(Prism) {\n  ;(function (Prism) {\n    // https://yaml.org/spec/1.2/spec.html#c-ns-anchor-property\n    // https://yaml.org/spec/1.2/spec.html#c-ns-alias-node\n    var anchorOrAlias = /[*&][^\\s[\\]{},]+/\n    // https://yaml.org/spec/1.2/spec.html#c-ns-tag-property\n    var tag =\n      /!(?:<[\\w\\-%#;/?:@&=+$,.!~*'()[\\]]+>|(?:[a-zA-Z\\d-]*!)?[\\w\\-%#;/?:@&=+$.~*'()]+)?/\n    // https://yaml.org/spec/1.2/spec.html#c-ns-properties(n,c)\n    var properties =\n      '(?:' +\n      tag.source +\n      '(?:[ \\t]+' +\n      anchorOrAlias.source +\n      ')?|' +\n      anchorOrAlias.source +\n      '(?:[ \\t]+' +\n      tag.source +\n      ')?)'\n    // https://yaml.org/spec/1.2/spec.html#ns-plain(n,c)\n    // This is a simplified version that doesn't support \"#\" and multiline keys\n    // All these long scarry character classes are simplified versions of YAML's characters\n    var plainKey =\n      /(?:[^\\s\\x00-\\x08\\x0e-\\x1f!\"#%&'*,\\-:>?@[\\]`{|}\\x7f-\\x84\\x86-\\x9f\\ud800-\\udfff\\ufffe\\uffff]|[?:-]<PLAIN>)(?:[ \\t]*(?:(?![#:])<PLAIN>|:<PLAIN>))*/.source.replace(\n        /<PLAIN>/g,\n        function () {\n          return /[^\\s\\x00-\\x08\\x0e-\\x1f,[\\]{}\\x7f-\\x84\\x86-\\x9f\\ud800-\\udfff\\ufffe\\uffff]/\n            .source\n        }\n      )\n    var string = /\"(?:[^\"\\\\\\r\\n]|\\\\.)*\"|'(?:[^'\\\\\\r\\n]|\\\\.)*'/.source\n\n    /**\n     *\n     * @param {string} value\n     * @param {string} [flags]\n     * @returns {RegExp}\n     */\n    function createValuePattern(value, flags) {\n      flags = (flags || '').replace(/m/g, '') + 'm' // add m flag\n      var pattern =\n        /([:\\-,[{]\\s*(?:\\s<<prop>>[ \\t]+)?)(?:<<value>>)(?=[ \\t]*(?:$|,|\\]|\\}|(?:[\\r\\n]\\s*)?#))/.source\n          .replace(/<<prop>>/g, function () {\n            return properties\n          })\n          .replace(/<<value>>/g, function () {\n            return value\n          })\n      return RegExp(pattern, flags)\n    }\n    Prism.languages.yaml = {\n      scalar: {\n        pattern: RegExp(\n          /([\\-:]\\s*(?:\\s<<prop>>[ \\t]+)?[|>])[ \\t]*(?:((?:\\r?\\n|\\r)[ \\t]+)\\S[^\\r\\n]*(?:\\2[^\\r\\n]+)*)/.source.replace(\n            /<<prop>>/g,\n            function () {\n              return properties\n            }\n          )\n        ),\n        lookbehind: true,\n        alias: 'string'\n      },\n      comment: /#.*/,\n      key: {\n        pattern: RegExp(\n          /((?:^|[:\\-,[{\\r\\n?])[ \\t]*(?:<<prop>>[ \\t]+)?)<<key>>(?=\\s*:\\s)/.source\n            .replace(/<<prop>>/g, function () {\n              return properties\n            })\n            .replace(/<<key>>/g, function () {\n              return '(?:' + plainKey + '|' + string + ')'\n            })\n        ),\n        lookbehind: true,\n        greedy: true,\n        alias: 'atrule'\n      },\n      directive: {\n        pattern: /(^[ \\t]*)%.+/m,\n        lookbehind: true,\n        alias: 'important'\n      },\n      datetime: {\n        pattern: createValuePattern(\n          /\\d{4}-\\d\\d?-\\d\\d?(?:[tT]|[ \\t]+)\\d\\d?:\\d{2}:\\d{2}(?:\\.\\d*)?(?:[ \\t]*(?:Z|[-+]\\d\\d?(?::\\d{2})?))?|\\d{4}-\\d{2}-\\d{2}|\\d\\d?:\\d{2}(?::\\d{2}(?:\\.\\d*)?)?/\n            .source\n        ),\n        lookbehind: true,\n        alias: 'number'\n      },\n      boolean: {\n        pattern: createValuePattern(/false|true/.source, 'i'),\n        lookbehind: true,\n        alias: 'important'\n      },\n      null: {\n        pattern: createValuePattern(/null|~/.source, 'i'),\n        lookbehind: true,\n        alias: 'important'\n      },\n      string: {\n        pattern: createValuePattern(string),\n        lookbehind: true,\n        greedy: true\n      },\n      number: {\n        pattern: createValuePattern(\n          /[+-]?(?:0x[\\da-f]+|0o[0-7]+|(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?|\\.inf|\\.nan)/\n            .source,\n          'i'\n        ),\n        lookbehind: true\n      },\n      tag: tag,\n      important: anchorOrAlias,\n      punctuation: /---|[:[\\]{}\\-,|>?]|\\.\\.\\./\n    }\n    Prism.languages.yml = Prism.languages.yaml\n  })(Prism)\n}\n"],"names":["yaml","Prism","anchorOrAlias","tag","properties","plainKey","string","createValuePattern","value","flags","pattern"],"mappings":"AAIAA,EAAK,cAAc;AACnBA,EAAK,UAAU,CAAC,KAAK;AAGN,SAASA,EAAKC,GAAO;AACjC,GAAC,SAAUA,GAAO;AAGjB,QAAIC,IAAgB,oBAEhBC,IACF,oFAEEC,IACF,QACAD,EAAI,SACJ,aACAD,EAAc,SACd,QACAA,EAAc,SACd,aACAC,EAAI,SACJ,OAIEE,IACF,kJAAkJ,OAAO;AAAA,MACvJ;AAAA,MACA,WAAY;AACV,eAAO,2EACJ;AAAA,MACL;AAAA,IACR,GACQC,IAAS,8CAA8C;AAQ3D,aAASC,EAAmBC,GAAOC,GAAO;AACxC,MAAAA,KAASA,KAAS,IAAI,QAAQ,MAAM,EAAE,IAAI;AAC1C,UAAIC,IACF,yFAAyF,OACtF,QAAQ,aAAa,WAAY;AAChC,eAAON;AAAA,MACT,CAAC,EACA,QAAQ,cAAc,WAAY;AACjC,eAAOI;AAAA,MACT,CAAC;AACL,aAAO,OAAOE,GAASD,CAAK;AAAA,IAC9B;AACA,IAAAR,EAAM,UAAU,OAAO;AAAA,MACrB,QAAQ;AAAA,QACN,SAAS;AAAA,UACP,6FAA6F,OAAO;AAAA,YAClG;AAAA,YACA,WAAY;AACV,qBAAOG;AAAA,YACT;AAAA,UACZ;AAAA,QACA;AAAA,QACQ,YAAY;AAAA,QACZ,OAAO;AAAA,MACf;AAAA,MACM,SAAS;AAAA,MACT,KAAK;AAAA,QACH,SAAS;AAAA,UACP,kEAAkE,OAC/D,QAAQ,aAAa,WAAY;AAChC,mBAAOA;AAAA,UACT,CAAC,EACA,QAAQ,YAAY,WAAY;AAC/B,mBAAO,QAAQC,IAAW,MAAMC,IAAS;AAAA,UAC3C,CAAC;AAAA,QACb;AAAA,QACQ,YAAY;AAAA,QACZ,QAAQ;AAAA,QACR,OAAO;AAAA,MACf;AAAA,MACM,WAAW;AAAA,QACT,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,OAAO;AAAA,MACf;AAAA,MACM,UAAU;AAAA,QACR,SAASC;AAAA,UACP,sJACG;AAAA,QACb;AAAA,QACQ,YAAY;AAAA,QACZ,OAAO;AAAA,MACf;AAAA,MACM,SAAS;AAAA,QACP,SAASA,EAAmB,aAAa,QAAQ,GAAG;AAAA,QACpD,YAAY;AAAA,QACZ,OAAO;AAAA,MACf;AAAA,MACM,MAAM;AAAA,QACJ,SAASA,EAAmB,SAAS,QAAQ,GAAG;AAAA,QAChD,YAAY;AAAA,QACZ,OAAO;AAAA,MACf;AAAA,MACM,QAAQ;AAAA,QACN,SAASA,EAAmBD,CAAM;AAAA,QAClC,YAAY;AAAA,QACZ,QAAQ;AAAA,MAChB;AAAA,MACM,QAAQ;AAAA,QACN,SAASC;AAAA,UACP,iFACG;AAAA,UACH;AAAA,QACV;AAAA,QACQ,YAAY;AAAA,MACpB;AAAA,MACM,KAAKJ;AAAA,MACL,WAAWD;AAAA,MACX,aAAa;AAAA,IACnB,GACID,EAAM,UAAU,MAAMA,EAAM,UAAU;AAAA,EACxC,GAAGA,CAAK;AACV;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,108 @@
+import { Prism as p } from "./prism-core.js";
+import { h } from "../../../../hastscript@9.0.1/vendor/hastscript/lib/index.js";
+import { parseEntities as l } from "../../../../parse-entities@4.0.2/vendor/parse-entities/lib/index.js";
+function a() {
+}
+a.prototype = p;
+const i = new a();
+i.highlight = y;
+i.register = w;
+i.alias = u;
+i.registered = m;
+i.listLanguages = d;
+i.util.encode = b;
+i.Token.stringify = f;
+function y(t, e) {
+  if (typeof t != "string")
+    throw new TypeError("Expected `string` for `value`, got `" + t + "`");
+  let n, r;
+  if (e && typeof e == "object")
+    n = e;
+  else {
+    if (r = e, typeof r != "string")
+      throw new TypeError("Expected `string` for `name`, got `" + r + "`");
+    if (Object.hasOwn(i.languages, r))
+      n = i.languages[r];
+    else
+      throw new Error("Unknown language: `" + r + "` is not registered");
+  }
+  return {
+    type: "root",
+    // @ts-expect-error: we hacked Prism to accept and return the things we want.
+    children: p.highlight.call(i, t, n, r)
+  };
+}
+function w(t) {
+  if (typeof t != "function" || !t.displayName)
+    throw new Error("Expected `function` for `syntax`, got `" + t + "`");
+  Object.hasOwn(i.languages, t.displayName) || t(i);
+}
+function u(t, e) {
+  const n = i.languages;
+  let r = {};
+  typeof t == "string" ? e && (r[t] = e) : r = t;
+  let s;
+  for (s in r)
+    if (Object.hasOwn(r, s)) {
+      const o = r[s], g = typeof o == "string" ? [o] : o;
+      let c = -1;
+      for (; ++c < g.length; )
+        n[g[c]] = n[s];
+    }
+}
+function m(t) {
+  if (typeof t != "string")
+    throw new TypeError(
+      "Expected `string` for `aliasOrLanguage`, got `" + t + "`"
+    );
+  return Object.hasOwn(i.languages, t);
+}
+function d() {
+  const t = i.languages, e = [];
+  let n;
+  for (n in t)
+    Object.hasOwn(t, n) && typeof t[n] == "object" && e.push(n);
+  return e;
+}
+function f(t, e) {
+  if (typeof t == "string")
+    return { type: "text", value: t };
+  if (Array.isArray(t)) {
+    const r = [];
+    let s = -1;
+    for (; ++s < t.length; )
+      t[s] !== null && t[s] !== void 0 && t[s] !== "" && r.push(
+        /** @type {Element | Text} */
+        f(t[s], e)
+      );
+    return r;
+  }
+  const n = {
+    attributes: {},
+    classes: ["token", t.type],
+    content: f(t.content, e),
+    language: e,
+    tag: "span",
+    type: t.type
+  };
+  return t.alias && n.classes.push(
+    ...typeof t.alias == "string" ? [t.alias] : t.alias
+  ), i.hooks.run("wrap", n), h(
+    n.tag + "." + n.classes.join("."),
+    O(n.attributes),
+    n.content
+  );
+}
+function b(t) {
+  return t;
+}
+function O(t) {
+  let e;
+  for (e in t)
+    Object.hasOwn(t, e) && (t[e] = l(t[e]));
+  return t;
+}
+export {
+  i as refractor
+};
+//# sourceMappingURL=core.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"core.js","sources":["../../../../../../../../../node_modules/.bun/refractor@5.0.0/node_modules/refractor/lib/core.js"],"sourcesContent":["/**\n * @import {Element, Root, Text} from 'hast'\n * @import {Grammar, Languages} from 'prismjs'\n */\n\n/**\n * @typedef _Token\n *   Hidden Prism token.\n * @property {string} alias\n *   Alias.\n * @property {string} content\n *   Content.\n * @property {number} length\n *   Length.\n * @property {string} type\n *   Type.\n */\n\n/**\n * @typedef _Env\n *   Hidden Prism environment.\n * @property {Record<string, string>} attributes\n *   Attributes.\n * @property {Array<string>} classes\n *   Classes.\n * @property {Array<Element | Text> | Element | Text} content\n *   Content.\n * @property {string} language\n *   Language.\n * @property {string} tag\n *   Tag.\n * @property {string} type\n *   Type.\n */\n\n/**\n * @typedef {((prism: Refractor) => undefined | void) & {aliases?: Array<string> | undefined, displayName: string}} Syntax\n *   Refractor syntax function.\n */\n\n/**\n * @typedef Refractor\n *   Virtual syntax highlighting\n * @property {typeof alias} alias\n * @property {Languages} languages\n * @property {typeof listLanguages} listLanguages\n * @property {typeof highlight} highlight\n * @property {typeof registered} registered\n * @property {typeof register} register\n */\n\n// Load all stuff in `prism.js` itself, except for `prism-file-highlight.js`.\n// The wrapped non-leaky grammars are loaded instead of Prism’s originals.\nimport {h} from 'hastscript'\nimport {parseEntities} from 'parse-entities'\nimport {Prism} from './prism-core.js'\n\n// Inherit.\nfunction Refractor() {}\n\nRefractor.prototype = Prism\n\n/** @type {Refractor} */\n// @ts-expect-error: TS is wrong.\nexport const refractor = new Refractor()\n\n// Create.\nrefractor.highlight = highlight\nrefractor.register = register\nrefractor.alias = alias\nrefractor.registered = registered\nrefractor.listLanguages = listLanguages\n\n// @ts-expect-error Overwrite Prism.\nrefractor.util.encode = encode\n// @ts-expect-error Overwrite Prism.\nrefractor.Token.stringify = stringify\n\n/**\n * Highlight `value` (code) as `language` (programming language).\n *\n * @param {string} value\n *   Code to highlight.\n * @param {Grammar | string} language\n *   Programming language name, alias, or grammar.\n * @returns {Root}\n *   Node representing highlighted code.\n */\nfunction highlight(value, language) {\n  if (typeof value !== 'string') {\n    throw new TypeError('Expected `string` for `value`, got `' + value + '`')\n  }\n\n  /** @type {Grammar} */\n  let grammar\n  /** @type {string | undefined} */\n  let name\n\n  // `name` is a grammar object.\n  // This was called internally by Prism.js before 1.28.0.\n  /* c8 ignore next 2 */\n  if (language && typeof language === 'object') {\n    grammar = language\n  } else {\n    name = language\n\n    if (typeof name !== 'string') {\n      throw new TypeError('Expected `string` for `name`, got `' + name + '`')\n    }\n\n    if (Object.hasOwn(refractor.languages, name)) {\n      grammar = refractor.languages[name]\n    } else {\n      throw new Error('Unknown language: `' + name + '` is not registered')\n    }\n  }\n\n  return {\n    type: 'root',\n    // @ts-expect-error: we hacked Prism to accept and return the things we want.\n    children: Prism.highlight.call(refractor, value, grammar, name)\n  }\n}\n\n/**\n * Register a syntax.\n *\n * @param {Syntax} syntax\n *   Language function made for refractor, as in, the files in\n *   `refractor/lang/*.js`.\n * @returns {undefined}\n *   Nothing.\n */\nfunction register(syntax) {\n  if (typeof syntax !== 'function' || !syntax.displayName) {\n    throw new Error('Expected `function` for `syntax`, got `' + syntax + '`')\n  }\n\n  // Do not duplicate registrations.\n  if (!Object.hasOwn(refractor.languages, syntax.displayName)) {\n    syntax(refractor)\n  }\n}\n\n/**\n * Register aliases for already registered languages.\n *\n * @param {Record<string, ReadonlyArray<string> | string> | string} language\n *   Language to alias.\n * @param {ReadonlyArray<string> | string | null | undefined} [alias]\n *   Aliases.\n * @returns {undefined}\n *   Nothing.\n */\nfunction alias(language, alias) {\n  const languages = refractor.languages\n  /** @type {Record<string, ReadonlyArray<string> | string>} */\n  let map = {}\n\n  if (typeof language === 'string') {\n    if (alias) {\n      map[language] = alias\n    }\n  } else {\n    map = language\n  }\n\n  /** @type {string} */\n  let key\n\n  for (key in map) {\n    if (Object.hasOwn(map, key)) {\n      const value = map[key]\n      const list = typeof value === 'string' ? [value] : value\n      let index = -1\n\n      while (++index < list.length) {\n        languages[list[index]] = languages[key]\n      }\n    }\n  }\n}\n\n/**\n * Check whether an `alias` or `language` is registered.\n *\n * @param {string} aliasOrLanguage\n *   Language or alias to check.\n * @returns {boolean}\n *   Whether the language is registered.\n */\nfunction registered(aliasOrLanguage) {\n  if (typeof aliasOrLanguage !== 'string') {\n    throw new TypeError(\n      'Expected `string` for `aliasOrLanguage`, got `' + aliasOrLanguage + '`'\n    )\n  }\n\n  return Object.hasOwn(refractor.languages, aliasOrLanguage)\n}\n\n/**\n * List all registered languages (names and aliases).\n *\n * @returns {Array<string>}\n *   List of language names.\n */\nfunction listLanguages() {\n  const languages = refractor.languages\n  /** @type {Array<string>} */\n  const list = []\n  /** @type {string} */\n  let language\n\n  for (language in languages) {\n    if (\n      Object.hasOwn(languages, language) &&\n      typeof languages[language] === 'object'\n    ) {\n      list.push(language)\n    }\n  }\n\n  return list\n}\n\n/**\n * @param {Array<_Token | string> | _Token | string} value\n *   Token to stringify.\n * @param {string} language\n *   Language of the token.\n * @returns {Array<Element | Text> | Element | Text}\n *   Node representing the token.\n */\nfunction stringify(value, language) {\n  if (typeof value === 'string') {\n    return {type: 'text', value}\n  }\n\n  if (Array.isArray(value)) {\n    /** @type {Array<Element | Text>} */\n    const result = []\n    let index = -1\n\n    while (++index < value.length) {\n      if (\n        value[index] !== null &&\n        value[index] !== undefined &&\n        value[index] !== ''\n      ) {\n        // Cast because we assume no sub-arrays.\n        result.push(\n          /** @type {Element | Text} */ (stringify(value[index], language))\n        )\n      }\n    }\n\n    return result\n  }\n\n  /** @type {_Env} */\n  const env = {\n    attributes: {},\n    classes: ['token', value.type],\n    content: stringify(value.content, language),\n    language,\n    tag: 'span',\n    type: value.type\n  }\n\n  if (value.alias) {\n    env.classes.push(\n      ...(typeof value.alias === 'string' ? [value.alias] : value.alias)\n    )\n  }\n\n  // @ts-expect-error Prism.\n  refractor.hooks.run('wrap', env)\n\n  return h(\n    env.tag + '.' + env.classes.join('.'),\n    attributes(env.attributes),\n    env.content\n  )\n}\n\n/**\n * @template {unknown} T\n *   Tokens.\n * @param {T} tokens\n *   Input.\n * @returns {T}\n *   Output, same as input.\n */\nfunction encode(tokens) {\n  return tokens\n}\n\n/**\n * @param {Record<string, string>} record\n *   Attributes.\n * @returns {Record<string, string>}\n *   Attributes.\n */\nfunction attributes(record) {\n  /** @type {string} */\n  let key\n\n  for (key in record) {\n    if (Object.hasOwn(record, key)) {\n      record[key] = parseEntities(record[key])\n    }\n  }\n\n  return record\n}\n"],"names":["Refractor","Prism","refractor","highlight","register","alias","registered","listLanguages","encode","stringify","value","language","grammar","name","syntax","languages","map","key","list","index","aliasOrLanguage","result","env","attributes","tokens","record","parseEntities"],"mappings":"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","x_google_ignoreList":[0]}