@photonix/basic 2.3.0 → 3.0.0

package/dist/chunk-VT6UVRUK.mjs

@@ -1,191 +0,0 @@
-import {
-  clike
-} from "./chunk-XWTEQUC3.mjs";
-
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/ruby.js
-ruby.displayName = "ruby";
-ruby.aliases = ["rb"];
-function ruby(Prism) {
-  Prism.register(clike);
-  (function(Prism2) {
-    Prism2.languages.ruby = Prism2.languages.extend("clike", {
-      comment: {
-        pattern: /#.*|^=begin\s[\s\S]*?^=end/m,
-        greedy: true
-      },
-      "class-name": {
-        pattern: /(\b(?:class|module)\s+|\bcatch\s+\()[\w.\\]+|\b[A-Z_]\w*(?=\s*\.\s*new\b)/,
-        lookbehind: true,
-        inside: {
-          punctuation: /[.\\]/
-        }
-      },
-      keyword: /\b(?:BEGIN|END|alias|and|begin|break|case|class|def|define_method|defined|do|each|else|elsif|end|ensure|extend|for|if|in|include|module|new|next|nil|not|or|prepend|private|protected|public|raise|redo|require|rescue|retry|return|self|super|then|throw|undef|unless|until|when|while|yield)\b/,
-      operator: /\.{2,3}|&\.|===|<?=>|[!=]?~|(?:&&|\|\||<<|>>|\*\*|[+\-*/%<>!^&|=])=?|[?:]/,
-      punctuation: /[(){}[\].,;]/
-    });
-    Prism2.languages.insertBefore("ruby", "operator", {
-      "double-colon": {
-        pattern: /::/,
-        alias: "punctuation"
-      }
-    });
-    var interpolation = {
-      pattern: /((?:^|[^\\])(?:\\{2})*)#\{(?:[^{}]|\{[^{}]*\})*\}/,
-      lookbehind: true,
-      inside: {
-        content: {
-          pattern: /^(#\{)[\s\S]+(?=\}$)/,
-          lookbehind: true,
-          inside: Prism2.languages.ruby
-        },
-        delimiter: {
-          pattern: /^#\{|\}$/,
-          alias: "punctuation"
-        }
-      }
-    };
-    delete Prism2.languages.ruby.function;
-    var percentExpression = "(?:" + [
-      /([^a-zA-Z0-9\s{(\[<=])(?:(?!\1)[^\\]|\\[\s\S])*\1/.source,
-      /\((?:[^()\\]|\\[\s\S]|\((?:[^()\\]|\\[\s\S])*\))*\)/.source,
-      /\{(?:[^{}\\]|\\[\s\S]|\{(?:[^{}\\]|\\[\s\S])*\})*\}/.source,
-      /\[(?:[^\[\]\\]|\\[\s\S]|\[(?:[^\[\]\\]|\\[\s\S])*\])*\]/.source,
-      /<(?:[^<>\\]|\\[\s\S]|<(?:[^<>\\]|\\[\s\S])*>)*>/.source
-    ].join("|") + ")";
-    var symbolName = /(?:"(?:\\.|[^"\\\r\n])*"|(?:\b[a-zA-Z_]\w*|[^\s\0-\x7F]+)[?!]?|\$.)/.source;
-    Prism2.languages.insertBefore("ruby", "keyword", {
-      "regex-literal": [
-        {
-          pattern: RegExp(
-            /%r/.source + percentExpression + /[egimnosux]{0,6}/.source
-          ),
-          greedy: true,
-          inside: {
-            interpolation,
-            regex: /[\s\S]+/
-          }
-        },
-        {
-          pattern: /(^|[^/])\/(?!\/)(?:\[[^\r\n\]]+\]|\\.|[^[/\\\r\n])+\/[egimnosux]{0,6}(?=\s*(?:$|[\r\n,.;})#]))/,
-          lookbehind: true,
-          greedy: true,
-          inside: {
-            interpolation,
-            regex: /[\s\S]+/
-          }
-        }
-      ],
-      variable: /[@$]+[a-zA-Z_]\w*(?:[?!]|\b)/,
-      symbol: [
-        {
-          pattern: RegExp(/(^|[^:]):/.source + symbolName),
-          lookbehind: true,
-          greedy: true
-        },
-        {
-          pattern: RegExp(
-            /([\r\n{(,][ \t]*)/.source + symbolName + /(?=:(?!:))/.source
-          ),
-          lookbehind: true,
-          greedy: true
-        }
-      ],
-      "method-definition": {
-        pattern: /(\bdef\s+)\w+(?:\s*\.\s*\w+)?/,
-        lookbehind: true,
-        inside: {
-          function: /\b\w+$/,
-          keyword: /^self\b/,
-          "class-name": /^\w+/,
-          punctuation: /\./
-        }
-      }
-    });
-    Prism2.languages.insertBefore("ruby", "string", {
-      "string-literal": [
-        {
-          pattern: RegExp(/%[qQiIwWs]?/.source + percentExpression),
-          greedy: true,
-          inside: {
-            interpolation,
-            string: /[\s\S]+/
-          }
-        },
-        {
-          pattern: /("|')(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|(?!\1)[^\\#\r\n])*\1/,
-          greedy: true,
-          inside: {
-            interpolation,
-            string: /[\s\S]+/
-          }
-        },
-        {
-          pattern: /<<[-~]?([a-z_]\w*)[\r\n](?:.*[\r\n])*?[\t ]*\1/i,
-          alias: "heredoc-string",
-          greedy: true,
-          inside: {
-            delimiter: {
-              pattern: /^<<[-~]?[a-z_]\w*|\b[a-z_]\w*$/i,
-              inside: {
-                symbol: /\b\w+/,
-                punctuation: /^<<[-~]?/
-              }
-            },
-            interpolation,
-            string: /[\s\S]+/
-          }
-        },
-        {
-          pattern: /<<[-~]?'([a-z_]\w*)'[\r\n](?:.*[\r\n])*?[\t ]*\1/i,
-          alias: "heredoc-string",
-          greedy: true,
-          inside: {
-            delimiter: {
-              pattern: /^<<[-~]?'[a-z_]\w*'|\b[a-z_]\w*$/i,
-              inside: {
-                symbol: /\b\w+/,
-                punctuation: /^<<[-~]?'|'$/
-              }
-            },
-            string: /[\s\S]+/
-          }
-        }
-      ],
-      "command-literal": [
-        {
-          pattern: RegExp(/%x/.source + percentExpression),
-          greedy: true,
-          inside: {
-            interpolation,
-            command: {
-              pattern: /[\s\S]+/,
-              alias: "string"
-            }
-          }
-        },
-        {
-          pattern: /`(?:#\{[^}]+\}|#(?!\{)|\\(?:\r\n|[\s\S])|[^\\`#\r\n])*`/,
-          greedy: true,
-          inside: {
-            interpolation,
-            command: {
-              pattern: /[\s\S]+/,
-              alias: "string"
-            }
-          }
-        }
-      ]
-    });
-    delete Prism2.languages.ruby.string;
-    Prism2.languages.insertBefore("ruby", "number", {
-      builtin: /\b(?:Array|Bignum|Binding|Class|Continuation|Dir|Exception|FalseClass|File|Fixnum|Float|Hash|IO|Integer|MatchData|Method|Module|NilClass|Numeric|Object|Proc|Range|Regexp|Stat|String|Struct|Symbol|TMS|Thread|ThreadGroup|Time|TrueClass)\b/,
-      constant: /\b[A-Z][A-Z0-9_]*(?:[?!]|\b)/
-    });
-    Prism2.languages.rb = Prism2.languages.ruby;
-  })(Prism);
-}
-
-export {
-  ruby
-};

package/dist/chunk-VU5NGO62.mjs

@@ -1,79 +0,0 @@
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/bicep.js
-bicep.displayName = "bicep";
-bicep.aliases = [];
-function bicep(Prism) {
-  Prism.languages.bicep = {
-    comment: [
-      {
-        // multiline comments eg /* ASDF */
-        pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
-        lookbehind: true,
-        greedy: true
-      },
-      {
-        // singleline comments eg // ASDF
-        pattern: /(^|[^\\:])\/\/.*/,
-        lookbehind: true,
-        greedy: true
-      }
-    ],
-    property: [
-      {
-        pattern: /([\r\n][ \t]*)[a-z_]\w*(?=[ \t]*:)/i,
-        lookbehind: true
-      },
-      {
-        pattern: /([\r\n][ \t]*)'(?:\\.|\$(?!\{)|[^'\\\r\n$])*'(?=[ \t]*:)/,
-        lookbehind: true,
-        greedy: true
-      }
-    ],
-    string: [
-      {
-        pattern: /'''[^'][\s\S]*?'''/,
-        greedy: true
-      },
-      {
-        pattern: /(^|[^\\'])'(?:\\.|\$(?!\{)|[^'\\\r\n$])*'/,
-        lookbehind: true,
-        greedy: true
-      }
-    ],
-    "interpolated-string": {
-      pattern: /(^|[^\\'])'(?:\\.|\$(?:(?!\{)|\{[^{}\r\n]*\})|[^'\\\r\n$])*'/,
-      lookbehind: true,
-      greedy: true,
-      inside: {
-        interpolation: {
-          pattern: /\$\{[^{}\r\n]*\}/,
-          inside: {
-            expression: {
-              pattern: /(^\$\{)[\s\S]+(?=\}$)/,
-              lookbehind: true
-            },
-            punctuation: /^\$\{|\}$/
-          }
-        },
-        string: /[\s\S]+/
-      }
-    },
-    datatype: {
-      pattern: /(\b(?:output|param)\b[ \t]+\w+[ \t]+)\w+\b/,
-      lookbehind: true,
-      alias: "class-name"
-    },
-    boolean: /\b(?:false|true)\b/,
-    // https://github.com/Azure/bicep/blob/114a3251b4e6e30082a58729f19a8cc4e374ffa6/src/textmate/bicep.tmlanguage#L184
-    keyword: /\b(?:existing|for|if|in|module|null|output|param|resource|targetScope|var)\b/,
-    decorator: /@\w+\b/,
-    function: /\b[a-z_]\w*(?=[ \t]*\()/i,
-    number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:E[+-]?\d+)?/i,
-    operator: /--|\+\+|\*\*=?|=>|&&=?|\|\|=?|[!=]==|<<=?|>>>?=?|[-+*/%&|^!=<>]=?|\.{3}|\?\?=?|\?\.?|[~:]/,
-    punctuation: /[{}[\];(),.:]/
-  };
-  Prism.languages.bicep["interpolated-string"].inside["interpolation"].inside["expression"].inside = Prism.languages.bicep;
-}
-
-export {
-  bicep
-};

package/dist/chunk-VUMGZLUD.mjs

@@ -1,46 +0,0 @@
-import {
-  javascript
-} from "./chunk-ZJYVOTZA.mjs";
-
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/flow.js
-flow.displayName = "flow";
-flow.aliases = [];
-function flow(Prism) {
-  Prism.register(javascript);
-  (function(Prism2) {
-    Prism2.languages.flow = Prism2.languages.extend("javascript", {});
-    Prism2.languages.insertBefore("flow", "keyword", {
-      type: [
-        {
-          pattern: /\b(?:[Bb]oolean|Function|[Nn]umber|[Ss]tring|[Ss]ymbol|any|mixed|null|void)\b/,
-          alias: "class-name"
-        }
-      ]
-    });
-    Prism2.languages.flow["function-variable"].pattern = /(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*=\s*(?:function\b|(?:\([^()]*\)(?:\s*:\s*\w+)?|(?!\s)[_$a-z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*)\s*=>))/i;
-    delete Prism2.languages.flow["parameter"];
-    Prism2.languages.insertBefore("flow", "operator", {
-      "flow-punctuation": {
-        pattern: /\{\||\|\}/,
-        alias: "punctuation"
-      }
-    });
-    if (!Array.isArray(Prism2.languages.flow.keyword)) {
-      Prism2.languages.flow.keyword = [Prism2.languages.flow.keyword];
-    }
-    Prism2.languages.flow.keyword.unshift(
-      {
-        pattern: /(^|[^$]\b)(?:Class|declare|opaque|type)\b(?!\$)/,
-        lookbehind: true
-      },
-      {
-        pattern: /(^|[^$]\B)\$(?:Diff|Enum|Exact|Keys|ObjMap|PropertyType|Record|Shape|Subtype|Supertype|await)\b(?!\$)/,
-        lookbehind: true
-      }
-    );
-  })(Prism);
-}
-
-export {
-  flow
-};

package/dist/chunk-VUPGUO7S.mjs

@@ -1,36 +0,0 @@
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/editorconfig.js
-editorconfig.displayName = "editorconfig";
-editorconfig.aliases = [];
-function editorconfig(Prism) {
-  Prism.languages.editorconfig = {
-    // https://editorconfig-specification.readthedocs.io
-    comment: /[;#].*/,
-    section: {
-      pattern: /(^[ \t]*)\[.+\]/m,
-      lookbehind: true,
-      alias: "selector",
-      inside: {
-        regex: /\\\\[\[\]{},!?.*]/,
-        // Escape special characters with '\\'
-        operator: /[!?]|\.\.|\*{1,2}/,
-        punctuation: /[\[\]{},]/
-      }
-    },
-    key: {
-      pattern: /(^[ \t]*)[^\s=]+(?=[ \t]*=)/m,
-      lookbehind: true,
-      alias: "attr-name"
-    },
-    value: {
-      pattern: /=.*/,
-      alias: "attr-value",
-      inside: {
-        punctuation: /^=/
-      }
-    }
-  };
-}
-
-export {
-  editorconfig
-};

package/dist/chunk-VYROA6XP.mjs

@@ -1,145 +0,0 @@
-import {
-  csharp
-} from "./chunk-MZQNC4B2.mjs";
-import {
-  markup
-} from "./chunk-ACDTS7FW.mjs";
-
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/cshtml.js
-cshtml.displayName = "cshtml";
-cshtml.aliases = ["razor"];
-function cshtml(Prism) {
-  Prism.register(csharp);
-  Prism.register(markup);
-  (function(Prism2) {
-    var commentLike = /\/(?![/*])|\/\/.*[\r\n]|\/\*[^*]*(?:\*(?!\/)[^*]*)*\*\//.source;
-    var stringLike = /@(?!")|"(?:[^\r\n\\"]|\\.)*"|@"(?:[^\\"]|""|\\[\s\S])*"(?!")/.source + "|" + /'(?:(?:[^\r\n'\\]|\\.|\\[Uux][\da-fA-F]{1,8})'|(?=[^\\](?!')))/.source;
-    function nested(pattern, depthLog2) {
-      for (var i = 0; i < depthLog2; i++) {
-        pattern = pattern.replace(/<self>/g, function() {
-          return "(?:" + pattern + ")";
-        });
-      }
-      return pattern.replace(/<self>/g, "[^\\s\\S]").replace(/<str>/g, "(?:" + stringLike + ")").replace(/<comment>/g, "(?:" + commentLike + ")");
-    }
-    var round = nested(/\((?:[^()'"@/]|<str>|<comment>|<self>)*\)/.source, 2);
-    var square = nested(/\[(?:[^\[\]'"@/]|<str>|<comment>|<self>)*\]/.source, 1);
-    var curly = nested(/\{(?:[^{}'"@/]|<str>|<comment>|<self>)*\}/.source, 2);
-    var angle = nested(/<(?:[^<>'"@/]|<comment>|<self>)*>/.source, 1);
-    var inlineCs = /@/.source + /(?:await\b\s*)?/.source + "(?:" + /(?!await\b)\w+\b/.source + "|" + round + ")(?:" + /[?!]?\.\w+\b/.source + "|(?:" + angle + ")?" + round + "|" + square + ")*" + /(?![?!\.(\[]|<(?!\/))/.source;
-    var tagAttrInlineCs = /@(?![\w()])/.source + "|" + inlineCs;
-    var tagAttrValue = "(?:" + /"[^"@]*"|'[^'@]*'|[^\s'"@>=]+(?=[\s>])/.source + `|["'][^"'@]*(?:(?:` + tagAttrInlineCs + `)[^"'@]*)+["'])`;
-    var tagAttrs = /(?:\s(?:\s*[^\s>\/=]+(?:\s*=\s*<tagAttrValue>|(?=[\s/>])))+)?/.source.replace(
-      /<tagAttrValue>/,
-      tagAttrValue
-    );
-    var tagContent = /(?!\d)[^\s>\/=$<%]+/.source + tagAttrs + /\s*\/?>/.source;
-    var tagRegion = /\B@?/.source + "(?:" + /<([a-zA-Z][\w:]*)/.source + tagAttrs + /\s*>/.source + "(?:" + (/[^<]/.source + "|" + // all tags that are not the start tag
-    // eslint-disable-next-line regexp/strict
-    /<\/?(?!\1\b)/.source + tagContent + "|" + // nested start tag
-    nested(
-      // eslint-disable-next-line regexp/strict
-      /<\1/.source + tagAttrs + /\s*>/.source + "(?:" + (/[^<]/.source + "|" + // all tags that are not the start tag
-      // eslint-disable-next-line regexp/strict
-      /<\/?(?!\1\b)/.source + tagContent + "|<self>") + ")*" + // eslint-disable-next-line regexp/strict
-      /<\/\1\s*>/.source,
-      2
-    )) + ")*" + // eslint-disable-next-line regexp/strict
-    /<\/\1\s*>/.source + "|" + /</.source + tagContent + ")";
-    Prism2.languages.cshtml = Prism2.languages.extend("markup", {});
-    var csharpWithHtml = Prism2.languages.insertBefore(
-      "csharp",
-      "string",
-      {
-        html: {
-          pattern: RegExp(tagRegion),
-          greedy: true,
-          inside: Prism2.languages.cshtml
-        }
-      },
-      {
-        csharp: Prism2.languages.extend("csharp", {})
-      }
-    );
-    var cs = {
-      pattern: /\S[\s\S]*/,
-      alias: "language-csharp",
-      inside: csharpWithHtml
-    };
-    var inlineValue = {
-      pattern: RegExp(/(^|[^@])/.source + inlineCs),
-      lookbehind: true,
-      greedy: true,
-      alias: "variable",
-      inside: {
-        keyword: /^@/,
-        csharp: cs
-      }
-    };
-    Prism2.languages.cshtml.tag.pattern = RegExp(/<\/?/.source + tagContent);
-    Prism2.languages.cshtml.tag.inside["attr-value"].pattern = RegExp(
-      /=\s*/.source + tagAttrValue
-    );
-    Prism2.languages.insertBefore(
-      "inside",
-      "punctuation",
-      {
-        value: inlineValue
-      },
-      Prism2.languages.cshtml.tag.inside["attr-value"]
-    );
-    Prism2.languages.insertBefore("cshtml", "prolog", {
-      "razor-comment": {
-        pattern: /@\*[\s\S]*?\*@/,
-        greedy: true,
-        alias: "comment"
-      },
-      block: {
-        pattern: RegExp(
-          /(^|[^@])@/.source + "(?:" + [
-            // @{ ... }
-            curly,
-            // @code{ ... }
-            /(?:code|functions)\s*/.source + curly,
-            // @for (...) { ... }
-            /(?:for|foreach|lock|switch|using|while)\s*/.source + round + /\s*/.source + curly,
-            // @do { ... } while (...);
-            /do\s*/.source + curly + /\s*while\s*/.source + round + /(?:\s*;)?/.source,
-            // @try { ... } catch (...) { ... } finally { ... }
-            /try\s*/.source + curly + /\s*catch\s*/.source + round + /\s*/.source + curly + /\s*finally\s*/.source + curly,
-            // @if (...) {...} else if (...) {...} else {...}
-            /if\s*/.source + round + /\s*/.source + curly + "(?:" + /\s*else/.source + "(?:" + /\s+if\s*/.source + round + ")?" + /\s*/.source + curly + ")*",
-            // @helper Ident(params) { ... }
-            /helper\s+\w+\s*/.source + round + /\s*/.source + curly
-          ].join("|") + ")"
-        ),
-        lookbehind: true,
-        greedy: true,
-        inside: {
-          keyword: /^@\w*/,
-          csharp: cs
-        }
-      },
-      directive: {
-        pattern: /^([ \t]*)@(?:addTagHelper|attribute|implements|inherits|inject|layout|model|namespace|page|preservewhitespace|removeTagHelper|section|tagHelperPrefix|using)(?=\s).*/m,
-        lookbehind: true,
-        greedy: true,
-        inside: {
-          keyword: /^@\w+/,
-          csharp: cs
-        }
-      },
-      value: inlineValue,
-      "delegate-operator": {
-        pattern: /(^|[^@])@(?=<)/,
-        lookbehind: true,
-        alias: "operator"
-      }
-    });
-    Prism2.languages.razor = Prism2.languages.cshtml;
-  })(Prism);
-}
-
-export {
-  cshtml
-};

package/dist/chunk-W3I5J6QO.mjs

@@ -1,106 +0,0 @@
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/elixir.js
-elixir.displayName = "elixir";
-elixir.aliases = [];
-function elixir(Prism) {
-  Prism.languages.elixir = {
-    doc: {
-      pattern: /@(?:doc|moduledoc)\s+(?:("""|''')[\s\S]*?\1|("|')(?:\\(?:\r\n|[\s\S])|(?!\2)[^\\\r\n])*\2)/,
-      inside: {
-        attribute: /^@\w+/,
-        string: /['"][\s\S]+/
-      }
-    },
-    comment: {
-      pattern: /#.*/,
-      greedy: true
-    },
-    // ~r"""foo""" (multi-line), ~r'''foo''' (multi-line), ~r/foo/, ~r|foo|, ~r"foo", ~r'foo', ~r(foo), ~r[foo], ~r{foo}, ~r<foo>
-    regex: {
-      pattern: /~[rR](?:("""|''')(?:\\[\s\S]|(?!\1)[^\\])+\1|([\/|"'])(?:\\.|(?!\2)[^\\\r\n])+\2|\((?:\\.|[^\\)\r\n])+\)|\[(?:\\.|[^\\\]\r\n])+\]|\{(?:\\.|[^\\}\r\n])+\}|<(?:\\.|[^\\>\r\n])+>)[uismxfr]*/,
-      greedy: true
-    },
-    string: [
-      {
-        // ~s"""foo""" (multi-line), ~s'''foo''' (multi-line), ~s/foo/, ~s|foo|, ~s"foo", ~s'foo', ~s(foo), ~s[foo], ~s{foo} (with interpolation care), ~s<foo>
-        pattern: /~[cCsSwW](?:("""|''')(?:\\[\s\S]|(?!\1)[^\\])+\1|([\/|"'])(?:\\.|(?!\2)[^\\\r\n])+\2|\((?:\\.|[^\\)\r\n])+\)|\[(?:\\.|[^\\\]\r\n])+\]|\{(?:\\.|#\{[^}]+\}|#(?!\{)|[^#\\}\r\n])+\}|<(?:\\.|[^\\>\r\n])+>)[csa]?/,
-        greedy: true,
-        inside: {
-          // See interpolation below
-        }
-      },
-      {
-        pattern: /("""|''')[\s\S]*?\1/,
-        greedy: true,
-        inside: {
-          // See interpolation below
-        }
-      },
-      {
-        // Multi-line strings are allowed
-        pattern: /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
-        greedy: true,
-        inside: {
-          // See interpolation below
-        }
-      }
-    ],
-    atom: {
-      // Look-behind prevents bad highlighting of the :: operator
-      pattern: /(^|[^:]):\w+/,
-      lookbehind: true,
-      alias: "symbol"
-    },
-    module: {
-      pattern: /\b[A-Z]\w*\b/,
-      alias: "class-name"
-    },
-    // Look-ahead prevents bad highlighting of the :: operator
-    "attr-name": /\b\w+\??:(?!:)/,
-    argument: {
-      // Look-behind prevents bad highlighting of the && operator
-      pattern: /(^|[^&])&\d+/,
-      lookbehind: true,
-      alias: "variable"
-    },
-    attribute: {
-      pattern: /@\w+/,
-      alias: "variable"
-    },
-    function: /\b[_a-zA-Z]\w*[?!]?(?:(?=\s*(?:\.\s*)?\()|(?=\/\d))/,
-    number: /\b(?:0[box][a-f\d_]+|\d[\d_]*)(?:\.[\d_]+)?(?:e[+-]?[\d_]+)?\b/i,
-    keyword: /\b(?:after|alias|and|case|catch|cond|def(?:callback|delegate|exception|impl|macro|module|n|np|p|protocol|struct)?|do|else|end|fn|for|if|import|not|or|quote|raise|require|rescue|try|unless|unquote|use|when)\b/,
-    boolean: /\b(?:false|nil|true)\b/,
-    operator: [
-      /\bin\b|&&?|\|[|>]?|\\\\|::|\.\.\.?|\+\+?|-[->]?|<[-=>]|>=|!==?|\B!|=(?:==?|[>~])?|[*\/^]/,
-      {
-        // We don't want to match <<
-        pattern: /([^<])<(?!<)/,
-        lookbehind: true
-      },
-      {
-        // We don't want to match >>
-        pattern: /([^>])>(?!>)/,
-        lookbehind: true
-      }
-    ],
-    punctuation: /<<|>>|[.,%\[\]{}()]/
-  };
-  Prism.languages.elixir.string.forEach(function(o) {
-    o.inside = {
-      interpolation: {
-        pattern: /#\{[^}]+\}/,
-        inside: {
-          delimiter: {
-            pattern: /^#\{|\}$/,
-            alias: "punctuation"
-          },
-          rest: Prism.languages.elixir
-        }
-      }
-    };
-  });
-}
-
-export {
-  elixir
-};

package/dist/chunk-WA4EZBP4.mjs

@@ -1,29 +0,0 @@
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/yang.js
-yang.displayName = "yang";
-yang.aliases = [];
-function yang(Prism) {
-  Prism.languages.yang = {
-    // https://tools.ietf.org/html/rfc6020#page-34
-    // http://www.yang-central.org/twiki/bin/view/Main/YangExamples
-    comment: /\/\*[\s\S]*?\*\/|\/\/.*/,
-    string: {
-      pattern: /"(?:[^\\"]|\\.)*"|'[^']*'/,
-      greedy: true
-    },
-    keyword: {
-      pattern: /(^|[{};\r\n][ \t]*)[a-z_][\w.-]*/i,
-      lookbehind: true
-    },
-    namespace: {
-      pattern: /(\s)[a-z_][\w.-]*(?=:)/i,
-      lookbehind: true
-    },
-    boolean: /\b(?:false|true)\b/,
-    operator: /\+/,
-    punctuation: /[{};:]/
-  };
-}
-
-export {
-  yang
-};

package/dist/chunk-WAQCRODX.mjs

@@ -1,31 +0,0 @@
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/ignore.js
-ignore.displayName = "ignore";
-ignore.aliases = ["gitignore", "hgignore", "npmignore"];
-function ignore(Prism) {
-  ;
-  (function(Prism2) {
-    Prism2.languages.ignore = {
-      // https://git-scm.com/docs/gitignore
-      comment: /^#.*/m,
-      entry: {
-        pattern: /\S(?:.*(?:(?:\\ )|\S))?/,
-        alias: "string",
-        inside: {
-          operator: /^!|\*\*?|\?/,
-          regex: {
-            pattern: /(^|[^\\])\[[^\[\]]*\]/,
-            lookbehind: true
-          },
-          punctuation: /\//
-        }
-      }
-    };
-    Prism2.languages.gitignore = Prism2.languages.ignore;
-    Prism2.languages.hgignore = Prism2.languages.ignore;
-    Prism2.languages.npmignore = Prism2.languages.ignore;
-  })(Prism);
-}
-
-export {
-  ignore
-};