@photonix/basic 1.5.0 → 1.6.0

package/dist/chunk-XY4A63YZ.mjs

@@ -0,0 +1,97 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/plant-uml.js
+plantUml.displayName = "plant-uml";
+plantUml.aliases = ["plantuml"];
+function plantUml(Prism) {
+  ;
+  (function(Prism2) {
+    var variable = /\$\w+|%[a-z]+%/;
+    var arrowAttr = /\[[^[\]]*\]/.source;
+    var arrowDirection = /(?:[drlu]|do|down|le|left|ri|right|up)/.source;
+    var arrowBody = "(?:-+" + arrowDirection + "-+|\\.+" + arrowDirection + "\\.+|-+(?:" + arrowAttr + "-*)?|" + arrowAttr + "-+|\\.+(?:" + arrowAttr + "\\.*)?|" + arrowAttr + "\\.+)";
+    var arrowLeft = /(?:<{1,2}|\/{1,2}|\\{1,2}|<\||[#*^+}xo])/.source;
+    var arrowRight = /(?:>{1,2}|\/{1,2}|\\{1,2}|\|>|[#*^+{xo])/.source;
+    var arrowPrefix = /[[?]?[ox]?/.source;
+    var arrowSuffix = /[ox]?[\]?]?/.source;
+    var arrow = arrowPrefix + "(?:" + arrowBody + arrowRight + "|" + arrowLeft + arrowBody + "(?:" + arrowRight + ")?)" + arrowSuffix;
+    Prism2.languages["plant-uml"] = {
+      comment: {
+        pattern: /(^[ \t]*)(?:'.*|\/'[\s\S]*?'\/)/m,
+        lookbehind: true,
+        greedy: true
+      },
+      preprocessor: {
+        pattern: /(^[ \t]*)!.*/m,
+        lookbehind: true,
+        greedy: true,
+        alias: "property",
+        inside: {
+          variable
+        }
+      },
+      delimiter: {
+        pattern: /(^[ \t]*)@(?:end|start)uml\b/m,
+        lookbehind: true,
+        greedy: true,
+        alias: "punctuation"
+      },
+      arrow: {
+        pattern: RegExp(
+          /(^|[^-.<>?|\\[\]ox])/.source + arrow + /(?![-.<>?|\\\]ox])/.source
+        ),
+        lookbehind: true,
+        greedy: true,
+        alias: "operator",
+        inside: {
+          expression: {
+            pattern: /(\[)[^[\]]+(?=\])/,
+            lookbehind: true,
+            inside: null
+            // see below
+          },
+          punctuation: /\[(?=$|\])|^\]/
+        }
+      },
+      string: {
+        pattern: /"[^"]*"/,
+        greedy: true
+      },
+      text: {
+        pattern: /(\[[ \t]*[\r\n]+(?![\r\n]))[^\]]*(?=\])/,
+        lookbehind: true,
+        greedy: true,
+        alias: "string"
+      },
+      keyword: [
+        {
+          pattern: /^([ \t]*)(?:abstract\s+class|end\s+(?:box|fork|group|merge|note|ref|split|title)|(?:fork|split)(?:\s+again)?|activate|actor|agent|alt|annotation|artifact|autoactivate|autonumber|backward|binary|boundary|box|break|caption|card|case|circle|class|clock|cloud|collections|component|concise|control|create|critical|database|deactivate|destroy|detach|diamond|else|elseif|end|end[hr]note|endif|endswitch|endwhile|entity|enum|file|folder|footer|frame|group|[hr]?note|header|hexagon|hide|if|interface|label|legend|loop|map|namespace|network|newpage|node|nwdiag|object|opt|package|page|par|participant|person|queue|rectangle|ref|remove|repeat|restore|return|robust|scale|set|show|skinparam|stack|start|state|stop|storage|switch|title|together|usecase|usecase\/|while)(?=\s|$)/m,
+          lookbehind: true,
+          greedy: true
+        },
+        /\b(?:elseif|equals|not|while)(?=\s*\()/,
+        /\b(?:as|is|then)\b/
+      ],
+      divider: {
+        pattern: /^==.+==$/m,
+        greedy: true,
+        alias: "important"
+      },
+      time: {
+        pattern: /@(?:\d+(?:[:/]\d+){2}|[+-]?\d+|:[a-z]\w*(?:[+-]\d+)?)\b/i,
+        greedy: true,
+        alias: "number"
+      },
+      color: {
+        pattern: /#(?:[a-z_]+|[a-fA-F0-9]+)\b/,
+        alias: "symbol"
+      },
+      variable,
+      punctuation: /[:,;()[\]{}]|\.{3}/
+    };
+    Prism2.languages["plant-uml"].arrow.inside.expression.inside = Prism2.languages["plant-uml"];
+    Prism2.languages["plantuml"] = Prism2.languages["plant-uml"];
+  })(Prism);
+}
+
+export {
+  plantUml
+};

package/dist/chunk-Y56MCF6T.mjs

@@ -0,0 +1,47 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/kusto.js
+kusto.displayName = "kusto";
+kusto.aliases = [];
+function kusto(Prism) {
+  Prism.languages.kusto = {
+    comment: {
+      pattern: /\/\/.*/,
+      greedy: true
+    },
+    string: {
+      pattern: /```[\s\S]*?```|[hH]?(?:"(?:[^\r\n\\"]|\\.)*"|'(?:[^\r\n\\']|\\.)*'|@(?:"[^\r\n"]*"|'[^\r\n']*'))/,
+      greedy: true
+    },
+    verb: {
+      pattern: /(\|\s*)[a-z][\w-]*/i,
+      lookbehind: true,
+      alias: "keyword"
+    },
+    command: {
+      pattern: /\.[a-z][a-z\d-]*\b/,
+      alias: "keyword"
+    },
+    "class-name": /\b(?:bool|datetime|decimal|dynamic|guid|int|long|real|string|timespan)\b/,
+    keyword: /\b(?:access|alias|and|anti|as|asc|auto|between|by|(?:contains|(?:ends|starts)with|has(?:perfix|suffix)?)(?:_cs)?|database|declare|desc|external|from|fullouter|has_all|in|ingestion|inline|inner|innerunique|into|(?:left|right)(?:anti(?:semi)?|inner|outer|semi)?|let|like|local|not|of|on|or|pattern|print|query_parameters|range|restrict|schema|set|step|table|tables|to|view|where|with|matches\s+regex|nulls\s+(?:first|last))(?![\w-])/,
+    boolean: /\b(?:false|null|true)\b/,
+    function: /\b[a-z_]\w*(?=\s*\()/,
+    datetime: [
+      {
+        // RFC 822 + RFC 850
+        pattern: /\b(?:(?:Fri|Friday|Mon|Monday|Sat|Saturday|Sun|Sunday|Thu|Thursday|Tue|Tuesday|Wed|Wednesday)\s*,\s*)?\d{1,2}(?:\s+|-)(?:Apr|Aug|Dec|Feb|Jan|Jul|Jun|Mar|May|Nov|Oct|Sep)(?:\s+|-)\d{2}\s+\d{2}:\d{2}(?::\d{2})?(?:\s*(?:\b(?:[A-Z]|(?:[ECMT][DS]|GM|U)T)|[+-]\d{4}))?\b/,
+        alias: "number"
+      },
+      {
+        // ISO 8601
+        pattern: /[+-]?\b(?:\d{4}-\d{2}-\d{2}(?:[ T]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?)?|\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?)Z?/,
+        alias: "number"
+      }
+    ],
+    number: /\b(?:0x[0-9A-Fa-f]+|\d+(?:\.\d+)?(?:[Ee][+-]?\d+)?)(?:(?:min|sec|[mnµ]s|[dhms]|microsecond|tick)\b)?|[+-]?\binf\b/,
+    operator: /=>|[!=]~|[!=<>]=?|[-+*/%|]|\.\./,
+    punctuation: /[()\[\]{},;.:]/
+  };
+}
+
+export {
+  kusto
+};

package/dist/chunk-Y6ESNTDP.mjs

@@ -0,0 +1,41 @@
+import {
+  haskell
+} from "./chunk-IZR4QWR2.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/purescript.js
+purescript.displayName = "purescript";
+purescript.aliases = ["purs"];
+function purescript(Prism) {
+  Prism.register(haskell);
+  Prism.languages.purescript = Prism.languages.extend("haskell", {
+    keyword: /\b(?:ado|case|class|data|derive|do|else|forall|if|in|infixl|infixr|instance|let|module|newtype|of|primitive|then|type|where)\b|∀/,
+    "import-statement": {
+      // The imported or hidden names are not included in this import
+      // statement. This is because we want to highlight those exactly like
+      // we do for the names in the program.
+      pattern: /(^[\t ]*)import\s+[A-Z][\w']*(?:\.[A-Z][\w']*)*(?:\s+as\s+[A-Z][\w']*(?:\.[A-Z][\w']*)*)?(?:\s+hiding\b)?/m,
+      lookbehind: true,
+      inside: {
+        keyword: /\b(?:as|hiding|import)\b/,
+        punctuation: /\./
+      }
+    },
+    // These are builtin functions only. Constructors are highlighted later as a constant.
+    builtin: /\b(?:absurd|add|ap|append|apply|between|bind|bottom|clamp|compare|comparing|compose|conj|const|degree|discard|disj|div|eq|flap|flip|gcd|identity|ifM|join|lcm|liftA1|liftM1|map|max|mempty|min|mod|mul|negate|not|notEq|one|otherwise|recip|show|sub|top|unit|unless|unlessM|void|when|whenM|zero)\b/,
+    operator: [
+      // Infix operators
+      Prism.languages.haskell.operator[0],
+      // ASCII operators
+      Prism.languages.haskell.operator[2],
+      // All UTF16 Unicode operator symbols
+      // This regex is equivalent to /(?=[\x80-\uFFFF])[\p{gc=Math_Symbol}\p{gc=Currency_Symbol}\p{Modifier_Symbol}\p{Other_Symbol}]/u
+      // See https://github.com/PrismJS/prism/issues/3006 for more details.
+      /[\xa2-\xa6\xa8\xa9\xac\xae-\xb1\xb4\xb8\xd7\xf7\u02c2-\u02c5\u02d2-\u02df\u02e5-\u02eb\u02ed\u02ef-\u02ff\u0375\u0384\u0385\u03f6\u0482\u058d-\u058f\u0606-\u0608\u060b\u060e\u060f\u06de\u06e9\u06fd\u06fe\u07f6\u07fe\u07ff\u09f2\u09f3\u09fa\u09fb\u0af1\u0b70\u0bf3-\u0bfa\u0c7f\u0d4f\u0d79\u0e3f\u0f01-\u0f03\u0f13\u0f15-\u0f17\u0f1a-\u0f1f\u0f34\u0f36\u0f38\u0fbe-\u0fc5\u0fc7-\u0fcc\u0fce\u0fcf\u0fd5-\u0fd8\u109e\u109f\u1390-\u1399\u166d\u17db\u1940\u19de-\u19ff\u1b61-\u1b6a\u1b74-\u1b7c\u1fbd\u1fbf-\u1fc1\u1fcd-\u1fcf\u1fdd-\u1fdf\u1fed-\u1fef\u1ffd\u1ffe\u2044\u2052\u207a-\u207c\u208a-\u208c\u20a0-\u20bf\u2100\u2101\u2103-\u2106\u2108\u2109\u2114\u2116-\u2118\u211e-\u2123\u2125\u2127\u2129\u212e\u213a\u213b\u2140-\u2144\u214a-\u214d\u214f\u218a\u218b\u2190-\u2307\u230c-\u2328\u232b-\u2426\u2440-\u244a\u249c-\u24e9\u2500-\u2767\u2794-\u27c4\u27c7-\u27e5\u27f0-\u2982\u2999-\u29d7\u29dc-\u29fb\u29fe-\u2b73\u2b76-\u2b95\u2b97-\u2bff\u2ce5-\u2cea\u2e50\u2e51\u2e80-\u2e99\u2e9b-\u2ef3\u2f00-\u2fd5\u2ff0-\u2ffb\u3004\u3012\u3013\u3020\u3036\u3037\u303e\u303f\u309b\u309c\u3190\u3191\u3196-\u319f\u31c0-\u31e3\u3200-\u321e\u322a-\u3247\u3250\u3260-\u327f\u328a-\u32b0\u32c0-\u33ff\u4dc0-\u4dff\ua490-\ua4c6\ua700-\ua716\ua720\ua721\ua789\ua78a\ua828-\ua82b\ua836-\ua839\uaa77-\uaa79\uab5b\uab6a\uab6b\ufb29\ufbb2-\ufbc1\ufdfc\ufdfd\ufe62\ufe64-\ufe66\ufe69\uff04\uff0b\uff1c-\uff1e\uff3e\uff40\uff5c\uff5e\uffe0-\uffe6\uffe8-\uffee\ufffc\ufffd]/
+    ]
+  });
+  Prism.languages.purs = Prism.languages.purescript;
+}
+
+export {
+  purescript
+};

