@photonix/basic 1.5.0 → 1.6.0

package/dist/chunk-BCCX6KVT.mjs

@@ -0,0 +1,121 @@
+import {
+  c
+} from "./chunk-PEEMT7UZ.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/cpp.js
+cpp.displayName = "cpp";
+cpp.aliases = [];
+function cpp(Prism) {
+  Prism.register(c);
+  (function(Prism2) {
+    var keyword = /\b(?:alignas|alignof|asm|auto|bool|break|case|catch|char|char16_t|char32_t|char8_t|class|co_await|co_return|co_yield|compl|concept|const|const_cast|consteval|constexpr|constinit|continue|decltype|default|delete|do|double|dynamic_cast|else|enum|explicit|export|extern|final|float|for|friend|goto|if|import|inline|int|int16_t|int32_t|int64_t|int8_t|long|module|mutable|namespace|new|noexcept|nullptr|operator|override|private|protected|public|register|reinterpret_cast|requires|return|short|signed|sizeof|static|static_assert|static_cast|struct|switch|template|this|thread_local|throw|try|typedef|typeid|typename|uint16_t|uint32_t|uint64_t|uint8_t|union|unsigned|using|virtual|void|volatile|wchar_t|while)\b/;
+    var modName = /\b(?!<keyword>)\w+(?:\s*\.\s*\w+)*\b/.source.replace(
+      /<keyword>/g,
+      function() {
+        return keyword.source;
+      }
+    );
+    Prism2.languages.cpp = Prism2.languages.extend("c", {
+      "class-name": [
+        {
+          pattern: RegExp(
+            /(\b(?:class|concept|enum|struct|typename)\s+)(?!<keyword>)\w+/.source.replace(
+              /<keyword>/g,
+              function() {
+                return keyword.source;
+              }
+            )
+          ),
+          lookbehind: true
+        },
+        // This is intended to capture the class name of method implementations like:
+        //   void foo::bar() const {}
+        // However! The `foo` in the above example could also be a namespace, so we only capture the class name if
+        // it starts with an uppercase letter. This approximation should give decent results.
+        /\b[A-Z]\w*(?=\s*::\s*\w+\s*\()/,
+        // This will capture the class name before destructors like:
+        //   Foo::~Foo() {}
+        /\b[A-Z_]\w*(?=\s*::\s*~\w+\s*\()/i,
+        // This also intends to capture the class name of method implementations but here the class has template
+        // parameters, so it can't be a namespace (until C++ adds generic namespaces).
+        /\b\w+(?=\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>\s*::\s*\w+\s*\()/
+      ],
+      keyword,
+      number: {
+        pattern: /(?:\b0b[01']+|\b0x(?:[\da-f']+(?:\.[\da-f']*)?|\.[\da-f']+)(?:p[+-]?[\d']+)?|(?:\b[\d']+(?:\.[\d']*)?|\B\.[\d']+)(?:e[+-]?[\d']+)?)[ful]{0,4}/i,
+        greedy: true
+      },
+      operator: />>=?|<<=?|->|--|\+\+|&&|\|\||[?:~]|<=>|[-+*/%&|^!=<>]=?|\b(?:and|and_eq|bitand|bitor|not|not_eq|or|or_eq|xor|xor_eq)\b/,
+      boolean: /\b(?:false|true)\b/
+    });
+    Prism2.languages.insertBefore("cpp", "string", {
+      module: {
+        // https://en.cppreference.com/w/cpp/language/modules
+        pattern: RegExp(
+          /(\b(?:import|module)\s+)/.source + "(?:" + // header-name
+          /"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"|<[^<>\r\n]*>/.source + "|" + // module name or partition or both
+          /<mod-name>(?:\s*:\s*<mod-name>)?|:\s*<mod-name>/.source.replace(
+            /<mod-name>/g,
+            function() {
+              return modName;
+            }
+          ) + ")"
+        ),
+        lookbehind: true,
+        greedy: true,
+        inside: {
+          string: /^[<"][\s\S]+/,
+          operator: /:/,
+          punctuation: /\./
+        }
+      },
+      "raw-string": {
+        pattern: /R"([^()\\ ]{0,16})\([\s\S]*?\)\1"/,
+        alias: "string",
+        greedy: true
+      }
+    });
+    Prism2.languages.insertBefore("cpp", "keyword", {
+      "generic-function": {
+        pattern: /\b(?!operator\b)[a-z_]\w*\s*<(?:[^<>]|<[^<>]*>)*>(?=\s*\()/i,
+        inside: {
+          function: /^\w+/,
+          generic: {
+            pattern: /<[\s\S]+/,
+            alias: "class-name",
+            inside: Prism2.languages.cpp
+          }
+        }
+      }
+    });
+    Prism2.languages.insertBefore("cpp", "operator", {
+      "double-colon": {
+        pattern: /::/,
+        alias: "punctuation"
+      }
+    });
+    Prism2.languages.insertBefore("cpp", "class-name", {
+      // the base clause is an optional list of parent classes
+      // https://en.cppreference.com/w/cpp/language/class
+      "base-clause": {
+        pattern: /(\b(?:class|struct)\s+\w+\s*:\s*)[^;{}"'\s]+(?:\s+[^;{}"'\s]+)*(?=\s*[;{])/,
+        lookbehind: true,
+        greedy: true,
+        inside: Prism2.languages.extend("cpp", {})
+      }
+    });
+    Prism2.languages.insertBefore(
+      "inside",
+      "double-colon",
+      {
+        // All untokenized words that are not namespaces should be class names
+        "class-name": /\b[a-z_]\w*\b(?!\s*::)/i
+      },
+      Prism2.languages.cpp["base-clause"]
+    );
+  })(Prism);
+}
+
+export {
+  cpp
+};

package/dist/chunk-BH2XPEPE.mjs

@@ -0,0 +1,72 @@
+import {
+  clike
+} from "./chunk-XWTEQUC3.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/purebasic.js
+purebasic.displayName = "purebasic";
+purebasic.aliases = ["pbfasm"];
+function purebasic(Prism) {
+  Prism.register(clike);
+  Prism.languages.purebasic = Prism.languages.extend("clike", {
+    comment: /;.*/,
+    keyword: /\b(?:align|and|as|break|calldebugger|case|compilercase|compilerdefault|compilerelse|compilerelseif|compilerendif|compilerendselect|compilererror|compilerif|compilerselect|continue|data|datasection|debug|debuglevel|declare|declarec|declarecdll|declaredll|declaremodule|default|define|dim|disableasm|disabledebugger|disableexplicit|else|elseif|enableasm|enabledebugger|enableexplicit|end|enddatasection|enddeclaremodule|endenumeration|endif|endimport|endinterface|endmacro|endmodule|endprocedure|endselect|endstructure|endstructureunion|endwith|enumeration|extends|fakereturn|for|foreach|forever|global|gosub|goto|if|import|importc|includebinary|includefile|includepath|interface|macro|module|newlist|newmap|next|not|or|procedure|procedurec|procedurecdll|proceduredll|procedurereturn|protected|prototype|prototypec|read|redim|repeat|restore|return|runtime|select|shared|static|step|structure|structureunion|swap|threaded|to|until|wend|while|with|xincludefile|xor)\b/i,
+    function: /\b\w+(?:\.\w+)?\s*(?=\()/,
+    number: /(?:\$[\da-f]+|\b-?(?:\d+(?:\.\d+)?|\.\d+)(?:e[+-]?\d+)?)\b/i,
+    operator: /(?:@\*?|\?|\*)\w+\$?|-[>-]?|\+\+?|!=?|<<?=?|>>?=?|==?|&&?|\|?\||[~^%?*/@]/
+  });
+  Prism.languages.insertBefore("purebasic", "keyword", {
+    tag: /#\w+\$?/,
+    asm: {
+      pattern: /(^[\t ]*)!.*/m,
+      lookbehind: true,
+      alias: "tag",
+      inside: {
+        comment: /;.*/,
+        string: {
+          pattern: /(["'`])(?:\\.|(?!\1)[^\\\r\n])*\1/,
+          greedy: true
+        },
+        // Anonymous label references, i.e.: jmp @b
+        "label-reference-anonymous": {
+          pattern: /(!\s*j[a-z]+\s+)@[fb]/i,
+          lookbehind: true,
+          alias: "fasm-label"
+        },
+        // Named label reference, i.e.: jne label1
+        "label-reference-addressed": {
+          pattern: /(!\s*j[a-z]+\s+)[A-Z._?$@][\w.?$@~#]*/i,
+          lookbehind: true,
+          alias: "fasm-label"
+        },
+        keyword: [
+          /\b(?:extern|global)\b[^;\r\n]*/i,
+          /\b(?:CPU|DEFAULT|FLOAT)\b.*/
+        ],
+        function: {
+          pattern: /^([\t ]*!\s*)[\da-z]+(?=\s|$)/im,
+          lookbehind: true
+        },
+        "function-inline": {
+          pattern: /(:\s*)[\da-z]+(?=\s)/i,
+          lookbehind: true,
+          alias: "function"
+        },
+        label: {
+          pattern: /^([\t ]*!\s*)[A-Za-z._?$@][\w.?$@~#]*(?=:)/m,
+          lookbehind: true,
+          alias: "fasm-label"
+        },
+        register: /\b(?:st\d|[xyz]mm\d\d?|[cdt]r\d|r\d\d?[bwd]?|[er]?[abcd]x|[abcd][hl]|[er]?(?:bp|di|si|sp)|[cdefgs]s|mm\d+)\b/i,
+        number: /(?:\b|-|(?=\$))(?:0[hx](?:[\da-f]*\.)?[\da-f]+(?:p[+-]?\d+)?|\d[\da-f]+[hx]|\$\d[\da-f]*|0[oq][0-7]+|[0-7]+[oq]|0[by][01]+|[01]+[by]|0[dt]\d+|(?:\d+(?:\.\d+)?|\.\d+)(?:\.?e[+-]?\d+)?[dt]?)\b/i,
+        operator: /[\[\]*+\-/%<>=&|$!,.:]/
+      }
+    }
+  });
+  delete Prism.languages.purebasic["class-name"];
+  delete Prism.languages.purebasic["boolean"];
+  Prism.languages.pbfasm = Prism.languages["purebasic"];
+}
+
+export {
+  purebasic
+};

package/dist/chunk-BHKWHYQV.mjs

@@ -0,0 +1,124 @@
+import {
+  css
+} from "./chunk-4RG7ZGOZ.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/css-extras.js
+cssExtras.displayName = "css-extras";
+cssExtras.aliases = [];
+function cssExtras(Prism) {
+  Prism.register(css);
+  (function(Prism2) {
+    var string = /("|')(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/;
+    var selectorInside;
+    Prism2.languages.css.selector = {
+      pattern: Prism2.languages.css.selector.pattern,
+      lookbehind: true,
+      inside: selectorInside = {
+        "pseudo-element": /:(?:after|before|first-letter|first-line|selection)|::[-\w]+/,
+        "pseudo-class": /:[-\w]+/,
+        class: /\.[-\w]+/,
+        id: /#[-\w]+/,
+        attribute: {
+          pattern: RegExp(`\\[(?:[^[\\]"']|` + string.source + ")*\\]"),
+          greedy: true,
+          inside: {
+            punctuation: /^\[|\]$/,
+            "case-sensitivity": {
+              pattern: /(\s)[si]$/i,
+              lookbehind: true,
+              alias: "keyword"
+            },
+            namespace: {
+              pattern: /^(\s*)(?:(?!\s)[-*\w\xA0-\uFFFF])*\|(?!=)/,
+              lookbehind: true,
+              inside: {
+                punctuation: /\|$/
+              }
+            },
+            "attr-name": {
+              pattern: /^(\s*)(?:(?!\s)[-\w\xA0-\uFFFF])+/,
+              lookbehind: true
+            },
+            "attr-value": [
+              string,
+              {
+                pattern: /(=\s*)(?:(?!\s)[-\w\xA0-\uFFFF])+(?=\s*$)/,
+                lookbehind: true
+              }
+            ],
+            operator: /[|~*^$]?=/
+          }
+        },
+        "n-th": [
+          {
+            pattern: /(\(\s*)[+-]?\d*[\dn](?:\s*[+-]\s*\d+)?(?=\s*\))/,
+            lookbehind: true,
+            inside: {
+              number: /[\dn]+/,
+              operator: /[+-]/
+            }
+          },
+          {
+            pattern: /(\(\s*)(?:even|odd)(?=\s*\))/i,
+            lookbehind: true
+          }
+        ],
+        combinator: />|\+|~|\|\|/,
+        // the `tag` token has been existed and removed.
+        // because we can't find a perfect tokenize to match it.
+        // if you want to add it, please read https://github.com/PrismJS/prism/pull/2373 first.
+        punctuation: /[(),]/
+      }
+    };
+    Prism2.languages.css["atrule"].inside["selector-function-argument"].inside = selectorInside;
+    Prism2.languages.insertBefore("css", "property", {
+      variable: {
+        pattern: /(^|[^-\w\xA0-\uFFFF])--(?!\s)[-_a-z\xA0-\uFFFF](?:(?!\s)[-\w\xA0-\uFFFF])*/i,
+        lookbehind: true
+      }
+    });
+    var unit = {
+      pattern: /(\b\d+)(?:%|[a-z]+(?![\w-]))/,
+      lookbehind: true
+    };
+    var number = {
+      pattern: /(^|[^\w.-])-?(?:\d+(?:\.\d+)?|\.\d+)/,
+      lookbehind: true
+    };
+    Prism2.languages.insertBefore("css", "function", {
+      operator: {
+        pattern: /(\s)[+\-*\/](?=\s)/,
+        lookbehind: true
+      },
+      // CAREFUL!
+      // Previewers and Inline color use hexcode and color.
+      hexcode: {
+        pattern: /\B#[\da-f]{3,8}\b/i,
+        alias: "color"
+      },
+      color: [
+        {
+          pattern: /(^|[^\w-])(?:AliceBlue|AntiqueWhite|Aqua|Aquamarine|Azure|Beige|Bisque|Black|BlanchedAlmond|Blue|BlueViolet|Brown|BurlyWood|CadetBlue|Chartreuse|Chocolate|Coral|CornflowerBlue|Cornsilk|Crimson|Cyan|DarkBlue|DarkCyan|DarkGoldenRod|DarkGr[ae]y|DarkGreen|DarkKhaki|DarkMagenta|DarkOliveGreen|DarkOrange|DarkOrchid|DarkRed|DarkSalmon|DarkSeaGreen|DarkSlateBlue|DarkSlateGr[ae]y|DarkTurquoise|DarkViolet|DeepPink|DeepSkyBlue|DimGr[ae]y|DodgerBlue|FireBrick|FloralWhite|ForestGreen|Fuchsia|Gainsboro|GhostWhite|Gold|GoldenRod|Gr[ae]y|Green|GreenYellow|HoneyDew|HotPink|IndianRed|Indigo|Ivory|Khaki|Lavender|LavenderBlush|LawnGreen|LemonChiffon|LightBlue|LightCoral|LightCyan|LightGoldenRodYellow|LightGr[ae]y|LightGreen|LightPink|LightSalmon|LightSeaGreen|LightSkyBlue|LightSlateGr[ae]y|LightSteelBlue|LightYellow|Lime|LimeGreen|Linen|Magenta|Maroon|MediumAquaMarine|MediumBlue|MediumOrchid|MediumPurple|MediumSeaGreen|MediumSlateBlue|MediumSpringGreen|MediumTurquoise|MediumVioletRed|MidnightBlue|MintCream|MistyRose|Moccasin|NavajoWhite|Navy|OldLace|Olive|OliveDrab|Orange|OrangeRed|Orchid|PaleGoldenRod|PaleGreen|PaleTurquoise|PaleVioletRed|PapayaWhip|PeachPuff|Peru|Pink|Plum|PowderBlue|Purple|RebeccaPurple|Red|RosyBrown|RoyalBlue|SaddleBrown|Salmon|SandyBrown|SeaGreen|SeaShell|Sienna|Silver|SkyBlue|SlateBlue|SlateGr[ae]y|Snow|SpringGreen|SteelBlue|Tan|Teal|Thistle|Tomato|Transparent|Turquoise|Violet|Wheat|White|WhiteSmoke|Yellow|YellowGreen)(?![\w-])/i,
+          lookbehind: true
+        },
+        {
+          pattern: /\b(?:hsl|rgb)\(\s*\d{1,3}\s*,\s*\d{1,3}%?\s*,\s*\d{1,3}%?\s*\)\B|\b(?:hsl|rgb)a\(\s*\d{1,3}\s*,\s*\d{1,3}%?\s*,\s*\d{1,3}%?\s*,\s*(?:0|0?\.\d+|1)\s*\)\B/i,
+          inside: {
+            unit,
+            number,
+            function: /[\w-]+(?=\()/,
+            punctuation: /[(),]/
+          }
+        }
+      ],
+      // it's important that there is no boundary assertion after the hex digits
+      entity: /\\[\da-f]{1,8}/i,
+      unit,
+      number
+    });
+  })(Prism);
+}
+
+export {
+  cssExtras
+};

package/dist/chunk-BOH2CHZ5.mjs

@@ -0,0 +1,55 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/tcl.js
+tcl.displayName = "tcl";
+tcl.aliases = [];
+function tcl(Prism) {
+  Prism.languages.tcl = {
+    comment: {
+      pattern: /(^|[^\\])#.*/,
+      lookbehind: true
+    },
+    string: {
+      pattern: /"(?:[^"\\\r\n]|\\(?:\r\n|[\s\S]))*"/,
+      greedy: true
+    },
+    variable: [
+      {
+        pattern: /(\$)(?:::)?(?:[a-zA-Z0-9]+::)*\w+/,
+        lookbehind: true
+      },
+      {
+        pattern: /(\$)\{[^}]+\}/,
+        lookbehind: true
+      },
+      {
+        pattern: /(^[\t ]*set[ \t]+)(?:::)?(?:[a-zA-Z0-9]+::)*\w+/m,
+        lookbehind: true
+      }
+    ],
+    function: {
+      pattern: /(^[\t ]*proc[ \t]+)\S+/m,
+      lookbehind: true
+    },
+    builtin: [
+      {
+        pattern: /(^[\t ]*)(?:break|class|continue|error|eval|exit|for|foreach|if|proc|return|switch|while)\b/m,
+        lookbehind: true
+      },
+      /\b(?:else|elseif)\b/
+    ],
+    scope: {
+      pattern: /(^[\t ]*)(?:global|upvar|variable)\b/m,
+      lookbehind: true,
+      alias: "constant"
+    },
+    keyword: {
+      pattern: /(^[\t ]*|\[)(?:Safe_Base|Tcl|after|append|apply|array|auto_(?:execok|import|load|mkindex|qualify|reset)|automkindex_old|bgerror|binary|catch|cd|chan|clock|close|concat|dde|dict|encoding|eof|exec|expr|fblocked|fconfigure|fcopy|file(?:event|name)?|flush|gets|glob|history|http|incr|info|interp|join|lappend|lassign|lindex|linsert|list|llength|load|lrange|lrepeat|lreplace|lreverse|lsearch|lset|lsort|math(?:func|op)|memory|msgcat|namespace|open|package|parray|pid|pkg_mkIndex|platform|puts|pwd|re_syntax|read|refchan|regexp|registry|regsub|rename|scan|seek|set|socket|source|split|string|subst|tcl(?:_endOfWord|_findLibrary|startOf(?:Next|Previous)Word|test|vars|wordBreak(?:After|Before))|tell|time|tm|trace|unknown|unload|unset|update|uplevel|vwait)\b/m,
+      lookbehind: true
+    },
+    operator: /!=?|\*\*?|==|&&?|\|\|?|<[=<]?|>[=>]?|[-+~\/%?^]|\b(?:eq|in|ne|ni)\b/,
+    punctuation: /[{}()\[\]]/
+  };
+}
+
+export {
+  tcl
+};

package/dist/chunk-BSW6U4XU.mjs

@@ -0,0 +1,65 @@
+import {
+  javascript
+} from "./chunk-ZJYVOTZA.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/typescript.js
+typescript.displayName = "typescript";
+typescript.aliases = ["ts"];
+function typescript(Prism) {
+  Prism.register(javascript);
+  (function(Prism2) {
+    Prism2.languages.typescript = Prism2.languages.extend("javascript", {
+      "class-name": {
+        pattern: /(\b(?:class|extends|implements|instanceof|interface|new|type)\s+)(?!keyof\b)(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?:\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>)?/,
+        lookbehind: true,
+        greedy: true,
+        inside: null
+        // see below
+      },
+      builtin: /\b(?:Array|Function|Promise|any|boolean|console|never|number|string|symbol|unknown)\b/
+    });
+    Prism2.languages.typescript.keyword.push(
+      /\b(?:abstract|declare|is|keyof|readonly|require)\b/,
+      // keywords that have to be followed by an identifier
+      /\b(?:asserts|infer|interface|module|namespace|type)\b(?=\s*(?:[{_$a-zA-Z\xA0-\uFFFF]|$))/,
+      // This is for `import type *, {}`
+      /\btype\b(?=\s*(?:[\{*]|$))/
+    );
+    delete Prism2.languages.typescript["parameter"];
+    delete Prism2.languages.typescript["literal-property"];
+    var typeInside = Prism2.languages.extend("typescript", {});
+    delete typeInside["class-name"];
+    Prism2.languages.typescript["class-name"].inside = typeInside;
+    Prism2.languages.insertBefore("typescript", "function", {
+      decorator: {
+        pattern: /@[$\w\xA0-\uFFFF]+/,
+        inside: {
+          at: {
+            pattern: /^@/,
+            alias: "operator"
+          },
+          function: /^[\s\S]+/
+        }
+      },
+      "generic-function": {
+        // e.g. foo<T extends "bar" | "baz">( ...
+        pattern: /#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>(?=\s*\()/,
+        greedy: true,
+        inside: {
+          function: /^#?(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/,
+          generic: {
+            pattern: /<[\s\S]+/,
+            // everything after the first <
+            alias: "class-name",
+            inside: typeInside
+          }
+        }
+      }
+    });
+    Prism2.languages.ts = Prism2.languages.typescript;
+  })(Prism);
+}
+
+export {
+  typescript
+};

package/dist/chunk-BTBO6PTL.mjs

@@ -0,0 +1,96 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/arturo.js
+arturo.displayName = "arturo";
+arturo.aliases = ["art"];
+function arturo(Prism) {
+  ;
+  (function(Prism2) {
+    var createLanguageString = function(lang, pattern) {
+      return {
+        pattern: RegExp(
+          /\{!/.source + "(?:" + (pattern || lang) + ")" + /$[\s\S]*\}/.source,
+          "m"
+        ),
+        greedy: true,
+        inside: {
+          embedded: {
+            pattern: /(^\{!\w+\b)[\s\S]+(?=\}$)/,
+            lookbehind: true,
+            alias: "language-" + lang,
+            inside: Prism2.languages[lang]
+          },
+          string: /[\s\S]+/
+        }
+      };
+    };
+    Prism2.languages.arturo = {
+      comment: {
+        pattern: /;.*/,
+        greedy: true
+      },
+      character: {
+        pattern: /`.`/,
+        alias: "char",
+        greedy: true
+      },
+      number: {
+        pattern: /\b\d+(?:\.\d+(?:\.\d+(?:-[\w+-]+)?)?)?\b/
+      },
+      string: {
+        pattern: /"(?:[^"\\\r\n]|\\.)*"/,
+        greedy: true
+      },
+      regex: {
+        pattern: /\{\/.*?\/\}/,
+        greedy: true
+      },
+      "html-string": createLanguageString("html"),
+      "css-string": createLanguageString("css"),
+      "js-string": createLanguageString("js"),
+      "md-string": createLanguageString("md"),
+      "sql-string": createLanguageString("sql"),
+      "sh-string": createLanguageString("shell", "sh"),
+      multistring: {
+        pattern: /».*|\{:[\s\S]*?:\}|\{[\s\S]*?\}|^-{6}$[\s\S]*/m,
+        alias: "string",
+        greedy: true
+      },
+      label: {
+        pattern: /\w+\b\??:/,
+        alias: "property"
+      },
+      literal: {
+        pattern: /'(?:\w+\b\??:?)/,
+        alias: "constant"
+      },
+      type: {
+        pattern: /:(?:\w+\b\??:?)/,
+        alias: "class-name"
+      },
+      color: /#\w+/,
+      predicate: {
+        pattern: /\b(?:all|and|any|ascii|attr|attribute|attributeLabel|binary|block|char|contains|database|date|dictionary|empty|equal|even|every|exists|false|floating|function|greater|greaterOrEqual|if|in|inline|integer|is|key|label|leap|less|lessOrEqual|literal|logical|lower|nand|negative|nor|not|notEqual|null|numeric|odd|or|path|pathLabel|positive|prefix|prime|regex|same|set|some|sorted|standalone|string|subset|suffix|superset|symbol|symbolLiteral|true|try|type|unless|upper|when|whitespace|word|xnor|xor|zero)\?/,
+        alias: "keyword"
+      },
+      "builtin-function": {
+        pattern: /\b(?:abs|acos|acosh|acsec|acsech|actan|actanh|add|after|alert|alias|and|angle|append|arg|args|arity|array|as|asec|asech|asin|asinh|atan|atan2|atanh|attr|attrs|average|before|benchmark|blend|break|call|capitalize|case|ceil|chop|clear|clip|close|color|combine|conj|continue|copy|cos|cosh|crc|csec|csech|ctan|ctanh|cursor|darken|dec|decode|define|delete|desaturate|deviation|dialog|dictionary|difference|digest|digits|div|do|download|drop|dup|e|else|empty|encode|ensure|env|escape|execute|exit|exp|extend|extract|factors|fdiv|filter|first|flatten|floor|fold|from|function|gamma|gcd|get|goto|hash|hypot|if|inc|indent|index|infinity|info|input|insert|inspect|intersection|invert|jaro|join|keys|kurtosis|last|let|levenshtein|lighten|list|ln|log|loop|lower|mail|map|match|max|median|min|mod|module|mul|nand|neg|new|nor|normalize|not|now|null|open|or|outdent|pad|palette|panic|path|pause|permissions|permutate|pi|pop|popup|pow|powerset|powmod|prefix|print|prints|process|product|query|random|range|read|relative|remove|rename|render|repeat|replace|request|return|reverse|round|sample|saturate|script|sec|sech|select|serve|set|shl|shr|shuffle|sin|sinh|size|skewness|slice|sort|spin|split|sqrt|squeeze|stack|strip|sub|suffix|sum|switch|symbols|symlink|sys|take|tan|tanh|terminal|terminate|to|truncate|try|type|unclip|union|unique|unless|until|unzip|upper|values|var|variance|volume|webview|while|with|wordwrap|write|xnor|xor|zip)\b/,
+        alias: "keyword"
+      },
+      sugar: {
+        pattern: /->|=>|\||::/,
+        alias: "operator"
+      },
+      punctuation: /[()[\],]/,
+      symbol: {
+        pattern: /<:|-:|ø|@|#|\+|\||\*|\$|---|-|%|\/|\.\.|\^|~|=|<|>|\\/
+      },
+      boolean: {
+        pattern: /\b(?:false|maybe|true)\b/
+      }
+    };
+    Prism2.languages.art = Prism2.languages["arturo"];
+  })(Prism);
+}
+
+export {
+  arturo
+};

package/dist/chunk-BYVRIGLP.mjs

@@ -0,0 +1,88 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/smali.js
+smali.displayName = "smali";
+smali.aliases = [];
+function smali(Prism) {
+  Prism.languages.smali = {
+    comment: /#.*/,
+    string: {
+      pattern: /"(?:[^\r\n\\"]|\\.)*"|'(?:[^\r\n\\']|\\(?:.|u[\da-fA-F]{4}))'/,
+      greedy: true
+    },
+    "class-name": {
+      pattern: /(^|[^L])L(?:(?:\w+|`[^`\r\n]*`)\/)*(?:[\w$]+|`[^`\r\n]*`)(?=\s*;)/,
+      lookbehind: true,
+      inside: {
+        "class-name": {
+          pattern: /(^L|\/)(?:[\w$]+|`[^`\r\n]*`)$/,
+          lookbehind: true
+        },
+        namespace: {
+          pattern: /^(L)(?:(?:\w+|`[^`\r\n]*`)\/)+/,
+          lookbehind: true,
+          inside: {
+            punctuation: /\//
+          }
+        },
+        builtin: /^L/
+      }
+    },
+    builtin: [
+      {
+        // Reference: https://github.com/JesusFreke/smali/wiki/TypesMethodsAndFields#types
+        pattern: /([();\[])[BCDFIJSVZ]+/,
+        lookbehind: true
+      },
+      {
+        // e.g. .field mWifiOnUid:I
+        pattern: /([\w$>]:)[BCDFIJSVZ]/,
+        lookbehind: true
+      }
+    ],
+    keyword: [
+      {
+        pattern: /(\.end\s+)[\w-]+/,
+        lookbehind: true
+      },
+      {
+        pattern: /(^|[^\w.-])\.(?!\d)[\w-]+/,
+        lookbehind: true
+      },
+      {
+        pattern: /(^|[^\w.-])(?:abstract|annotation|bridge|constructor|enum|final|interface|private|protected|public|runtime|static|synthetic|system|transient)(?![\w.-])/,
+        lookbehind: true
+      }
+    ],
+    function: {
+      pattern: /(^|[^\w.-])(?:\w+|<[\w$-]+>)(?=\()/,
+      lookbehind: true
+    },
+    field: {
+      pattern: /[\w$]+(?=:)/,
+      alias: "variable"
+    },
+    register: {
+      pattern: /(^|[^\w.-])[vp]\d(?![\w.-])/,
+      lookbehind: true,
+      alias: "variable"
+    },
+    boolean: {
+      pattern: /(^|[^\w.-])(?:false|true)(?![\w.-])/,
+      lookbehind: true
+    },
+    number: {
+      pattern: /(^|[^/\w.-])-?(?:NAN|INFINITY|0x(?:[\dA-F]+(?:\.[\dA-F]*)?|\.[\dA-F]+)(?:p[+-]?[\dA-F]+)?|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?)[dflst]?(?![\w.-])/i,
+      lookbehind: true
+    },
+    label: {
+      pattern: /(:)\w+/,
+      lookbehind: true,
+      alias: "property"
+    },
+    operator: /->|\.\.|[\[=]/,
+    punctuation: /[{}(),;:]/
+  };
+}
+
+export {
+  smali
+};