storybook 10.0.0-rc.0 → 10.0.0-rc.2

package/dist/_browser-chunks/chunk-6QSA74OD.js

@@ -1,93 +0,0 @@
-import {
-  __commonJS,
-  __name
-} from "./chunk-MM7DTO55.js";
-
-// ../node_modules/refractor/lang/dot.js
-var require_dot = __commonJS({
-  "../node_modules/refractor/lang/dot.js"(exports, module) {
-    module.exports = dot;
-    dot.displayName = "dot";
-    dot.aliases = ["gv"];
-    function dot(Prism) {
-      ;
-      (function(Prism2) {
-        var ID = "(?:" + [
-          // an identifier
-          /[a-zA-Z_\x80-\uFFFF][\w\x80-\uFFFF]*/.source,
-          // a number
-          /-?(?:\.\d+|\d+(?:\.\d*)?)/.source,
-          // a double-quoted string
-          /"[^"\\]*(?:\\[\s\S][^"\\]*)*"/.source,
-          // HTML-like string
-          /<(?:[^<>]|(?!<!--)<(?:[^<>"']|"[^"]*"|'[^']*')+>|<!--(?:[^-]|-(?!->))*-->)*>/.source
-        ].join("|") + ")";
-        var IDInside = {
-          markup: {
-            pattern: /(^<)[\s\S]+(?=>$)/,
-            lookbehind: true,
-            alias: ["language-markup", "language-html", "language-xml"],
-            inside: Prism2.languages.markup
-          }
-        };
-        function withID(source, flags) {
-          return RegExp(
-            source.replace(/<ID>/g, function() {
-              return ID;
-            }),
-            flags
-          );
-        }
-        __name(withID, "withID");
-        Prism2.languages.dot = {
-          comment: {
-            pattern: /\/\/.*|\/\*[\s\S]*?\*\/|^#.*/m,
-            greedy: true
-          },
-          "graph-name": {
-            pattern: withID(
-              /(\b(?:digraph|graph|subgraph)[ \t\r\n]+)<ID>/.source,
-              "i"
-            ),
-            lookbehind: true,
-            greedy: true,
-            alias: "class-name",
-            inside: IDInside
-          },
-          "attr-value": {
-            pattern: withID(/(=[ \t\r\n]*)<ID>/.source),
-            lookbehind: true,
-            greedy: true,
-            inside: IDInside
-          },
-          "attr-name": {
-            pattern: withID(/([\[;, \t\r\n])<ID>(?=[ \t\r\n]*=)/.source),
-            lookbehind: true,
-            greedy: true,
-            inside: IDInside
-          },
-          keyword: /\b(?:digraph|edge|graph|node|strict|subgraph)\b/i,
-          "compass-point": {
-            pattern: /(:[ \t\r\n]*)(?:[ewc_]|[ns][ew]?)(?![\w\x80-\uFFFF])/,
-            lookbehind: true,
-            alias: "builtin"
-          },
-          node: {
-            pattern: withID(/(^|[^-.\w\x80-\uFFFF\\])<ID>/.source),
-            lookbehind: true,
-            greedy: true,
-            inside: IDInside
-          },
-          operator: /[=:]|-[->]/,
-          punctuation: /[\[\]{};,]/
-        };
-        Prism2.languages.gv = Prism2.languages.dot;
-      })(Prism);
-    }
-    __name(dot, "dot");
-  }
-});
-
-export {
-  require_dot
-};

package/dist/_browser-chunks/chunk-6RVIUUQL.js

@@ -1,78 +0,0 @@
-import {
-  __commonJS,
-  __name
-} from "./chunk-MM7DTO55.js";
-
-// ../node_modules/refractor/lang/purebasic.js
-var require_purebasic = __commonJS({
-  "../node_modules/refractor/lang/purebasic.js"(exports, module) {
-    module.exports = purebasic;
-    purebasic.displayName = "purebasic";
-    purebasic.aliases = [];
-    function purebasic(Prism) {
-      Prism.languages.purebasic = Prism.languages.extend("clike", {
-        comment: /;.*/,
-        keyword: /\b(?:align|and|as|break|calldebugger|case|compilercase|compilerdefault|compilerelse|compilerelseif|compilerendif|compilerendselect|compilererror|compilerif|compilerselect|continue|data|datasection|debug|debuglevel|declare|declarec|declarecdll|declaredll|declaremodule|default|define|dim|disableasm|disabledebugger|disableexplicit|else|elseif|enableasm|enabledebugger|enableexplicit|end|enddatasection|enddeclaremodule|endenumeration|endif|endimport|endinterface|endmacro|endmodule|endprocedure|endselect|endstructure|endstructureunion|endwith|enumeration|extends|fakereturn|for|foreach|forever|global|gosub|goto|if|import|importc|includebinary|includefile|includepath|interface|macro|module|newlist|newmap|next|not|or|procedure|procedurec|procedurecdll|proceduredll|procedurereturn|protected|prototype|prototypec|read|redim|repeat|restore|return|runtime|select|shared|static|step|structure|structureunion|swap|threaded|to|until|wend|while|with|xincludefile|xor)\b/i,
-        function: /\b\w+(?:\.\w+)?\s*(?=\()/,
-        number: /(?:\$[\da-f]+|\b-?(?:\d+(?:\.\d+)?|\.\d+)(?:e[+-]?\d+)?)\b/i,
-        operator: /(?:@\*?|\?|\*)\w+|-[>-]?|\+\+?|!=?|<<?=?|>>?=?|==?|&&?|\|?\||[~^%?*/@]/
-      });
-      Prism.languages.insertBefore("purebasic", "keyword", {
-        tag: /#\w+\$?/,
-        asm: {
-          pattern: /(^[\t ]*)!.*/m,
-          lookbehind: true,
-          alias: "tag",
-          inside: {
-            comment: /;.*/,
-            string: {
-              pattern: /(["'`])(?:\\.|(?!\1)[^\\\r\n])*\1/,
-              greedy: true
-            },
-            // Anonymous label references, i.e.: jmp @b
-            "label-reference-anonymous": {
-              pattern: /(!\s*j[a-z]+\s+)@[fb]/i,
-              lookbehind: true,
-              alias: "fasm-label"
-            },
-            // Named label reference, i.e.: jne label1
-            "label-reference-addressed": {
-              pattern: /(!\s*j[a-z]+\s+)[A-Z._?$@][\w.?$@~#]*/i,
-              lookbehind: true,
-              alias: "fasm-label"
-            },
-            keyword: [
-              /\b(?:extern|global)\b[^;\r\n]*/i,
-              /\b(?:CPU|DEFAULT|FLOAT)\b.*/
-            ],
-            function: {
-              pattern: /^([\t ]*!\s*)[\da-z]+(?=\s|$)/im,
-              lookbehind: true
-            },
-            "function-inline": {
-              pattern: /(:\s*)[\da-z]+(?=\s)/i,
-              lookbehind: true,
-              alias: "function"
-            },
-            label: {
-              pattern: /^([\t ]*!\s*)[A-Za-z._?$@][\w.?$@~#]*(?=:)/m,
-              lookbehind: true,
-              alias: "fasm-label"
-            },
-            register: /\b(?:st\d|[xyz]mm\d\d?|[cdt]r\d|r\d\d?[bwd]?|[er]?[abcd]x|[abcd][hl]|[er]?(?:bp|di|si|sp)|[cdefgs]s|mm\d+)\b/i,
-            number: /(?:\b|-|(?=\$))(?:0[hx](?:[\da-f]*\.)?[\da-f]+(?:p[+-]?\d+)?|\d[\da-f]+[hx]|\$\d[\da-f]*|0[oq][0-7]+|[0-7]+[oq]|0[by][01]+|[01]+[by]|0[dt]\d+|(?:\d+(?:\.\d+)?|\.\d+)(?:\.?e[+-]?\d+)?[dt]?)\b/i,
-            operator: /[\[\]*+\-/%<>=&|$!,.:]/
-          }
-        }
-      });
-      delete Prism.languages.purebasic["class-name"];
-      delete Prism.languages.purebasic["boolean"];
-      Prism.languages.pbfasm = Prism.languages["purebasic"];
-    }
-    __name(purebasic, "purebasic");
-  }
-});
-
-export {
-  require_purebasic
-};

package/dist/_browser-chunks/chunk-6SUW5N3Z.js

@@ -1,83 +0,0 @@
-import {
-  require_bash
-} from "./chunk-A4MLX43Y.js";
-import {
-  __commonJS,
-  __name
-} from "./chunk-MM7DTO55.js";
-
-// ../node_modules/refractor/lang/shell-session.js
-var require_shell_session = __commonJS({
-  "../node_modules/refractor/lang/shell-session.js"(exports, module) {
-    var refractorBash = require_bash();
-    module.exports = shellSession;
-    shellSession.displayName = "shellSession";
-    shellSession.aliases = [];
-    function shellSession(Prism) {
-      Prism.register(refractorBash);
-      (function(Prism2) {
-        var strings = [
-          // normal string
-          /"(?:\\[\s\S]|\$\([^)]+\)|\$(?!\()|`[^`]+`|[^"\\`$])*"/.source,
-          /'[^']*'/.source,
-          /\$'(?:[^'\\]|\\[\s\S])*'/.source,
-          // here doc
-          // 2 capturing groups
-          /<<-?\s*(["']?)(\w+)\1\s[\s\S]*?[\r\n]\2/.source
-        ].join("|");
-        Prism2.languages["shell-session"] = {
-          command: {
-            pattern: RegExp(
-              // user info
-              /^/.source + "(?:" + // <user> ":" ( <path> )?
-              (/[^\s@:$#%*!/\\]+@[^\r\n@:$#%*!/\\]+(?::[^\0-\x1F$#%*?"<>:;|]+)?/.source + "|" + // <path>
-              // Since the path pattern is quite general, we will require it to start with a special character to
-              // prevent false positives.
-              /[/~.][^\0-\x1F$#%*?"<>@:;|]*/.source) + ")?" + // shell symbol
-              /[$#%](?=\s)/.source + // bash command
-              /(?:[^\\\r\n \t'"<$]|[ \t](?:(?!#)|#.*$)|\\(?:[^\r]|\r\n?)|\$(?!')|<(?!<)|<<str>>)+/.source.replace(
-                /<<str>>/g,
-                function() {
-                  return strings;
-                }
-              ),
-              "m"
-            ),
-            greedy: true,
-            inside: {
-              info: {
-                // foo@bar:~/files$ exit
-                // foo@bar$ exit
-                // ~/files$ exit
-                pattern: /^[^#$%]+/,
-                alias: "punctuation",
-                inside: {
-                  user: /^[^\s@:$#%*!/\\]+@[^\r\n@:$#%*!/\\]+/,
-                  punctuation: /:/,
-                  path: /[\s\S]+/
-                }
-              },
-              bash: {
-                pattern: /(^[$#%]\s*)\S[\s\S]*/,
-                lookbehind: true,
-                alias: "language-bash",
-                inside: Prism2.languages.bash
-              },
-              "shell-symbol": {
-                pattern: /^[$#%]/,
-                alias: "important"
-              }
-            }
-          },
-          output: /.(?:.*(?:[\r\n]|.$))*/
-        };
-        Prism2.languages["sh-session"] = Prism2.languages["shellsession"] = Prism2.languages["shell-session"];
-      })(Prism);
-    }
-    __name(shellSession, "shellSession");
-  }
-});
-
-export {
-  require_shell_session
-};

package/dist/_browser-chunks/chunk-6WVDCU2L.js

@@ -1,102 +0,0 @@
-import {
-  __commonJS,
-  __name
-} from "./chunk-MM7DTO55.js";
-
-// ../node_modules/refractor/lang/vala.js
-var require_vala = __commonJS({
-  "../node_modules/refractor/lang/vala.js"(exports, module) {
-    module.exports = vala;
-    vala.displayName = "vala";
-    vala.aliases = [];
-    function vala(Prism) {
-      Prism.languages.vala = Prism.languages.extend("clike", {
-        // Classes copied from prism-csharp
-        "class-name": [
-          {
-            // (Foo bar, Bar baz)
-            pattern: /\b[A-Z]\w*(?:\.\w+)*\b(?=(?:\?\s+|\*?\s+\*?)\w)/,
-            inside: {
-              punctuation: /\./
-            }
-          },
-          {
-            // [Foo]
-            pattern: /(\[)[A-Z]\w*(?:\.\w+)*\b/,
-            lookbehind: true,
-            inside: {
-              punctuation: /\./
-            }
-          },
-          {
-            // class Foo : Bar
-            pattern: /(\b(?:class|interface)\s+[A-Z]\w*(?:\.\w+)*\s*:\s*)[A-Z]\w*(?:\.\w+)*\b/,
-            lookbehind: true,
-            inside: {
-              punctuation: /\./
-            }
-          },
-          {
-            // class Foo
-            pattern: /((?:\b(?:class|enum|interface|new|struct)\s+)|(?:catch\s+\())[A-Z]\w*(?:\.\w+)*\b/,
-            lookbehind: true,
-            inside: {
-              punctuation: /\./
-            }
-          }
-        ],
-        keyword: /\b(?:abstract|as|assert|async|base|bool|break|case|catch|char|class|const|construct|continue|default|delegate|delete|do|double|dynamic|else|ensures|enum|errordomain|extern|finally|float|for|foreach|get|if|in|inline|int|int16|int32|int64|int8|interface|internal|is|lock|long|namespace|new|null|out|override|owned|params|private|protected|public|ref|requires|return|set|short|signal|sizeof|size_t|ssize_t|static|string|struct|switch|this|throw|throws|try|typeof|uchar|uint|uint16|uint32|uint64|uint8|ulong|unichar|unowned|ushort|using|value|var|virtual|void|volatile|weak|while|yield)\b/i,
-        function: /\b\w+(?=\s*\()/,
-        number: /(?:\b0x[\da-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?)(?:f|u?l?)?/i,
-        operator: /\+\+|--|&&|\|\||<<=?|>>=?|=>|->|~|[+\-*\/%&^|=!<>]=?|\?\??|\.\.\./,
-        punctuation: /[{}[\];(),.:]/,
-        constant: /\b[A-Z0-9_]+\b/
-      });
-      Prism.languages.insertBefore("vala", "string", {
-        "raw-string": {
-          pattern: /"""[\s\S]*?"""/,
-          greedy: true,
-          alias: "string"
-        },
-        "template-string": {
-          pattern: /@"[\s\S]*?"/,
-          greedy: true,
-          inside: {
-            interpolation: {
-              pattern: /\$(?:\([^)]*\)|[a-zA-Z]\w*)/,
-              inside: {
-                delimiter: {
-                  pattern: /^\$\(?|\)$/,
-                  alias: "punctuation"
-                },
-                rest: Prism.languages.vala
-              }
-            },
-            string: /[\s\S]+/
-          }
-        }
-      });
-      Prism.languages.insertBefore("vala", "keyword", {
-        regex: {
-          pattern: /\/(?:\[(?:[^\]\\\r\n]|\\.)*\]|\\.|[^/\\\[\r\n])+\/[imsx]{0,4}(?=\s*(?:$|[\r\n,.;})\]]))/,
-          greedy: true,
-          inside: {
-            "regex-source": {
-              pattern: /^(\/)[\s\S]+(?=\/[a-z]*$)/,
-              lookbehind: true,
-              alias: "language-regex",
-              inside: Prism.languages.regex
-            },
-            "regex-delimiter": /^\//,
-            "regex-flags": /^[a-z]+$/
-          }
-        }
-      });
-    }
-    __name(vala, "vala");
-  }
-});
-
-export {
-  require_vala
-};

package/dist/_browser-chunks/chunk-75DPUEWH.js

@@ -1,48 +0,0 @@
-import {
-  __commonJS,
-  __name
-} from "./chunk-MM7DTO55.js";
-
-// ../node_modules/refractor/lang/wolfram.js
-var require_wolfram = __commonJS({
-  "../node_modules/refractor/lang/wolfram.js"(exports, module) {
-    module.exports = wolfram;
-    wolfram.displayName = "wolfram";
-    wolfram.aliases = ["mathematica", "wl", "nb"];
-    function wolfram(Prism) {
-      Prism.languages.wolfram = {
-        // Allow one level of nesting - note: regex taken from applescipt
-        comment: /\(\*(?:\(\*(?:[^*]|\*(?!\)))*\*\)|(?!\(\*)[\s\S])*?\*\)/,
-        string: {
-          pattern: /"(?:\\.|[^"\\\r\n])*"/,
-          greedy: true
-        },
-        keyword: /\b(?:Abs|AbsArg|Accuracy|Block|Do|For|Function|If|Manipulate|Module|Nest|NestList|None|Return|Switch|Table|Which|While)\b/,
-        context: {
-          pattern: /\b\w+`+\w*/,
-          alias: "class-name"
-        },
-        blank: {
-          pattern: /\b\w+_\b/,
-          alias: "regex"
-        },
-        "global-variable": {
-          pattern: /\$\w+/,
-          alias: "variable"
-        },
-        boolean: /\b(?:False|True)\b/,
-        number: /(?:\b(?=\d)|\B(?=\.))(?:0[bo])?(?:(?:\d|0x[\da-f])[\da-f]*(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?j?\b/i,
-        operator: /\/\.|;|=\.|\^=|\^:=|:=|<<|>>|<\||\|>|:>|\|->|->|<-|@@@|@@|@|\/@|=!=|===|==|=|\+|-|\^|\[\/-+%=\]=?|!=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
-        punctuation: /[{}[\];(),.:]/
-      };
-      Prism.languages.mathematica = Prism.languages.wolfram;
-      Prism.languages.wl = Prism.languages.wolfram;
-      Prism.languages.nb = Prism.languages.wolfram;
-    }
-    __name(wolfram, "wolfram");
-  }
-});
-
-export {
-  require_wolfram
-};

package/dist/_browser-chunks/chunk-75LCFTTE.js

@@ -1,113 +0,0 @@
-import {
-  require_typescript
-} from "./chunk-CYY5G5IY.js";
-import {
-  require_javadoclike
-} from "./chunk-QYRSUTR5.js";
-import {
-  __commonJS,
-  __name
-} from "./chunk-MM7DTO55.js";
-
-// ../node_modules/refractor/lang/jsdoc.js
-var require_jsdoc = __commonJS({
-  "../node_modules/refractor/lang/jsdoc.js"(exports, module) {
-    var refractorJavadoclike = require_javadoclike();
-    var refractorTypescript = require_typescript();
-    module.exports = jsdoc;
-    jsdoc.displayName = "jsdoc";
-    jsdoc.aliases = [];
-    function jsdoc(Prism) {
-      Prism.register(refractorJavadoclike);
-      Prism.register(refractorTypescript);
-      (function(Prism2) {
-        var javascript = Prism2.languages.javascript;
-        var type = /\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})+\}/.source;
-        var parameterPrefix = "(@(?:arg|argument|param|property)\\s+(?:" + type + "\\s+)?)";
-        Prism2.languages.jsdoc = Prism2.languages.extend("javadoclike", {
-          parameter: {
-            // @param {string} foo - foo bar
-            pattern: RegExp(
-              parameterPrefix + /(?:(?!\s)[$\w\xA0-\uFFFF.])+(?=\s|$)/.source
-            ),
-            lookbehind: true,
-            inside: {
-              punctuation: /\./
-            }
-          }
-        });
-        Prism2.languages.insertBefore("jsdoc", "keyword", {
-          "optional-parameter": {
-            // @param {string} [baz.foo="bar"] foo bar
-            pattern: RegExp(
-              parameterPrefix + /\[(?:(?!\s)[$\w\xA0-\uFFFF.])+(?:=[^[\]]+)?\](?=\s|$)/.source
-            ),
-            lookbehind: true,
-            inside: {
-              parameter: {
-                pattern: /(^\[)[$\w\xA0-\uFFFF\.]+/,
-                lookbehind: true,
-                inside: {
-                  punctuation: /\./
-                }
-              },
-              code: {
-                pattern: /(=)[\s\S]*(?=\]$)/,
-                lookbehind: true,
-                inside: javascript,
-                alias: "language-javascript"
-              },
-              punctuation: /[=[\]]/
-            }
-          },
-          "class-name": [
-            {
-              pattern: RegExp(
-                /(@(?:augments|class|extends|interface|memberof!?|template|this|typedef)\s+(?:<TYPE>\s+)?)[A-Z]\w*(?:\.[A-Z]\w*)*/.source.replace(
-                  /<TYPE>/g,
-                  function() {
-                    return type;
-                  }
-                )
-              ),
-              lookbehind: true,
-              inside: {
-                punctuation: /\./
-              }
-            },
-            {
-              pattern: RegExp("(@[a-z]+\\s+)" + type),
-              lookbehind: true,
-              inside: {
-                string: javascript.string,
-                number: javascript.number,
-                boolean: javascript.boolean,
-                keyword: Prism2.languages.typescript.keyword,
-                operator: /=>|\.\.\.|[&|?:*]/,
-                punctuation: /[.,;=<>{}()[\]]/
-              }
-            }
-          ],
-          example: {
-            pattern: /(@example\s+(?!\s))(?:[^@\s]|\s+(?!\s))+?(?=\s*(?:\*\s*)?(?:@\w|\*\/))/,
-            lookbehind: true,
-            inside: {
-              code: {
-                pattern: /^([\t ]*(?:\*\s*)?)\S.*$/m,
-                lookbehind: true,
-                inside: javascript,
-                alias: "language-javascript"
-              }
-            }
-          }
-        });
-        Prism2.languages.javadoclike.addSupport("javascript", Prism2.languages.jsdoc);
-      })(Prism);
-    }
-    __name(jsdoc, "jsdoc");
-  }
-});
-
-export {
-  require_jsdoc
-};

package/dist/_browser-chunks/chunk-75LFKB6B.js

@@ -1,68 +0,0 @@
-import {
-  __commonJS,
-  __name
-} from "./chunk-MM7DTO55.js";
-
-// ../node_modules/refractor/lang/lolcode.js
-var require_lolcode = __commonJS({
-  "../node_modules/refractor/lang/lolcode.js"(exports, module) {
-    module.exports = lolcode;
-    lolcode.displayName = "lolcode";
-    lolcode.aliases = [];
-    function lolcode(Prism) {
-      Prism.languages.lolcode = {
-        comment: [/\bOBTW\s[\s\S]*?\sTLDR\b/, /\bBTW.+/],
-        string: {
-          pattern: /"(?::.|[^":])*"/,
-          inside: {
-            variable: /:\{[^}]+\}/,
-            symbol: [/:\([a-f\d]+\)/i, /:\[[^\]]+\]/, /:[)>o":]/]
-          },
-          greedy: true
-        },
-        number: /(?:\B-)?(?:\b\d+(?:\.\d*)?|\B\.\d+)/,
-        symbol: {
-          pattern: /(^|\s)(?:A )?(?:BUKKIT|NOOB|NUMBAR|NUMBR|TROOF|YARN)(?=\s|,|$)/,
-          lookbehind: true,
-          inside: {
-            keyword: /A(?=\s)/
-          }
-        },
-        label: {
-          pattern: /((?:^|\s)(?:IM IN YR|IM OUTTA YR) )[a-zA-Z]\w*/,
-          lookbehind: true,
-          alias: "string"
-        },
-        function: {
-          pattern: /((?:^|\s)(?:HOW IZ I|I IZ|IZ) )[a-zA-Z]\w*/,
-          lookbehind: true
-        },
-        keyword: [
-          {
-            pattern: /(^|\s)(?:AN|FOUND YR|GIMMEH|GTFO|HAI|HAS A|HOW IZ I|I HAS A|I IZ|IF U SAY SO|IM IN YR|IM OUTTA YR|IS NOW(?: A)?|ITZ(?: A)?|IZ|KTHX|KTHXBYE|LIEK(?: A)?|MAEK|MEBBE|MKAY|NERFIN|NO WAI|O HAI IM|O RLY\?|OIC|OMG|OMGWTF|R|SMOOSH|SRS|TIL|UPPIN|VISIBLE|WILE|WTF\?|YA RLY|YR)(?=\s|,|$)/,
-            lookbehind: true
-          },
-          /'Z(?=\s|,|$)/
-        ],
-        boolean: {
-          pattern: /(^|\s)(?:FAIL|WIN)(?=\s|,|$)/,
-          lookbehind: true
-        },
-        variable: {
-          pattern: /(^|\s)IT(?=\s|,|$)/,
-          lookbehind: true
-        },
-        operator: {
-          pattern: /(^|\s)(?:NOT|BOTH SAEM|DIFFRINT|(?:ALL|ANY|BIGGR|BOTH|DIFF|EITHER|MOD|PRODUKT|QUOSHUNT|SMALLR|SUM|WON) OF)(?=\s|,|$)/,
-          lookbehind: true
-        },
-        punctuation: /\.{3}|…|,|!/
-      };
-    }
-    __name(lolcode, "lolcode");
-  }
-});
-
-export {
-  require_lolcode
-};

package/dist/_browser-chunks/chunk-76374D3V.js

@@ -1,104 +0,0 @@
-import {
-  __commonJS,
-  __name
-} from "./chunk-MM7DTO55.js";
-
-// ../node_modules/refractor/lang/uri.js
-var require_uri = __commonJS({
-  "../node_modules/refractor/lang/uri.js"(exports, module) {
-    module.exports = uri;
-    uri.displayName = "uri";
-    uri.aliases = ["url"];
-    function uri(Prism) {
-      Prism.languages.uri = {
-        scheme: {
-          pattern: /^[a-z][a-z0-9+.-]*:/im,
-          greedy: true,
-          inside: {
-            "scheme-delimiter": /:$/
-          }
-        },
-        fragment: {
-          pattern: /#[\w\-.~!$&'()*+,;=%:@/?]*/,
-          inside: {
-            "fragment-delimiter": /^#/
-          }
-        },
-        query: {
-          pattern: /\?[\w\-.~!$&'()*+,;=%:@/?]*/,
-          inside: {
-            "query-delimiter": {
-              pattern: /^\?/,
-              greedy: true
-            },
-            "pair-delimiter": /[&;]/,
-            pair: {
-              pattern: /^[^=][\s\S]*/,
-              inside: {
-                key: /^[^=]+/,
-                value: {
-                  pattern: /(^=)[\s\S]+/,
-                  lookbehind: true
-                }
-              }
-            }
-          }
-        },
-        authority: {
-          pattern: RegExp(
-            /^\/\//.source + // [ userinfo "@" ]
-            /(?:[\w\-.~!$&'()*+,;=%:]*@)?/.source + // host
-            ("(?:" + // IP-literal
-            /\[(?:[0-9a-fA-F:.]{2,48}|v[0-9a-fA-F]+\.[\w\-.~!$&'()*+,;=]+)\]/.source + "|" + // IPv4address or registered name
-            /[\w\-.~!$&'()*+,;=%]*/.source + ")") + // [ ":" port ]
-            /(?::\d*)?/.source,
-            "m"
-          ),
-          inside: {
-            "authority-delimiter": /^\/\//,
-            "user-info-segment": {
-              pattern: /^[\w\-.~!$&'()*+,;=%:]*@/,
-              inside: {
-                "user-info-delimiter": /@$/,
-                "user-info": /^[\w\-.~!$&'()*+,;=%:]+/
-              }
-            },
-            "port-segment": {
-              pattern: /:\d*$/,
-              inside: {
-                "port-delimiter": /^:/,
-                port: /^\d+/
-              }
-            },
-            host: {
-              pattern: /[\s\S]+/,
-              inside: {
-                "ip-literal": {
-                  pattern: /^\[[\s\S]+\]$/,
-                  inside: {
-                    "ip-literal-delimiter": /^\[|\]$/,
-                    "ipv-future": /^v[\s\S]+/,
-                    "ipv6-address": /^[\s\S]+/
-                  }
-                },
-                "ipv4-address": /^(?:(?:[03-9]\d?|[12]\d{0,2})\.){3}(?:[03-9]\d?|[12]\d{0,2})$/
-              }
-            }
-          }
-        },
-        path: {
-          pattern: /^[\w\-.~!$&'()*+,;=%:@/]+/m,
-          inside: {
-            "path-separator": /\//
-          }
-        }
-      };
-      Prism.languages.url = Prism.languages.uri;
-    }
-    __name(uri, "uri");
-  }
-});
-
-export {
-  require_uri
-};