package/dist/chunk-YA533AI6.mjs

@@ -0,0 +1,81 @@
+import {
+  markupTemplating
+} from "./chunk-DFNMTLAN.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/liquid.js
+liquid.displayName = "liquid";
+liquid.aliases = [];
+function liquid(Prism) {
+  Prism.register(markupTemplating);
+  Prism.languages.liquid = {
+    comment: {
+      pattern: /(^\{%\s*comment\s*%\})[\s\S]+(?=\{%\s*endcomment\s*%\}$)/,
+      lookbehind: true
+    },
+    delimiter: {
+      pattern: /^\{(?:\{\{|[%\{])-?|-?(?:\}\}|[%\}])\}$/,
+      alias: "punctuation"
+    },
+    string: {
+      pattern: /"[^"]*"|'[^']*'/,
+      greedy: true
+    },
+    keyword: /\b(?:as|assign|break|(?:end)?(?:capture|case|comment|for|form|if|paginate|raw|style|tablerow|unless)|continue|cycle|decrement|echo|else|elsif|in|include|increment|limit|liquid|offset|range|render|reversed|section|when|with)\b/,
+    object: /\b(?:address|all_country_option_tags|article|block|blog|cart|checkout|collection|color|country|country_option_tags|currency|current_page|current_tags|customer|customer_address|date|discount_allocation|discount_application|external_video|filter|filter_value|font|forloop|fulfillment|generic_file|gift_card|group|handle|image|line_item|link|linklist|localization|location|measurement|media|metafield|model|model_source|order|page|page_description|page_image|page_title|part|policy|product|product_option|recommendations|request|robots|routes|rule|script|search|selling_plan|selling_plan_allocation|selling_plan_group|shipping_method|shop|shop_locale|sitemap|store_availability|tax_line|template|theme|transaction|unit_price_measurement|user_agent|variant|video|video_source)\b/,
+    function: [
+      {
+        pattern: /(\|\s*)\w+/,
+        lookbehind: true,
+        alias: "filter"
+      },
+      {
+        // array functions
+        pattern: /(\.\s*)(?:first|last|size)/,
+        lookbehind: true
+      }
+    ],
+    boolean: /\b(?:false|nil|true)\b/,
+    range: {
+      pattern: /\.\./,
+      alias: "operator"
+    },
+    // https://github.com/Shopify/liquid/blob/698f5e0d967423e013f6169d9111bd969bd78337/lib/liquid/lexer.rb#L21
+    number: /\b\d+(?:\.\d+)?\b/,
+    operator: /[!=]=|<>|[<>]=?|[|?:=-]|\b(?:and|contains(?=\s)|or)\b/,
+    punctuation: /[.,\[\]()]/,
+    empty: {
+      pattern: /\bempty\b/,
+      alias: "keyword"
+    }
+  };
+  Prism.hooks.add("before-tokenize", function(env) {
+    var liquidPattern = /\{%\s*comment\s*%\}[\s\S]*?\{%\s*endcomment\s*%\}|\{(?:%[\s\S]*?%|\{\{[\s\S]*?\}\}|\{[\s\S]*?\})\}/g;
+    var insideRaw = false;
+    Prism.languages["markup-templating"].buildPlaceholders(
+      env,
+      "liquid",
+      liquidPattern,
+      function(match) {
+        var tagMatch = /^\{%-?\s*(\w+)/.exec(match);
+        if (tagMatch) {
+          var tag = tagMatch[1];
+          if (tag === "raw" && !insideRaw) {
+            insideRaw = true;
+            return true;
+          } else if (tag === "endraw") {
+            insideRaw = false;
+            return true;
+          }
+        }
+        return !insideRaw;
+      }
+    );
+  });
+  Prism.hooks.add("after-tokenize", function(env) {
+    Prism.languages["markup-templating"].tokenizePlaceholders(env, "liquid");
+  });
+}
+
+export {
+  liquid
+};

