@distri/react 0.3.3 → 0.3.4

package/dist/chunk-QHKGD7XU.js

@@ -1,199 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/markup.js
-var require_markup = __commonJS({
-  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/markup.js"(exports, module) {
-    module.exports = markup;
-    markup.displayName = "markup";
-    markup.aliases = ["html", "mathml", "svg", "xml", "ssml", "atom", "rss"];
-    function markup(Prism) {
-      Prism.languages.markup = {
-        comment: {
-          pattern: /<!--(?:(?!<!--)[\s\S])*?-->/,
-          greedy: true
-        },
-        prolog: {
-          pattern: /<\?[\s\S]+?\?>/,
-          greedy: true
-        },
-        doctype: {
-          // https://www.w3.org/TR/xml/#NT-doctypedecl
-          pattern: /<!DOCTYPE(?:[^>"'[\]]|"[^"]*"|'[^']*')+(?:\[(?:[^<"'\]]|"[^"]*"|'[^']*'|<(?!!--)|<!--(?:[^-]|-(?!->))*-->)*\]\s*)?>/i,
-          greedy: true,
-          inside: {
-            "internal-subset": {
-              pattern: /(^[^\[]*\[)[\s\S]+(?=\]>$)/,
-              lookbehind: true,
-              greedy: true,
-              inside: null
-              // see below
-            },
-            string: {
-              pattern: /"[^"]*"|'[^']*'/,
-              greedy: true
-            },
-            punctuation: /^<!|>$|[[\]]/,
-            "doctype-tag": /^DOCTYPE/i,
-            name: /[^\s<>'"]+/
-          }
-        },
-        cdata: {
-          pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
-          greedy: true
-        },
-        tag: {
-          pattern: /<\/?(?!\d)[^\s>\/=$<%]+(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))|(?=[\s/>])))+)?\s*\/?>/,
-          greedy: true,
-          inside: {
-            tag: {
-              pattern: /^<\/?[^\s>\/]+/,
-              inside: {
-                punctuation: /^<\/?/,
-                namespace: /^[^\s>\/:]+:/
-              }
-            },
-            "special-attr": [],
-            "attr-value": {
-              pattern: /=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+)/,
-              inside: {
-                punctuation: [
-                  {
-                    pattern: /^=/,
-                    alias: "attr-equals"
-                  },
-                  /"|'/
-                ]
-              }
-            },
-            punctuation: /\/?>/,
-            "attr-name": {
-              pattern: /[^\s>\/]+/,
-              inside: {
-                namespace: /^[^\s>\/:]+:/
-              }
-            }
-          }
-        },
-        entity: [
-          {
-            pattern: /&[\da-z]{1,8};/i,
-            alias: "named-entity"
-          },
-          /&#x?[\da-f]{1,8};/i
-        ]
-      };
-      Prism.languages.markup["tag"].inside["attr-value"].inside["entity"] = Prism.languages.markup["entity"];
-      Prism.languages.markup["doctype"].inside["internal-subset"].inside = Prism.languages.markup;
-      Prism.hooks.add("wrap", function(env) {
-        if (env.type === "entity") {
-          env.attributes["title"] = env.content.value.replace(/&amp;/, "&");
-        }
-      });
-      Object.defineProperty(Prism.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 addInlined(tagName, lang) {
-          var includedCdataInside = {};
-          includedCdataInside["language-" + lang] = {
-            pattern: /(^<!\[CDATA\[)[\s\S]+?(?=\]\]>$)/i,
-            lookbehind: true,
-            inside: Prism.languages[lang]
-          };
-          includedCdataInside["cdata"] = /^<!\[CDATA\[|\]\]>$/i;
-          var inside = {
-            "included-cdata": {
-              pattern: /<!\[CDATA\[[\s\S]*?\]\]>/i,
-              inside: includedCdataInside
-            }
-          };
-          inside["language-" + lang] = {
-            pattern: /[\s\S]+/,
-            inside: Prism.languages[lang]
-          };
-          var def = {};
-          def[tagName] = {
-            pattern: RegExp(
-              /(<__[^>]*>)(?:<!\[CDATA\[(?:[^\]]|\](?!\]>))*\]\]>|(?!<!\[CDATA\[)[\s\S])*?(?=<\/__>)/.source.replace(
-                /__/g,
-                function() {
-                  return tagName;
-                }
-              ),
-              "i"
-            ),
-            lookbehind: true,
-            greedy: true,
-            inside
-          };
-          Prism.languages.insertBefore("markup", "cdata", def);
-        }
-      });
-      Object.defineProperty(Prism.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(attrName, lang) {
-          Prism.languages.markup.tag.inside["special-attr"].push({
-            pattern: RegExp(
-              /(^|["'\s])/.source + "(?:" + attrName + ")" + /\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+(?=[\s>]))/.source,
-              "i"
-            ),
-            lookbehind: true,
-            inside: {
-              "attr-name": /^[^\s=]+/,
-              "attr-value": {
-                pattern: /=[\s\S]+/,
-                inside: {
-                  value: {
-                    pattern: /(^=\s*(["']|(?!["'])))\S[\s\S]*(?=\2$)/,
-                    lookbehind: true,
-                    alias: [lang, "language-" + lang],
-                    inside: Prism.languages[lang]
-                  },
-                  punctuation: [
-                    {
-                      pattern: /^=/,
-                      alias: "attr-equals"
-                    },
-                    /"|'/
-                  ]
-                }
-              }
-            }
-          });
-        }
-      });
-      Prism.languages.html = Prism.languages.markup;
-      Prism.languages.mathml = Prism.languages.markup;
-      Prism.languages.svg = Prism.languages.markup;
-      Prism.languages.xml = Prism.languages.extend("markup", {});
-      Prism.languages.ssml = Prism.languages.xml;
-      Prism.languages.atom = Prism.languages.xml;
-      Prism.languages.rss = Prism.languages.xml;
-    }
-  }
-});
-
-export {
-  require_markup
-};

