@photonix/basic 1.5.0 → 1.6.0

package/dist/chunk-OOPUNW7X.mjs

@@ -0,0 +1,141 @@
+import {
+  javascript
+} from "./chunk-ZJYVOTZA.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/js-extras.js
+jsExtras.displayName = "js-extras";
+jsExtras.aliases = [];
+function jsExtras(Prism) {
+  Prism.register(javascript);
+  (function(Prism2) {
+    Prism2.languages.insertBefore("javascript", "function-variable", {
+      "method-variable": {
+        pattern: RegExp(
+          "(\\.\\s*)" + Prism2.languages.javascript["function-variable"].pattern.source
+        ),
+        lookbehind: true,
+        alias: ["function-variable", "method", "function", "property-access"]
+      }
+    });
+    Prism2.languages.insertBefore("javascript", "function", {
+      method: {
+        pattern: RegExp(
+          "(\\.\\s*)" + Prism2.languages.javascript["function"].source
+        ),
+        lookbehind: true,
+        alias: ["function", "property-access"]
+      }
+    });
+    Prism2.languages.insertBefore("javascript", "constant", {
+      "known-class-name": [
+        {
+          // standard built-ins
+          // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects
+          pattern: /\b(?:(?:Float(?:32|64)|(?:Int|Uint)(?:8|16|32)|Uint8Clamped)?Array|ArrayBuffer|BigInt|Boolean|DataView|Date|Error|Function|Intl|JSON|(?:Weak)?(?:Map|Set)|Math|Number|Object|Promise|Proxy|Reflect|RegExp|String|Symbol|WebAssembly)\b/,
+          alias: "class-name"
+        },
+        {
+          // errors
+          pattern: /\b(?:[A-Z]\w*)Error\b/,
+          alias: "class-name"
+        }
+      ]
+    });
+    function withId(source, flags) {
+      return RegExp(
+        source.replace(/<ID>/g, function() {
+          return /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/.source;
+        }),
+        flags
+      );
+    }
+    Prism2.languages.insertBefore("javascript", "keyword", {
+      imports: {
+        // https://tc39.es/ecma262/#sec-imports
+        pattern: withId(
+          /(\bimport\b\s*)(?:<ID>(?:\s*,\s*(?:\*\s*as\s+<ID>|\{[^{}]*\}))?|\*\s*as\s+<ID>|\{[^{}]*\})(?=\s*\bfrom\b)/.source
+        ),
+        lookbehind: true,
+        inside: Prism2.languages.javascript
+      },
+      exports: {
+        // https://tc39.es/ecma262/#sec-exports
+        pattern: withId(
+          /(\bexport\b\s*)(?:\*(?:\s*as\s+<ID>)?(?=\s*\bfrom\b)|\{[^{}]*\})/.source
+        ),
+        lookbehind: true,
+        inside: Prism2.languages.javascript
+      }
+    });
+    Prism2.languages.javascript["keyword"].unshift(
+      {
+        pattern: /\b(?:as|default|export|from|import)\b/,
+        alias: "module"
+      },
+      {
+        pattern: /\b(?:await|break|catch|continue|do|else|finally|for|if|return|switch|throw|try|while|yield)\b/,
+        alias: "control-flow"
+      },
+      {
+        pattern: /\bnull\b/,
+        alias: ["null", "nil"]
+      },
+      {
+        pattern: /\bundefined\b/,
+        alias: "nil"
+      }
+    );
+    Prism2.languages.insertBefore("javascript", "operator", {
+      spread: {
+        pattern: /\.{3}/,
+        alias: "operator"
+      },
+      arrow: {
+        pattern: /=>/,
+        alias: "operator"
+      }
+    });
+    Prism2.languages.insertBefore("javascript", "punctuation", {
+      "property-access": {
+        pattern: withId(/(\.\s*)#?<ID>/.source),
+        lookbehind: true
+      },
+      "maybe-class-name": {
+        pattern: /(^|[^$\w\xA0-\uFFFF])[A-Z][$\w\xA0-\uFFFF]+/,
+        lookbehind: true
+      },
+      dom: {
+        // this contains only a few commonly used DOM variables
+        pattern: /\b(?:document|(?:local|session)Storage|location|navigator|performance|window)\b/,
+        alias: "variable"
+      },
+      console: {
+        pattern: /\bconsole(?=\s*\.)/,
+        alias: "class-name"
+      }
+    });
+    var maybeClassNameTokens = [
+      "function",
+      "function-variable",
+      "method",
+      "method-variable",
+      "property-access"
+    ];
+    for (var i = 0; i < maybeClassNameTokens.length; i++) {
+      var token = maybeClassNameTokens[i];
+      var value = Prism2.languages.javascript[token];
+      if (Prism2.util.type(value) === "RegExp") {
+        value = Prism2.languages.javascript[token] = {
+          pattern: value
+        };
+      }
+      var inside = value.inside || {};
+      value.inside = inside;
+      inside["maybe-class-name"] = /^[A-Z][\s\S]*/;
+    }
+  })(Prism);
+}
+
+export {
+  jsExtras
+};

package/dist/chunk-OREANV5Y.mjs

@@ -0,0 +1,122 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/scheme.js
+scheme.displayName = "scheme";
+scheme.aliases = [];
+function scheme(Prism) {
+  ;
+  (function(Prism2) {
+    Prism2.languages.scheme = {
+      // this supports "normal" single-line comments:
+      //   ; comment
+      // and (potentially nested) multiline comments:
+      //   #| comment #| nested |# still comment |#
+      // (only 1 level of nesting is supported)
+      comment: /;.*|#;\s*(?:\((?:[^()]|\([^()]*\))*\)|\[(?:[^\[\]]|\[[^\[\]]*\])*\])|#\|(?:[^#|]|#(?!\|)|\|(?!#)|#\|(?:[^#|]|#(?!\|)|\|(?!#))*\|#)*\|#/,
+      string: {
+        pattern: /"(?:[^"\\]|\\.)*"/,
+        greedy: true
+      },
+      symbol: {
+        pattern: /'[^()\[\]#'\s]+/,
+        greedy: true
+      },
+      char: {
+        pattern: /#\\(?:[ux][a-fA-F\d]+\b|[-a-zA-Z]+\b|[\uD800-\uDBFF][\uDC00-\uDFFF]|\S)/,
+        greedy: true
+      },
+      "lambda-parameter": [
+        // https://www.cs.cmu.edu/Groups/AI/html/r4rs/r4rs_6.html#SEC30
+        {
+          pattern: /((?:^|[^'`#])[(\[]lambda\s+)(?:[^|()\[\]'\s]+|\|(?:[^\\|]|\\.)*\|)/,
+          lookbehind: true
+        },
+        {
+          pattern: /((?:^|[^'`#])[(\[]lambda\s+[(\[])[^()\[\]']+/,
+          lookbehind: true
+        }
+      ],
+      keyword: {
+        pattern: /((?:^|[^'`#])[(\[])(?:begin|case(?:-lambda)?|cond(?:-expand)?|define(?:-library|-macro|-record-type|-syntax|-values)?|defmacro|delay(?:-force)?|do|else|except|export|guard|if|import|include(?:-ci|-library-declarations)?|lambda|let(?:rec)?(?:-syntax|-values|\*)?|let\*-values|only|parameterize|prefix|(?:quasi-?)?quote|rename|set!|syntax-(?:case|rules)|unless|unquote(?:-splicing)?|when)(?=[()\[\]\s]|$)/,
+        lookbehind: true
+      },
+      builtin: {
+        // all functions of the base library of R7RS plus some of built-ins of R5Rs
+        pattern: /((?:^|[^'`#])[(\[])(?:abs|and|append|apply|assoc|ass[qv]|binary-port\?|boolean=?\?|bytevector(?:-append|-copy|-copy!|-length|-u8-ref|-u8-set!|\?)?|caar|cadr|call-with-(?:current-continuation|port|values)|call\/cc|car|cdar|cddr|cdr|ceiling|char(?:->integer|-ready\?|\?|<\?|<=\?|=\?|>\?|>=\?)|close-(?:input-port|output-port|port)|complex\?|cons|current-(?:error|input|output)-port|denominator|dynamic-wind|eof-object\??|eq\?|equal\?|eqv\?|error|error-object(?:-irritants|-message|\?)|eval|even\?|exact(?:-integer-sqrt|-integer\?|\?)?|expt|features|file-error\?|floor(?:-quotient|-remainder|\/)?|flush-output-port|for-each|gcd|get-output-(?:bytevector|string)|inexact\??|input-port(?:-open\?|\?)|integer(?:->char|\?)|lcm|length|list(?:->string|->vector|-copy|-ref|-set!|-tail|\?)?|make-(?:bytevector|list|parameter|string|vector)|map|max|member|memq|memv|min|modulo|negative\?|newline|not|null\?|number(?:->string|\?)|numerator|odd\?|open-(?:input|output)-(?:bytevector|string)|or|output-port(?:-open\?|\?)|pair\?|peek-char|peek-u8|port\?|positive\?|procedure\?|quotient|raise|raise-continuable|rational\?|rationalize|read-(?:bytevector|bytevector!|char|error\?|line|string|u8)|real\?|remainder|reverse|round|set-c[ad]r!|square|string(?:->list|->number|->symbol|->utf8|->vector|-append|-copy|-copy!|-fill!|-for-each|-length|-map|-ref|-set!|\?|<\?|<=\?|=\?|>\?|>=\?)?|substring|symbol(?:->string|\?|=\?)|syntax-error|textual-port\?|truncate(?:-quotient|-remainder|\/)?|u8-ready\?|utf8->string|values|vector(?:->list|->string|-append|-copy|-copy!|-fill!|-for-each|-length|-map|-ref|-set!|\?)?|with-exception-handler|write-(?:bytevector|char|string|u8)|zero\?)(?=[()\[\]\s]|$)/,
+        lookbehind: true
+      },
+      operator: {
+        pattern: /((?:^|[^'`#])[(\[])(?:[-+*%/]|[<>]=?|=>?)(?=[()\[\]\s]|$)/,
+        lookbehind: true
+      },
+      number: {
+        // The number pattern from [the R7RS spec](https://small.r7rs.org/attachment/r7rs.pdf).
+        //
+        // <number>      := <num 2>|<num 8>|<num 10>|<num 16>
+        // <num R>       := <prefix R><complex R>
+        // <complex R>   := <real R>(?:@<real R>|<imaginary R>)?|<imaginary R>
+        // <imaginary R> := [+-](?:<ureal R>|(?:inf|nan)\.0)?i
+        // <real R>      := [+-]?<ureal R>|[+-](?:inf|nan)\.0
+        // <ureal R>     := <uint R>(?:\/<uint R>)?
+        //                | <decimal R>
+        //
+        // <decimal 10>  := (?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?
+        // <uint R>      := <digit R>+
+        // <prefix R>    := <radix R>(?:#[ei])?|(?:#[ei])?<radix R>
+        // <radix 2>     := #b
+        // <radix 8>     := #o
+        // <radix 10>    := (?:#d)?
+        // <radix 16>    := #x
+        // <digit 2>     := [01]
+        // <digit 8>     := [0-7]
+        // <digit 10>    := \d
+        // <digit 16>    := [0-9a-f]
+        //
+        // The problem with this grammar is that the resulting regex is way to complex, so we simplify by grouping all
+        // non-decimal bases together. This results in a decimal (dec) and combined binary, octal, and hexadecimal (box)
+        // pattern:
+        pattern: RegExp(
+          SortedBNF({
+            "<ureal dec>": /\d+(?:\/\d+)|(?:\d+(?:\.\d*)?|\.\d+)(?:[esfdl][+-]?\d+)?/.source,
+            "<real dec>": /[+-]?<ureal dec>|[+-](?:inf|nan)\.0/.source,
+            "<imaginary dec>": /[+-](?:<ureal dec>|(?:inf|nan)\.0)?i/.source,
+            "<complex dec>": /<real dec>(?:@<real dec>|<imaginary dec>)?|<imaginary dec>/.source,
+            "<num dec>": /(?:#d(?:#[ei])?|#[ei](?:#d)?)?<complex dec>/.source,
+            "<ureal box>": /[0-9a-f]+(?:\/[0-9a-f]+)?/.source,
+            "<real box>": /[+-]?<ureal box>|[+-](?:inf|nan)\.0/.source,
+            "<imaginary box>": /[+-](?:<ureal box>|(?:inf|nan)\.0)?i/.source,
+            "<complex box>": /<real box>(?:@<real box>|<imaginary box>)?|<imaginary box>/.source,
+            "<num box>": /#[box](?:#[ei])?|(?:#[ei])?#[box]<complex box>/.source,
+            "<number>": /(^|[()\[\]\s])(?:<num dec>|<num box>)(?=[()\[\]\s]|$)/.source
+          }),
+          "i"
+        ),
+        lookbehind: true
+      },
+      boolean: {
+        pattern: /(^|[()\[\]\s])#(?:[ft]|false|true)(?=[()\[\]\s]|$)/,
+        lookbehind: true
+      },
+      function: {
+        pattern: /((?:^|[^'`#])[(\[])(?:[^|()\[\]'\s]+|\|(?:[^\\|]|\\.)*\|)(?=[()\[\]\s]|$)/,
+        lookbehind: true
+      },
+      identifier: {
+        pattern: /(^|[()\[\]\s])\|(?:[^\\|]|\\.)*\|(?=[()\[\]\s]|$)/,
+        lookbehind: true,
+        greedy: true
+      },
+      punctuation: /[()\[\]']/
+    };
+    function SortedBNF(grammar) {
+      for (var key in grammar) {
+        grammar[key] = grammar[key].replace(/<[\w\s]+>/g, function(key2) {
+          return "(?:" + grammar[key2].trim() + ")";
+        });
+      }
+      return grammar[key];
+    }
+  })(Prism);
+}
+
+export {
+  scheme
+};

package/dist/chunk-OSQR4RS6.mjs

@@ -0,0 +1,29 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/llvm.js
+llvm.displayName = "llvm";
+llvm.aliases = [];
+function llvm(Prism) {
+  ;
+  (function(Prism2) {
+    Prism2.languages.llvm = {
+      comment: /;.*/,
+      string: {
+        pattern: /"[^"]*"/,
+        greedy: true
+      },
+      boolean: /\b(?:false|true)\b/,
+      variable: /[%@!#](?:(?!\d)(?:[-$.\w]|\\[a-f\d]{2})+|\d+)/i,
+      label: /(?!\d)(?:[-$.\w]|\\[a-f\d]{2})+:/i,
+      type: {
+        pattern: /\b(?:double|float|fp128|half|i[1-9]\d*|label|metadata|ppc_fp128|token|void|x86_fp80|x86_mmx)\b/,
+        alias: "class-name"
+      },
+      keyword: /\b[a-z_][a-z_0-9]*\b/,
+      number: /[+-]?\b\d+(?:\.\d+)?(?:[eE][+-]?\d+)?\b|\b0x[\dA-Fa-f]+\b|\b0xK[\dA-Fa-f]{20}\b|\b0x[ML][\dA-Fa-f]{32}\b|\b0xH[\dA-Fa-f]{4}\b/,
+      punctuation: /[{}[\];(),.!*=<>]/
+    };
+  })(Prism);
+}
+
+export {
+  llvm
+};

package/dist/chunk-OTOGMM45.mjs

@@ -0,0 +1,31 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/go-module.js
+goModule.displayName = "go-module";
+goModule.aliases = ["go-mod"];
+function goModule(Prism) {
+  Prism.languages["go-mod"] = Prism.languages["go-module"] = {
+    comment: {
+      pattern: /\/\/.*/,
+      greedy: true
+    },
+    version: {
+      pattern: /(^|[\s()[\],])v\d+\.\d+\.\d+(?:[+-][-+.\w]*)?(?![^\s()[\],])/,
+      lookbehind: true,
+      alias: "number"
+    },
+    "go-version": {
+      pattern: /((?:^|\s)go\s+)\d+(?:\.\d+){1,2}/,
+      lookbehind: true,
+      alias: "number"
+    },
+    keyword: {
+      pattern: /^([ \t]*)(?:exclude|go|module|replace|require|retract)\b/m,
+      lookbehind: true
+    },
+    operator: /=>/,
+    punctuation: /[()[\],]/
+  };
+}
+
+export {
+  goModule
+};

package/dist/chunk-OVAPXF32.mjs

@@ -0,0 +1,283 @@
+import {
+  markup
+} from "./chunk-ACDTS7FW.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/textile.js
+textile.displayName = "textile";
+textile.aliases = [];
+function textile(Prism) {
+  Prism.register(markup);
+  (function(Prism2) {
+    var modifierRegex = /\([^|()\n]+\)|\[[^\]\n]+\]|\{[^}\n]+\}/.source;
+    var parenthesesRegex = /\)|\((?![^|()\n]+\))/.source;
+    function withModifier(source, flags) {
+      return RegExp(
+        source.replace(/<MOD>/g, function() {
+          return "(?:" + modifierRegex + ")";
+        }).replace(/<PAR>/g, function() {
+          return "(?:" + parenthesesRegex + ")";
+        }),
+        flags || ""
+      );
+    }
+    var modifierTokens = {
+      css: {
+        pattern: /\{[^{}]+\}/,
+        inside: {
+          rest: Prism2.languages.css
+        }
+      },
+      "class-id": {
+        pattern: /(\()[^()]+(?=\))/,
+        lookbehind: true,
+        alias: "attr-value"
+      },
+      lang: {
+        pattern: /(\[)[^\[\]]+(?=\])/,
+        lookbehind: true,
+        alias: "attr-value"
+      },
+      // Anything else is punctuation (the first pattern is for row/col spans inside tables)
+      punctuation: /[\\\/]\d+|\S/
+    };
+    var textile2 = Prism2.languages.textile = Prism2.languages.extend("markup", {
+      phrase: {
+        pattern: /(^|\r|\n)\S[\s\S]*?(?=$|\r?\n\r?\n|\r\r)/,
+        lookbehind: true,
+        inside: {
+          // h1. Header 1
+          "block-tag": {
+            pattern: withModifier(/^[a-z]\w*(?:<MOD>|<PAR>|[<>=])*\./.source),
+            inside: {
+              modifier: {
+                pattern: withModifier(
+                  /(^[a-z]\w*)(?:<MOD>|<PAR>|[<>=])+(?=\.)/.source
+                ),
+                lookbehind: true,
+                inside: modifierTokens
+              },
+              tag: /^[a-z]\w*/,
+              punctuation: /\.$/
+            }
+          },
+          // # List item
+          // * List item
+          list: {
+            pattern: withModifier(/^[*#]+<MOD>*\s+\S.*/.source, "m"),
+            inside: {
+              modifier: {
+                pattern: withModifier(/(^[*#]+)<MOD>+/.source),
+                lookbehind: true,
+                inside: modifierTokens
+              },
+              punctuation: /^[*#]+/
+            }
+          },
+          // | cell | cell | cell |
+          table: {
+            // Modifiers can be applied to the row: {color:red}.|1|2|3|
+            // or the cell: |{color:red}.1|2|3|
+            pattern: withModifier(
+              /^(?:(?:<MOD>|<PAR>|[<>=^~])+\.\s*)?(?:\|(?:(?:<MOD>|<PAR>|[<>=^~_]|[\\/]\d+)+\.|(?!(?:<MOD>|<PAR>|[<>=^~_]|[\\/]\d+)+\.))[^|]*)+\|/.source,
+              "m"
+            ),
+            inside: {
+              modifier: {
+                // Modifiers for rows after the first one are
+                // preceded by a pipe and a line feed
+                pattern: withModifier(
+                  /(^|\|(?:\r?\n|\r)?)(?:<MOD>|<PAR>|[<>=^~_]|[\\/]\d+)+(?=\.)/.source
+                ),
+                lookbehind: true,
+                inside: modifierTokens
+              },
+              punctuation: /\||^\./
+            }
+          },
+          inline: {
+            // eslint-disable-next-line regexp/no-super-linear-backtracking
+            pattern: withModifier(
+              /(^|[^a-zA-Z\d])(\*\*|__|\?\?|[*_%@+\-^~])<MOD>*.+?\2(?![a-zA-Z\d])/.source
+            ),
+            lookbehind: true,
+            inside: {
+              // Note: superscripts and subscripts are not handled specifically
+              // *bold*, **bold**
+              bold: {
+                // eslint-disable-next-line regexp/no-super-linear-backtracking
+                pattern: withModifier(/(^(\*\*?)<MOD>*).+?(?=\2)/.source),
+                lookbehind: true
+              },
+              // _italic_, __italic__
+              italic: {
+                // eslint-disable-next-line regexp/no-super-linear-backtracking
+                pattern: withModifier(/(^(__?)<MOD>*).+?(?=\2)/.source),
+                lookbehind: true
+              },
+              // ??cite??
+              cite: {
+                // eslint-disable-next-line regexp/no-super-linear-backtracking
+                pattern: withModifier(/(^\?\?<MOD>*).+?(?=\?\?)/.source),
+                lookbehind: true,
+                alias: "string"
+              },
+              // @code@
+              code: {
+                // eslint-disable-next-line regexp/no-super-linear-backtracking
+                pattern: withModifier(/(^@<MOD>*).+?(?=@)/.source),
+                lookbehind: true,
+                alias: "keyword"
+              },
+              // +inserted+
+              inserted: {
+                // eslint-disable-next-line regexp/no-super-linear-backtracking
+                pattern: withModifier(/(^\+<MOD>*).+?(?=\+)/.source),
+                lookbehind: true
+              },
+              // -deleted-
+              deleted: {
+                // eslint-disable-next-line regexp/no-super-linear-backtracking
+                pattern: withModifier(/(^-<MOD>*).+?(?=-)/.source),
+                lookbehind: true
+              },
+              // %span%
+              span: {
+                // eslint-disable-next-line regexp/no-super-linear-backtracking
+                pattern: withModifier(/(^%<MOD>*).+?(?=%)/.source),
+                lookbehind: true
+              },
+              modifier: {
+                pattern: withModifier(
+                  /(^\*\*|__|\?\?|[*_%@+\-^~])<MOD>+/.source
+                ),
+                lookbehind: true,
+                inside: modifierTokens
+              },
+              punctuation: /[*_%?@+\-^~]+/
+            }
+          },
+          // [alias]http://example.com
+          "link-ref": {
+            pattern: /^\[[^\]]+\]\S+$/m,
+            inside: {
+              string: {
+                pattern: /(^\[)[^\]]+(?=\])/,
+                lookbehind: true
+              },
+              url: {
+                pattern: /(^\])\S+$/,
+                lookbehind: true
+              },
+              punctuation: /[\[\]]/
+            }
+          },
+          // "text":http://example.com
+          // "text":link-ref
+          link: {
+            // eslint-disable-next-line regexp/no-super-linear-backtracking
+            pattern: withModifier(
+              /"<MOD>*[^"]+":.+?(?=[^\w/]?(?:\s|$))/.source
+            ),
+            inside: {
+              text: {
+                // eslint-disable-next-line regexp/no-super-linear-backtracking
+                pattern: withModifier(/(^"<MOD>*)[^"]+(?=")/.source),
+                lookbehind: true
+              },
+              modifier: {
+                pattern: withModifier(/(^")<MOD>+/.source),
+                lookbehind: true,
+                inside: modifierTokens
+              },
+              url: {
+                pattern: /(:).+/,
+                lookbehind: true
+              },
+              punctuation: /[":]/
+            }
+          },
+          // !image.jpg!
+          // !image.jpg(Title)!:http://example.com
+          image: {
+            pattern: withModifier(
+              /!(?:<MOD>|<PAR>|[<>=])*(?![<>=])[^!\s()]+(?:\([^)]+\))?!(?::.+?(?=[^\w/]?(?:\s|$)))?/.source
+            ),
+            inside: {
+              source: {
+                pattern: withModifier(
+                  /(^!(?:<MOD>|<PAR>|[<>=])*)(?![<>=])[^!\s()]+(?:\([^)]+\))?(?=!)/.source
+                ),
+                lookbehind: true,
+                alias: "url"
+              },
+              modifier: {
+                pattern: withModifier(/(^!)(?:<MOD>|<PAR>|[<>=])+/.source),
+                lookbehind: true,
+                inside: modifierTokens
+              },
+              url: {
+                pattern: /(:).+/,
+                lookbehind: true
+              },
+              punctuation: /[!:]/
+            }
+          },
+          // Footnote[1]
+          footnote: {
+            pattern: /\b\[\d+\]/,
+            alias: "comment",
+            inside: {
+              punctuation: /\[|\]/
+            }
+          },
+          // CSS(Cascading Style Sheet)
+          acronym: {
+            pattern: /\b[A-Z\d]+\([^)]+\)/,
+            inside: {
+              comment: {
+                pattern: /(\()[^()]+(?=\))/,
+                lookbehind: true
+              },
+              punctuation: /[()]/
+            }
+          },
+          // Prism(C)
+          mark: {
+            pattern: /\b\((?:C|R|TM)\)/,
+            alias: "comment",
+            inside: {
+              punctuation: /[()]/
+            }
+          }
+        }
+      }
+    });
+    var phraseInside = textile2["phrase"].inside;
+    var nestedPatterns = {
+      inline: phraseInside["inline"],
+      link: phraseInside["link"],
+      image: phraseInside["image"],
+      footnote: phraseInside["footnote"],
+      acronym: phraseInside["acronym"],
+      mark: phraseInside["mark"]
+    };
+    textile2.tag.pattern = /<\/?(?!\d)[a-z0-9]+(?:\s+[^\s>\/=]+(?:=(?:("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|[^\s'">=]+))?)*\s*\/?>/i;
+    var phraseInlineInside = phraseInside["inline"].inside;
+    phraseInlineInside["bold"].inside = nestedPatterns;
+    phraseInlineInside["italic"].inside = nestedPatterns;
+    phraseInlineInside["inserted"].inside = nestedPatterns;
+    phraseInlineInside["deleted"].inside = nestedPatterns;
+    phraseInlineInside["span"].inside = nestedPatterns;
+    var phraseTableInside = phraseInside["table"].inside;
+    phraseTableInside["inline"] = nestedPatterns["inline"];
+    phraseTableInside["link"] = nestedPatterns["link"];
+    phraseTableInside["image"] = nestedPatterns["image"];
+    phraseTableInside["footnote"] = nestedPatterns["footnote"];
+    phraseTableInside["acronym"] = nestedPatterns["acronym"];
+    phraseTableInside["mark"] = nestedPatterns["mark"];
+  })(Prism);
+}
+
+export {
+  textile
+};

package/dist/chunk-OXM2GN65.mjs

@@ -0,0 +1,29 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/icon.js
+icon.displayName = "icon";
+icon.aliases = [];
+function icon(Prism) {
+  Prism.languages.icon = {
+    comment: /#.*/,
+    string: {
+      pattern: /(["'])(?:(?!\1)[^\\\r\n_]|\\.|_(?!\1)(?:\r\n|[\s\S]))*\1/,
+      greedy: true
+    },
+    number: /\b(?:\d+r[a-z\d]+|\d+(?:\.\d+)?(?:e[+-]?\d+)?)\b|\.\d+\b/i,
+    "builtin-keyword": {
+      pattern: /&(?:allocated|ascii|clock|collections|cset|current|date|dateline|digits|dump|e|error(?:number|text|value)?|errout|fail|features|file|host|input|lcase|letters|level|line|main|null|output|phi|pi|pos|progname|random|regions|source|storage|subject|time|trace|ucase|version)\b/,
+      alias: "variable"
+    },
+    directive: {
+      pattern: /\$\w+/,
+      alias: "builtin"
+    },
+    keyword: /\b(?:break|by|case|create|default|do|else|end|every|fail|global|if|initial|invocable|link|local|next|not|of|procedure|record|repeat|return|static|suspend|then|to|until|while)\b/,
+    function: /\b(?!\d)\w+(?=\s*[({]|\s*!\s*\[)/,
+    operator: /[+-]:(?!=)|(?:[\/?@^%&]|\+\+?|--?|==?=?|~==?=?|\*\*?|\|\|\|?|<(?:->?|<?=?)|>>?=?)(?::=)?|:(?:=:?)?|[!.\\|~]/,
+    punctuation: /[\[\](){},;]/
+  };
+}
+
+export {
+  icon
+};