@photonix/basic 2.2.1 → 3.0.0

package/dist/chunk-XY4A63YZ.mjs

@@ -1,97 +0,0 @@
-// ../../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

@@ -1,47 +0,0 @@
-// ../../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

@@ -1,41 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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

@@ -1,31 +0,0 @@
-// ../../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

@@ -1,43 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,51 +0,0 @@
-// ../../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

@@ -1,100 +0,0 @@
-// ../../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
-};