package/dist/chunk-QK37NBUF.js

@@ -1,68 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/aql.js
-var require_aql = __commonJS({
-  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/aql.js"(exports, module) {
-    module.exports = aql;
-    aql.displayName = "aql";
-    aql.aliases = [];
-    function aql(Prism) {
-      Prism.languages.aql = {
-        comment: /\/\/.*|\/\*[\s\S]*?\*\//,
-        property: {
-          pattern: /([{,]\s*)(?:(?!\d)\w+|(["'´`])(?:(?!\2)[^\\\r\n]|\\.)*\2)(?=\s*:)/,
-          lookbehind: true,
-          greedy: true
-        },
-        string: {
-          pattern: /(["'])(?:(?!\1)[^\\\r\n]|\\.)*\1/,
-          greedy: true
-        },
-        identifier: {
-          pattern: /([´`])(?:(?!\1)[^\\\r\n]|\\.)*\1/,
-          greedy: true
-        },
-        variable: /@@?\w+/,
-        keyword: [
-          {
-            pattern: /(\bWITH\s+)COUNT(?=\s+INTO\b)/i,
-            lookbehind: true
-          },
-          /\b(?:AGGREGATE|ALL|AND|ANY|ASC|COLLECT|DESC|DISTINCT|FILTER|FOR|GRAPH|IN|INBOUND|INSERT|INTO|K_PATHS|K_SHORTEST_PATHS|LET|LIKE|LIMIT|NONE|NOT|NULL|OR|OUTBOUND|REMOVE|REPLACE|RETURN|SHORTEST_PATH|SORT|UPDATE|UPSERT|WINDOW|WITH)\b/i,
-          // pseudo keywords get a lookbehind to avoid false positives
-          {
-            pattern: /(^|[^\w.[])(?:KEEP|PRUNE|SEARCH|TO)\b/i,
-            lookbehind: true
-          },
-          {
-            pattern: /(^|[^\w.[])(?:CURRENT|NEW|OLD)\b/,
-            lookbehind: true
-          },
-          {
-            pattern: /\bOPTIONS(?=\s*\{)/i
-          }
-        ],
-        function: /\b(?!\d)\w+(?=\s*\()/,
-        boolean: /\b(?:false|true)\b/i,
-        range: {
-          pattern: /\.\./,
-          alias: "operator"
-        },
-        number: [
-          /\b0b[01]+/i,
-          /\b0x[0-9a-f]+/i,
-          /(?:\B\.\d+|\b(?:0|[1-9]\d*)(?:\.\d+)?)(?:e[+-]?\d+)?/i
-        ],
-        operator: /\*{2,}|[=!]~|[!=<>]=?|&&|\|\||[-+*/%]/,
-        punctuation: /::|[?.:,;()[\]{}]/
-      };
-    }
-  }
-});
-
-export {
-  require_aql
-};

package/dist/chunk-QN4RHWLR.js

@@ -1,239 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/asciidoc.js
-var require_asciidoc = __commonJS({
-  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/asciidoc.js"(exports, module) {
-    module.exports = asciidoc;
-    asciidoc.displayName = "asciidoc";
-    asciidoc.aliases = ["adoc"];
-    function asciidoc(Prism) {
-      ;
-      (function(Prism2) {
-        var attributes = {
-          pattern: /(^[ \t]*)\[(?!\[)(?:(["'$`])(?:(?!\2)[^\\]|\\.)*\2|\[(?:[^\[\]\\]|\\.)*\]|[^\[\]\\"'$`]|\\.)*\]/m,
-          lookbehind: true,
-          inside: {
-            quoted: {
-              pattern: /([$`])(?:(?!\1)[^\\]|\\.)*\1/,
-              inside: {
-                punctuation: /^[$`]|[$`]$/
-              }
-            },
-            interpreted: {
-              pattern: /'(?:[^'\\]|\\.)*'/,
-              inside: {
-                punctuation: /^'|'$/
-                // See rest below
-              }
-            },
-            string: /"(?:[^"\\]|\\.)*"/,
-            variable: /\w+(?==)/,
-            punctuation: /^\[|\]$|,/,
-            operator: /=/,
-            // The negative look-ahead prevents blank matches
-            "attr-value": /(?!^\s+$).+/
-          }
-        };
-        var asciidoc2 = Prism2.languages.asciidoc = {
-          "comment-block": {
-            pattern: /^(\/{4,})(?:\r?\n|\r)(?:[\s\S]*(?:\r?\n|\r))??\1/m,
-            alias: "comment"
-          },
-          table: {
-            pattern: /^\|={3,}(?:(?:\r?\n|\r(?!\n)).*)*?(?:\r?\n|\r)\|={3,}$/m,
-            inside: {
-              specifiers: {
-                pattern: /(?:(?:(?:\d+(?:\.\d+)?|\.\d+)[+*](?:[<^>](?:\.[<^>])?|\.[<^>])?|[<^>](?:\.[<^>])?|\.[<^>])[a-z]*|[a-z]+)(?=\|)/,
-                alias: "attr-value"
-              },
-              punctuation: {
-                pattern: /(^|[^\\])[|!]=*/,
-                lookbehind: true
-              }
-              // See rest below
-            }
-          },
-          "passthrough-block": {
-            pattern: /^(\+{4,})(?:\r?\n|\r)(?:[\s\S]*(?:\r?\n|\r))??\1$/m,
-            inside: {
-              punctuation: /^\++|\++$/
-              // See rest below
-            }
-          },
-          // Literal blocks and listing blocks
-          "literal-block": {
-            pattern: /^(-{4,}|\.{4,})(?:\r?\n|\r)(?:[\s\S]*(?:\r?\n|\r))??\1$/m,
-            inside: {
-              punctuation: /^(?:-+|\.+)|(?:-+|\.+)$/
-              // See rest below
-            }
-          },
-          // Sidebar blocks, quote blocks, example blocks and open blocks
-          "other-block": {
-            pattern: /^(--|\*{4,}|_{4,}|={4,})(?:\r?\n|\r)(?:[\s\S]*(?:\r?\n|\r))??\1$/m,
-            inside: {
-              punctuation: /^(?:-+|\*+|_+|=+)|(?:-+|\*+|_+|=+)$/
-              // See rest below
-            }
-          },
-          // list-punctuation and list-label must appear before indented-block
-          "list-punctuation": {
-            pattern: /(^[ \t]*)(?:-|\*{1,5}|\.{1,5}|(?:[a-z]|\d+)\.|[xvi]+\))(?= )/im,
-            lookbehind: true,
-            alias: "punctuation"
-          },
-          "list-label": {
-            pattern: /(^[ \t]*)[a-z\d].+(?::{2,4}|;;)(?=\s)/im,
-            lookbehind: true,
-            alias: "symbol"
-          },
-          "indented-block": {
-            pattern: /((\r?\n|\r)\2)([ \t]+)\S.*(?:(?:\r?\n|\r)\3.+)*(?=\2{2}|$)/,
-            lookbehind: true
-          },
-          comment: /^\/\/.*/m,
-          title: {
-            pattern: /^.+(?:\r?\n|\r)(?:={3,}|-{3,}|~{3,}|\^{3,}|\+{3,})$|^={1,5} .+|^\.(?![\s.]).*/m,
-            alias: "important",
-            inside: {
-              punctuation: /^(?:\.|=+)|(?:=+|-+|~+|\^+|\++)$/
-              // See rest below
-            }
-          },
-          "attribute-entry": {
-            pattern: /^:[^:\r\n]+:(?: .*?(?: \+(?:\r?\n|\r).*?)*)?$/m,
-            alias: "tag"
-          },
-          attributes,
-          hr: {
-            pattern: /^'{3,}$/m,
-            alias: "punctuation"
-          },
-          "page-break": {
-            pattern: /^<{3,}$/m,
-            alias: "punctuation"
-          },
-          admonition: {
-            pattern: /^(?:CAUTION|IMPORTANT|NOTE|TIP|WARNING):/m,
-            alias: "keyword"
-          },
-          callout: [
-            {
-              pattern: /(^[ \t]*)<?\d*>/m,
-              lookbehind: true,
-              alias: "symbol"
-            },
-            {
-              pattern: /<\d+>/,
-              alias: "symbol"
-            }
-          ],
-          macro: {
-            pattern: /\b[a-z\d][a-z\d-]*::?(?:[^\s\[\]]*\[(?:[^\]\\"']|(["'])(?:(?!\1)[^\\]|\\.)*\1|\\.)*\])/,
-            inside: {
-              function: /^[a-z\d-]+(?=:)/,
-              punctuation: /^::?/,
-              attributes: {
-                pattern: /(?:\[(?:[^\]\\"']|(["'])(?:(?!\1)[^\\]|\\.)*\1|\\.)*\])/,
-                inside: attributes.inside
-              }
-            }
-          },
-          inline: {
-            /*
-            The initial look-behind prevents the highlighting of escaped quoted text.
-            Quoted text can be multi-line but cannot span an empty line.
-            All quoted text can have attributes before [foobar, 'foobar', baz="bar"].
-            First, we handle the constrained quotes.
-            Those must be bounded by non-word chars and cannot have spaces between the delimiter and the first char.
-            They are, in order: _emphasis_, ``double quotes'', `single quotes', `monospace`, 'emphasis', *strong*, +monospace+ and #unquoted#
-            Then we handle the unconstrained quotes.
-            Those do not have the restrictions of the constrained quotes.
-            They are, in order: __emphasis__, **strong**, ++monospace++, +++passthrough+++, ##unquoted##, $$passthrough$$, ~subscript~, ^superscript^, {attribute-reference}, [[anchor]], [[[bibliography anchor]]], <<xref>>, (((indexes))) and ((indexes))
-            */
-            pattern: /(^|[^\\])(?:(?:\B\[(?:[^\]\\"']|(["'])(?:(?!\2)[^\\]|\\.)*\2|\\.)*\])?(?:\b_(?!\s)(?: _|[^_\\\r\n]|\\.)+(?:(?:\r?\n|\r)(?: _|[^_\\\r\n]|\\.)+)*_\b|\B``(?!\s).+?(?:(?:\r?\n|\r).+?)*''\B|\B`(?!\s)(?:[^`'\s]|\s+\S)+['`]\B|\B(['*+#])(?!\s)(?: \3|(?!\3)[^\\\r\n]|\\.)+(?:(?:\r?\n|\r)(?: \3|(?!\3)[^\\\r\n]|\\.)+)*\3\B)|(?:\[(?:[^\]\\"']|(["'])(?:(?!\4)[^\\]|\\.)*\4|\\.)*\])?(?:(__|\*\*|\+\+\+?|##|\$\$|[~^]).+?(?:(?:\r?\n|\r).+?)*\5|\{[^}\r\n]+\}|\[\[\[?.+?(?:(?:\r?\n|\r).+?)*\]?\]\]|<<.+?(?:(?:\r?\n|\r).+?)*>>|\(\(\(?.+?(?:(?:\r?\n|\r).+?)*\)?\)\)))/m,
-            lookbehind: true,
-            inside: {
-              attributes,
-              url: {
-                pattern: /^(?:\[\[\[?.+?\]?\]\]|<<.+?>>)$/,
-                inside: {
-                  punctuation: /^(?:\[\[\[?|<<)|(?:\]\]\]?|>>)$/
-                }
-              },
-              "attribute-ref": {
-                pattern: /^\{.+\}$/,
-                inside: {
-                  variable: {
-                    pattern: /(^\{)[a-z\d,+_-]+/,
-                    lookbehind: true
-                  },
-                  operator: /^[=?!#%@$]|!(?=[:}])/,
-                  punctuation: /^\{|\}$|::?/
-                }
-              },
-              italic: {
-                pattern: /^(['_])[\s\S]+\1$/,
-                inside: {
-                  punctuation: /^(?:''?|__?)|(?:''?|__?)$/
-                }
-              },
-              bold: {
-                pattern: /^\*[\s\S]+\*$/,
-                inside: {
-                  punctuation: /^\*\*?|\*\*?$/
-                }
-              },
-              punctuation: /^(?:``?|\+{1,3}|##?|\$\$|[~^]|\(\(\(?)|(?:''?|\+{1,3}|##?|\$\$|[~^`]|\)?\)\))$/
-            }
-          },
-          replacement: {
-            pattern: /\((?:C|R|TM)\)/,
-            alias: "builtin"
-          },
-          entity: /&#?[\da-z]{1,8};/i,
-          "line-continuation": {
-            pattern: /(^| )\+$/m,
-            lookbehind: true,
-            alias: "punctuation"
-          }
-        };
-        function copyFromAsciiDoc(keys) {
-          keys = keys.split(" ");
-          var o = {};
-          for (var i = 0, l = keys.length; i < l; i++) {
-            o[keys[i]] = asciidoc2[keys[i]];
-          }
-          return o;
-        }
-        attributes.inside["interpreted"].inside.rest = copyFromAsciiDoc(
-          "macro inline replacement entity"
-        );
-        asciidoc2["passthrough-block"].inside.rest = copyFromAsciiDoc("macro");
-        asciidoc2["literal-block"].inside.rest = copyFromAsciiDoc("callout");
-        asciidoc2["table"].inside.rest = copyFromAsciiDoc(
-          "comment-block passthrough-block literal-block other-block list-punctuation indented-block comment title attribute-entry attributes hr page-break admonition list-label callout macro inline replacement entity line-continuation"
-        );
-        asciidoc2["other-block"].inside.rest = copyFromAsciiDoc(
-          "table list-punctuation indented-block comment attribute-entry attributes hr page-break admonition list-label macro inline replacement entity line-continuation"
-        );
-        asciidoc2["title"].inside.rest = copyFromAsciiDoc(
-          "macro inline replacement entity"
-        );
-        Prism2.hooks.add("wrap", function(env) {
-          if (env.type === "entity") {
-            env.attributes["title"] = env.content.value.replace(/&amp;/, "&");
-          }
-        });
-        Prism2.languages.adoc = Prism2.languages.asciidoc;
-      })(Prism);
-    }
-  }
-});
-
-export {
-  require_asciidoc
-};

package/dist/chunk-QOBICMKH.js

@@ -1,83 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/antlr4.js
-var require_antlr4 = __commonJS({
-  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/antlr4.js"(exports, module) {
-    module.exports = antlr4;
-    antlr4.displayName = "antlr4";
-    antlr4.aliases = ["g4"];
-    function antlr4(Prism) {
-      Prism.languages.antlr4 = {
-        comment: /\/\/.*|\/\*[\s\S]*?(?:\*\/|$)/,
-        string: {
-          pattern: /'(?:\\.|[^\\'\r\n])*'/,
-          greedy: true
-        },
-        "character-class": {
-          pattern: /\[(?:\\.|[^\\\]\r\n])*\]/,
-          greedy: true,
-          alias: "regex",
-          inside: {
-            range: {
-              pattern: /([^[]|(?:^|[^\\])(?:\\\\)*\\\[)-(?!\])/,
-              lookbehind: true,
-              alias: "punctuation"
-            },
-            escape: /\\(?:u(?:[a-fA-F\d]{4}|\{[a-fA-F\d]+\})|[pP]\{[=\w-]+\}|[^\r\nupP])/,
-            punctuation: /[\[\]]/
-          }
-        },
-        action: {
-          pattern: /\{(?:[^{}]|\{(?:[^{}]|\{(?:[^{}]|\{[^{}]*\})*\})*\})*\}/,
-          greedy: true,
-          inside: {
-            content: {
-              // this might be C, C++, Python, Java, C#, or any other language ANTLR4 compiles to
-              pattern: /(\{)[\s\S]+(?=\})/,
-              lookbehind: true
-            },
-            punctuation: /[{}]/
-          }
-        },
-        command: {
-          pattern: /(->\s*(?!\s))(?:\s*(?:,\s*)?\b[a-z]\w*(?:\s*\([^()\r\n]*\))?)+(?=\s*;)/i,
-          lookbehind: true,
-          inside: {
-            function: /\b\w+(?=\s*(?:[,(]|$))/,
-            punctuation: /[,()]/
-          }
-        },
-        annotation: {
-          pattern: /@\w+(?:::\w+)*/,
-          alias: "keyword"
-        },
-        label: {
-          pattern: /#[ \t]*\w+/,
-          alias: "punctuation"
-        },
-        keyword: /\b(?:catch|channels|finally|fragment|grammar|import|lexer|locals|mode|options|parser|returns|throws|tokens)\b/,
-        definition: [
-          {
-            pattern: /\b[a-z]\w*(?=\s*:)/,
-            alias: ["rule", "class-name"]
-          },
-          {
-            pattern: /\b[A-Z]\w*(?=\s*:)/,
-            alias: ["token", "constant"]
-          }
-        ],
-        constant: /\b[A-Z][A-Z_]*\b/,
-        operator: /\.\.|->|[|~]|[*+?]\??/,
-        punctuation: /[;:()=]/
-      };
-      Prism.languages.g4 = Prism.languages.antlr4;
-    }
-  }
-});
-
-export {
-  require_antlr4
-};

package/dist/chunk-QRKZ53CV.js

@@ -1,40 +0,0 @@
-"use client";
-import {
-  __commonJS
-} from "./chunk-Z7PWFZG5.js";
-
-// ../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/warpscript.js
-var require_warpscript = __commonJS({
-  "../../node_modules/.pnpm/refractor@3.6.0/node_modules/refractor/lang/warpscript.js"(exports, module) {
-    module.exports = warpscript;
-    warpscript.displayName = "warpscript";
-    warpscript.aliases = [];
-    function warpscript(Prism) {
-      Prism.languages.warpscript = {
-        comment: /#.*|\/\/.*|\/\*[\s\S]*?\*\//,
-        string: {
-          pattern: /"(?:[^"\\\r\n]|\\.)*"|'(?:[^'\\\r\n]|\\.)*'|<'(?:[^\\']|'(?!>)|\\.)*'>/,
-          greedy: true
-        },
-        variable: /\$\S+/,
-        macro: {
-          pattern: /@\S+/,
-          alias: "property"
-        },
-        // WarpScript doesn't have any keywords, these are all functions under the control category
-        // https://www.warp10.io/tags/control
-        keyword: /\b(?:BREAK|CHECKMACRO|CONTINUE|CUDF|DEFINED|DEFINEDMACRO|EVAL|FAIL|FOR|FOREACH|FORSTEP|IFT|IFTE|MSGFAIL|NRETURN|RETHROW|RETURN|SWITCH|TRY|UDF|UNTIL|WHILE)\b/,
-        number: /[+-]?\b(?:NaN|Infinity|\d+(?:\.\d*)?(?:[Ee][+-]?\d+)?|0x[\da-fA-F]+|0b[01]+)\b/,
-        boolean: /\b(?:F|T|false|true)\b/,
-        punctuation: /<%|%>|[{}[\]()]/,
-        // Some operators from the "operators" category
-        // https://www.warp10.io/tags/operators
-        operator: /==|&&?|\|\|?|\*\*?|>>>?|<<|[<>!~]=?|[-/%^]|\+!?|\b(?:AND|NOT|OR)\b/
-      };
-    }
-  }
-});
-
-export {
-  require_warpscript
-};