@photonix/basic 2.3.0 → 3.0.0

package/dist/chunk-OOPUNW7X.mjs

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

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

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

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

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

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