@photonix/basic 1.5.1 → 1.6.1

package/dist/chunk-S7MUH6TF.mjs

@@ -0,0 +1,98 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/wren.js
+wren.displayName = "wren";
+wren.aliases = [];
+function wren(Prism) {
+  Prism.languages.wren = {
+    // Multiline comments in Wren can have nested multiline comments
+    // Comments: // and /* */
+    comment: [
+      {
+        // support 3 levels of nesting
+        // regex: \/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|<self>)*\*\/
+        pattern: /\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|\/\*(?:[^*/]|\*(?!\/)|\/(?!\*)|\/\*(?:[^*/]|\*(?!\/)|\/(?!\*))*\*\/)*\*\/)*\*\//,
+        greedy: true
+      },
+      {
+        pattern: /(^|[^\\:])\/\/.*/,
+        lookbehind: true,
+        greedy: true
+      }
+    ],
+    // Triple quoted strings are multiline but cannot have interpolation (raw strings)
+    // Based on prism-python.js
+    "triple-quoted-string": {
+      pattern: /"""[\s\S]*?"""/,
+      greedy: true,
+      alias: "string"
+    },
+    // see below
+    "string-literal": null,
+    // #!/usr/bin/env wren on the first line
+    hashbang: {
+      pattern: /^#!\/.+/,
+      greedy: true,
+      alias: "comment"
+    },
+    // Attributes are special keywords to add meta data to classes
+    attribute: {
+      // #! attributes are stored in class properties
+      // #!myvar = true
+      // #attributes are not stored and dismissed at compilation
+      pattern: /#!?[ \t\u3000]*\w+/,
+      alias: "keyword"
+    },
+    "class-name": [
+      {
+        // class definition
+        // class Meta {}
+        pattern: /(\bclass\s+)\w+/,
+        lookbehind: true
+      },
+      // A class must always start with an uppercase.
+      // File.read
+      /\b[A-Z][a-z\d_]*\b/
+    ],
+    // A constant can be a variable, class, property or method. Just named in all uppercase letters
+    constant: /\b[A-Z][A-Z\d_]*\b/,
+    null: {
+      pattern: /\bnull\b/,
+      alias: "keyword"
+    },
+    keyword: /\b(?:as|break|class|construct|continue|else|for|foreign|if|import|in|is|return|static|super|this|var|while)\b/,
+    boolean: /\b(?:false|true)\b/,
+    number: /\b(?:0x[\da-f]+|\d+(?:\.\d+)?(?:e[+-]?\d+)?)\b/i,
+    // Functions can be Class.method()
+    function: /\b[a-z_]\w*(?=\s*[({])/i,
+    operator: /<<|>>|[=!<>]=?|&&|\|\||[-+*/%~^&|?:]|\.{2,3}/,
+    punctuation: /[\[\](){}.,;]/
+  };
+  Prism.languages.wren["string-literal"] = {
+    // A single quote string is multiline and can have interpolation (similar to JS backticks ``)
+    pattern: /(^|[^\\"])"(?:[^\\"%]|\\[\s\S]|%(?!\()|%\((?:[^()]|\((?:[^()]|\([^)]*\))*\))*\))*"/,
+    lookbehind: true,
+    greedy: true,
+    inside: {
+      interpolation: {
+        // "%(interpolation)"
+        pattern: /((?:^|[^\\])(?:\\{2})*)%\((?:[^()]|\((?:[^()]|\([^)]*\))*\))*\)/,
+        lookbehind: true,
+        inside: {
+          expression: {
+            pattern: /^(%\()[\s\S]+(?=\)$)/,
+            lookbehind: true,
+            inside: Prism.languages.wren
+          },
+          "interpolation-punctuation": {
+            pattern: /^%\(|\)$/,
+            alias: "punctuation"
+          }
+        }
+      },
+      string: /[\s\S]+/
+    }
+  };
+}
+
+export {
+  wren
+};

package/dist/chunk-SBMOGTJU.mjs

@@ -0,0 +1,49 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/fortran.js
+fortran.displayName = "fortran";
+fortran.aliases = [];
+function fortran(Prism) {
+  Prism.languages.fortran = {
+    "quoted-number": {
+      pattern: /[BOZ](['"])[A-F0-9]+\1/i,
+      alias: "number"
+    },
+    string: {
+      pattern: /(?:\b\w+_)?(['"])(?:\1\1|&(?:\r\n?|\n)(?:[ \t]*!.*(?:\r\n?|\n)|(?![ \t]*!))|(?!\1).)*(?:\1|&)/,
+      inside: {
+        comment: {
+          pattern: /(&(?:\r\n?|\n)\s*)!.*/,
+          lookbehind: true
+        }
+      }
+    },
+    comment: {
+      pattern: /!.*/,
+      greedy: true
+    },
+    boolean: /\.(?:FALSE|TRUE)\.(?:_\w+)?/i,
+    number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[ED][+-]?\d+)?(?:_\w+)?/i,
+    keyword: [
+      // Types
+      /\b(?:CHARACTER|COMPLEX|DOUBLE ?PRECISION|INTEGER|LOGICAL|REAL)\b/i,
+      // END statements
+      /\b(?:END ?)?(?:BLOCK ?DATA|DO|FILE|FORALL|FUNCTION|IF|INTERFACE|MODULE(?! PROCEDURE)|PROGRAM|SELECT|SUBROUTINE|TYPE|WHERE)\b/i,
+      // Statements
+      /\b(?:ALLOCATABLE|ALLOCATE|BACKSPACE|CALL|CASE|CLOSE|COMMON|CONTAINS|CONTINUE|CYCLE|DATA|DEALLOCATE|DIMENSION|DO|END|EQUIVALENCE|EXIT|EXTERNAL|FORMAT|GO ?TO|IMPLICIT(?: NONE)?|INQUIRE|INTENT|INTRINSIC|MODULE PROCEDURE|NAMELIST|NULLIFY|OPEN|OPTIONAL|PARAMETER|POINTER|PRINT|PRIVATE|PUBLIC|READ|RETURN|REWIND|SAVE|SELECT|STOP|TARGET|WHILE|WRITE)\b/i,
+      // Others
+      /\b(?:ASSIGNMENT|DEFAULT|ELEMENTAL|ELSE|ELSEIF|ELSEWHERE|ENTRY|IN|INCLUDE|INOUT|KIND|NULL|ONLY|OPERATOR|OUT|PURE|RECURSIVE|RESULT|SEQUENCE|STAT|THEN|USE)\b/i
+    ],
+    operator: [
+      /\*\*|\/\/|=>|[=\/]=|[<>]=?|::|[+\-*=%]|\.[A-Z]+\./i,
+      {
+        // Use lookbehind to prevent confusion with (/ /)
+        pattern: /(^|(?!\().)\/(?!\))/,
+        lookbehind: true
+      }
+    ],
+    punctuation: /\(\/|\/\)|[(),;:&]/
+  };
+}
+
+export {
+  fortran
+};

package/dist/chunk-SEHSEEAP.mjs

@@ -0,0 +1,59 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/nginx.js
+nginx.displayName = "nginx";
+nginx.aliases = [];
+function nginx(Prism) {
+  ;
+  (function(Prism2) {
+    var variable = /\$(?:\w[a-z\d]*(?:_[^\x00-\x1F\s"'\\()$]*)?|\{[^}\s"'\\]+\})/i;
+    Prism2.languages.nginx = {
+      comment: {
+        pattern: /(^|[\s{};])#.*/,
+        lookbehind: true,
+        greedy: true
+      },
+      directive: {
+        pattern: /(^|\s)\w(?:[^;{}"'\\\s]|\\.|"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|\s+(?:#.*(?!.)|(?![#\s])))*?(?=\s*[;{])/,
+        lookbehind: true,
+        greedy: true,
+        inside: {
+          string: {
+            pattern: /((?:^|[^\\])(?:\\\\)*)(?:"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')/,
+            lookbehind: true,
+            greedy: true,
+            inside: {
+              escape: {
+                pattern: /\\["'\\nrt]/,
+                alias: "entity"
+              },
+              variable
+            }
+          },
+          comment: {
+            pattern: /(\s)#.*/,
+            lookbehind: true,
+            greedy: true
+          },
+          keyword: {
+            pattern: /^\S+/,
+            greedy: true
+          },
+          // other patterns
+          boolean: {
+            pattern: /(\s)(?:off|on)(?!\S)/,
+            lookbehind: true
+          },
+          number: {
+            pattern: /(\s)\d+[a-z]*(?!\S)/i,
+            lookbehind: true
+          },
+          variable
+        }
+      },
+      punctuation: /[{};]/
+    };
+  })(Prism);
+}
+
+export {
+  nginx
+};

package/dist/chunk-SFJW53QW.mjs

@@ -0,0 +1,29 @@
+import {
+  turtle
+} from "./chunk-VAOG5Q4J.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/sparql.js
+sparql.displayName = "sparql";
+sparql.aliases = ["rq"];
+function sparql(Prism) {
+  Prism.register(turtle);
+  Prism.languages.sparql = Prism.languages.extend("turtle", {
+    boolean: /\b(?:false|true)\b/i,
+    variable: {
+      pattern: /[?$]\w+/,
+      greedy: true
+    }
+  });
+  Prism.languages.insertBefore("sparql", "punctuation", {
+    keyword: [
+      /\b(?:A|ADD|ALL|AS|ASC|ASK|BNODE|BY|CLEAR|CONSTRUCT|COPY|CREATE|DATA|DEFAULT|DELETE|DESC|DESCRIBE|DISTINCT|DROP|EXISTS|FILTER|FROM|GROUP|HAVING|INSERT|INTO|LIMIT|LOAD|MINUS|MOVE|NAMED|NOT|NOW|OFFSET|OPTIONAL|ORDER|RAND|REDUCED|SELECT|SEPARATOR|SERVICE|SILENT|STRUUID|UNION|USING|UUID|VALUES|WHERE)\b/i,
+      /\b(?:ABS|AVG|BIND|BOUND|CEIL|COALESCE|CONCAT|CONTAINS|COUNT|DATATYPE|DAY|ENCODE_FOR_URI|FLOOR|GROUP_CONCAT|HOURS|IF|IRI|isBLANK|isIRI|isLITERAL|isNUMERIC|isURI|LANG|LANGMATCHES|LCASE|MAX|MD5|MIN|MINUTES|MONTH|REGEX|REPLACE|ROUND|sameTerm|SAMPLE|SECONDS|SHA1|SHA256|SHA384|SHA512|STR|STRAFTER|STRBEFORE|STRDT|STRENDS|STRLANG|STRLEN|STRSTARTS|SUBSTR|SUM|TIMEZONE|TZ|UCASE|URI|YEAR)\b(?=\s*\()/i,
+      /\b(?:BASE|GRAPH|PREFIX)\b/i
+    ]
+  });
+  Prism.languages.rq = Prism.languages.sparql;
+}
+
+export {
+  sparql
+};

package/dist/chunk-SGCH3ADR.mjs

@@ -0,0 +1,61 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/coq.js
+coq.displayName = "coq";
+coq.aliases = [];
+function coq(Prism) {
+  ;
+  (function(Prism2) {
+    var commentSource = /\(\*(?:[^(*]|\((?!\*)|\*(?!\))|<self>)*\*\)/.source;
+    for (var i = 0; i < 2; i++) {
+      commentSource = commentSource.replace(/<self>/g, function() {
+        return commentSource;
+      });
+    }
+    commentSource = commentSource.replace(/<self>/g, "[]");
+    Prism2.languages.coq = {
+      comment: RegExp(commentSource),
+      string: {
+        pattern: /"(?:[^"]|"")*"(?!")/,
+        greedy: true
+      },
+      attribute: [
+        {
+          pattern: RegExp(
+            /#\[(?:[^\[\]("]|"(?:[^"]|"")*"(?!")|\((?!\*)|<comment>)*\]/.source.replace(
+              /<comment>/g,
+              function() {
+                return commentSource;
+              }
+            )
+          ),
+          greedy: true,
+          alias: "attr-name",
+          inside: {
+            comment: RegExp(commentSource),
+            string: {
+              pattern: /"(?:[^"]|"")*"(?!")/,
+              greedy: true
+            },
+            operator: /=/,
+            punctuation: /^#\[|\]$|[,()]/
+          }
+        },
+        {
+          pattern: /\b(?:Cumulative|Global|Local|Monomorphic|NonCumulative|Polymorphic|Private|Program)\b/,
+          alias: "attr-name"
+        }
+      ],
+      keyword: /\b(?:Abort|About|Add|Admit|Admitted|All|Arguments|As|Assumptions|Axiom|Axioms|Back|BackTo|Backtrace|BinOp|BinOpSpec|BinRel|Bind|Blacklist|Canonical|Case|Cd|Check|Class|Classes|Close|CoFixpoint|CoInductive|Coercion|Coercions|Collection|Combined|Compute|Conjecture|Conjectures|Constant|Constants|Constraint|Constructors|Context|Corollary|Create|CstOp|Custom|Cut|Debug|Declare|Defined|Definition|Delimit|Dependencies|Dependent|Derive|Diffs|Drop|Elimination|End|Entry|Equality|Eval|Example|Existential|Existentials|Existing|Export|Extern|Extraction|Fact|Fail|Field|File|Firstorder|Fixpoint|Flags|Focus|From|Funclass|Function|Functional|GC|Generalizable|Goal|Grab|Grammar|Graph|Guarded|Haskell|Heap|Hide|Hint|HintDb|Hints|Hypotheses|Hypothesis|IF|Identity|Immediate|Implicit|Implicits|Import|Include|Induction|Inductive|Infix|Info|Initial|InjTyp|Inline|Inspect|Instance|Instances|Intro|Intros|Inversion|Inversion_clear|JSON|Language|Left|Lemma|Let|Lia|Libraries|Library|Load|LoadPath|Locate|Ltac|Ltac2|ML|Match|Method|Minimality|Module|Modules|Morphism|Next|NoInline|Notation|Number|OCaml|Obligation|Obligations|Opaque|Open|Optimize|Parameter|Parameters|Parametric|Path|Paths|Prenex|Preterm|Primitive|Print|Profile|Projections|Proof|Prop|PropBinOp|PropOp|PropUOp|Property|Proposition|Pwd|Qed|Quit|Rec|Record|Recursive|Redirect|Reduction|Register|Relation|Remark|Remove|Require|Reserved|Reset|Resolve|Restart|Rewrite|Right|Ring|Rings|SProp|Saturate|Save|Scheme|Scope|Scopes|Search|SearchHead|SearchPattern|SearchRewrite|Section|Separate|Set|Setoid|Show|Signatures|Solve|Solver|Sort|Sortclass|Sorted|Spec|Step|Strategies|Strategy|String|Structure|SubClass|Subgraph|SuchThat|Tactic|Term|TestCompile|Theorem|Time|Timeout|To|Transparent|Type|Typeclasses|Types|Typing|UnOp|UnOpSpec|Undelimit|Undo|Unfocus|Unfocused|Unfold|Universe|Universes|Unshelve|Variable|Variables|Variant|Verbose|View|Visibility|Zify|_|apply|as|at|by|cofix|else|end|exists|exists2|fix|for|forall|fun|if|in|let|match|measure|move|removed|return|struct|then|using|wf|where|with)\b/,
+      number: /\b(?:0x[a-f0-9][a-f0-9_]*(?:\.[a-f0-9_]+)?(?:p[+-]?\d[\d_]*)?|\d[\d_]*(?:\.[\d_]+)?(?:e[+-]?\d[\d_]*)?)\b/i,
+      punct: {
+        pattern: /@\{|\{\||\[=|:>/,
+        alias: "punctuation"
+      },
+      operator: /\/\\|\\\/|\.{2,3}|:{1,2}=|\*\*|[-=]>|<(?:->?|[+:=>]|<:)|>(?:=|->)|\|[-|]?|[-!%&*+/<=>?@^~']/,
+      punctuation: /\.\(|`\(|@\{|`\{|\{\||\[=|:>|[:.,;(){}\[\]]/
+    };
+  })(Prism);
+}
+
+export {
+  coq
+};

package/dist/chunk-SJXEIMJG.mjs

@@ -0,0 +1,23 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/jexl.js
+jexl.displayName = "jexl";
+jexl.aliases = [];
+function jexl(Prism) {
+  Prism.languages.jexl = {
+    string: /(["'])(?:\\[\s\S]|(?!\1)[^\\])*\1/,
+    transform: {
+      pattern: /(\|\s*)[a-zA-Zа-яА-Я_\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF$][\wа-яА-Я\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF$]*/,
+      alias: "function",
+      lookbehind: true
+    },
+    function: /[a-zA-Zа-яА-Я_\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF$][\wа-яА-Я\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u00FF$]*\s*(?=\()/,
+    number: /\b\d+(?:\.\d+)?\b|\B\.\d+\b/,
+    operator: /[<>!]=?|-|\+|&&|==|\|\|?|\/\/?|[?:*^%]/,
+    boolean: /\b(?:false|true)\b/,
+    keyword: /\bin\b/,
+    punctuation: /[{}[\](),.]/
+  };
+}
+
+export {
+  jexl
+};

package/dist/chunk-SME75MDR.mjs

@@ -0,0 +1,69 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/tremor.js
+tremor.displayName = "tremor";
+tremor.aliases = ["trickle", "troy"];
+function tremor(Prism) {
+  ;
+  (function(Prism2) {
+    Prism2.languages.tremor = {
+      comment: {
+        pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:--|\/\/|#).*)/,
+        lookbehind: true
+      },
+      "interpolated-string": null,
+      // see below
+      extractor: {
+        pattern: /\b[a-z_]\w*\|(?:[^\r\n\\|]|\\(?:\r\n|[\s\S]))*\|/i,
+        greedy: true,
+        inside: {
+          regex: {
+            pattern: /(^re)\|[\s\S]+/,
+            lookbehind: true
+          },
+          function: /^\w+/,
+          value: /\|[\s\S]+/
+        }
+      },
+      identifier: {
+        pattern: /`[^`]*`/,
+        greedy: true
+      },
+      function: /\b[a-z_]\w*(?=\s*(?:::\s*<|\())\b/,
+      keyword: /\b(?:args|as|by|case|config|connect|connector|const|copy|create|default|define|deploy|drop|each|emit|end|erase|event|flow|fn|for|from|group|having|insert|into|intrinsic|let|links|match|merge|mod|move|of|operator|patch|pipeline|recur|script|select|set|sliding|state|stream|to|tumbling|update|use|when|where|window|with)\b/,
+      boolean: /\b(?:false|null|true)\b/i,
+      number: /\b(?:0b[01_]*|0x[0-9a-fA-F_]*|\d[\d_]*(?:\.\d[\d_]*)?(?:[Ee][+-]?[\d_]+)?)\b/,
+      "pattern-punctuation": {
+        pattern: /%(?=[({[])/,
+        alias: "punctuation"
+      },
+      operator: /[-+*\/%~!^]=?|=[=>]?|&[&=]?|\|[|=]?|<<?=?|>>?>?=?|(?:absent|and|not|or|present|xor)\b/,
+      punctuation: /::|[;\[\]()\{\},.:]/
+    };
+    var interpolationPattern = /#\{(?:[^"{}]|\{[^{}]*\}|"(?:[^"\\\r\n]|\\(?:\r\n|[\s\S]))*")*\}/.source;
+    Prism2.languages.tremor["interpolated-string"] = {
+      pattern: RegExp(
+        /(^|[^\\])/.source + '(?:"""(?:' + /[^"\\#]|\\[\s\S]|"(?!"")|#(?!\{)/.source + "|" + interpolationPattern + ')*"""|"(?:' + /[^"\\\r\n#]|\\(?:\r\n|[\s\S])|#(?!\{)/.source + "|" + interpolationPattern + ')*")'
+      ),
+      lookbehind: true,
+      greedy: true,
+      inside: {
+        interpolation: {
+          pattern: RegExp(interpolationPattern),
+          inside: {
+            punctuation: /^#\{|\}$/,
+            expression: {
+              pattern: /[\s\S]+/,
+              inside: Prism2.languages.tremor
+            }
+          }
+        },
+        string: /[\s\S]+/
+      }
+    };
+    Prism2.languages.troy = Prism2.languages["tremor"];
+    Prism2.languages.trickle = Prism2.languages["tremor"];
+  })(Prism);
+}
+
+export {
+  tremor
+};

package/dist/chunk-SOSLW7OD.mjs

@@ -0,0 +1,37 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/oz.js
+oz.displayName = "oz";
+oz.aliases = [];
+function oz(Prism) {
+  Prism.languages.oz = {
+    comment: {
+      pattern: /\/\*[\s\S]*?\*\/|%.*/,
+      greedy: true
+    },
+    string: {
+      pattern: /"(?:[^"\\]|\\[\s\S])*"/,
+      greedy: true
+    },
+    atom: {
+      pattern: /'(?:[^'\\]|\\[\s\S])*'/,
+      greedy: true,
+      alias: "builtin"
+    },
+    keyword: /\$|\[\]|\b(?:_|at|attr|case|catch|choice|class|cond|declare|define|dis|else(?:case|if)?|end|export|fail|false|feat|finally|from|fun|functor|if|import|in|local|lock|meth|nil|not|of|or|prepare|proc|prop|raise|require|self|skip|then|thread|true|try|unit)\b/,
+    function: [
+      /\b[a-z][A-Za-z\d]*(?=\()/,
+      {
+        pattern: /(\{)[A-Z][A-Za-z\d]*\b/,
+        lookbehind: true
+      }
+    ],
+    number: /\b(?:0[bx][\da-f]+|\d+(?:\.\d*)?(?:e~?\d+)?)\b|&(?:[^\\]|\\(?:\d{3}|.))/i,
+    variable: /`(?:[^`\\]|\\.)+`/,
+    "attr-name": /\b\w+(?=[ \t]*:(?![:=]))/,
+    operator: /:(?:=|::?)|<[-:=]?|=(?:=|<?:?)|>=?:?|\\=:?|!!?|[|#+\-*\/,~^@]|\b(?:andthen|div|mod|orelse)\b/,
+    punctuation: /[\[\](){}.:;?]/
+  };
+}
+
+export {
+  oz
+};

package/dist/chunk-SSWTK56H.mjs

@@ -0,0 +1,33 @@
+import {
+  clike
+} from "./chunk-XWTEQUC3.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/solidity.js
+solidity.displayName = "solidity";
+solidity.aliases = ["sol"];
+function solidity(Prism) {
+  Prism.register(clike);
+  Prism.languages.solidity = Prism.languages.extend("clike", {
+    "class-name": {
+      pattern: /(\b(?:contract|enum|interface|library|new|struct|using)\s+)(?!\d)[\w$]+/,
+      lookbehind: true
+    },
+    keyword: /\b(?:_|anonymous|as|assembly|assert|break|calldata|case|constant|constructor|continue|contract|default|delete|do|else|emit|enum|event|external|for|from|function|if|import|indexed|inherited|interface|internal|is|let|library|mapping|memory|modifier|new|payable|pragma|private|public|pure|require|returns?|revert|selfdestruct|solidity|storage|struct|suicide|switch|this|throw|using|var|view|while)\b/,
+    operator: /=>|->|:=|=:|\*\*|\+\+|--|\|\||&&|<<=?|>>=?|[-+*/%^&|<>!=]=?|[~?]/
+  });
+  Prism.languages.insertBefore("solidity", "keyword", {
+    builtin: /\b(?:address|bool|byte|u?int(?:8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?|string|bytes(?:[1-9]|[12]\d|3[0-2])?)\b/
+  });
+  Prism.languages.insertBefore("solidity", "number", {
+    version: {
+      pattern: /([<>]=?|\^)\d+\.\d+\.\d+\b/,
+      lookbehind: true,
+      alias: "number"
+    }
+  });
+  Prism.languages.sol = Prism.languages.solidity;
+}
+
+export {
+  solidity
+};

package/dist/chunk-SUJ46ITU.mjs

@@ -0,0 +1,30 @@
+import {
+  sql
+} from "./chunk-4F6TSYBP.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/plsql.js
+plsql.displayName = "plsql";
+plsql.aliases = [];
+function plsql(Prism) {
+  Prism.register(sql);
+  Prism.languages.plsql = Prism.languages.extend("sql", {
+    comment: {
+      pattern: /\/\*[\s\S]*?\*\/|--.*/,
+      greedy: true
+    },
+    // https://docs.oracle.com/en/database/oracle/oracle-database/21/lnpls/plsql-reserved-words-keywords.html
+    keyword: /\b(?:A|ACCESSIBLE|ADD|AGENT|AGGREGATE|ALL|ALTER|AND|ANY|ARRAY|AS|ASC|AT|ATTRIBUTE|AUTHID|AVG|BEGIN|BETWEEN|BFILE_BASE|BINARY|BLOB_BASE|BLOCK|BODY|BOTH|BOUND|BULK|BY|BYTE|C|CALL|CALLING|CASCADE|CASE|CHAR|CHARACTER|CHARSET|CHARSETFORM|CHARSETID|CHAR_BASE|CHECK|CLOB_BASE|CLONE|CLOSE|CLUSTER|CLUSTERS|COLAUTH|COLLECT|COLUMNS|COMMENT|COMMIT|COMMITTED|COMPILED|COMPRESS|CONNECT|CONSTANT|CONSTRUCTOR|CONTEXT|CONTINUE|CONVERT|COUNT|CRASH|CREATE|CREDENTIAL|CURRENT|CURSOR|CUSTOMDATUM|DANGLING|DATA|DATE|DATE_BASE|DAY|DECLARE|DEFAULT|DEFINE|DELETE|DESC|DETERMINISTIC|DIRECTORY|DISTINCT|DOUBLE|DROP|DURATION|ELEMENT|ELSE|ELSIF|EMPTY|END|ESCAPE|EXCEPT|EXCEPTION|EXCEPTIONS|EXCLUSIVE|EXECUTE|EXISTS|EXIT|EXTERNAL|FETCH|FINAL|FIRST|FIXED|FLOAT|FOR|FORALL|FORCE|FROM|FUNCTION|GENERAL|GOTO|GRANT|GROUP|HASH|HAVING|HEAP|HIDDEN|HOUR|IDENTIFIED|IF|IMMEDIATE|IMMUTABLE|IN|INCLUDING|INDEX|INDEXES|INDICATOR|INDICES|INFINITE|INSERT|INSTANTIABLE|INT|INTERFACE|INTERSECT|INTERVAL|INTO|INVALIDATE|IS|ISOLATION|JAVA|LANGUAGE|LARGE|LEADING|LENGTH|LEVEL|LIBRARY|LIKE|LIKE2|LIKE4|LIKEC|LIMIT|LIMITED|LOCAL|LOCK|LONG|LOOP|MAP|MAX|MAXLEN|MEMBER|MERGE|MIN|MINUS|MINUTE|MOD|MODE|MODIFY|MONTH|MULTISET|MUTABLE|NAME|NAN|NATIONAL|NATIVE|NCHAR|NEW|NOCOMPRESS|NOCOPY|NOT|NOWAIT|NULL|NUMBER_BASE|OBJECT|OCICOLL|OCIDATE|OCIDATETIME|OCIDURATION|OCIINTERVAL|OCILOBLOCATOR|OCINUMBER|OCIRAW|OCIREF|OCIREFCURSOR|OCIROWID|OCISTRING|OCITYPE|OF|OLD|ON|ONLY|OPAQUE|OPEN|OPERATOR|OPTION|OR|ORACLE|ORADATA|ORDER|ORGANIZATION|ORLANY|ORLVARY|OTHERS|OUT|OVERLAPS|OVERRIDING|PACKAGE|PARALLEL_ENABLE|PARAMETER|PARAMETERS|PARENT|PARTITION|PASCAL|PERSISTABLE|PIPE|PIPELINED|PLUGGABLE|POLYMORPHIC|PRAGMA|PRECISION|PRIOR|PRIVATE|PROCEDURE|PUBLIC|RAISE|RANGE|RAW|READ|RECORD|REF|REFERENCE|RELIES_ON|REM|REMAINDER|RENAME|RESOURCE|RESULT|RESULT_CACHE|RETURN|RETURNING|REVERSE|REVOKE|ROLLBACK|ROW|SAMPLE|SAVE|SAVEPOINT|SB1|SB2|SB4|SECOND|SEGMENT|SELECT|SELF|SEPARATE|SEQUENCE|SERIALIZABLE|SET|SHARE|SHORT|SIZE|SIZE_T|SOME|SPARSE|SQL|SQLCODE|SQLDATA|SQLNAME|SQLSTATE|STANDARD|START|STATIC|STDDEV|STORED|STRING|STRUCT|STYLE|SUBMULTISET|SUBPARTITION|SUBSTITUTABLE|SUBTYPE|SUM|SYNONYM|TABAUTH|TABLE|TDO|THE|THEN|TIME|TIMESTAMP|TIMEZONE_ABBR|TIMEZONE_HOUR|TIMEZONE_MINUTE|TIMEZONE_REGION|TO|TRAILING|TRANSACTION|TRANSACTIONAL|TRUSTED|TYPE|UB1|UB2|UB4|UNDER|UNION|UNIQUE|UNPLUG|UNSIGNED|UNTRUSTED|UPDATE|USE|USING|VALIST|VALUE|VALUES|VARIABLE|VARIANCE|VARRAY|VARYING|VIEW|VIEWS|VOID|WHEN|WHERE|WHILE|WITH|WORK|WRAPPED|WRITE|YEAR|ZONE)\b/i,
+    // https://docs.oracle.com/en/database/oracle/oracle-database/21/lnpls/plsql-language-fundamentals.html#GUID-96A42F7C-7A71-4B90-8255-CA9C8BD9722E
+    operator: /:=?|=>|[<>^~!]=|\.\.|\|\||\*\*|[-+*/%<>=@]/
+  });
+  Prism.languages.insertBefore("plsql", "operator", {
+    label: {
+      pattern: /<<\s*\w+\s*>>/,
+      alias: "symbol"
+    }
+  });
+}
+
+export {
+  plsql
+};

package/dist/chunk-SUZBWU64.mjs

@@ -0,0 +1,111 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/docker.js
+docker.displayName = "docker";
+docker.aliases = ["dockerfile"];
+function docker(Prism) {
+  ;
+  (function(Prism2) {
+    var spaceAfterBackSlash = /\\[\r\n](?:\s|\\[\r\n]|#.*(?!.))*(?![\s#]|\\[\r\n])/.source;
+    var space = /(?:[ \t]+(?![ \t])(?:<SP_BS>)?|<SP_BS>)/.source.replace(
+      /<SP_BS>/g,
+      function() {
+        return spaceAfterBackSlash;
+      }
+    );
+    var string = /"(?:[^"\\\r\n]|\\(?:\r\n|[\s\S]))*"|'(?:[^'\\\r\n]|\\(?:\r\n|[\s\S]))*'/.source;
+    var option = /--[\w-]+=(?:<STR>|(?!["'])(?:[^\s\\]|\\.)+)/.source.replace(
+      /<STR>/g,
+      function() {
+        return string;
+      }
+    );
+    var stringRule = {
+      pattern: RegExp(string),
+      greedy: true
+    };
+    var commentRule = {
+      pattern: /(^[ \t]*)#.*/m,
+      lookbehind: true,
+      greedy: true
+    };
+    function re(source, flags) {
+      source = source.replace(/<OPT>/g, function() {
+        return option;
+      }).replace(/<SP>/g, function() {
+        return space;
+      });
+      return RegExp(source, flags);
+    }
+    Prism2.languages.docker = {
+      instruction: {
+        pattern: /(^[ \t]*)(?:ADD|ARG|CMD|COPY|ENTRYPOINT|ENV|EXPOSE|FROM|HEALTHCHECK|LABEL|MAINTAINER|ONBUILD|RUN|SHELL|STOPSIGNAL|USER|VOLUME|WORKDIR)(?=\s)(?:\\.|[^\r\n\\])*(?:\\$(?:\s|#.*$)*(?![\s#])(?:\\.|[^\r\n\\])*)*/im,
+        lookbehind: true,
+        greedy: true,
+        inside: {
+          options: {
+            pattern: re(
+              /(^(?:ONBUILD<SP>)?\w+<SP>)<OPT>(?:<SP><OPT>)*/.source,
+              "i"
+            ),
+            lookbehind: true,
+            greedy: true,
+            inside: {
+              property: {
+                pattern: /(^|\s)--[\w-]+/,
+                lookbehind: true
+              },
+              string: [
+                stringRule,
+                {
+                  pattern: /(=)(?!["'])(?:[^\s\\]|\\.)+/,
+                  lookbehind: true
+                }
+              ],
+              operator: /\\$/m,
+              punctuation: /=/
+            }
+          },
+          keyword: [
+            {
+              // https://docs.docker.com/engine/reference/builder/#healthcheck
+              pattern: re(
+                /(^(?:ONBUILD<SP>)?HEALTHCHECK<SP>(?:<OPT><SP>)*)(?:CMD|NONE)\b/.source,
+                "i"
+              ),
+              lookbehind: true,
+              greedy: true
+            },
+            {
+              // https://docs.docker.com/engine/reference/builder/#from
+              pattern: re(
+                /(^(?:ONBUILD<SP>)?FROM<SP>(?:<OPT><SP>)*(?!--)[^ \t\\]+<SP>)AS/.source,
+                "i"
+              ),
+              lookbehind: true,
+              greedy: true
+            },
+            {
+              // https://docs.docker.com/engine/reference/builder/#onbuild
+              pattern: re(/(^ONBUILD<SP>)\w+/.source, "i"),
+              lookbehind: true,
+              greedy: true
+            },
+            {
+              pattern: /^\w+/,
+              greedy: true
+            }
+          ],
+          comment: commentRule,
+          string: stringRule,
+          variable: /\$(?:\w+|\{[^{}"'\\]*\})/,
+          operator: /\\$/m
+        }
+      },
+      comment: commentRule
+    };
+    Prism2.languages.dockerfile = Prism2.languages.docker;
+  })(Prism);
+}
+
+export {
+  docker
+};