@photonix/basic 1.5.1 → 1.6.0

package/dist/chunk-DXKGIJ7C.mjs

@@ -0,0 +1,41 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/dns-zone-file.js
+dnsZoneFile.displayName = "dns-zone-file";
+dnsZoneFile.aliases = ["dns-zone"];
+function dnsZoneFile(Prism) {
+  Prism.languages["dns-zone-file"] = {
+    comment: /;.*/,
+    string: {
+      pattern: /"(?:\\.|[^"\\\r\n])*"/,
+      greedy: true
+    },
+    variable: [
+      {
+        pattern: /(^\$ORIGIN[ \t]+)\S+/m,
+        lookbehind: true
+      },
+      {
+        pattern: /(^|\s)@(?=\s|$)/,
+        lookbehind: true
+      }
+    ],
+    keyword: /^\$(?:INCLUDE|ORIGIN|TTL)(?=\s|$)/m,
+    class: {
+      // https://tools.ietf.org/html/rfc1035#page-13
+      pattern: /(^|\s)(?:CH|CS|HS|IN)(?=\s|$)/,
+      lookbehind: true,
+      alias: "keyword"
+    },
+    type: {
+      // https://en.wikipedia.org/wiki/List_of_DNS_record_types
+      pattern: /(^|\s)(?:A|A6|AAAA|AFSDB|APL|ATMA|CAA|CDNSKEY|CDS|CERT|CNAME|DHCID|DLV|DNAME|DNSKEY|DS|EID|GID|GPOS|HINFO|HIP|IPSECKEY|ISDN|KEY|KX|LOC|MAILA|MAILB|MB|MD|MF|MG|MINFO|MR|MX|NAPTR|NB|NBSTAT|NIMLOC|NINFO|NS|NSAP|NSAP-PTR|NSEC|NSEC3|NSEC3PARAM|NULL|NXT|OPENPGPKEY|PTR|PX|RKEY|RP|RRSIG|RT|SIG|SINK|SMIMEA|SOA|SPF|SRV|SSHFP|TA|TKEY|TLSA|TSIG|TXT|UID|UINFO|UNSPEC|URI|WKS|X25)(?=\s|$)/,
+      lookbehind: true,
+      alias: "keyword"
+    },
+    punctuation: /[()]/
+  };
+  Prism.languages["dns-zone"] = Prism.languages["dns-zone-file"];
+}
+
+export {
+  dnsZoneFile
+};

package/dist/chunk-DYRZKQCY.mjs

@@ -0,0 +1,19 @@
+import {
+  t4Templating
+} from "./chunk-IOD54SQ2.mjs";
+import {
+  vbnet
+} from "./chunk-7DNV4OOB.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/t4-vb.js
+t4Vb.displayName = "t4-vb";
+t4Vb.aliases = [];
+function t4Vb(Prism) {
+  Prism.register(t4Templating);
+  Prism.register(vbnet);
+  Prism.languages["t4-vb"] = Prism.languages["t4-templating"].createT4("vbnet");
+}
+
+export {
+  t4Vb
+};

package/dist/chunk-DZ6JISBQ.mjs

@@ -0,0 +1,41 @@
+import {
+  lua
+} from "./chunk-TGPVDA2E.mjs";
+import {
+  markupTemplating
+} from "./chunk-DFNMTLAN.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/etlua.js
+etlua.displayName = "etlua";
+etlua.aliases = [];
+function etlua(Prism) {
+  Prism.register(lua);
+  Prism.register(markupTemplating);
+  (function(Prism2) {
+    Prism2.languages.etlua = {
+      delimiter: {
+        pattern: /^<%[-=]?|-?%>$/,
+        alias: "punctuation"
+      },
+      "language-lua": {
+        pattern: /[\s\S]+/,
+        inside: Prism2.languages.lua
+      }
+    };
+    Prism2.hooks.add("before-tokenize", function(env) {
+      var pattern = /<%[\s\S]+?%>/g;
+      Prism2.languages["markup-templating"].buildPlaceholders(
+        env,
+        "etlua",
+        pattern
+      );
+    });
+    Prism2.hooks.add("after-tokenize", function(env) {
+      Prism2.languages["markup-templating"].tokenizePlaceholders(env, "etlua");
+    });
+  })(Prism);
+}
+
+export {
+  etlua
+};

