@photonix/basic 2.3.0 → 3.0.0

package/dist/chunk-5SKARUX7.mjs

@@ -1,203 +0,0 @@
-import {
-  markup
-} from "./chunk-ACDTS7FW.mjs";
-import {
-  javascript
-} from "./chunk-ZJYVOTZA.mjs";
-
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/pug.js
-pug.displayName = "pug";
-pug.aliases = [];
-function pug(Prism) {
-  Prism.register(javascript);
-  Prism.register(markup);
-  (function(Prism2) {
-    Prism2.languages.pug = {
-      // Multiline stuff should appear before the rest
-      // This handles both single-line and multi-line comments
-      comment: {
-        pattern: /(^([\t ]*))\/\/.*(?:(?:\r?\n|\r)\2[\t ].+)*/m,
-        lookbehind: true
-      },
-      // All the tag-related part is in lookbehind
-      // so that it can be highlighted by the "tag" pattern
-      "multiline-script": {
-        pattern: /(^([\t ]*)script\b.*\.[\t ]*)(?:(?:\r?\n|\r(?!\n))(?:\2[\t ].+|\s*?(?=\r?\n|\r)))+/m,
-        lookbehind: true,
-        inside: Prism2.languages.javascript
-      },
-      // See at the end of the file for known filters
-      filter: {
-        pattern: /(^([\t ]*)):.+(?:(?:\r?\n|\r(?!\n))(?:\2[\t ].+|\s*?(?=\r?\n|\r)))+/m,
-        lookbehind: true,
-        inside: {
-          "filter-name": {
-            pattern: /^:[\w-]+/,
-            alias: "variable"
-          },
-          text: /\S[\s\S]*/
-        }
-      },
-      "multiline-plain-text": {
-        pattern: /(^([\t ]*)[\w\-#.]+\.[\t ]*)(?:(?:\r?\n|\r(?!\n))(?:\2[\t ].+|\s*?(?=\r?\n|\r)))+/m,
-        lookbehind: true
-      },
-      markup: {
-        pattern: /(^[\t ]*)<.+/m,
-        lookbehind: true,
-        inside: Prism2.languages.markup
-      },
-      doctype: {
-        pattern: /((?:^|\n)[\t ]*)doctype(?: .+)?/,
-        lookbehind: true
-      },
-      // This handle all conditional and loop keywords
-      "flow-control": {
-        pattern: /(^[\t ]*)(?:case|default|each|else|if|unless|when|while)\b(?: .+)?/m,
-        lookbehind: true,
-        inside: {
-          each: {
-            pattern: /^each .+? in\b/,
-            inside: {
-              keyword: /\b(?:each|in)\b/,
-              punctuation: /,/
-            }
-          },
-          branch: {
-            pattern: /^(?:case|default|else|if|unless|when|while)\b/,
-            alias: "keyword"
-          },
-          rest: Prism2.languages.javascript
-        }
-      },
-      keyword: {
-        pattern: /(^[\t ]*)(?:append|block|extends|include|prepend)\b.+/m,
-        lookbehind: true
-      },
-      mixin: [
-        // Declaration
-        {
-          pattern: /(^[\t ]*)mixin .+/m,
-          lookbehind: true,
-          inside: {
-            keyword: /^mixin/,
-            function: /\w+(?=\s*\(|\s*$)/,
-            punctuation: /[(),.]/
-          }
-        },
-        // Usage
-        {
-          pattern: /(^[\t ]*)\+.+/m,
-          lookbehind: true,
-          inside: {
-            name: {
-              pattern: /^\+\w+/,
-              alias: "function"
-            },
-            rest: Prism2.languages.javascript
-          }
-        }
-      ],
-      script: {
-        pattern: /(^[\t ]*script(?:(?:&[^(]+)?\([^)]+\))*[\t ]).+/m,
-        lookbehind: true,
-        inside: Prism2.languages.javascript
-      },
-      "plain-text": {
-        pattern: /(^[\t ]*(?!-)[\w\-#.]*[\w\-](?:(?:&[^(]+)?\([^)]+\))*\/?[\t ]).+/m,
-        lookbehind: true
-      },
-      tag: {
-        pattern: /(^[\t ]*)(?!-)[\w\-#.]*[\w\-](?:(?:&[^(]+)?\([^)]+\))*\/?:?/m,
-        lookbehind: true,
-        inside: {
-          attributes: [
-            {
-              pattern: /&[^(]+\([^)]+\)/,
-              inside: Prism2.languages.javascript
-            },
-            {
-              pattern: /\([^)]+\)/,
-              inside: {
-                "attr-value": {
-                  pattern: /(=\s*(?!\s))(?:\{[^}]*\}|[^,)\r\n]+)/,
-                  lookbehind: true,
-                  inside: Prism2.languages.javascript
-                },
-                "attr-name": /[\w-]+(?=\s*!?=|\s*[,)])/,
-                punctuation: /[!=(),]+/
-              }
-            }
-          ],
-          punctuation: /:/,
-          "attr-id": /#[\w\-]+/,
-          "attr-class": /\.[\w\-]+/
-        }
-      },
-      code: [
-        {
-          pattern: /(^[\t ]*(?:-|!?=)).+/m,
-          lookbehind: true,
-          inside: Prism2.languages.javascript
-        }
-      ],
-      punctuation: /[.\-!=|]+/
-    };
-    var filter_pattern = /(^([\t ]*)):<filter_name>(?:(?:\r?\n|\r(?!\n))(?:\2[\t ].+|\s*?(?=\r?\n|\r)))+/.source;
-    var filters = [
-      {
-        filter: "atpl",
-        language: "twig"
-      },
-      {
-        filter: "coffee",
-        language: "coffeescript"
-      },
-      "ejs",
-      "handlebars",
-      "less",
-      "livescript",
-      "markdown",
-      {
-        filter: "sass",
-        language: "scss"
-      },
-      "stylus"
-    ];
-    var all_filters = {};
-    for (var i = 0, l = filters.length; i < l; i++) {
-      var filter = filters[i];
-      filter = typeof filter === "string" ? {
-        filter,
-        language: filter
-      } : filter;
-      if (Prism2.languages[filter.language]) {
-        all_filters["filter-" + filter.filter] = {
-          pattern: RegExp(
-            filter_pattern.replace("<filter_name>", function() {
-              return filter.filter;
-            }),
-            "m"
-          ),
-          lookbehind: true,
-          inside: {
-            "filter-name": {
-              pattern: /^:[\w-]+/,
-              alias: "variable"
-            },
-            text: {
-              pattern: /\S[\s\S]*/,
-              alias: [filter.language, "language-" + filter.language],
-              inside: Prism2.languages[filter.language]
-            }
-          }
-        };
-      }
-    }
-    Prism2.languages.insertBefore("pug", "filter", all_filters);
-  })(Prism);
-}
-
-export {
-  pug
-};

package/dist/chunk-5TDAWQZ6.mjs

@@ -1,89 +0,0 @@
-import {
-  clike
-} from "./chunk-XWTEQUC3.mjs";
-
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/fsharp.js
-fsharp.displayName = "fsharp";
-fsharp.aliases = [];
-function fsharp(Prism) {
-  Prism.register(clike);
-  Prism.languages.fsharp = Prism.languages.extend("clike", {
-    comment: [
-      {
-        pattern: /(^|[^\\])\(\*(?!\))[\s\S]*?\*\)/,
-        lookbehind: true,
-        greedy: true
-      },
-      {
-        pattern: /(^|[^\\:])\/\/.*/,
-        lookbehind: true,
-        greedy: true
-      }
-    ],
-    string: {
-      pattern: /(?:"""[\s\S]*?"""|@"(?:""|[^"])*"|"(?:\\[\s\S]|[^\\"])*")B?/,
-      greedy: true
-    },
-    "class-name": {
-      pattern: /(\b(?:exception|inherit|interface|new|of|type)\s+|\w\s*:\s*|\s:\??>\s*)[.\w]+\b(?:\s*(?:->|\*)\s*[.\w]+\b)*(?!\s*[:.])/,
-      lookbehind: true,
-      inside: {
-        operator: /->|\*/,
-        punctuation: /\./
-      }
-    },
-    keyword: /\b(?:let|return|use|yield)(?:!\B|\b)|\b(?:abstract|and|as|asr|assert|atomic|base|begin|break|checked|class|component|const|constraint|constructor|continue|default|delegate|do|done|downcast|downto|eager|elif|else|end|event|exception|extern|external|false|finally|fixed|for|fun|function|functor|global|if|in|include|inherit|inline|interface|internal|land|lazy|lor|lsl|lsr|lxor|match|member|method|mixin|mod|module|mutable|namespace|new|not|null|object|of|open|or|override|parallel|private|process|protected|public|pure|rec|sealed|select|sig|static|struct|tailcall|then|to|trait|true|try|type|upcast|val|virtual|void|volatile|when|while|with)\b/,
-    number: [
-      /\b0x[\da-fA-F]+(?:LF|lf|un)?\b/,
-      /\b0b[01]+(?:uy|y)?\b/,
-      /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[fm]|e[+-]?\d+)?\b/i,
-      /\b\d+(?:[IlLsy]|UL|u[lsy]?)?\b/
-    ],
-    operator: /([<>~&^])\1\1|([*.:<>&])\2|<-|->|[!=:]=|<?\|{1,3}>?|\??(?:<=|>=|<>|[-+*/%=<>])\??|[!?^&]|~[+~-]|:>|:\?>?/
-  });
-  Prism.languages.insertBefore("fsharp", "keyword", {
-    preprocessor: {
-      pattern: /(^[\t ]*)#.*/m,
-      lookbehind: true,
-      alias: "property",
-      inside: {
-        directive: {
-          pattern: /(^#)\b(?:else|endif|if|light|line|nowarn)\b/,
-          lookbehind: true,
-          alias: "keyword"
-        }
-      }
-    }
-  });
-  Prism.languages.insertBefore("fsharp", "punctuation", {
-    "computation-expression": {
-      pattern: /\b[_a-z]\w*(?=\s*\{)/i,
-      alias: "keyword"
-    }
-  });
-  Prism.languages.insertBefore("fsharp", "string", {
-    annotation: {
-      pattern: /\[<.+?>\]/,
-      greedy: true,
-      inside: {
-        punctuation: /^\[<|>\]$/,
-        "class-name": {
-          pattern: /^\w+$|(^|;\s*)[A-Z]\w*(?=\()/,
-          lookbehind: true
-        },
-        "annotation-content": {
-          pattern: /[\s\S]+/,
-          inside: Prism.languages.fsharp
-        }
-      }
-    },
-    char: {
-      pattern: /'(?:[^\\']|\\(?:.|\d{3}|x[a-fA-F\d]{2}|u[a-fA-F\d]{4}|U[a-fA-F\d]{8}))'B?/,
-      greedy: true
-    }
-  });
-}
-
-export {
-  fsharp
-};

package/dist/chunk-5VZFZIWT.mjs

@@ -1,37 +0,0 @@
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/awk.js
-awk.displayName = "awk";
-awk.aliases = ["gawk"];
-function awk(Prism) {
-  Prism.languages.awk = {
-    hashbang: {
-      pattern: /^#!.*/,
-      greedy: true,
-      alias: "comment"
-    },
-    comment: {
-      pattern: /#.*/,
-      greedy: true
-    },
-    string: {
-      pattern: /(^|[^\\])"(?:[^\\"\r\n]|\\.)*"/,
-      lookbehind: true,
-      greedy: true
-    },
-    regex: {
-      pattern: /((?:^|[^\w\s)])\s*)\/(?:[^\/\\\r\n]|\\.)*\//,
-      lookbehind: true,
-      greedy: true
-    },
-    variable: /\$\w+/,
-    keyword: /\b(?:BEGIN|BEGINFILE|END|ENDFILE|break|case|continue|default|delete|do|else|exit|for|function|getline|if|in|next|nextfile|printf?|return|switch|while)\b|@(?:include|load)\b/,
-    function: /\b[a-z_]\w*(?=\s*\()/i,
-    number: /\b(?:\d+(?:\.\d+)?(?:e[+-]?\d+)?|0x[a-fA-F0-9]+)\b/,
-    operator: /--|\+\+|!?~|>&|>>|<<|(?:\*\*|[<>!=+\-*/%^])=?|&&|\|[|&]|[?:]/,
-    punctuation: /[()[\]{},;]/
-  };
-  Prism.languages.gawk = Prism.languages.awk;
-}
-
-export {
-  awk
-};

