@photonix/basic 1.5.0 → 1.6.0

package/dist/chunk-225JLQAA.mjs

@@ -0,0 +1,53 @@
+import {
+  markupTemplating
+} from "./chunk-DFNMTLAN.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/twig.js
+twig.displayName = "twig";
+twig.aliases = [];
+function twig(Prism) {
+  Prism.register(markupTemplating);
+  Prism.languages.twig = {
+    comment: /^\{#[\s\S]*?#\}$/,
+    "tag-name": {
+      pattern: /(^\{%-?\s*)\w+/,
+      lookbehind: true,
+      alias: "keyword"
+    },
+    delimiter: {
+      pattern: /^\{[{%]-?|-?[%}]\}$/,
+      alias: "punctuation"
+    },
+    string: {
+      pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+      inside: {
+        punctuation: /^['"]|['"]$/
+      }
+    },
+    keyword: /\b(?:even|if|odd)\b/,
+    boolean: /\b(?:false|null|true)\b/,
+    number: /\b0x[\dA-Fa-f]+|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee][-+]?\d+)?/,
+    operator: [
+      {
+        pattern: /(\s)(?:and|b-and|b-or|b-xor|ends with|in|is|matches|not|or|same as|starts with)(?=\s)/,
+        lookbehind: true
+      },
+      /[=<>]=?|!=|\*\*?|\/\/?|\?:?|[-+~%|]/
+    ],
+    punctuation: /[()\[\]{}:.,]/
+  };
+  Prism.hooks.add("before-tokenize", function(env) {
+    if (env.language !== "twig") {
+      return;
+    }
+    var pattern = /\{(?:#[\s\S]*?#|%[\s\S]*?%|\{[\s\S]*?\})\}/g;
+    Prism.languages["markup-templating"].buildPlaceholders(env, "twig", pattern);
+  });
+  Prism.hooks.add("after-tokenize", function(env) {
+    Prism.languages["markup-templating"].tokenizePlaceholders(env, "twig");
+  });
+}
+
+export {
+  twig
+};

package/dist/chunk-26YPCSON.mjs

@@ -0,0 +1,33 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/nasm.js
+nasm.displayName = "nasm";
+nasm.aliases = [];
+function nasm(Prism) {
+  Prism.languages.nasm = {
+    comment: /;.*$/m,
+    string: /(["'`])(?:\\.|(?!\1)[^\\\r\n])*\1/,
+    label: {
+      pattern: /(^\s*)[A-Za-z._?$][\w.?$@~#]*:/m,
+      lookbehind: true,
+      alias: "function"
+    },
+    keyword: [
+      /\[?BITS (?:16|32|64)\]?/,
+      {
+        pattern: /(^\s*)section\s*[a-z.]+:?/im,
+        lookbehind: true
+      },
+      /(?:extern|global)[^;\r\n]*/i,
+      /(?:CPU|DEFAULT|FLOAT).*$/m
+    ],
+    register: {
+      pattern: /\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)\b/i,
+      alias: "variable"
+    },
+    number: /(?:\b|(?=\$))(?:0[hx](?:\.[\da-f]+|[\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: /[\[\]*+\-\/%<>=&|$!]/
+  };
+}
+
+export {
+  nasm
+};

package/dist/chunk-27KF74WX.mjs

@@ -0,0 +1,207 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/rest.js
+rest.displayName = "rest";
+rest.aliases = [];
+function rest(Prism) {
+  Prism.languages.rest = {
+    table: [
+      {
+        pattern: /(^[\t ]*)(?:\+[=-]+)+\+(?:\r?\n|\r)(?:\1[+|].+[+|](?:\r?\n|\r))+\1(?:\+[=-]+)+\+/m,
+        lookbehind: true,
+        inside: {
+          punctuation: /\||(?:\+[=-]+)+\+/
+        }
+      },
+      {
+        pattern: /(^[\t ]*)=+ [ =]*=(?:(?:\r?\n|\r)\1.+)+(?:\r?\n|\r)\1=+ [ =]*=(?=(?:\r?\n|\r){2}|\s*$)/m,
+        lookbehind: true,
+        inside: {
+          punctuation: /[=-]+/
+        }
+      }
+    ],
+    // Directive-like patterns
+    "substitution-def": {
+      pattern: /(^[\t ]*\.\. )\|(?:[^|\s](?:[^|]*[^|\s])?)\| [^:]+::/m,
+      lookbehind: true,
+      inside: {
+        substitution: {
+          pattern: /^\|(?:[^|\s]|[^|\s][^|]*[^|\s])\|/,
+          alias: "attr-value",
+          inside: {
+            punctuation: /^\||\|$/
+          }
+        },
+        directive: {
+          pattern: /( )(?! )[^:]+::/,
+          lookbehind: true,
+          alias: "function",
+          inside: {
+            punctuation: /::$/
+          }
+        }
+      }
+    },
+    "link-target": [
+      {
+        pattern: /(^[\t ]*\.\. )\[[^\]]+\]/m,
+        lookbehind: true,
+        alias: "string",
+        inside: {
+          punctuation: /^\[|\]$/
+        }
+      },
+      {
+        pattern: /(^[\t ]*\.\. )_(?:`[^`]+`|(?:[^:\\]|\\.)+):/m,
+        lookbehind: true,
+        alias: "string",
+        inside: {
+          punctuation: /^_|:$/
+        }
+      }
+    ],
+    directive: {
+      pattern: /(^[\t ]*\.\. )[^:]+::/m,
+      lookbehind: true,
+      alias: "function",
+      inside: {
+        punctuation: /::$/
+      }
+    },
+    comment: {
+      // The two alternatives try to prevent highlighting of blank comments
+      pattern: /(^[\t ]*\.\.)(?:(?: .+)?(?:(?:\r?\n|\r).+)+| .+)(?=(?:\r?\n|\r){2}|$)/m,
+      lookbehind: true
+    },
+    title: [
+      // Overlined and underlined
+      {
+        pattern: /^(([!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~])\2+)(?:\r?\n|\r).+(?:\r?\n|\r)\1$/m,
+        inside: {
+          punctuation: /^[!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~]+|[!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~]+$/,
+          important: /.+/
+        }
+      },
+      // Underlined only
+      {
+        pattern: /(^|(?:\r?\n|\r){2}).+(?:\r?\n|\r)([!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~])\2+(?=\r?\n|\r|$)/,
+        lookbehind: true,
+        inside: {
+          punctuation: /[!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~]+$/,
+          important: /.+/
+        }
+      }
+    ],
+    hr: {
+      pattern: /((?:\r?\n|\r){2})([!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~])\2{3,}(?=(?:\r?\n|\r){2})/,
+      lookbehind: true,
+      alias: "punctuation"
+    },
+    field: {
+      pattern: /(^[\t ]*):[^:\r\n]+:(?= )/m,
+      lookbehind: true,
+      alias: "attr-name"
+    },
+    "command-line-option": {
+      pattern: /(^[\t ]*)(?:[+-][a-z\d]|(?:--|\/)[a-z\d-]+)(?:[ =](?:[a-z][\w-]*|<[^<>]+>))?(?:, (?:[+-][a-z\d]|(?:--|\/)[a-z\d-]+)(?:[ =](?:[a-z][\w-]*|<[^<>]+>))?)*(?=(?:\r?\n|\r)? {2,}\S)/im,
+      lookbehind: true,
+      alias: "symbol"
+    },
+    "literal-block": {
+      pattern: /::(?:\r?\n|\r){2}([ \t]+)(?![ \t]).+(?:(?:\r?\n|\r)\1.+)*/,
+      inside: {
+        "literal-block-punctuation": {
+          pattern: /^::/,
+          alias: "punctuation"
+        }
+      }
+    },
+    "quoted-literal-block": {
+      pattern: /::(?:\r?\n|\r){2}([!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~]).*(?:(?:\r?\n|\r)\1.*)*/,
+      inside: {
+        "literal-block-punctuation": {
+          pattern: /^(?:::|([!"#$%&'()*+,\-.\/:;<=>?@\[\\\]^_`{|}~])\1*)/m,
+          alias: "punctuation"
+        }
+      }
+    },
+    "list-bullet": {
+      pattern: /(^[\t ]*)(?:[*+\-•‣⁃]|\(?(?:\d+|[a-z]|[ivxdclm]+)\)|(?:\d+|[a-z]|[ivxdclm]+)\.)(?= )/im,
+      lookbehind: true,
+      alias: "punctuation"
+    },
+    "doctest-block": {
+      pattern: /(^[\t ]*)>>> .+(?:(?:\r?\n|\r).+)*/m,
+      lookbehind: true,
+      inside: {
+        punctuation: /^>>>/
+      }
+    },
+    inline: [
+      {
+        pattern: /(^|[\s\-:\/'"<(\[{])(?::[^:]+:`.*?`|`.*?`:[^:]+:|(\*\*?|``?|\|)(?!\s)(?:(?!\2).)*\S\2(?=[\s\-.,:;!?\\\/'")\]}]|$))/m,
+        lookbehind: true,
+        inside: {
+          bold: {
+            pattern: /(^\*\*).+(?=\*\*$)/,
+            lookbehind: true
+          },
+          italic: {
+            pattern: /(^\*).+(?=\*$)/,
+            lookbehind: true
+          },
+          "inline-literal": {
+            pattern: /(^``).+(?=``$)/,
+            lookbehind: true,
+            alias: "symbol"
+          },
+          role: {
+            pattern: /^:[^:]+:|:[^:]+:$/,
+            alias: "function",
+            inside: {
+              punctuation: /^:|:$/
+            }
+          },
+          "interpreted-text": {
+            pattern: /(^`).+(?=`$)/,
+            lookbehind: true,
+            alias: "attr-value"
+          },
+          substitution: {
+            pattern: /(^\|).+(?=\|$)/,
+            lookbehind: true,
+            alias: "attr-value"
+          },
+          punctuation: /\*\*?|``?|\|/
+        }
+      }
+    ],
+    link: [
+      {
+        pattern: /\[[^\[\]]+\]_(?=[\s\-.,:;!?\\\/'")\]}]|$)/,
+        alias: "string",
+        inside: {
+          punctuation: /^\[|\]_$/
+        }
+      },
+      {
+        pattern: /(?:\b[a-z\d]+(?:[_.:+][a-z\d]+)*_?_|`[^`]+`_?_|_`[^`]+`)(?=[\s\-.,:;!?\\\/'")\]}]|$)/i,
+        alias: "string",
+        inside: {
+          punctuation: /^_?`|`$|`?_?_$/
+        }
+      }
+    ],
+    // Line block start,
+    // quote attribution,
+    // explicit markup start,
+    // and anonymous hyperlink target shortcut (__)
+    punctuation: {
+      pattern: /(^[\t ]*)(?:\|(?= |$)|(?:---?|—|\.\.|__)(?= )|\.\.$)/m,
+      lookbehind: true
+    }
+  };
+}
+
+export {
+  rest
+};

package/dist/chunk-27XY4SR3.mjs

@@ -0,0 +1,27 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/openqasm.js
+openqasm.displayName = "openqasm";
+openqasm.aliases = ["qasm"];
+function openqasm(Prism) {
+  Prism.languages.openqasm = {
+    comment: /\/\*[\s\S]*?\*\/|\/\/.*/,
+    string: {
+      pattern: /"[^"\r\n\t]*"|'[^'\r\n\t]*'/,
+      greedy: true
+    },
+    keyword: /\b(?:CX|OPENQASM|U|barrier|boxas|boxto|break|const|continue|ctrl|def|defcal|defcalgrammar|delay|else|end|for|gate|gphase|if|in|include|inv|kernel|lengthof|let|measure|pow|reset|return|rotary|stretchinf|while)\b|#pragma\b/,
+    "class-name": /\b(?:angle|bit|bool|creg|fixed|float|int|length|qreg|qubit|stretch|uint)\b/,
+    function: /\b(?:cos|exp|ln|popcount|rotl|rotr|sin|sqrt|tan)\b(?=\s*\()/,
+    constant: /\b(?:euler|pi|tau)\b|π|𝜏|ℇ/,
+    number: {
+      pattern: /(^|[^.\w$])(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?(?:dt|ns|us|µs|ms|s)?/i,
+      lookbehind: true
+    },
+    operator: /->|>>=?|<<=?|&&|\|\||\+\+|--|[!=<>&|~^+\-*/%]=?|@/,
+    punctuation: /[(){}\[\];,:.]/
+  };
+  Prism.languages.qasm = Prism.languages.openqasm;
+}
+
+export {
+  openqasm
+};

package/dist/chunk-27YX7MFJ.mjs

@@ -0,0 +1,30 @@
+import {
+  jsx
+} from "./chunk-7DNOFDAC.mjs";
+import {
+  typescript
+} from "./chunk-BSW6U4XU.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/tsx.js
+tsx.displayName = "tsx";
+tsx.aliases = [];
+function tsx(Prism) {
+  Prism.register(jsx);
+  Prism.register(typescript);
+  (function(Prism2) {
+    var typescript2 = Prism2.util.clone(Prism2.languages.typescript);
+    Prism2.languages.tsx = Prism2.languages.extend("jsx", typescript2);
+    delete Prism2.languages.tsx["parameter"];
+    delete Prism2.languages.tsx["literal-property"];
+    var tag = Prism2.languages.tsx.tag;
+    tag.pattern = RegExp(
+      /(^|[^\w$]|(?=<\/))/.source + "(?:" + tag.pattern.source + ")",
+      tag.pattern.flags
+    );
+    tag.lookbehind = true;
+  })(Prism);
+}
+
+export {
+  tsx
+};

package/dist/chunk-2DU2ON4M.mjs

@@ -0,0 +1,43 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/autoit.js
+autoit.displayName = "autoit";
+autoit.aliases = [];
+function autoit(Prism) {
+  Prism.languages.autoit = {
+    comment: [
+      /;.*/,
+      {
+        // The multi-line comments delimiters can actually be commented out with ";"
+        pattern: /(^[\t ]*)#(?:comments-start|cs)[\s\S]*?^[ \t]*#(?:ce|comments-end)/m,
+        lookbehind: true
+      }
+    ],
+    url: {
+      pattern: /(^[\t ]*#include\s+)(?:<[^\r\n>]+>|"[^\r\n"]+")/m,
+      lookbehind: true
+    },
+    string: {
+      pattern: /(["'])(?:\1\1|(?!\1)[^\r\n])*\1/,
+      greedy: true,
+      inside: {
+        variable: /([%$@])\w+\1/
+      }
+    },
+    directive: {
+      pattern: /(^[\t ]*)#[\w-]+/m,
+      lookbehind: true,
+      alias: "keyword"
+    },
+    function: /\b\w+(?=\()/,
+    // Variables and macros
+    variable: /[$@]\w+/,
+    keyword: /\b(?:Case|Const|Continue(?:Case|Loop)|Default|Dim|Do|Else(?:If)?|End(?:Func|If|Select|Switch|With)|Enum|Exit(?:Loop)?|For|Func|Global|If|In|Local|Next|Null|ReDim|Select|Static|Step|Switch|Then|To|Until|Volatile|WEnd|While|With)\b/i,
+    number: /\b(?:0x[\da-f]+|\d+(?:\.\d+)?(?:e[+-]?\d+)?)\b/i,
+    boolean: /\b(?:False|True)\b/i,
+    operator: /<[=>]?|[-+*\/=&>]=?|[?^]|\b(?:And|Not|Or)\b/i,
+    punctuation: /[\[\]().,:]/
+  };
+}
+
+export {
+  autoit
+};

package/dist/chunk-2LS2HC6H.mjs

@@ -0,0 +1,68 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/concurnas.js
+concurnas.displayName = "concurnas";
+concurnas.aliases = ["conc"];
+function concurnas(Prism) {
+  Prism.languages.concurnas = {
+    comment: {
+      pattern: /(^|[^\\])(?:\/\*[\s\S]*?(?:\*\/|$)|\/\/.*)/,
+      lookbehind: true,
+      greedy: true
+    },
+    langext: {
+      pattern: /\b\w+\s*\|\|[\s\S]+?\|\|/,
+      greedy: true,
+      inside: {
+        "class-name": /^\w+/,
+        string: {
+          pattern: /(^\s*\|\|)[\s\S]+(?=\|\|$)/,
+          lookbehind: true
+        },
+        punctuation: /\|\|/
+      }
+    },
+    function: {
+      pattern: /((?:^|\s)def[ \t]+)[a-zA-Z_]\w*(?=\s*\()/,
+      lookbehind: true
+    },
+    keyword: /\b(?:abstract|actor|also|annotation|assert|async|await|bool|boolean|break|byte|case|catch|changed|char|class|closed|constant|continue|def|default|del|double|elif|else|enum|every|extends|false|finally|float|for|from|global|gpudef|gpukernel|if|import|in|init|inject|int|lambda|local|long|loop|match|new|nodefault|null|of|onchange|open|out|override|package|parfor|parforsync|post|pre|private|protected|provide|provider|public|return|shared|short|single|size_t|sizeof|super|sync|this|throw|trait|trans|transient|true|try|typedef|unchecked|using|val|var|void|while|with)\b/,
+    boolean: /\b(?:false|true)\b/,
+    number: /\b0b[01][01_]*L?\b|\b0x(?:[\da-f_]*\.)?[\da-f_p+-]+\b|(?:\b\d[\d_]*(?:\.[\d_]*)?|\B\.\d[\d_]*)(?:e[+-]?\d[\d_]*)?[dfls]?/i,
+    punctuation: /[{}[\];(),.:]/,
+    operator: /<==|>==|=>|->|<-|<>|&==|&<>|\?:?|\.\?|\+\+|--|[-+*/=<>]=?|[!^~]|\b(?:and|as|band|bor|bxor|comp|is|isnot|mod|or)\b=?/,
+    annotation: {
+      pattern: /@(?:\w+:)?(?:\w+|\[[^\]]+\])?/,
+      alias: "builtin"
+    }
+  };
+  Prism.languages.insertBefore("concurnas", "langext", {
+    "regex-literal": {
+      pattern: /\br("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+      greedy: true,
+      inside: {
+        interpolation: {
+          pattern: /((?:^|[^\\])(?:\\{2})*)\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
+          lookbehind: true,
+          inside: Prism.languages.concurnas
+        },
+        regex: /[\s\S]+/
+      }
+    },
+    "string-literal": {
+      pattern: /(?:\B|\bs)("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+      greedy: true,
+      inside: {
+        interpolation: {
+          pattern: /((?:^|[^\\])(?:\\{2})*)\{(?:[^{}]|\{(?:[^{}]|\{[^}]*\})*\})+\}/,
+          lookbehind: true,
+          inside: Prism.languages.concurnas
+        },
+        string: /[\s\S]+/
+      }
+    }
+  });
+  Prism.languages.conc = Prism.languages.concurnas;
+}
+
+export {
+  concurnas
+};

package/dist/chunk-2O5VMYAQ.mjs

@@ -0,0 +1,13 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/csv.js
+csv.displayName = "csv";
+csv.aliases = [];
+function csv(Prism) {
+  Prism.languages.csv = {
+    value: /[^\r\n,"]+|"(?:[^"]|"")*"(?!")/,
+    punctuation: /,/
+  };
+}
+
+export {
+  csv
+};

package/dist/chunk-2PMEUBEF.mjs

@@ -0,0 +1,127 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/livescript.js
+livescript.displayName = "livescript";
+livescript.aliases = [];
+function livescript(Prism) {
+  Prism.languages.livescript = {
+    comment: [
+      {
+        pattern: /(^|[^\\])\/\*[\s\S]*?\*\//,
+        lookbehind: true
+      },
+      {
+        pattern: /(^|[^\\])#.*/,
+        lookbehind: true
+      }
+    ],
+    "interpolated-string": {
+      /* Look-behind and look-ahead prevents wrong behavior of the greedy pattern
+       * forcing it to match """-quoted string when it would otherwise match "-quoted first. */
+      pattern: /(^|[^"])("""|")(?:\\[\s\S]|(?!\2)[^\\])*\2(?!")/,
+      lookbehind: true,
+      greedy: true,
+      inside: {
+        variable: {
+          pattern: /(^|[^\\])#[a-z_](?:-?[a-z]|[\d_])*/m,
+          lookbehind: true
+        },
+        interpolation: {
+          pattern: /(^|[^\\])#\{[^}]+\}/m,
+          lookbehind: true,
+          inside: {
+            "interpolation-punctuation": {
+              pattern: /^#\{|\}$/,
+              alias: "variable"
+            }
+            // See rest below
+          }
+        },
+        string: /[\s\S]+/
+      }
+    },
+    string: [
+      {
+        pattern: /('''|')(?:\\[\s\S]|(?!\1)[^\\])*\1/,
+        greedy: true
+      },
+      {
+        pattern: /<\[[\s\S]*?\]>/,
+        greedy: true
+      },
+      /\\[^\s,;\])}]+/
+    ],
+    regex: [
+      {
+        pattern: /\/\/(?:\[[^\r\n\]]*\]|\\.|(?!\/\/)[^\\\[])+\/\/[gimyu]{0,5}/,
+        greedy: true,
+        inside: {
+          comment: {
+            pattern: /(^|[^\\])#.*/,
+            lookbehind: true
+          }
+        }
+      },
+      {
+        pattern: /\/(?:\[[^\r\n\]]*\]|\\.|[^/\\\r\n\[])+\/[gimyu]{0,5}/,
+        greedy: true
+      }
+    ],
+    keyword: {
+      pattern: /(^|(?!-).)\b(?:break|case|catch|class|const|continue|default|do|else|extends|fallthrough|finally|for(?: ever)?|function|if|implements|it|let|loop|new|null|otherwise|own|return|super|switch|that|then|this|throw|try|unless|until|var|void|when|while|yield)(?!-)\b/m,
+      lookbehind: true
+    },
+    "keyword-operator": {
+      pattern: /(^|[^-])\b(?:(?:delete|require|typeof)!|(?:and|by|delete|export|from|import(?: all)?|in|instanceof|is(?: not|nt)?|not|of|or|til|to|typeof|with|xor)(?!-)\b)/m,
+      lookbehind: true,
+      alias: "operator"
+    },
+    boolean: {
+      pattern: /(^|[^-])\b(?:false|no|off|on|true|yes)(?!-)\b/m,
+      lookbehind: true
+    },
+    argument: {
+      // Don't match .&. nor &&
+      pattern: /(^|(?!\.&\.)[^&])&(?!&)\d*/m,
+      lookbehind: true,
+      alias: "variable"
+    },
+    number: /\b(?:\d+~[\da-z]+|\d[\d_]*(?:\.\d[\d_]*)?(?:[a-z]\w*)?)/i,
+    identifier: /[a-z_](?:-?[a-z]|[\d_])*/i,
+    operator: [
+      // Spaced .
+      {
+        pattern: /( )\.(?= )/,
+        lookbehind: true
+      },
+      // Full list, in order:
+      // .= .~ .. ...
+      // .&. .^. .<<. .>>. .>>>.
+      // := :: ::=
+      // &&
+      // || |>
+      // < << <<< <<<<
+      // <- <-- <-! <--!
+      // <~ <~~ <~! <~~!
+      // <| <= <?
+      // > >> >= >?
+      // - -- -> -->
+      // + ++
+      // @ @@
+      // % %%
+      // * **
+      // ! != !~=
+      // !~> !~~>
+      // !-> !-->
+      // ~ ~> ~~> ~=
+      // = ==
+      // ^ ^^
+      // / ?
+      /\.(?:[=~]|\.\.?)|\.(?:[&|^]|<<|>>>?)\.|:(?:=|:=?)|&&|\|[|>]|<(?:<<?<?|--?!?|~~?!?|[|=?])?|>[>=?]?|-(?:->?|>)?|\+\+?|@@?|%%?|\*\*?|!(?:~?=|--?>|~?~>)?|~(?:~?>|=)?|==?|\^\^?|[\/?]/
+    ],
+    punctuation: /[(){}\[\]|.,:;`]/
+  };
+  Prism.languages.livescript["interpolated-string"].inside["interpolation"].inside.rest = Prism.languages.livescript;
+}
+
+export {
+  livescript
+};

package/dist/chunk-2U3PS6ZK.mjs

@@ -0,0 +1,26 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/applescript.js
+applescript.displayName = "applescript";
+applescript.aliases = [];
+function applescript(Prism) {
+  Prism.languages.applescript = {
+    comment: [
+      // Allow one level of nesting
+      /\(\*(?:\(\*(?:[^*]|\*(?!\)))*\*\)|(?!\(\*)[\s\S])*?\*\)/,
+      /--.+/,
+      /#.+/
+    ],
+    string: /"(?:\\.|[^"\\\r\n])*"/,
+    number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e-?\d+)?\b/i,
+    operator: [
+      /[&=≠≤≥*+\-\/÷^]|[<>]=?/,
+      /\b(?:(?:begin|end|start)s? with|(?:contains?|(?:does not|doesn't) contain)|(?:is|isn't|is not) (?:contained by|in)|(?:(?:is|isn't|is not) )?(?:greater|less) than(?: or equal)?(?: to)?|(?:comes|(?:does not|doesn't) come) (?:after|before)|(?:is|isn't|is not) equal(?: to)?|(?:(?:does not|doesn't) equal|equal to|equals|is not|isn't)|(?:a )?(?:ref(?: to)?|reference to)|(?:and|as|div|mod|not|or))\b/
+    ],
+    keyword: /\b(?:about|above|after|against|apart from|around|aside from|at|back|before|beginning|behind|below|beneath|beside|between|but|by|considering|continue|copy|does|eighth|else|end|equal|error|every|exit|false|fifth|first|for|fourth|from|front|get|given|global|if|ignoring|in|instead of|into|is|it|its|last|local|me|middle|my|ninth|of|on|onto|out of|over|prop|property|put|repeat|return|returning|second|set|seventh|since|sixth|some|tell|tenth|that|the|then|third|through|thru|timeout|times|to|transaction|true|try|until|where|while|whose|with|without)\b/,
+    "class-name": /\b(?:POSIX file|RGB color|alias|application|boolean|centimeters|centimetres|class|constant|cubic centimeters|cubic centimetres|cubic feet|cubic inches|cubic meters|cubic metres|cubic yards|date|degrees Celsius|degrees Fahrenheit|degrees Kelvin|feet|file|gallons|grams|inches|integer|kilograms|kilometers|kilometres|list|liters|litres|meters|metres|miles|number|ounces|pounds|quarts|real|record|reference|script|square feet|square kilometers|square kilometres|square meters|square metres|square miles|square yards|text|yards)\b/,
+    punctuation: /[{}():,¬«»《》]/
+  };
+}
+
+export {
+  applescript
+};