@photonix/basic 1.5.0 → 1.6.0

package/dist/chunk-SXZNJTY6.mjs

@@ -0,0 +1,81 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/dot.js
+dot.displayName = "dot";
+dot.aliases = ["gv"];
+function dot(Prism) {
+  ;
+  (function(Prism2) {
+    var ID = "(?:" + [
+      // an identifier
+      /[a-zA-Z_\x80-\uFFFF][\w\x80-\uFFFF]*/.source,
+      // a number
+      /-?(?:\.\d+|\d+(?:\.\d*)?)/.source,
+      // a double-quoted string
+      /"[^"\\]*(?:\\[\s\S][^"\\]*)*"/.source,
+      // HTML-like string
+      /<(?:[^<>]|(?!<!--)<(?:[^<>"']|"[^"]*"|'[^']*')+>|<!--(?:[^-]|-(?!->))*-->)*>/.source
+    ].join("|") + ")";
+    var IDInside = {
+      markup: {
+        pattern: /(^<)[\s\S]+(?=>$)/,
+        lookbehind: true,
+        alias: ["language-markup", "language-html", "language-xml"],
+        inside: Prism2.languages.markup
+      }
+    };
+    function withID(source, flags) {
+      return RegExp(
+        source.replace(/<ID>/g, function() {
+          return ID;
+        }),
+        flags
+      );
+    }
+    Prism2.languages.dot = {
+      comment: {
+        pattern: /\/\/.*|\/\*[\s\S]*?\*\/|^#.*/m,
+        greedy: true
+      },
+      "graph-name": {
+        pattern: withID(
+          /(\b(?:digraph|graph|subgraph)[ \t\r\n]+)<ID>/.source,
+          "i"
+        ),
+        lookbehind: true,
+        greedy: true,
+        alias: "class-name",
+        inside: IDInside
+      },
+      "attr-value": {
+        pattern: withID(/(=[ \t\r\n]*)<ID>/.source),
+        lookbehind: true,
+        greedy: true,
+        inside: IDInside
+      },
+      "attr-name": {
+        pattern: withID(/([\[;, \t\r\n])<ID>(?=[ \t\r\n]*=)/.source),
+        lookbehind: true,
+        greedy: true,
+        inside: IDInside
+      },
+      keyword: /\b(?:digraph|edge|graph|node|strict|subgraph)\b/i,
+      "compass-point": {
+        pattern: /(:[ \t\r\n]*)(?:[ewc_]|[ns][ew]?)(?![\w\x80-\uFFFF])/,
+        lookbehind: true,
+        alias: "builtin"
+      },
+      node: {
+        pattern: withID(/(^|[^-.\w\x80-\uFFFF\\])<ID>/.source),
+        lookbehind: true,
+        greedy: true,
+        inside: IDInside
+      },
+      operator: /[=:]|-[->]/,
+      punctuation: /[\[\]{};,]/
+    };
+    Prism2.languages.gv = Prism2.languages.dot;
+  })(Prism);
+}
+
+export {
+  dot
+};

package/dist/chunk-SYRAUUDM.mjs

@@ -0,0 +1,34 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/nsis.js
+nsis.displayName = "nsis";
+nsis.aliases = [];
+function nsis(Prism) {
+  Prism.languages.nsis = {
+    comment: {
+      pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|[#;].*)/,
+      lookbehind: true,
+      greedy: true
+    },
+    string: {
+      pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+      greedy: true
+    },
+    keyword: {
+      pattern: /(^[\t ]*)(?:Abort|Add(?:BrandingImage|Size)|AdvSplash|Allow(?:RootDirInstall|SkipFiles)|AutoCloseWindow|BG(?:Font|Gradient|Image)|Banner|BrandingText|BringToFront|CRCCheck|Call(?:InstDLL)?|Caption|ChangeUI|CheckBitmap|ClearErrors|CompletedText|ComponentText|CopyFiles|Create(?:Directory|Font|ShortCut)|Delete(?:INISec|INIStr|RegKey|RegValue)?|Detail(?:Print|sButtonText)|Dialer|Dir(?:Text|Var|Verify)|EnableWindow|Enum(?:RegKey|RegValue)|Exch|Exec(?:Shell(?:Wait)?|Wait)?|ExpandEnvStrings|File(?:BufSize|Close|ErrorText|Open|Read|ReadByte|ReadUTF16LE|ReadWord|Seek|Write|WriteByte|WriteUTF16LE|WriteWord)?|Find(?:Close|First|Next|Window)|FlushINI|Get(?:CurInstType|CurrentAddress|DLLVersion(?:Local)?|DlgItem|ErrorLevel|FileTime(?:Local)?|FullPathName|Function(?:Address|End)?|InstDirError|KnownFolderPath|LabelAddress|TempFileName|WinVer)|Goto|HideWindow|Icon|If(?:Abort|Errors|FileExists|RebootFlag|RtlLanguage|ShellVarContextAll|Silent)|InitPluginsDir|InstProgressFlags|Inst(?:Type(?:GetText|SetText)?)|Install(?:ButtonText|Colors|Dir(?:RegKey)?)|Int(?:64|Ptr)?CmpU?|Int(?:64)?Fmt|Int(?:Ptr)?Op|IsWindow|Lang(?:DLL|String)|License(?:BkColor|Data|ForceSelection|LangString|Text)|LoadLanguageFile|LockWindow|Log(?:Set|Text)|Manifest(?:DPIAware|SupportedOS)|Math|MessageBox|MiscButtonText|NSISdl|Name|Nop|OutFile|PE(?:DllCharacteristics|SubsysVer)|Page(?:Callbacks)?|Pop|Push|Quit|RMDir|Read(?:EnvStr|INIStr|RegDWORD|RegStr)|Reboot|RegDLL|Rename|RequestExecutionLevel|ReserveFile|Return|SearchPath|Section(?:End|GetFlags|GetInstTypes|GetSize|GetText|Group|In|SetFlags|SetInstTypes|SetSize|SetText)?|SendMessage|Set(?:AutoClose|BrandingImage|Compress|Compressor(?:DictSize)?|CtlColors|CurInstType|DatablockOptimize|DateSave|Details(?:Print|View)|ErrorLevel|Errors|FileAttributes|Font|OutPath|Overwrite|PluginUnload|RebootFlag|RegView|ShellVarContext|Silent)|Show(?:InstDetails|UninstDetails|Window)|Silent(?:Install|UnInstall)|Sleep|SpaceTexts|Splash|StartMenu|Str(?:CmpS?|Cpy|Len)|SubCaption|System|Target|UnRegDLL|Unicode|UninstPage|Uninstall(?:ButtonText|Caption|Icon|SubCaption|Text)|UserInfo|VI(?:AddVersionKey|FileVersion|ProductVersion)|VPatch|Var|WindowIcon|Write(?:INIStr|Reg(?:Bin|DWORD|ExpandStr|MultiStr|None|Str)|Uninstaller)|XPStyle|ns(?:Dialogs|Exec))\b/m,
+      lookbehind: true
+    },
+    property: /\b(?:ARCHIVE|FILE_(?:ATTRIBUTE_ARCHIVE|ATTRIBUTE_NORMAL|ATTRIBUTE_OFFLINE|ATTRIBUTE_READONLY|ATTRIBUTE_SYSTEM|ATTRIBUTE_TEMPORARY)|HK(?:(?:CR|CU|LM)(?:32|64)?|DD|PD|U)|HKEY_(?:CLASSES_ROOT|CURRENT_CONFIG|CURRENT_USER|DYN_DATA|LOCAL_MACHINE|PERFORMANCE_DATA|USERS)|ID(?:ABORT|CANCEL|IGNORE|NO|OK|RETRY|YES)|MB_(?:ABORTRETRYIGNORE|DEFBUTTON1|DEFBUTTON2|DEFBUTTON3|DEFBUTTON4|ICONEXCLAMATION|ICONINFORMATION|ICONQUESTION|ICONSTOP|OK|OKCANCEL|RETRYCANCEL|RIGHT|RTLREADING|SETFOREGROUND|TOPMOST|USERICON|YESNO)|NORMAL|OFFLINE|READONLY|SHCTX|SHELL_CONTEXT|SYSTEM|TEMPORARY|admin|all|auto|both|colored|false|force|hide|highest|lastused|leave|listonly|none|normal|notset|off|on|open|print|show|silent|silentlog|smooth|textonly|true|user)\b/,
+    constant: /\$\{[!\w\.:\^-]+\}|\$\([!\w\.:\^-]+\)/,
+    variable: /\$\w[\w\.]*/,
+    number: /\b0x[\dA-Fa-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee]-?\d+)?/,
+    operator: /--?|\+\+?|<=?|>=?|==?=?|&&?|\|\|?|[?*\/~^%]/,
+    punctuation: /[{}[\];(),.:]/,
+    important: {
+      pattern: /(^[\t ]*)!(?:addincludedir|addplugindir|appendfile|cd|define|delfile|echo|else|endif|error|execute|finalize|getdllversion|gettlbversion|if|ifdef|ifmacrodef|ifmacrondef|ifndef|include|insertmacro|macro|macroend|makensis|packhdr|pragma|searchparse|searchreplace|system|tempfile|undef|verbose|warning)\b/im,
+      lookbehind: true
+    }
+  };
+}
+
+export {
+  nsis
+};

package/dist/chunk-T3PZYOR5.mjs

@@ -0,0 +1,141 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/perl.js
+perl.displayName = "perl";
+perl.aliases = [];
+function perl(Prism) {
+  ;
+  (function(Prism2) {
+    var brackets = /(?:\((?:[^()\\]|\\[\s\S])*\)|\{(?:[^{}\\]|\\[\s\S])*\}|\[(?:[^[\]\\]|\\[\s\S])*\]|<(?:[^<>\\]|\\[\s\S])*>)/.source;
+    Prism2.languages.perl = {
+      comment: [
+        {
+          // POD
+          pattern: /(^\s*)=\w[\s\S]*?=cut.*/m,
+          lookbehind: true,
+          greedy: true
+        },
+        {
+          pattern: /(^|[^\\$])#.*/,
+          lookbehind: true,
+          greedy: true
+        }
+      ],
+      // TODO Could be nice to handle Heredoc too.
+      string: [
+        {
+          pattern: RegExp(
+            /\b(?:q|qq|qw|qx)(?![a-zA-Z0-9])\s*/.source + "(?:" + [
+              // q/.../
+              /([^a-zA-Z0-9\s{(\[<])(?:(?!\1)[^\\]|\\[\s\S])*\1/.source,
+              // q a...a
+              // eslint-disable-next-line regexp/strict
+              /([a-zA-Z0-9])(?:(?!\2)[^\\]|\\[\s\S])*\2/.source,
+              // q(...)
+              // q{...}
+              // q[...]
+              // q<...>
+              brackets
+            ].join("|") + ")"
+          ),
+          greedy: true
+        },
+        // "...", `...`
+        {
+          pattern: /("|`)(?:(?!\1)[^\\]|\\[\s\S])*\1/,
+          greedy: true
+        },
+        // '...'
+        // FIXME Multi-line single-quoted strings are not supported as they would break variables containing '
+        {
+          pattern: /'(?:[^'\\\r\n]|\\.)*'/,
+          greedy: true
+        }
+      ],
+      regex: [
+        {
+          pattern: RegExp(
+            /\b(?:m|qr)(?![a-zA-Z0-9])\s*/.source + "(?:" + [
+              // m/.../
+              /([^a-zA-Z0-9\s{(\[<])(?:(?!\1)[^\\]|\\[\s\S])*\1/.source,
+              // m a...a
+              // eslint-disable-next-line regexp/strict
+              /([a-zA-Z0-9])(?:(?!\2)[^\\]|\\[\s\S])*\2/.source,
+              // m(...)
+              // m{...}
+              // m[...]
+              // m<...>
+              brackets
+            ].join("|") + ")" + /[msixpodualngc]*/.source
+          ),
+          greedy: true
+        },
+        // The lookbehinds prevent -s from breaking
+        {
+          pattern: RegExp(
+            /(^|[^-])\b(?:s|tr|y)(?![a-zA-Z0-9])\s*/.source + "(?:" + [
+              // s/.../.../
+              // eslint-disable-next-line regexp/strict
+              /([^a-zA-Z0-9\s{(\[<])(?:(?!\2)[^\\]|\\[\s\S])*\2(?:(?!\2)[^\\]|\\[\s\S])*\2/.source,
+              // s a...a...a
+              // eslint-disable-next-line regexp/strict
+              /([a-zA-Z0-9])(?:(?!\3)[^\\]|\\[\s\S])*\3(?:(?!\3)[^\\]|\\[\s\S])*\3/.source,
+              // s(...)(...)
+              // s{...}{...}
+              // s[...][...]
+              // s<...><...>
+              // s(...)[...]
+              brackets + /\s*/.source + brackets
+            ].join("|") + ")" + /[msixpodualngcer]*/.source
+          ),
+          lookbehind: true,
+          greedy: true
+        },
+        // /.../
+        // The look-ahead tries to prevent two divisions on
+        // the same line from being highlighted as regex.
+        // This does not support multi-line regex.
+        {
+          pattern: /\/(?:[^\/\\\r\n]|\\.)*\/[msixpodualngc]*(?=\s*(?:$|[\r\n,.;})&|\-+*~<>!?^]|(?:and|cmp|eq|ge|gt|le|lt|ne|not|or|x|xor)\b))/,
+          greedy: true
+        }
+      ],
+      // FIXME Not sure about the handling of ::, ', and #
+      variable: [
+        // ${^POSTMATCH}
+        /[&*$@%]\{\^[A-Z]+\}/,
+        // $^V
+        /[&*$@%]\^[A-Z_]/,
+        // ${...}
+        /[&*$@%]#?(?=\{)/,
+        // $foo
+        /[&*$@%]#?(?:(?:::)*'?(?!\d)[\w$]+(?![\w$]))+(?:::)*/,
+        // $1
+        /[&*$@%]\d+/,
+        // $_, @_, %!
+        // The negative lookahead prevents from breaking the %= operator
+        /(?!%=)[$@%][!"#$%&'()*+,\-.\/:;<=>?@[\\\]^_`{|}~]/
+      ],
+      filehandle: {
+        // <>, <FOO>, _
+        pattern: /<(?![<=])\S*?>|\b_\b/,
+        alias: "symbol"
+      },
+      "v-string": {
+        // v1.2, 1.2.3
+        pattern: /v\d+(?:\.\d+)*|\d+(?:\.\d+){2,}/,
+        alias: "string"
+      },
+      function: {
+        pattern: /(\bsub[ \t]+)\w+/,
+        lookbehind: true
+      },
+      keyword: /\b(?:any|break|continue|default|delete|die|do|else|elsif|eval|for|foreach|given|goto|if|last|local|my|next|our|package|print|redo|require|return|say|state|sub|switch|undef|unless|until|use|when|while)\b/,
+      number: /\b(?:0x[\dA-Fa-f](?:_?[\dA-Fa-f])*|0b[01](?:_?[01])*|(?:(?:\d(?:_?\d)*)?\.)?\d(?:_?\d)*(?:[Ee][+-]?\d+)?)\b/,
+      operator: /-[rwxoRWXOezsfdlpSbctugkTBMAC]\b|\+[+=]?|-[-=>]?|\*\*?=?|\/\/?=?|=[=~>]?|~[~=]?|\|\|?=?|&&?=?|<(?:=>?|<=?)?|>>?=?|![~=]?|[%^]=?|\.(?:=|\.\.?)?|[\\?]|\bx(?:=|\b)|\b(?:and|cmp|eq|ge|gt|le|lt|ne|not|or|xor)\b/,
+      punctuation: /[{}[\];(),:]/
+    };
+  })(Prism);
+}
+
+export {
+  perl
+};

package/dist/chunk-T72AY6AN.mjs

@@ -0,0 +1,87 @@
+import {
+  clike
+} from "./chunk-XWTEQUC3.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/dart.js
+dart.displayName = "dart";
+dart.aliases = [];
+function dart(Prism) {
+  Prism.register(clike);
+  (function(Prism2) {
+    var keywords = [
+      /\b(?:async|sync|yield)\*/,
+      /\b(?:abstract|assert|async|await|break|case|catch|class|const|continue|covariant|default|deferred|do|dynamic|else|enum|export|extends|extension|external|factory|final|finally|for|get|hide|if|implements|import|in|interface|library|mixin|new|null|on|operator|part|rethrow|return|set|show|static|super|switch|sync|this|throw|try|typedef|var|void|while|with|yield)\b/
+    ];
+    var packagePrefix = /(^|[^\w.])(?:[a-z]\w*\s*\.\s*)*(?:[A-Z]\w*\s*\.\s*)*/.source;
+    var className = {
+      pattern: RegExp(packagePrefix + /[A-Z](?:[\d_A-Z]*[a-z]\w*)?\b/.source),
+      lookbehind: true,
+      inside: {
+        namespace: {
+          pattern: /^[a-z]\w*(?:\s*\.\s*[a-z]\w*)*(?:\s*\.)?/,
+          inside: {
+            punctuation: /\./
+          }
+        }
+      }
+    };
+    Prism2.languages.dart = Prism2.languages.extend("clike", {
+      "class-name": [
+        className,
+        {
+          // variables and parameters
+          // this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods)
+          pattern: RegExp(
+            packagePrefix + /[A-Z]\w*(?=\s+\w+\s*[;,=()])/.source
+          ),
+          lookbehind: true,
+          inside: className.inside
+        }
+      ],
+      keyword: keywords,
+      operator: /\bis!|\b(?:as|is)\b|\+\+|--|&&|\|\||<<=?|>>=?|~(?:\/=?)?|[+\-*\/%&^|=!<>]=?|\?/
+    });
+    Prism2.languages.insertBefore("dart", "string", {
+      "string-literal": {
+        pattern: /r?(?:("""|''')[\s\S]*?\1|(["'])(?:\\.|(?!\2)[^\\\r\n])*\2(?!\2))/,
+        greedy: true,
+        inside: {
+          interpolation: {
+            pattern: /((?:^|[^\\])(?:\\{2})*)\$(?:\w+|\{(?:[^{}]|\{[^{}]*\})*\})/,
+            lookbehind: true,
+            inside: {
+              punctuation: /^\$\{?|\}$/,
+              expression: {
+                pattern: /[\s\S]+/,
+                inside: Prism2.languages.dart
+              }
+            }
+          },
+          string: /[\s\S]+/
+        }
+      },
+      string: void 0
+    });
+    Prism2.languages.insertBefore("dart", "class-name", {
+      metadata: {
+        pattern: /@\w+/,
+        alias: "function"
+      }
+    });
+    Prism2.languages.insertBefore("dart", "class-name", {
+      generics: {
+        pattern: /<(?:[\w\s,.&?]|<(?:[\w\s,.&?]|<(?:[\w\s,.&?]|<[\w\s,.&?]*>)*>)*>)*>/,
+        inside: {
+          "class-name": className,
+          keyword: keywords,
+          punctuation: /[<>(),.:]/,
+          operator: /[?&|]/
+        }
+      }
+    });
+  })(Prism);
+}
+
+export {
+  dart
+};

package/dist/chunk-TG6MIYIG.mjs

@@ -0,0 +1,145 @@
+import {
+  clike
+} from "./chunk-XWTEQUC3.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/java.js
+java.displayName = "java";
+java.aliases = [];
+function java(Prism) {
+  Prism.register(clike);
+  (function(Prism2) {
+    var keywords = /\b(?:abstract|assert|boolean|break|byte|case|catch|char|class|const|continue|default|do|double|else|enum|exports|extends|final|finally|float|for|goto|if|implements|import|instanceof|int|interface|long|module|native|new|non-sealed|null|open|opens|package|permits|private|protected|provides|public|record(?!\s*[(){}[\]<>=%~.:,;?+\-*/&|^])|requires|return|sealed|short|static|strictfp|super|switch|synchronized|this|throw|throws|to|transient|transitive|try|uses|var|void|volatile|while|with|yield)\b/;
+    var classNamePrefix = /(?:[a-z]\w*\s*\.\s*)*(?:[A-Z]\w*\s*\.\s*)*/.source;
+    var className = {
+      pattern: RegExp(
+        /(^|[^\w.])/.source + classNamePrefix + /[A-Z](?:[\d_A-Z]*[a-z]\w*)?\b/.source
+      ),
+      lookbehind: true,
+      inside: {
+        namespace: {
+          pattern: /^[a-z]\w*(?:\s*\.\s*[a-z]\w*)*(?:\s*\.)?/,
+          inside: {
+            punctuation: /\./
+          }
+        },
+        punctuation: /\./
+      }
+    };
+    Prism2.languages.java = Prism2.languages.extend("clike", {
+      string: {
+        pattern: /(^|[^\\])"(?:\\.|[^"\\\r\n])*"/,
+        lookbehind: true,
+        greedy: true
+      },
+      "class-name": [
+        className,
+        {
+          // variables, parameters, and constructor references
+          // this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods)
+          pattern: RegExp(
+            /(^|[^\w.])/.source + classNamePrefix + /[A-Z]\w*(?=\s+\w+\s*[;,=()]|\s*(?:\[[\s,]*\]\s*)?::\s*new\b)/.source
+          ),
+          lookbehind: true,
+          inside: className.inside
+        },
+        {
+          // class names based on keyword
+          // this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods)
+          pattern: RegExp(
+            /(\b(?:class|enum|extends|implements|instanceof|interface|new|record|throws)\s+)/.source + classNamePrefix + /[A-Z]\w*\b/.source
+          ),
+          lookbehind: true,
+          inside: className.inside
+        }
+      ],
+      keyword: keywords,
+      function: [
+        Prism2.languages.clike.function,
+        {
+          pattern: /(::\s*)[a-z_]\w*/,
+          lookbehind: true
+        }
+      ],
+      number: /\b0b[01][01_]*L?\b|\b0x(?:\.[\da-f_p+-]+|[\da-f_]+(?:\.[\da-f_p+-]+)?)\b|(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?\d[\d_]*)?[dfl]?/i,
+      operator: {
+        pattern: /(^|[^.])(?:<<=?|>>>?=?|->|--|\+\+|&&|\|\||::|[?:~]|[-+*/%&|^!=<>]=?)/m,
+        lookbehind: true
+      },
+      constant: /\b[A-Z][A-Z_\d]+\b/
+    });
+    Prism2.languages.insertBefore("java", "string", {
+      "triple-quoted-string": {
+        // http://openjdk.java.net/jeps/355#Description
+        pattern: /"""[ \t]*[\r\n](?:(?:"|"")?(?:\\.|[^"\\]))*"""/,
+        greedy: true,
+        alias: "string"
+      },
+      char: {
+        pattern: /'(?:\\.|[^'\\\r\n]){1,6}'/,
+        greedy: true
+      }
+    });
+    Prism2.languages.insertBefore("java", "class-name", {
+      annotation: {
+        pattern: /(^|[^.])@\w+(?:\s*\.\s*\w+)*/,
+        lookbehind: true,
+        alias: "punctuation"
+      },
+      generics: {
+        pattern: /<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&)|<(?:[\w\s,.?]|&(?!&))*>)*>)*>)*>/,
+        inside: {
+          "class-name": className,
+          keyword: keywords,
+          punctuation: /[<>(),.:]/,
+          operator: /[?&|]/
+        }
+      },
+      import: [
+        {
+          pattern: RegExp(
+            /(\bimport\s+)/.source + classNamePrefix + /(?:[A-Z]\w*|\*)(?=\s*;)/.source
+          ),
+          lookbehind: true,
+          inside: {
+            namespace: className.inside.namespace,
+            punctuation: /\./,
+            operator: /\*/,
+            "class-name": /\w+/
+          }
+        },
+        {
+          pattern: RegExp(
+            /(\bimport\s+static\s+)/.source + classNamePrefix + /(?:\w+|\*)(?=\s*;)/.source
+          ),
+          lookbehind: true,
+          alias: "static",
+          inside: {
+            namespace: className.inside.namespace,
+            static: /\b\w+$/,
+            punctuation: /\./,
+            operator: /\*/,
+            "class-name": /\w+/
+          }
+        }
+      ],
+      namespace: {
+        pattern: RegExp(
+          /(\b(?:exports|import(?:\s+static)?|module|open|opens|package|provides|requires|to|transitive|uses|with)\s+)(?!<keyword>)[a-z]\w*(?:\.[a-z]\w*)*\.?/.source.replace(
+            /<keyword>/g,
+            function() {
+              return keywords.source;
+            }
+          )
+        ),
+        lookbehind: true,
+        inside: {
+          punctuation: /\./
+        }
+      }
+    });
+  })(Prism);
+}
+
+export {
+  java
+};

package/dist/chunk-TGKFMVR5.mjs

@@ -0,0 +1,56 @@
+import {
+  markupTemplating
+} from "./chunk-DFNMTLAN.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/handlebars.js
+handlebars.displayName = "handlebars";
+handlebars.aliases = ["hbs", "mustache"];
+function handlebars(Prism) {
+  Prism.register(markupTemplating);
+  (function(Prism2) {
+    Prism2.languages.handlebars = {
+      comment: /\{\{![\s\S]*?\}\}/,
+      delimiter: {
+        pattern: /^\{\{\{?|\}\}\}?$/,
+        alias: "punctuation"
+      },
+      string: /(["'])(?:\\.|(?!\1)[^\\\r\n])*\1/,
+      number: /\b0x[\dA-Fa-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee][+-]?\d+)?/,
+      boolean: /\b(?:false|true)\b/,
+      block: {
+        pattern: /^(\s*(?:~\s*)?)[#\/]\S+?(?=\s*(?:~\s*)?$|\s)/,
+        lookbehind: true,
+        alias: "keyword"
+      },
+      brackets: {
+        pattern: /\[[^\]]+\]/,
+        inside: {
+          punctuation: /\[|\]/,
+          variable: /[\s\S]+/
+        }
+      },
+      punctuation: /[!"#%&':()*+,.\/;<=>@\[\\\]^`{|}~]/,
+      variable: /[^!"#%&'()*+,\/;<=>@\[\\\]^`{|}~\s]+/
+    };
+    Prism2.hooks.add("before-tokenize", function(env) {
+      var handlebarsPattern = /\{\{\{[\s\S]+?\}\}\}|\{\{[\s\S]+?\}\}/g;
+      Prism2.languages["markup-templating"].buildPlaceholders(
+        env,
+        "handlebars",
+        handlebarsPattern
+      );
+    });
+    Prism2.hooks.add("after-tokenize", function(env) {
+      Prism2.languages["markup-templating"].tokenizePlaceholders(
+        env,
+        "handlebars"
+      );
+    });
+    Prism2.languages.hbs = Prism2.languages.handlebars;
+    Prism2.languages.mustache = Prism2.languages.handlebars;
+  })(Prism);
+}
+
+export {
+  handlebars
+};

package/dist/chunk-TGPVDA2E.mjs

@@ -0,0 +1,29 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/lua.js
+lua.displayName = "lua";
+lua.aliases = [];
+function lua(Prism) {
+  Prism.languages.lua = {
+    comment: /^#!.+|--(?:\[(=*)\[[\s\S]*?\]\1\]|.*)/m,
+    // \z may be used to skip the following space
+    string: {
+      pattern: /(["'])(?:(?!\1)[^\\\r\n]|\\z(?:\r\n|\s)|\\(?:\r\n|[^z]))*\1|\[(=*)\[[\s\S]*?\]\2\]/,
+      greedy: true
+    },
+    number: /\b0x[a-f\d]+(?:\.[a-f\d]*)?(?:p[+-]?\d+)?\b|\b\d+(?:\.\B|(?:\.\d*)?(?:e[+-]?\d+)?\b)|\B\.\d+(?:e[+-]?\d+)?\b/i,
+    keyword: /\b(?:and|break|do|else|elseif|end|false|for|function|goto|if|in|local|nil|not|or|repeat|return|then|true|until|while)\b/,
+    function: /(?!\d)\w+(?=\s*(?:[({]))/,
+    operator: [
+      /[-+*%^&|#]|\/\/?|<[<=]?|>[>=]?|[=~]=?/,
+      {
+        // Match ".." but don't break "..."
+        pattern: /(^|[^.])\.\.(?!\.)/,
+        lookbehind: true
+      }
+    ],
+    punctuation: /[\[\](){},;]|\.+|:+/
+  };
+}
+
+export {
+  lua
+};

package/dist/chunk-THGDTVTG.mjs

@@ -0,0 +1,72 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/excel-formula.js
+excelFormula.displayName = "excel-formula";
+excelFormula.aliases = ["xls", "xlsx"];
+function excelFormula(Prism) {
+  Prism.languages["excel-formula"] = {
+    comment: {
+      pattern: /(\bN\(\s*)"(?:[^"]|"")*"(?=\s*\))/i,
+      lookbehind: true,
+      greedy: true
+    },
+    string: {
+      pattern: /"(?:[^"]|"")*"(?!")/,
+      greedy: true
+    },
+    reference: {
+      // https://www.ablebits.com/office-addins-blog/2015/12/08/excel-reference-another-sheet-workbook/
+      // Sales!B2
+      // 'Winter sales'!B2
+      // [Sales.xlsx]Jan!B2:B5
+      // D:\Reports\[Sales.xlsx]Jan!B2:B5
+      // '[Sales.xlsx]Jan sales'!B2:B5
+      // 'D:\Reports\[Sales.xlsx]Jan sales'!B2:B5
+      pattern: /(?:'[^']*'|(?:[^\s()[\]{}<>*?"';,$&]*\[[^^\s()[\]{}<>*?"']+\])?\w+)!/,
+      greedy: true,
+      alias: "string",
+      inside: {
+        operator: /!$/,
+        punctuation: /'/,
+        sheet: {
+          pattern: /[^[\]]+$/,
+          alias: "function"
+        },
+        file: {
+          pattern: /\[[^[\]]+\]$/,
+          inside: {
+            punctuation: /[[\]]/
+          }
+        },
+        path: /[\s\S]+/
+      }
+    },
+    "function-name": {
+      pattern: /\b[A-Z]\w*(?=\()/i,
+      alias: "builtin"
+    },
+    range: {
+      pattern: /\$?\b(?:[A-Z]+\$?\d+:\$?[A-Z]+\$?\d+|[A-Z]+:\$?[A-Z]+|\d+:\$?\d+)\b/i,
+      alias: "selector",
+      inside: {
+        operator: /:/,
+        cell: /\$?[A-Z]+\$?\d+/i,
+        column: /\$?[A-Z]+/i,
+        row: /\$?\d+/
+      }
+    },
+    cell: {
+      // Excel is case insensitive, so the string "foo1" could be either a variable or a cell.
+      // To combat this, we match cells case insensitive, if the contain at least one "$", and case sensitive otherwise.
+      pattern: /\b[A-Z]+\d+\b|\$[A-Za-z]+\$?\d+\b|\b[A-Za-z]+\$\d+\b/,
+      alias: "selector"
+    },
+    number: /(?:\b\d+(?:\.\d+)?|\B\.\d+)(?:e[+-]?\d+)?\b/i,
+    boolean: /\b(?:FALSE|TRUE)\b/i,
+    operator: /[-+*/^%=&,]|<[=>]?|>=?/,
+    punctuation: /[[\]();{}|]/
+  };
+  Prism.languages["xlsx"] = Prism.languages["xls"] = Prism.languages["excel-formula"];
+}
+
+export {
+  excelFormula
+};