package/dist/chunk-5WCKYEAK.mjs

@@ -1,57 +0,0 @@
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/uorazor.js
-uorazor.displayName = "uorazor";
-uorazor.aliases = [];
-function uorazor(Prism) {
-  Prism.languages.uorazor = {
-    "comment-hash": {
-      pattern: /#.*/,
-      alias: "comment",
-      greedy: true
-    },
-    "comment-slash": {
-      pattern: /\/\/.*/,
-      alias: "comment",
-      greedy: true
-    },
-    string: {
-      pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
-      inside: {
-        punctuation: /^['"]|['"]$/
-      },
-      greedy: true
-    },
-    "source-layers": {
-      pattern: /\b(?:arms|backpack|blue|bracelet|cancel|clear|cloak|criminal|earrings|enemy|facialhair|friend|friendly|gloves|gray|grey|ground|hair|head|innerlegs|innertorso|innocent|lefthand|middletorso|murderer|neck|nonfriendly|onehandedsecondary|outerlegs|outertorso|pants|red|righthand|ring|self|shirt|shoes|talisman|waist)\b/i,
-      alias: "function"
-    },
-    "source-commands": {
-      pattern: /\b(?:alliance|attack|cast|clearall|clearignore|clearjournal|clearlist|clearsysmsg|createlist|createtimer|dclick|dclicktype|dclickvar|dress|dressconfig|drop|droprelloc|emote|getlabel|guild|gumpclose|gumpresponse|hotkey|ignore|lasttarget|lift|lifttype|menu|menuresponse|msg|org|organize|organizer|overhead|pause|poplist|potion|promptresponse|pushlist|removelist|removetimer|rename|restock|say|scav|scavenger|script|setability|setlasttarget|setskill|settimer|setvar|sysmsg|target|targetloc|targetrelloc|targettype|undress|unignore|unsetvar|useobject|useonce|useskill|usetype|virtue|wait|waitforgump|waitformenu|waitforprompt|waitforstat|waitforsysmsg|waitfortarget|walk|wfsysmsg|wft|whisper|yell)\b/,
-      alias: "function"
-    },
-    "tag-name": {
-      pattern: /(^\{%-?\s*)\w+/,
-      lookbehind: true,
-      alias: "keyword"
-    },
-    delimiter: {
-      pattern: /^\{[{%]-?|-?[%}]\}$/,
-      alias: "punctuation"
-    },
-    function: /\b(?:atlist|close|closest|count|counter|counttype|dead|dex|diffhits|diffmana|diffstam|diffweight|find|findbuff|finddebuff|findlayer|findtype|findtypelist|followers|gumpexists|hidden|hits|hp|hue|human|humanoid|ingump|inlist|insysmessage|insysmsg|int|invul|lhandempty|list|listexists|mana|maxhits|maxhp|maxmana|maxstam|maxweight|monster|mounted|name|next|noto|paralyzed|poisoned|position|prev|previous|queued|rand|random|rhandempty|skill|stam|str|targetexists|timer|timerexists|varexist|warmode|weight)\b/,
-    keyword: /\b(?:and|as|break|continue|else|elseif|endfor|endif|endwhile|for|if|loop|not|or|replay|stop|while)\b/,
-    boolean: /\b(?:false|null|true)\b/,
-    number: /\b0x[\dA-Fa-f]+|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee][-+]?\d+)?/,
-    operator: [
-      {
-        pattern: /(\s)(?:and|b-and|b-or|b-xor|ends with|in|is|matches|not|or|same as|starts with)(?=\s)/,
-        lookbehind: true
-      },
-      /[=<>]=?|!=|\*\*?|\/\/?|\?:?|[-+~%|]/
-    ],
-    punctuation: /[()\[\]{}:.,]/
-  };
-}
-
-export {
-  uorazor
-};

