@photonix/basic 1.5.1 → 1.6.1

package/dist/chunk-5SKARUX7.mjs

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

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

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

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

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

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

@@ -0,0 +1,43 @@
+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
+};