package/dist/chunk-YDLI5CNE.mjs

@@ -0,0 +1,31 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/n1ql.js
+n1ql.displayName = "n1ql";
+n1ql.aliases = [];
+function n1ql(Prism) {
+  Prism.languages.n1ql = {
+    comment: {
+      pattern: /\/\*[\s\S]*?(?:$|\*\/)|--.*/,
+      greedy: true
+    },
+    string: {
+      pattern: /(["'])(?:\\[\s\S]|(?!\1)[^\\]|\1\1)*\1/,
+      greedy: true
+    },
+    identifier: {
+      pattern: /`(?:\\[\s\S]|[^\\`]|``)*`/,
+      greedy: true
+    },
+    parameter: /\$[\w.]+/,
+    // https://docs.couchbase.com/server/current/n1ql/n1ql-language-reference/reservedwords.html#n1ql-reserved-words
+    keyword: /\b(?:ADVISE|ALL|ALTER|ANALYZE|AS|ASC|AT|BEGIN|BINARY|BOOLEAN|BREAK|BUCKET|BUILD|BY|CALL|CAST|CLUSTER|COLLATE|COLLECTION|COMMIT|COMMITTED|CONNECT|CONTINUE|CORRELATE|CORRELATED|COVER|CREATE|CURRENT|DATABASE|DATASET|DATASTORE|DECLARE|DECREMENT|DELETE|DERIVED|DESC|DESCRIBE|DISTINCT|DO|DROP|EACH|ELEMENT|EXCEPT|EXCLUDE|EXECUTE|EXPLAIN|FETCH|FILTER|FLATTEN|FLUSH|FOLLOWING|FOR|FORCE|FROM|FTS|FUNCTION|GOLANG|GRANT|GROUP|GROUPS|GSI|HASH|HAVING|IF|IGNORE|ILIKE|INCLUDE|INCREMENT|INDEX|INFER|INLINE|INNER|INSERT|INTERSECT|INTO|IS|ISOLATION|JAVASCRIPT|JOIN|KEY|KEYS|KEYSPACE|KNOWN|LANGUAGE|LAST|LEFT|LET|LETTING|LEVEL|LIMIT|LSM|MAP|MAPPING|MATCHED|MATERIALIZED|MERGE|MINUS|MISSING|NAMESPACE|NEST|NL|NO|NTH_VALUE|NULL|NULLS|NUMBER|OBJECT|OFFSET|ON|OPTION|OPTIONS|ORDER|OTHERS|OUTER|OVER|PARSE|PARTITION|PASSWORD|PATH|POOL|PRECEDING|PREPARE|PRIMARY|PRIVATE|PRIVILEGE|PROBE|PROCEDURE|PUBLIC|RANGE|RAW|REALM|REDUCE|RENAME|RESPECT|RETURN|RETURNING|REVOKE|RIGHT|ROLE|ROLLBACK|ROW|ROWS|SATISFIES|SAVEPOINT|SCHEMA|SCOPE|SELECT|SELF|SEMI|SET|SHOW|SOME|START|STATISTICS|STRING|SYSTEM|TIES|TO|TRAN|TRANSACTION|TRIGGER|TRUNCATE|UNBOUNDED|UNDER|UNION|UNIQUE|UNKNOWN|UNNEST|UNSET|UPDATE|UPSERT|USE|USER|USING|VALIDATE|VALUE|VALUES|VIA|VIEW|WHERE|WHILE|WINDOW|WITH|WORK|XOR)\b/i,
+    function: /\b[a-z_]\w*(?=\s*\()/i,
+    boolean: /\b(?:FALSE|TRUE)\b/i,
+    number: /(?:\b\d+\.|\B\.)\d+e[+\-]?\d+\b|\b\d+(?:\.\d*)?|\B\.\d+\b/i,
+    operator: /[-+*\/%]|!=|==?|\|\||<[>=]?|>=?|\b(?:AND|ANY|ARRAY|BETWEEN|CASE|ELSE|END|EVERY|EXISTS|FIRST|IN|LIKE|NOT|OR|THEN|VALUED|WHEN|WITHIN)\b/i,
+    punctuation: /[;[\](),.{}:]/
+  };
+}
+
+export {
+  n1ql
+};

package/dist/chunk-YSVVB5LE.mjs

@@ -0,0 +1,43 @@
+import {
+  markup
+} from "./chunk-ACDTS7FW.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/xml-doc.js
+xmlDoc.displayName = "xml-doc";
+xmlDoc.aliases = [];
+function xmlDoc(Prism) {
+  Prism.register(markup);
+  (function(Prism2) {
+    function insertDocComment(lang, docComment) {
+      if (Prism2.languages[lang]) {
+        Prism2.languages.insertBefore(lang, "comment", {
+          "doc-comment": docComment
+        });
+      }
+    }
+    var tag = Prism2.languages.markup.tag;
+    var slashDocComment = {
+      pattern: /\/\/\/.*/,
+      greedy: true,
+      alias: "comment",
+      inside: {
+        tag
+      }
+    };
+    var tickDocComment = {
+      pattern: /'''.*/,
+      greedy: true,
+      alias: "comment",
+      inside: {
+        tag
+      }
+    };
+    insertDocComment("csharp", slashDocComment);
+    insertDocComment("fsharp", slashDocComment);
+    insertDocComment("vbnet", tickDocComment);
+  })(Prism);
+}
+
+export {
+  xmlDoc
+};

package/dist/chunk-YUZH6CL5.mjs

@@ -0,0 +1,87 @@
+import {
+  sql
+} from "./chunk-4F6TSYBP.mjs";
+import {
+  clike
+} from "./chunk-XWTEQUC3.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/apex.js
+apex.displayName = "apex";
+apex.aliases = [];
+function apex(Prism) {
+  Prism.register(clike);
+  Prism.register(sql);
+  (function(Prism2) {
+    var keywords = /\b(?:(?:after|before)(?=\s+[a-z])|abstract|activate|and|any|array|as|asc|autonomous|begin|bigdecimal|blob|boolean|break|bulk|by|byte|case|cast|catch|char|class|collect|commit|const|continue|currency|date|datetime|decimal|default|delete|desc|do|double|else|end|enum|exception|exit|export|extends|final|finally|float|for|from|get(?=\s*[{};])|global|goto|group|having|hint|if|implements|import|in|inner|insert|instanceof|int|integer|interface|into|join|like|limit|list|long|loop|map|merge|new|not|null|nulls|number|object|of|on|or|outer|override|package|parallel|pragma|private|protected|public|retrieve|return|rollback|select|set|short|sObject|sort|static|string|super|switch|synchronized|system|testmethod|then|this|throw|time|transaction|transient|trigger|try|undelete|update|upsert|using|virtual|void|webservice|when|where|while|(?:inherited|with|without)\s+sharing)\b/i;
+    var className = /\b(?:(?=[a-z_]\w*\s*[<\[])|(?!<keyword>))[A-Z_]\w*(?:\s*\.\s*[A-Z_]\w*)*\b(?:\s*(?:\[\s*\]|<(?:[^<>]|<(?:[^<>]|<[^<>]*>)*>)*>))*/.source.replace(
+      /<keyword>/g,
+      function() {
+        return keywords.source;
+      }
+    );
+    function insertClassName(pattern) {
+      return RegExp(
+        pattern.replace(/<CLASS-NAME>/g, function() {
+          return className;
+        }),
+        "i"
+      );
+    }
+    var classNameInside = {
+      keyword: keywords,
+      punctuation: /[()\[\]{};,:.<>]/
+    };
+    Prism2.languages.apex = {
+      comment: Prism2.languages.clike.comment,
+      string: Prism2.languages.clike.string,
+      sql: {
+        pattern: /((?:[=,({:]|\breturn)\s*)\[[^\[\]]*\]/i,
+        lookbehind: true,
+        greedy: true,
+        alias: "language-sql",
+        inside: Prism2.languages.sql
+      },
+      annotation: {
+        pattern: /@\w+\b/,
+        alias: "punctuation"
+      },
+      "class-name": [
+        {
+          pattern: insertClassName(
+            /(\b(?:class|enum|extends|implements|instanceof|interface|new|trigger\s+\w+\s+on)\s+)<CLASS-NAME>/.source
+          ),
+          lookbehind: true,
+          inside: classNameInside
+        },
+        {
+          // cast
+          pattern: insertClassName(
+            /(\(\s*)<CLASS-NAME>(?=\s*\)\s*[\w(])/.source
+          ),
+          lookbehind: true,
+          inside: classNameInside
+        },
+        {
+          // variable/parameter declaration and return types
+          pattern: insertClassName(/<CLASS-NAME>(?=\s*\w+\s*[;=,(){:])/.source),
+          inside: classNameInside
+        }
+      ],
+      trigger: {
+        pattern: /(\btrigger\s+)\w+\b/i,
+        lookbehind: true,
+        alias: "class-name"
+      },
+      keyword: keywords,
+      function: /\b[a-z_]\w*(?=\s*\()/i,
+      boolean: /\b(?:false|true)\b/i,
+      number: /(?:\B\.\d+|\b\d+(?:\.\d+|L)?)\b/i,
+      operator: /[!=](?:==?)?|\?\.?|&&|\|\||--|\+\+|[-+*/^&|]=?|:|<<?=?|>{1,3}=?/,
+      punctuation: /[()\[\]{};,.]/
+    };
+  })(Prism);
+}
+
+export {
+  apex
+};

package/dist/chunk-Z7F2RQLW.mjs

@@ -0,0 +1,20 @@
+import {
+  json
+} from "./chunk-AI7UQ3R6.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/jsonp.js
+jsonp.displayName = "jsonp";
+jsonp.aliases = [];
+function jsonp(Prism) {
+  Prism.register(json);
+  Prism.languages.jsonp = Prism.languages.extend("json", {
+    punctuation: /[{}[\]();,.]/
+  });
+  Prism.languages.insertBefore("jsonp", "punctuation", {
+    function: /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*(?=\s*\()/
+  });
+}
+
+export {
+  jsonp
+};

package/dist/chunk-ZA5QJ6DQ.mjs

@@ -0,0 +1,51 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/gettext.js
+gettext.displayName = "gettext";
+gettext.aliases = ["po"];
+function gettext(Prism) {
+  Prism.languages.gettext = {
+    comment: [
+      {
+        pattern: /# .*/,
+        greedy: true,
+        alias: "translator-comment"
+      },
+      {
+        pattern: /#\..*/,
+        greedy: true,
+        alias: "extracted-comment"
+      },
+      {
+        pattern: /#:.*/,
+        greedy: true,
+        alias: "reference-comment"
+      },
+      {
+        pattern: /#,.*/,
+        greedy: true,
+        alias: "flag-comment"
+      },
+      {
+        pattern: /#\|.*/,
+        greedy: true,
+        alias: "previously-untranslated-comment"
+      },
+      {
+        pattern: /#.*/,
+        greedy: true
+      }
+    ],
+    string: {
+      pattern: /(^|[^\\])"(?:[^"\\]|\\.)*"/,
+      lookbehind: true,
+      greedy: true
+    },
+    keyword: /^msg(?:ctxt|id|id_plural|str)\b/m,
+    number: /\b\d+\b/,
+    punctuation: /[\[\]]/
+  };
+  Prism.languages.po = Prism.languages.gettext;
+}
+
+export {
+  gettext
+};

package/dist/chunk-ZAI5UH3N.mjs

@@ -0,0 +1,100 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/web-idl.js
+webIdl.displayName = "web-idl";
+webIdl.aliases = ["webidl"];
+function webIdl(Prism) {
+  ;
+  (function(Prism2) {
+    var id = /(?:\B-|\b_|\b)[A-Za-z][\w-]*(?![\w-])/.source;
+    var type = "(?:" + /\b(?:unsigned\s+)?long\s+long(?![\w-])/.source + "|" + /\b(?:unrestricted|unsigned)\s+[a-z]+(?![\w-])/.source + "|" + /(?!(?:unrestricted|unsigned)\b)/.source + id + /(?:\s*<(?:[^<>]|<[^<>]*>)*>)?/.source + ")" + /(?:\s*\?)?/.source;
+    var typeInside = {};
+    Prism2.languages["web-idl"] = {
+      comment: {
+        pattern: /\/\/.*|\/\*[\s\S]*?\*\//,
+        greedy: true
+      },
+      string: {
+        pattern: /"[^"]*"/,
+        greedy: true
+      },
+      namespace: {
+        pattern: RegExp(/(\bnamespace\s+)/.source + id),
+        lookbehind: true
+      },
+      "class-name": [
+        {
+          pattern: /(^|[^\w-])(?:iterable|maplike|setlike)\s*<(?:[^<>]|<[^<>]*>)*>/,
+          lookbehind: true,
+          inside: typeInside
+        },
+        {
+          pattern: RegExp(
+            /(\b(?:attribute|const|deleter|getter|optional|setter)\s+)/.source + type
+          ),
+          lookbehind: true,
+          inside: typeInside
+        },
+        {
+          // callback return type
+          pattern: RegExp(
+            "(" + /\bcallback\s+/.source + id + /\s*=\s*/.source + ")" + type
+          ),
+          lookbehind: true,
+          inside: typeInside
+        },
+        {
+          // typedef
+          pattern: RegExp(/(\btypedef\b\s*)/.source + type),
+          lookbehind: true,
+          inside: typeInside
+        },
+        {
+          pattern: RegExp(
+            /(\b(?:callback|dictionary|enum|interface(?:\s+mixin)?)\s+)(?!(?:interface|mixin)\b)/.source + id
+          ),
+          lookbehind: true
+        },
+        {
+          // inheritance
+          pattern: RegExp(/(:\s*)/.source + id),
+          lookbehind: true
+        },
+        // includes and implements
+        RegExp(id + /(?=\s+(?:implements|includes)\b)/.source),
+        {
+          pattern: RegExp(/(\b(?:implements|includes)\s+)/.source + id),
+          lookbehind: true
+        },
+        {
+          // function return type, parameter types, and dictionary members
+          pattern: RegExp(
+            type + "(?=" + /\s*(?:\.{3}\s*)?/.source + id + /\s*[(),;=]/.source + ")"
+          ),
+          inside: typeInside
+        }
+      ],
+      builtin: /\b(?:ArrayBuffer|BigInt64Array|BigUint64Array|ByteString|DOMString|DataView|Float32Array|Float64Array|FrozenArray|Int16Array|Int32Array|Int8Array|ObservableArray|Promise|USVString|Uint16Array|Uint32Array|Uint8Array|Uint8ClampedArray)\b/,
+      keyword: [
+        /\b(?:async|attribute|callback|const|constructor|deleter|dictionary|enum|getter|implements|includes|inherit|interface|mixin|namespace|null|optional|or|partial|readonly|required|setter|static|stringifier|typedef|unrestricted)\b/,
+        // type keywords
+        /\b(?:any|bigint|boolean|byte|double|float|iterable|long|maplike|object|octet|record|sequence|setlike|short|symbol|undefined|unsigned|void)\b/
+      ],
+      boolean: /\b(?:false|true)\b/,
+      number: {
+        pattern: /(^|[^\w-])-?(?:0x[0-9a-f]+|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?|NaN|Infinity)(?![\w-])/i,
+        lookbehind: true
+      },
+      operator: /\.{3}|[=:?<>-]/,
+      punctuation: /[(){}[\].,;]/
+    };
+    for (var key in Prism2.languages["web-idl"]) {
+      if (key !== "class-name") {
+        typeInside[key] = Prism2.languages["web-idl"][key];
+      }
+    }
+    Prism2.languages["webidl"] = Prism2.languages["web-idl"];
+  })(Prism);
+}
+
+export {
+  webIdl
+};