package/dist/chunk-DZPN45IA.mjs

@@ -0,0 +1,41 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/iecst.js
+iecst.displayName = "iecst";
+iecst.aliases = [];
+function iecst(Prism) {
+  Prism.languages.iecst = {
+    comment: [
+      {
+        pattern: /(^|[^\\])(?:\/\*[\s\S]*?(?:\*\/|$)|\(\*[\s\S]*?(?:\*\)|$)|\{[\s\S]*?(?:\}|$))/,
+        lookbehind: true,
+        greedy: true
+      },
+      {
+        pattern: /(^|[^\\:])\/\/.*/,
+        lookbehind: true,
+        greedy: true
+      }
+    ],
+    string: {
+      pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+      greedy: true
+    },
+    keyword: [
+      /\b(?:END_)?(?:PROGRAM|CONFIGURATION|INTERFACE|FUNCTION_BLOCK|FUNCTION|ACTION|TRANSITION|TYPE|STRUCT|(?:INITIAL_)?STEP|NAMESPACE|LIBRARY|CHANNEL|FOLDER|RESOURCE|VAR_(?:ACCESS|CONFIG|EXTERNAL|GLOBAL|INPUT|IN_OUT|OUTPUT|TEMP)|VAR|METHOD|PROPERTY)\b/i,
+      /\b(?:AT|BY|(?:END_)?(?:CASE|FOR|IF|REPEAT|WHILE)|CONSTANT|CONTINUE|DO|ELSE|ELSIF|EXIT|EXTENDS|FROM|GET|GOTO|IMPLEMENTS|JMP|NON_RETAIN|OF|PRIVATE|PROTECTED|PUBLIC|RETAIN|RETURN|SET|TASK|THEN|TO|UNTIL|USING|WITH|__CATCH|__ENDTRY|__FINALLY|__TRY)\b/
+    ],
+    "class-name": /\b(?:ANY|ARRAY|BOOL|BYTE|U?(?:D|L|S)?INT|(?:D|L)?WORD|DATE(?:_AND_TIME)?|DT|L?REAL|POINTER|STRING|TIME(?:_OF_DAY)?|TOD)\b/,
+    address: {
+      pattern: /%[IQM][XBWDL][\d.]*|%[IQ][\d.]*/,
+      alias: "symbol"
+    },
+    number: /\b(?:16#[\da-f]+|2#[01_]+|0x[\da-f]+)\b|\b(?:D|DT|T|TOD)#[\d_shmd:]*|\b[A-Z]*#[\d.,_]*|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
+    boolean: /\b(?:FALSE|NULL|TRUE)\b/,
+    operator: /S?R?:?=>?|&&?|\*\*?|<[=>]?|>=?|[-:^/+#]|\b(?:AND|EQ|EXPT|GE|GT|LE|LT|MOD|NE|NOT|OR|XOR)\b/,
+    function: /\b[a-z_]\w*(?=\s*\()/i,
+    punctuation: /[()[\].,;]/
+  };
+}
+
+export {
+  iecst
+};

package/dist/chunk-E3FGC5QK.mjs

@@ -0,0 +1,129 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/swift.js
+swift.displayName = "swift";
+swift.aliases = [];
+function swift(Prism) {
+  Prism.languages.swift = {
+    comment: {
+      // Nested comments are supported up to 2 levels
+      pattern: /(^|[^\\:])(?:\/\/.*|\/\*(?:[^/*]|\/(?!\*)|\*(?!\/)|\/\*(?:[^*]|\*(?!\/))*\*\/)*\*\/)/,
+      lookbehind: true,
+      greedy: true
+    },
+    "string-literal": [
+      // https://docs.swift.org/swift-book/LanguageGuide/StringsAndCharacters.html
+      {
+        pattern: RegExp(
+          /(^|[^"#])/.source + "(?:" + // single-line string
+          /"(?:\\(?:\((?:[^()]|\([^()]*\))*\)|\r\n|[^(])|[^\\\r\n"])*"/.source + "|" + // multi-line string
+          /"""(?:\\(?:\((?:[^()]|\([^()]*\))*\)|[^(])|[^\\"]|"(?!""))*"""/.source + ")" + /(?!["#])/.source
+        ),
+        lookbehind: true,
+        greedy: true,
+        inside: {
+          interpolation: {
+            pattern: /(\\\()(?:[^()]|\([^()]*\))*(?=\))/,
+            lookbehind: true,
+            inside: null
+            // see below
+          },
+          "interpolation-punctuation": {
+            pattern: /^\)|\\\($/,
+            alias: "punctuation"
+          },
+          punctuation: /\\(?=[\r\n])/,
+          string: /[\s\S]+/
+        }
+      },
+      {
+        pattern: RegExp(
+          /(^|[^"#])(#+)/.source + "(?:" + // single-line string
+          /"(?:\\(?:#+\((?:[^()]|\([^()]*\))*\)|\r\n|[^#])|[^\\\r\n])*?"/.source + "|" + // multi-line string
+          /"""(?:\\(?:#+\((?:[^()]|\([^()]*\))*\)|[^#])|[^\\])*?"""/.source + ")\\2"
+        ),
+        lookbehind: true,
+        greedy: true,
+        inside: {
+          interpolation: {
+            pattern: /(\\#+\()(?:[^()]|\([^()]*\))*(?=\))/,
+            lookbehind: true,
+            inside: null
+            // see below
+          },
+          "interpolation-punctuation": {
+            pattern: /^\)|\\#+\($/,
+            alias: "punctuation"
+          },
+          string: /[\s\S]+/
+        }
+      }
+    ],
+    directive: {
+      // directives with conditions
+      pattern: RegExp(
+        /#/.source + "(?:" + (/(?:elseif|if)\b/.source + "(?:[ 	]*" + // This regex is a little complex. It's equivalent to this:
+        //   (?:![ \t]*)?(?:\b\w+\b(?:[ \t]*<round>)?|<round>)(?:[ \t]*(?:&&|\|\|))?
+        // where <round> is a general parentheses expression.
+        /(?:![ \t]*)?(?:\b\w+\b(?:[ \t]*\((?:[^()]|\([^()]*\))*\))?|\((?:[^()]|\([^()]*\))*\))(?:[ \t]*(?:&&|\|\|))?/.source + ")+") + "|" + /(?:else|endif)\b/.source + ")"
+      ),
+      alias: "property",
+      inside: {
+        "directive-name": /^#\w+/,
+        boolean: /\b(?:false|true)\b/,
+        number: /\b\d+(?:\.\d+)*\b/,
+        operator: /!|&&|\|\||[<>]=?/,
+        punctuation: /[(),]/
+      }
+    },
+    literal: {
+      pattern: /#(?:colorLiteral|column|dsohandle|file(?:ID|Literal|Path)?|function|imageLiteral|line)\b/,
+      alias: "constant"
+    },
+    "other-directive": {
+      pattern: /#\w+\b/,
+      alias: "property"
+    },
+    attribute: {
+      pattern: /@\w+/,
+      alias: "atrule"
+    },
+    "function-definition": {
+      pattern: /(\bfunc\s+)\w+/,
+      lookbehind: true,
+      alias: "function"
+    },
+    label: {
+      // https://docs.swift.org/swift-book/LanguageGuide/ControlFlow.html#ID141
+      pattern: /\b(break|continue)\s+\w+|\b[a-zA-Z_]\w*(?=\s*:\s*(?:for|repeat|while)\b)/,
+      lookbehind: true,
+      alias: "important"
+    },
+    keyword: /\b(?:Any|Protocol|Self|Type|actor|as|assignment|associatedtype|associativity|async|await|break|case|catch|class|continue|convenience|default|defer|deinit|didSet|do|dynamic|else|enum|extension|fallthrough|fileprivate|final|for|func|get|guard|higherThan|if|import|in|indirect|infix|init|inout|internal|is|isolated|lazy|left|let|lowerThan|mutating|none|nonisolated|nonmutating|open|operator|optional|override|postfix|precedencegroup|prefix|private|protocol|public|repeat|required|rethrows|return|right|safe|self|set|some|static|struct|subscript|super|switch|throw|throws|try|typealias|unowned|unsafe|var|weak|where|while|willSet)\b/,
+    boolean: /\b(?:false|true)\b/,
+    nil: {
+      pattern: /\bnil\b/,
+      alias: "constant"
+    },
+    "short-argument": /\$\d+\b/,
+    omit: {
+      pattern: /\b_\b/,
+      alias: "keyword"
+    },
+    number: /\b(?:[\d_]+(?:\.[\de_]+)?|0x[a-f0-9_]+(?:\.[a-f0-9p_]+)?|0b[01_]+|0o[0-7_]+)\b/i,
+    // A class name must start with an upper-case letter and be either 1 letter long or contain a lower-case letter.
+    "class-name": /\b[A-Z](?:[A-Z_\d]*[a-z]\w*)?\b/,
+    function: /\b[a-z_]\w*(?=\s*\()/i,
+    constant: /\b(?:[A-Z_]{2,}|k[A-Z][A-Za-z_]+)\b/,
+    // Operators are generic in Swift. Developers can even create new operators (e.g. +++).
+    // https://docs.swift.org/swift-book/ReferenceManual/zzSummaryOfTheGrammar.html#ID481
+    // This regex only supports ASCII operators.
+    operator: /[-+*/%=!<>&|^~?]+|\.[.\-+*/%=!<>&|^~?]+/,
+    punctuation: /[{}[\]();,.:\\]/
+  };
+  Prism.languages.swift["string-literal"].forEach(function(rule) {
+    rule.inside["interpolation"].inside = Prism.languages.swift;
+  });
+}
+
+export {
+  swift
+};

package/dist/chunk-E6A2MK2O.mjs

@@ -0,0 +1,63 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/toml.js
+toml.displayName = "toml";
+toml.aliases = [];
+function toml(Prism) {
+  ;
+  (function(Prism2) {
+    var key = /(?:[\w-]+|'[^'\n\r]*'|"(?:\\.|[^\\"\r\n])*")/.source;
+    function insertKey(pattern) {
+      return pattern.replace(/__/g, function() {
+        return key;
+      });
+    }
+    Prism2.languages.toml = {
+      comment: {
+        pattern: /#.*/,
+        greedy: true
+      },
+      table: {
+        pattern: RegExp(
+          insertKey(
+            /(^[\t ]*\[\s*(?:\[\s*)?)__(?:\s*\.\s*__)*(?=\s*\])/.source
+          ),
+          "m"
+        ),
+        lookbehind: true,
+        greedy: true,
+        alias: "class-name"
+      },
+      key: {
+        pattern: RegExp(
+          insertKey(/(^[\t ]*|[{,]\s*)__(?:\s*\.\s*__)*(?=\s*=)/.source),
+          "m"
+        ),
+        lookbehind: true,
+        greedy: true,
+        alias: "property"
+      },
+      string: {
+        pattern: /"""(?:\\[\s\S]|[^\\])*?"""|'''[\s\S]*?'''|'[^'\n\r]*'|"(?:\\.|[^\\"\r\n])*"/,
+        greedy: true
+      },
+      date: [
+        {
+          // Offset Date-Time, Local Date-Time, Local Date
+          pattern: /\b\d{4}-\d{2}-\d{2}(?:[T\s]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?)?\b/i,
+          alias: "number"
+        },
+        {
+          // Local Time
+          pattern: /\b\d{2}:\d{2}:\d{2}(?:\.\d+)?\b/,
+          alias: "number"
+        }
+      ],
+      number: /(?:\b0(?:x[\da-zA-Z]+(?:_[\da-zA-Z]+)*|o[0-7]+(?:_[0-7]+)*|b[10]+(?:_[10]+)*))\b|[-+]?\b\d+(?:_\d+)*(?:\.\d+(?:_\d+)*)?(?:[eE][+-]?\d+(?:_\d+)*)?\b|[-+]?\b(?:inf|nan)\b/,
+      boolean: /\b(?:false|true)\b/,
+      punctuation: /[.,=[\]{}]/
+    };
+  })(Prism);
+}
+
+export {
+  toml
+};

package/dist/chunk-ECKDOL3W.mjs

@@ -0,0 +1,39 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/clojure.js
+clojure.displayName = "clojure";
+clojure.aliases = [];
+function clojure(Prism) {
+  Prism.languages.clojure = {
+    comment: {
+      pattern: /;.*/,
+      greedy: true
+    },
+    string: {
+      pattern: /"(?:[^"\\]|\\.)*"/,
+      greedy: true
+    },
+    char: /\\\w+/,
+    symbol: {
+      pattern: /(^|[\s()\[\]{},])::?[\w*+!?'<>=/.-]+/,
+      lookbehind: true
+    },
+    keyword: {
+      pattern: /(\()(?:-|->|->>|\.|\.\.|\*|\/|\+|<|<=|=|==|>|>=|accessor|agent|agent-errors|aget|alength|all-ns|alter|and|append-child|apply|array-map|aset|aset-boolean|aset-byte|aset-char|aset-double|aset-float|aset-int|aset-long|aset-short|assert|assoc|await|await-for|bean|binding|bit-and|bit-not|bit-or|bit-shift-left|bit-shift-right|bit-xor|boolean|branch\?|butlast|byte|cast|char|children|class|clear-agent-errors|comment|commute|comp|comparator|complement|concat|cond|conj|cons|constantly|construct-proxy|contains\?|count|create-ns|create-struct|cycle|dec|declare|def|def-|definline|definterface|defmacro|defmethod|defmulti|defn|defn-|defonce|defproject|defprotocol|defrecord|defstruct|deftype|deref|difference|disj|dissoc|distinct|do|doall|doc|dorun|doseq|dosync|dotimes|doto|double|down|drop|drop-while|edit|end\?|ensure|eval|every\?|false\?|ffirst|file-seq|filter|find|find-doc|find-ns|find-var|first|float|flush|fn|fnseq|for|frest|gensym|get|get-proxy-class|hash-map|hash-set|identical\?|identity|if|if-let|if-not|import|in-ns|inc|index|insert-child|insert-left|insert-right|inspect-table|inspect-tree|instance\?|int|interleave|intersection|into|into-array|iterate|join|key|keys|keyword|keyword\?|last|lazy-cat|lazy-cons|left|lefts|let|line-seq|list|list\*|load|load-file|locking|long|loop|macroexpand|macroexpand-1|make-array|make-node|map|map-invert|map\?|mapcat|max|max-key|memfn|merge|merge-with|meta|min|min-key|monitor-enter|name|namespace|neg\?|new|newline|next|nil\?|node|not|not-any\?|not-every\?|not=|ns|ns-imports|ns-interns|ns-map|ns-name|ns-publics|ns-refers|ns-resolve|ns-unmap|nth|nthrest|or|parse|partial|path|peek|pop|pos\?|pr|pr-str|print|print-str|println|println-str|prn|prn-str|project|proxy|proxy-mappings|quot|quote|rand|rand-int|range|re-find|re-groups|re-matcher|re-matches|re-pattern|re-seq|read|read-line|recur|reduce|ref|ref-set|refer|rem|remove|remove-method|remove-ns|rename|rename-keys|repeat|replace|replicate|resolve|rest|resultset-seq|reverse|rfirst|right|rights|root|rrest|rseq|second|select|select-keys|send|send-off|seq|seq-zip|seq\?|set|set!|short|slurp|some|sort|sort-by|sorted-map|sorted-map-by|sorted-set|special-symbol\?|split-at|split-with|str|string\?|struct|struct-map|subs|subvec|symbol|symbol\?|sync|take|take-nth|take-while|test|throw|time|to-array|to-array-2d|tree-seq|true\?|try|union|up|update-proxy|val|vals|var|var-get|var-set|var\?|vector|vector-zip|vector\?|when|when-first|when-let|when-not|with-local-vars|with-meta|with-open|with-out-str|xml-seq|xml-zip|zero\?|zipmap|zipper)(?=[\s)]|$)/,
+      lookbehind: true
+    },
+    boolean: /\b(?:false|nil|true)\b/,
+    number: {
+      pattern: /(^|[^\w$@])(?:\d+(?:[/.]\d+)?(?:e[+-]?\d+)?|0x[a-f0-9]+|[1-9]\d?r[a-z0-9]+)[lmn]?(?![\w$@])/i,
+      lookbehind: true
+    },
+    function: {
+      pattern: /((?:^|[^'])\()[\w*+!?'<>=/.-]+(?=[\s)]|$)/,
+      lookbehind: true
+    },
+    operator: /[#@^`~]/,
+    punctuation: /[{}\[\](),]/
+  };
+}
+
+export {
+  clojure
+};

package/dist/chunk-EH6HRGXI.mjs

@@ -0,0 +1,49 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/ini.js
+ini.displayName = "ini";
+ini.aliases = [];
+function ini(Prism) {
+  Prism.languages.ini = {
+    /**
+     * The component mimics the behavior of the Win32 API parser.
+     *
+     * @see {@link https://github.com/PrismJS/prism/issues/2775#issuecomment-787477723}
+     */
+    comment: {
+      pattern: /(^[ \f\t\v]*)[#;][^\n\r]*/m,
+      lookbehind: true
+    },
+    section: {
+      pattern: /(^[ \f\t\v]*)\[[^\n\r\]]*\]?/m,
+      lookbehind: true,
+      inside: {
+        "section-name": {
+          pattern: /(^\[[ \f\t\v]*)[^ \f\t\v\]]+(?:[ \f\t\v]+[^ \f\t\v\]]+)*/,
+          lookbehind: true,
+          alias: "selector"
+        },
+        punctuation: /\[|\]/
+      }
+    },
+    key: {
+      pattern: /(^[ \f\t\v]*)[^ \f\n\r\t\v=]+(?:[ \f\t\v]+[^ \f\n\r\t\v=]+)*(?=[ \f\t\v]*=)/m,
+      lookbehind: true,
+      alias: "attr-name"
+    },
+    value: {
+      pattern: /(=[ \f\t\v]*)[^ \f\n\r\t\v]+(?:[ \f\t\v]+[^ \f\n\r\t\v]+)*/,
+      lookbehind: true,
+      alias: "attr-value",
+      inside: {
+        "inner-value": {
+          pattern: /^("|').+(?=\1$)/,
+          lookbehind: true
+        }
+      }
+    },
+    punctuation: /=/
+  };
+}
+
+export {
+  ini
+};

package/dist/chunk-EKYNALLO.mjs

@@ -0,0 +1,29 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/bbj.js
+bbj.displayName = "bbj";
+bbj.aliases = [];
+function bbj(Prism) {
+  ;
+  (function(Prism2) {
+    Prism2.languages.bbj = {
+      comment: {
+        pattern: /(^|[^\\:])rem\s+.*/i,
+        lookbehind: true,
+        greedy: true
+      },
+      string: {
+        pattern: /(['"])(?:(?!\1|\\).|\\.)*\1/,
+        greedy: true
+      },
+      number: /(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:E[+-]?\d+)?/i,
+      keyword: /\b(?:abstract|all|argc|begin|bye|callback|case|chn|class|classend|ctl|day|declare|delete|dim|dom|dread|dsz|else|end|endif|err|exitto|extends|fi|field|for|from|gosub|goto|if|implements|interface|interfaceend|iol|iolist|let|list|load|method|methodend|methodret|on|opts|pfx|print|private|process_events|protected|psz|public|read|read_resource|release|remove_callback|repeat|restore|return|rev|seterr|setesc|sqlchn|sqlunt|ssn|start|static|swend|switch|sys|then|tim|unt|until|use|void|wend|where|while)\b/i,
+      function: /\b\w+(?=\()/,
+      boolean: /\b(?:BBjAPI\.TRUE|BBjAPI\.FALSE)\b/i,
+      operator: /<[=>]?|>=?|[+\-*\/^=&]|\b(?:and|not|or|xor)\b/i,
+      punctuation: /[.,;:()]/
+    };
+  })(Prism);
+}
+
+export {
+  bbj
+};

package/dist/chunk-ELI7PF5E.mjs

@@ -0,0 +1,83 @@
+import {
+  css
+} from "./chunk-4RG7ZGOZ.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/sass.js
+sass.displayName = "sass";
+sass.aliases = [];
+function sass(Prism) {
+  Prism.register(css);
+  (function(Prism2) {
+    Prism2.languages.sass = Prism2.languages.extend("css", {
+      // Sass comments don't need to be closed, only indented
+      comment: {
+        pattern: /^([ \t]*)\/[\/*].*(?:(?:\r?\n|\r)\1[ \t].+)*/m,
+        lookbehind: true,
+        greedy: true
+      }
+    });
+    Prism2.languages.insertBefore("sass", "atrule", {
+      // We want to consume the whole line
+      "atrule-line": {
+        // Includes support for = and + shortcuts
+        pattern: /^(?:[ \t]*)[@+=].+/m,
+        greedy: true,
+        inside: {
+          atrule: /(?:@[\w-]+|[+=])/
+        }
+      }
+    });
+    delete Prism2.languages.sass.atrule;
+    var variable = /\$[-\w]+|#\{\$[-\w]+\}/;
+    var operator = [
+      /[+*\/%]|[=!]=|<=?|>=?|\b(?:and|not|or)\b/,
+      {
+        pattern: /(\s)-(?=\s)/,
+        lookbehind: true
+      }
+    ];
+    Prism2.languages.insertBefore("sass", "property", {
+      // We want to consume the whole line
+      "variable-line": {
+        pattern: /^[ \t]*\$.+/m,
+        greedy: true,
+        inside: {
+          punctuation: /:/,
+          variable,
+          operator
+        }
+      },
+      // We want to consume the whole line
+      "property-line": {
+        pattern: /^[ \t]*(?:[^:\s]+ *:.*|:[^:\s].*)/m,
+        greedy: true,
+        inside: {
+          property: [
+            /[^:\s]+(?=\s*:)/,
+            {
+              pattern: /(:)[^:\s]+/,
+              lookbehind: true
+            }
+          ],
+          punctuation: /:/,
+          variable,
+          operator,
+          important: Prism2.languages.sass.important
+        }
+      }
+    });
+    delete Prism2.languages.sass.property;
+    delete Prism2.languages.sass.important;
+    Prism2.languages.insertBefore("sass", "punctuation", {
+      selector: {
+        pattern: /^([ \t]*)\S(?:,[^,\r\n]+|[^,\r\n]*)(?:,[^,\r\n]+)*(?:,(?:\r?\n|\r)\1[ \t]+\S(?:,[^,\r\n]+|[^,\r\n]*)(?:,[^,\r\n]+)*)*/m,
+        lookbehind: true,
+        greedy: true
+      }
+    });
+  })(Prism);
+}
+
+export {
+  sass
+};

package/dist/chunk-EM33YS3S.mjs

@@ -0,0 +1,89 @@
+import {
+  javascript
+} from "./chunk-ZJYVOTZA.mjs";
+
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/qml.js
+qml.displayName = "qml";
+qml.aliases = [];
+function qml(Prism) {
+  Prism.register(javascript);
+  (function(Prism2) {
+    var jsString = /"(?:\\.|[^\\"\r\n])*"|'(?:\\.|[^\\'\r\n])*'/.source;
+    var jsComment = /\/\/.*(?!.)|\/\*(?:[^*]|\*(?!\/))*\*\//.source;
+    var jsExpr = /(?:[^\\()[\]{}"'/]|<string>|\/(?![*/])|<comment>|\(<expr>*\)|\[<expr>*\]|\{<expr>*\}|\\[\s\S])/.source.replace(/<string>/g, function() {
+      return jsString;
+    }).replace(/<comment>/g, function() {
+      return jsComment;
+    });
+    for (var i = 0; i < 2; i++) {
+      jsExpr = jsExpr.replace(/<expr>/g, function() {
+        return jsExpr;
+      });
+    }
+    jsExpr = jsExpr.replace(/<expr>/g, "[^\\s\\S]");
+    Prism2.languages.qml = {
+      comment: {
+        pattern: /\/\/.*|\/\*[\s\S]*?\*\//,
+        greedy: true
+      },
+      "javascript-function": {
+        pattern: RegExp(
+          /((?:^|;)[ \t]*)function\s+(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*\s*\(<js>*\)\s*\{<js>*\}/.source.replace(
+            /<js>/g,
+            function() {
+              return jsExpr;
+            }
+          ),
+          "m"
+        ),
+        lookbehind: true,
+        greedy: true,
+        alias: "language-javascript",
+        inside: Prism2.languages.javascript
+      },
+      "class-name": {
+        pattern: /((?:^|[:;])[ \t]*)(?!\d)\w+(?=[ \t]*\{|[ \t]+on\b)/m,
+        lookbehind: true
+      },
+      property: [
+        {
+          pattern: /((?:^|[;{])[ \t]*)(?!\d)\w+(?:\.\w+)*(?=[ \t]*:)/m,
+          lookbehind: true
+        },
+        {
+          pattern: /((?:^|[;{])[ \t]*)property[ \t]+(?!\d)\w+(?:\.\w+)*[ \t]+(?!\d)\w+(?:\.\w+)*(?=[ \t]*:)/m,
+          lookbehind: true,
+          inside: {
+            keyword: /^property/,
+            property: /\w+(?:\.\w+)*/
+          }
+        }
+      ],
+      "javascript-expression": {
+        pattern: RegExp(
+          /(:[ \t]*)(?![\s;}[])(?:(?!$|[;}])<js>)+/.source.replace(
+            /<js>/g,
+            function() {
+              return jsExpr;
+            }
+          ),
+          "m"
+        ),
+        lookbehind: true,
+        greedy: true,
+        alias: "language-javascript",
+        inside: Prism2.languages.javascript
+      },
+      string: {
+        pattern: /"(?:\\.|[^\\"\r\n])*"/,
+        greedy: true
+      },
+      keyword: /\b(?:as|import|on)\b/,
+      punctuation: /[{}[\]:;,]/
+    };
+  })(Prism);
+}
+
+export {
+  qml
+};

package/dist/chunk-EO74FIEH.mjs

@@ -0,0 +1,37 @@
+// ../../node_modules/.pnpm/refractor@5.0.0/node_modules/refractor/lang/j.js
+j.displayName = "j";
+j.aliases = [];
+function j(Prism) {
+  Prism.languages.j = {
+    comment: {
+      pattern: /\bNB\..*/,
+      greedy: true
+    },
+    string: {
+      pattern: /'(?:''|[^'\r\n])*'/,
+      greedy: true
+    },
+    keyword: /\b(?:(?:CR|LF|adverb|conjunction|def|define|dyad|monad|noun|verb)\b|(?:assert|break|case|catch[dt]?|continue|do|else|elseif|end|fcase|for|for_\w+|goto_\w+|if|label_\w+|return|select|throw|try|while|whilst)\.)/,
+    verb: {
+      // Negative look-ahead prevents bad highlighting
+      // of ^: ;. =. =: !. !:
+      pattern: /(?!\^:|;\.|[=!][.:])(?:\{(?:\.|::?)?|p(?:\.\.?|:)|[=!\]]|[<>+*\-%$|,#][.:]?|[?^]\.?|[;\[]:?|[~}"i][.:]|[ACeEIjLor]\.|(?:[_\/\\qsux]|_?\d):)/,
+      alias: "keyword"
+    },
+    number: /\b_?(?:(?!\d:)\d+(?:\.\d+)?(?:(?:ad|ar|[ejpx])_?\d+(?:\.\d+)?)*(?:b_?[\da-z]+(?:\.[\da-z]+)?)?|_\b(?!\.))/,
+    adverb: {
+      pattern: /[~}]|[\/\\]\.?|[bfM]\.|t[.:]/,
+      alias: "builtin"
+    },
+    operator: /[=a][.:]|_\./,
+    conjunction: {
+      pattern: /&(?:\.:?|:)?|[.:@][.:]?|[!D][.:]|[;dHT]\.|`:?|[\^LS]:|"/,
+      alias: "variable"
+    },
+    punctuation: /[()]/
+  };
+}
+
+export {
+  j
+};