@photonix/basic 1.5.1 → 1.6.0

package/dist/chunk-VT6UVRUK.mjs

@@ -0,0 +1,191 @@
+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

@@ -0,0 +1,79 @@
+// ../../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

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,36 @@
+// ../../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

@@ -0,0 +1,145 @@
+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

@@ -0,0 +1,106 @@
+// ../../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

@@ -0,0 +1,29 @@
+// ../../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

@@ -0,0 +1,31 @@
+// ../../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
+};