package/dist/chunk-5XRE2LMI.mjs

@@ -1,39 +0,0 @@
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/wolfram.js
-wolfram.displayName = "wolfram";
-wolfram.aliases = ["mathematica", "nb", "wl"];
-function wolfram(Prism) {
-  Prism.languages.wolfram = {
-    comment: (
-      // Allow one level of nesting - note: regex taken from applescipt
-      /\(\*(?:\(\*(?:[^*]|\*(?!\)))*\*\)|(?!\(\*)[\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;
-}
-
-export {
-  wolfram
-};

package/dist/chunk-62HT53P7.mjs

@@ -1,98 +0,0 @@
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/pure.js
-pure.displayName = "pure";
-pure.aliases = [];
-function pure(Prism) {
-  ;
-  (function(Prism2) {
-    Prism2.languages.pure = {
-      comment: [
-        {
-          pattern: /(^|[^\\])\/\*[\s\S]*?\*\//,
-          lookbehind: true
-        },
-        {
-          pattern: /(^|[^\\:])\/\/.*/,
-          lookbehind: true
-        },
-        /#!.+/
-      ],
-      "inline-lang": {
-        pattern: /%<[\s\S]+?%>/,
-        greedy: true,
-        inside: {
-          lang: {
-            pattern: /(^%< *)-\*-.+?-\*-/,
-            lookbehind: true,
-            alias: "comment"
-          },
-          delimiter: {
-            pattern: /^%<.*|%>$/,
-            alias: "punctuation"
-          }
-        }
-      },
-      string: {
-        pattern: /"(?:\\.|[^"\\\r\n])*"/,
-        greedy: true
-      },
-      number: {
-        // The look-behind prevents wrong highlighting of the .. operator
-        pattern: /((?:\.\.)?)(?:\b(?:inf|nan)\b|\b0x[\da-f]+|(?:\b(?:0b)?\d+(?:\.\d+)?|\B\.\d+)(?:e[+-]?\d+)?L?)/i,
-        lookbehind: true
-      },
-      keyword: /\b(?:NULL|ans|break|bt|case|catch|cd|clear|const|def|del|dump|else|end|exit|extern|false|force|help|if|infix[lr]?|interface|let|ls|mem|namespace|nonfix|of|otherwise|outfix|override|postfix|prefix|private|public|pwd|quit|run|save|show|stats|then|throw|trace|true|type|underride|using|when|with)\b/,
-      function: /\b(?:abs|add_(?:addr|constdef|(?:fundef|interface|macdef|typedef)(?:_at)?|vardef)|all|any|applp?|arity|bigintp?|blob(?:_crc|_size|p)?|boolp?|byte_c?string(?:_pointer)?|byte_(?:matrix|pointer)|calloc|cat|catmap|ceil|char[ps]?|check_ptrtag|chr|clear_sentry|clearsym|closurep?|cmatrixp?|cols?|colcat(?:map)?|colmap|colrev|colvector(?:p|seq)?|complex(?:_float_(?:matrix|pointer)|_matrix(?:_view)?|_pointer|p)?|conj|cookedp?|cst|cstring(?:_(?:dup|list|vector))?|curry3?|cyclen?|del_(?:constdef|fundef|interface|macdef|typedef|vardef)|delete|diag(?:mat)?|dim|dmatrixp?|do|double(?:_matrix(?:_view)?|_pointer|p)?|dowith3?|drop|dropwhile|eval(?:cmd)?|exactp|filter|fix|fixity|flip|float(?:_matrix|_pointer)|floor|fold[lr]1?|frac|free|funp?|functionp?|gcd|get(?:_(?:byte|constdef|double|float|fundef|int(?:64)?|interface(?:_typedef)?|long|macdef|pointer|ptrtag|sentry|short|string|typedef|vardef))?|globsym|hash|head|id|im|imatrixp?|index|inexactp|infp|init|insert|int(?:_matrix(?:_view)?|_pointer|p)?|int64_(?:matrix|pointer)|integerp?|iteraten?|iterwhile|join|keys?|lambdap?|last(?:err(?:pos)?)?|lcd|list[2p]?|listmap|make_ptrtag|malloc|map|matcat|matrixp?|max|member|min|nanp|nargs|nmatrixp?|null|numberp?|ord|pack(?:ed)?|pointer(?:_cast|_tag|_type|p)?|pow|pred|ptrtag|put(?:_(?:byte|double|float|int(?:64)?|long|pointer|short|string))?|rationalp?|re|realp?|realloc|recordp?|redim|reduce(?:_with)?|refp?|repeatn?|reverse|rlistp?|round|rows?|rowcat(?:map)?|rowmap|rowrev|rowvector(?:p|seq)?|same|scan[lr]1?|sentry|sgn|short_(?:matrix|pointer)|slice|smatrixp?|sort|split|str|strcat|stream|stride|string(?:_(?:dup|list|vector)|p)?|subdiag(?:mat)?|submat|subseq2?|substr|succ|supdiag(?:mat)?|symbolp?|tail|take|takewhile|thunkp?|transpose|trunc|tuplep?|typep|ubyte|uint(?:64)?|ulong|uncurry3?|unref|unzip3?|update|ushort|vals?|varp?|vector(?:p|seq)?|void|zip3?|zipwith3?)\b/,
-      special: {
-        pattern: /\b__[a-z]+__\b/i,
-        alias: "builtin"
-      },
-      // Any combination of operator chars can be an operator
-      // eslint-disable-next-line no-misleading-character-class
-      operator: /(?:[!"#$%&'*+,\-.\/:<=>?@\\^`|~\u00a1-\u00bf\u00d7-\u00f7\u20d0-\u2bff]|\b_+\b)+|\b(?:and|div|mod|not|or)\b/,
-      // FIXME: How can we prevent | and , to be highlighted as operator when they are used alone?
-      punctuation: /[(){}\[\];,|]/
-    };
-    var inlineLanguages = [
-      "c",
-      {
-        lang: "c++",
-        alias: "cpp"
-      },
-      "fortran"
-    ];
-    var inlineLanguageRe = /%< *-\*- *<lang>\d* *-\*-[\s\S]+?%>/.source;
-    inlineLanguages.forEach(function(lang) {
-      var alias = lang;
-      if (typeof lang !== "string") {
-        alias = lang.alias;
-        lang = lang.lang;
-      }
-      if (Prism2.languages[alias]) {
-        var o = {};
-        o["inline-lang-" + alias] = {
-          pattern: RegExp(
-            inlineLanguageRe.replace(
-              "<lang>",
-              lang.replace(/([.+*?\/\\(){}\[\]])/g, "\\$1")
-            ),
-            "i"
-          ),
-          inside: Prism2.util.clone(Prism2.languages.pure["inline-lang"].inside)
-        };
-        o["inline-lang-" + alias].inside.rest = Prism2.util.clone(
-          Prism2.languages[alias]
-        );
-        Prism2.languages.insertBefore("pure", "inline-lang", o);
-      }
-    });
-    if (Prism2.languages.c) {
-      Prism2.languages.pure["inline-lang"].inside.rest = Prism2.util.clone(
-        Prism2.languages.c
-      );
-    }
-  })(Prism);
-}
-
-export {
-  pure
-};

package/dist/chunk-63T3V7T3.mjs

@@ -1,43 +0,0 @@
-import {
-  markupTemplating
-} from "./chunk-DFNMTLAN.mjs";
-import {
-  ruby
-} from "./chunk-VT6UVRUK.mjs";
-
-// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/erb.js
-erb.displayName = "erb";
-erb.aliases = [];
-function erb(Prism) {
-  Prism.register(markupTemplating);
-  Prism.register(ruby);
-  (function(Prism2) {
-    Prism2.languages.erb = {
-      delimiter: {
-        pattern: /^(\s*)<%=?|%>(?=\s*$)/,
-        lookbehind: true,
-        alias: "punctuation"
-      },
-      ruby: {
-        pattern: /\s*\S[\s\S]*/,
-        alias: "language-ruby",
-        inside: Prism2.languages.ruby
-      }
-    };
-    Prism2.hooks.add("before-tokenize", function(env) {
-      var erbPattern = /<%=?(?:[^\r\n]|[\r\n](?!=begin)|[\r\n]=begin\s(?:[^\r\n]|[\r\n](?!=end))*[\r\n]=end)+?%>/g;
-      Prism2.languages["markup-templating"].buildPlaceholders(
-        env,
-        "erb",
-        erbPattern
-      );
-    });
-    Prism2.hooks.add("after-tokenize", function(env) {
-      Prism2.languages["markup-templating"].tokenizePlaceholders(env, "erb");
-    });
-  })(Prism);
-}
-
-export {
-  erb
-};