@oscloudlab/knowledge-card 0.0.1 → 0.0.3

package/dist/swift-B7UDjEPv.js

@@ -0,0 +1,162 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: () => e[k]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var swift_1;
+var hasRequiredSwift;
+function requireSwift() {
+  if (hasRequiredSwift) return swift_1;
+  hasRequiredSwift = 1;
+  swift_1 = swift2;
+  swift2.displayName = "swift";
+  swift2.aliases = [];
+  function swift2(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;
+    });
+  }
+  return swift_1;
+}
+var swiftExports = requireSwift();
+const swift = /* @__PURE__ */ getDefaultExportFromCjs(swiftExports);
+const swift$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: swift
+}, [swiftExports]);
+export {
+  swift$1 as s
+};
+//# sourceMappingURL=swift-B7UDjEPv.js.map

package/dist/swift-B7UDjEPv.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"swift-B7UDjEPv.js","sources":["../node_modules/refractor/lang/swift.js"],"sourcesContent":["'use strict'\n\nmodule.exports = swift\nswift.displayName = 'swift'\nswift.aliases = []\nfunction swift(Prism) {\n  Prism.languages.swift = {\n    comment: {\n      // Nested comments are supported up to 2 levels\n      pattern:\n        /(^|[^\\\\:])(?:\\/\\/.*|\\/\\*(?:[^/*]|\\/(?!\\*)|\\*(?!\\/)|\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/)*\\*\\/)/,\n      lookbehind: true,\n      greedy: true\n    },\n    'string-literal': [\n      // https://docs.swift.org/swift-book/LanguageGuide/StringsAndCharacters.html\n      {\n        pattern: RegExp(\n          /(^|[^\"#])/.source +\n            '(?:' + // single-line string\n            /\"(?:\\\\(?:\\((?:[^()]|\\([^()]*\\))*\\)|\\r\\n|[^(])|[^\\\\\\r\\n\"])*\"/\n              .source +\n            '|' + // multi-line string\n            /\"\"\"(?:\\\\(?:\\((?:[^()]|\\([^()]*\\))*\\)|[^(])|[^\\\\\"]|\"(?!\"\"))*\"\"\"/\n              .source +\n            ')' +\n            /(?![\"#])/.source\n        ),\n        lookbehind: true,\n        greedy: true,\n        inside: {\n          interpolation: {\n            pattern: /(\\\\\\()(?:[^()]|\\([^()]*\\))*(?=\\))/,\n            lookbehind: true,\n            inside: null // see below\n          },\n          'interpolation-punctuation': {\n            pattern: /^\\)|\\\\\\($/,\n            alias: 'punctuation'\n          },\n          punctuation: /\\\\(?=[\\r\\n])/,\n          string: /[\\s\\S]+/\n        }\n      },\n      {\n        pattern: RegExp(\n          /(^|[^\"#])(#+)/.source +\n            '(?:' + // single-line string\n            /\"(?:\\\\(?:#+\\((?:[^()]|\\([^()]*\\))*\\)|\\r\\n|[^#])|[^\\\\\\r\\n])*?\"/\n              .source +\n            '|' + // multi-line string\n            /\"\"\"(?:\\\\(?:#+\\((?:[^()]|\\([^()]*\\))*\\)|[^#])|[^\\\\])*?\"\"\"/.source +\n            ')' +\n            '\\\\2'\n        ),\n        lookbehind: true,\n        greedy: true,\n        inside: {\n          interpolation: {\n            pattern: /(\\\\#+\\()(?:[^()]|\\([^()]*\\))*(?=\\))/,\n            lookbehind: true,\n            inside: null // see below\n          },\n          'interpolation-punctuation': {\n            pattern: /^\\)|\\\\#+\\($/,\n            alias: 'punctuation'\n          },\n          string: /[\\s\\S]+/\n        }\n      }\n    ],\n    directive: {\n      // directives with conditions\n      pattern: RegExp(\n        /#/.source +\n          '(?:' +\n          (/(?:elseif|if)\\b/.source +\n            '(?:[ \\t]*' + // This regex is a little complex. It's equivalent to this:\n            //   (?:![ \\t]*)?(?:\\b\\w+\\b(?:[ \\t]*<round>)?|<round>)(?:[ \\t]*(?:&&|\\|\\|))?\n            // where <round> is a general parentheses expression.\n            /(?:![ \\t]*)?(?:\\b\\w+\\b(?:[ \\t]*\\((?:[^()]|\\([^()]*\\))*\\))?|\\((?:[^()]|\\([^()]*\\))*\\))(?:[ \\t]*(?:&&|\\|\\|))?/\n              .source +\n            ')+') +\n          '|' +\n          /(?:else|endif)\\b/.source +\n          ')'\n      ),\n      alias: 'property',\n      inside: {\n        'directive-name': /^#\\w+/,\n        boolean: /\\b(?:false|true)\\b/,\n        number: /\\b\\d+(?:\\.\\d+)*\\b/,\n        operator: /!|&&|\\|\\||[<>]=?/,\n        punctuation: /[(),]/\n      }\n    },\n    literal: {\n      pattern:\n        /#(?:colorLiteral|column|dsohandle|file(?:ID|Literal|Path)?|function|imageLiteral|line)\\b/,\n      alias: 'constant'\n    },\n    'other-directive': {\n      pattern: /#\\w+\\b/,\n      alias: 'property'\n    },\n    attribute: {\n      pattern: /@\\w+/,\n      alias: 'atrule'\n    },\n    'function-definition': {\n      pattern: /(\\bfunc\\s+)\\w+/,\n      lookbehind: true,\n      alias: 'function'\n    },\n    label: {\n      // https://docs.swift.org/swift-book/LanguageGuide/ControlFlow.html#ID141\n      pattern:\n        /\\b(break|continue)\\s+\\w+|\\b[a-zA-Z_]\\w*(?=\\s*:\\s*(?:for|repeat|while)\\b)/,\n      lookbehind: true,\n      alias: 'important'\n    },\n    keyword:\n      /\\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/,\n    boolean: /\\b(?:false|true)\\b/,\n    nil: {\n      pattern: /\\bnil\\b/,\n      alias: 'constant'\n    },\n    'short-argument': /\\$\\d+\\b/,\n    omit: {\n      pattern: /\\b_\\b/,\n      alias: 'keyword'\n    },\n    number:\n      /\\b(?:[\\d_]+(?:\\.[\\de_]+)?|0x[a-f0-9_]+(?:\\.[a-f0-9p_]+)?|0b[01_]+|0o[0-7_]+)\\b/i,\n    // A class name must start with an upper-case letter and be either 1 letter long or contain a lower-case letter.\n    'class-name': /\\b[A-Z](?:[A-Z_\\d]*[a-z]\\w*)?\\b/,\n    function: /\\b[a-z_]\\w*(?=\\s*\\()/i,\n    constant: /\\b(?:[A-Z_]{2,}|k[A-Z][A-Za-z_]+)\\b/,\n    // Operators are generic in Swift. Developers can even create new operators (e.g. +++).\n    // https://docs.swift.org/swift-book/ReferenceManual/zzSummaryOfTheGrammar.html#ID481\n    // This regex only supports ASCII operators.\n    operator: /[-+*/%=!<>&|^~?]+|\\.[.\\-+*/%=!<>&|^~?]+/,\n    punctuation: /[{}[\\]();,.:\\\\]/\n  }\n  Prism.languages.swift['string-literal'].forEach(function (rule) {\n    rule.inside['interpolation'].inside = Prism.languages.swift\n  })\n}\n"],"names":["swift"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,YAAiBA;AACjB,EAAAA,OAAM,cAAc;AACpB,EAAAA,OAAM,UAAU,CAAA;AAChB,WAASA,OAAM,OAAO;AACpB,UAAM,UAAU,QAAQ;AAAA,MACtB,SAAS;AAAA;AAAA,QAEP,SACE;AAAA,QACF,YAAY;AAAA,QACZ,QAAQ;AAAA;MAEV,kBAAkB;AAAA;AAAA,QAEhB;AAAA,UACE,SAAS;AAAA,YACP,YAAY,SACV;AAAA,YACA,8DACG,SACH;AAAA,YACA,iEACG,SACH,MACA,WAAW;AAAA;UAEf,YAAY;AAAA,UACZ,QAAQ;AAAA,UACR,QAAQ;AAAA,YACN,eAAe;AAAA,cACb,SAAS;AAAA,cACT,YAAY;AAAA,cACZ,QAAQ;AAAA;AAAA;YAEV,6BAA6B;AAAA,cAC3B,SAAS;AAAA,cACT,OAAO;AAAA;YAET,aAAa;AAAA,YACb,QAAQ;AAAA;;QAGZ;AAAA,UACE,SAAS;AAAA,YACP,gBAAgB,SACd;AAAA,YACA,gEACG,SACH;AAAA,YACA,2DAA2D,SAC3D;AAAA;UAGJ,YAAY;AAAA,UACZ,QAAQ;AAAA,UACR,QAAQ;AAAA,YACN,eAAe;AAAA,cACb,SAAS;AAAA,cACT,YAAY;AAAA,cACZ,QAAQ;AAAA;AAAA;YAEV,6BAA6B;AAAA,cAC3B,SAAS;AAAA,cACT,OAAO;AAAA;YAET,QAAQ;AAAA;;;MAId,WAAW;AAAA;AAAA,QAET,SAAS;AAAA,UACP,IAAI,SACF,SACC,kBAAkB,SACjB;AAAA;AAAA;AAAA,UAGA,8GACG,SACH,QACF,MACA,mBAAmB,SACnB;AAAA;QAEJ,OAAO;AAAA,QACP,QAAQ;AAAA,UACN,kBAAkB;AAAA,UAClB,SAAS;AAAA,UACT,QAAQ;AAAA,UACR,UAAU;AAAA,UACV,aAAa;AAAA;;MAGjB,SAAS;AAAA,QACP,SACE;AAAA,QACF,OAAO;AAAA;MAET,mBAAmB;AAAA,QACjB,SAAS;AAAA,QACT,OAAO;AAAA;MAET,WAAW;AAAA,QACT,SAAS;AAAA,QACT,OAAO;AAAA;MAET,uBAAuB;AAAA,QACrB,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,OAAO;AAAA;MAET,OAAO;AAAA;AAAA,QAEL,SACE;AAAA,QACF,YAAY;AAAA,QACZ,OAAO;AAAA;MAET,SACE;AAAA,MACF,SAAS;AAAA,MACT,KAAK;AAAA,QACH,SAAS;AAAA,QACT,OAAO;AAAA;MAET,kBAAkB;AAAA,MAClB,MAAM;AAAA,QACJ,SAAS;AAAA,QACT,OAAO;AAAA;MAET,QACE;AAAA;AAAA,MAEF,cAAc;AAAA,MACd,UAAU;AAAA,MACV,UAAU;AAAA;AAAA;AAAA;AAAA,MAIV,UAAU;AAAA,MACV,aAAa;AAAA;AAEf,UAAM,UAAU,MAAM,gBAAgB,EAAE,QAAQ,SAAU,MAAM;AAC9D,WAAK,OAAO,eAAe,EAAE,SAAS,MAAM,UAAU;AAAA,IAC1D,CAAG;AAAA,EACH;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/systemd-Bd53Ny4S.js

@@ -0,0 +1,97 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: () => e[k]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var systemd_1;
+var hasRequiredSystemd;
+function requireSystemd() {
+  if (hasRequiredSystemd) return systemd_1;
+  hasRequiredSystemd = 1;
+  systemd_1 = systemd2;
+  systemd2.displayName = "systemd";
+  systemd2.aliases = [];
+  function systemd2(Prism) {
+    (function(Prism2) {
+      var comment = {
+        pattern: /^[;#].*/m,
+        greedy: true
+      };
+      var quotesSource = /"(?:[^\r\n"\\]|\\(?:[^\r]|\r\n?))*"(?!\S)/.source;
+      Prism2.languages.systemd = {
+        comment,
+        section: {
+          pattern: /^\[[^\n\r\[\]]*\](?=[ \t]*$)/m,
+          greedy: true,
+          inside: {
+            punctuation: /^\[|\]$/,
+            "section-name": {
+              pattern: /[\s\S]+/,
+              alias: "selector"
+            }
+          }
+        },
+        key: {
+          pattern: /^[^\s=]+(?=[ \t]*=)/m,
+          greedy: true,
+          alias: "attr-name"
+        },
+        value: {
+          // This pattern is quite complex because of two properties:
+          //  1) Quotes (strings) must be preceded by a space. Since we can't use lookbehinds, we have to "resolve"
+          //     the lookbehind. You will see this in the main loop where spaces are handled separately.
+          //  2) Line continuations.
+          //     After line continuations, empty lines and comments are ignored so we have to consume them.
+          pattern: RegExp(
+            /(=[ \t]*(?!\s))/.source + // the value either starts with quotes or not
+            "(?:" + quotesSource + '|(?=[^"\r\n]))(?:' + (/[^\s\\]/.source + // handle spaces separately because of quotes
+            '|[ 	]+(?:(?![ 	"])|' + quotesSource + ")|" + /\\[\r\n]+(?:[#;].*[\r\n]+)*(?![#;])/.source) + ")*"
+          ),
+          lookbehind: true,
+          greedy: true,
+          alias: "attr-value",
+          inside: {
+            comment,
+            quoted: {
+              pattern: RegExp(/(^|\s)/.source + quotesSource),
+              lookbehind: true,
+              greedy: true
+            },
+            punctuation: /\\$/m,
+            boolean: {
+              pattern: /^(?:false|no|off|on|true|yes)$/,
+              greedy: true
+            }
+          }
+        },
+        punctuation: /=/
+      };
+    })(Prism);
+  }
+  return systemd_1;
+}
+var systemdExports = requireSystemd();
+const systemd = /* @__PURE__ */ getDefaultExportFromCjs(systemdExports);
+const systemd$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: systemd
+}, [systemdExports]);
+export {
+  systemd$1 as s
+};
+//# sourceMappingURL=systemd-Bd53Ny4S.js.map

package/dist/systemd-Bd53Ny4S.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"systemd-Bd53Ny4S.js","sources":["../node_modules/refractor/lang/systemd.js"],"sourcesContent":["'use strict'\n\nmodule.exports = systemd\nsystemd.displayName = 'systemd'\nsystemd.aliases = []\nfunction systemd(Prism) {\n  // https://www.freedesktop.org/software/systemd/man/systemd.syntax.html\n  ;(function (Prism) {\n    var comment = {\n      pattern: /^[;#].*/m,\n      greedy: true\n    }\n    var quotesSource = /\"(?:[^\\r\\n\"\\\\]|\\\\(?:[^\\r]|\\r\\n?))*\"(?!\\S)/.source\n    Prism.languages.systemd = {\n      comment: comment,\n      section: {\n        pattern: /^\\[[^\\n\\r\\[\\]]*\\](?=[ \\t]*$)/m,\n        greedy: true,\n        inside: {\n          punctuation: /^\\[|\\]$/,\n          'section-name': {\n            pattern: /[\\s\\S]+/,\n            alias: 'selector'\n          }\n        }\n      },\n      key: {\n        pattern: /^[^\\s=]+(?=[ \\t]*=)/m,\n        greedy: true,\n        alias: 'attr-name'\n      },\n      value: {\n        // This pattern is quite complex because of two properties:\n        //  1) Quotes (strings) must be preceded by a space. Since we can't use lookbehinds, we have to \"resolve\"\n        //     the lookbehind. You will see this in the main loop where spaces are handled separately.\n        //  2) Line continuations.\n        //     After line continuations, empty lines and comments are ignored so we have to consume them.\n        pattern: RegExp(\n          /(=[ \\t]*(?!\\s))/.source + // the value either starts with quotes or not\n            '(?:' +\n            quotesSource +\n            '|(?=[^\"\\r\\n]))' + // main loop\n            '(?:' +\n            (/[^\\s\\\\]/.source + // handle spaces separately because of quotes\n              '|' +\n              '[ \\t]+(?:(?![ \\t\"])|' +\n              quotesSource +\n              ')' + // line continuation\n              '|' +\n              /\\\\[\\r\\n]+(?:[#;].*[\\r\\n]+)*(?![#;])/.source) +\n            ')*'\n        ),\n        lookbehind: true,\n        greedy: true,\n        alias: 'attr-value',\n        inside: {\n          comment: comment,\n          quoted: {\n            pattern: RegExp(/(^|\\s)/.source + quotesSource),\n            lookbehind: true,\n            greedy: true\n          },\n          punctuation: /\\\\$/m,\n          boolean: {\n            pattern: /^(?:false|no|off|on|true|yes)$/,\n            greedy: true\n          }\n        }\n      },\n      punctuation: /=/\n    }\n  })(Prism)\n}\n"],"names":["systemd","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,cAAiBA;AACjB,EAAAA,SAAQ,cAAc;AACtB,EAAAA,SAAQ,UAAU,CAAA;AAClB,WAASA,SAAQ,OAAO;AAErB,KAAC,SAAUC,QAAO;AACjB,UAAI,UAAU;AAAA,QACZ,SAAS;AAAA,QACT,QAAQ;AAAA;AAEV,UAAI,eAAe,4CAA4C;AAC/D,MAAAA,OAAM,UAAU,UAAU;AAAA,QACxB;AAAA,QACA,SAAS;AAAA,UACP,SAAS;AAAA,UACT,QAAQ;AAAA,UACR,QAAQ;AAAA,YACN,aAAa;AAAA,YACb,gBAAgB;AAAA,cACd,SAAS;AAAA,cACT,OAAO;AAAA;;;QAIb,KAAK;AAAA,UACH,SAAS;AAAA,UACT,QAAQ;AAAA,UACR,OAAO;AAAA;QAET,OAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UAML,SAAS;AAAA,YACP,kBAAkB;AAAA,YAChB,QACA,eACA,uBAEC,UAAU;AAAA,YACT,wBAEA,eACA,OAEA,sCAAsC,UACxC;AAAA;UAEJ,YAAY;AAAA,UACZ,QAAQ;AAAA,UACR,OAAO;AAAA,UACP,QAAQ;AAAA,YACN;AAAA,YACA,QAAQ;AAAA,cACN,SAAS,OAAO,SAAS,SAAS,YAAY;AAAA,cAC9C,YAAY;AAAA,cACZ,QAAQ;AAAA;YAEV,aAAa;AAAA,YACb,SAAS;AAAA,cACP,SAAS;AAAA,cACT,QAAQ;AAAA;;;QAId,aAAa;AAAA;IAEnB,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/t4-cs-Dw98XrIw.js

@@ -0,0 +1,49 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+import { r as requireT4Templating } from "./t4-templating-BGmVz2pK.js";
+import { r as requireCsharp } from "./csharp-iD8vdCRX.js";
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: () => e[k]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var t4Cs_1;
+var hasRequiredT4Cs;
+function requireT4Cs() {
+  if (hasRequiredT4Cs) return t4Cs_1;
+  hasRequiredT4Cs = 1;
+  var refractorT4Templating = requireT4Templating();
+  var refractorCsharp = requireCsharp();
+  t4Cs_1 = t4Cs2;
+  t4Cs2.displayName = "t4Cs";
+  t4Cs2.aliases = [];
+  function t4Cs2(Prism) {
+    Prism.register(refractorT4Templating);
+    Prism.register(refractorCsharp);
+    Prism.languages.t4 = Prism.languages["t4-cs"] = Prism.languages["t4-templating"].createT4("csharp");
+  }
+  return t4Cs_1;
+}
+var t4CsExports = requireT4Cs();
+const t4Cs = /* @__PURE__ */ getDefaultExportFromCjs(t4CsExports);
+const t4Cs$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: t4Cs
+}, [t4CsExports]);
+export {
+  t4Cs$1 as t
+};
+//# sourceMappingURL=t4-cs-Dw98XrIw.js.map

package/dist/t4-cs-Dw98XrIw.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"t4-cs-Dw98XrIw.js","sources":["../node_modules/refractor/lang/t4-cs.js"],"sourcesContent":["'use strict'\nvar refractorT4Templating = require('./t4-templating.js')\nvar refractorCsharp = require('./csharp.js')\nmodule.exports = t4Cs\nt4Cs.displayName = 't4Cs'\nt4Cs.aliases = []\nfunction t4Cs(Prism) {\n  Prism.register(refractorT4Templating)\n  Prism.register(refractorCsharp)\n  Prism.languages.t4 = Prism.languages['t4-cs'] =\n    Prism.languages['t4-templating'].createT4('csharp')\n}\n"],"names":["require$$0","require$$1","t4Cs"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,MAAI,wBAAwBA,oBAAA;AAC5B,MAAI,kBAAkBC,cAAA;AACtB,WAAiBC;AACjB,EAAAA,MAAK,cAAc;AACnB,EAAAA,MAAK,UAAU,CAAA;AACf,WAASA,MAAK,OAAO;AACnB,UAAM,SAAS,qBAAqB;AACpC,UAAM,SAAS,eAAe;AAC9B,UAAM,UAAU,KAAK,MAAM,UAAU,OAAO,IAC1C,MAAM,UAAU,eAAe,EAAE,SAAS,QAAQ;AAAA,EACtD;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/t4-templating-BGmVz2pK.js

@@ -0,0 +1,62 @@
+var t4Templating_1;
+var hasRequiredT4Templating;
+function requireT4Templating() {
+  if (hasRequiredT4Templating) return t4Templating_1;
+  hasRequiredT4Templating = 1;
+  t4Templating_1 = t4Templating;
+  t4Templating.displayName = "t4Templating";
+  t4Templating.aliases = [];
+  function t4Templating(Prism) {
+    (function(Prism2) {
+      function createBlock(prefix, inside, contentAlias) {
+        return {
+          pattern: RegExp("<#" + prefix + "[\\s\\S]*?#>"),
+          alias: "block",
+          inside: {
+            delimiter: {
+              pattern: RegExp("^<#" + prefix + "|#>$"),
+              alias: "important"
+            },
+            content: {
+              pattern: /[\s\S]+/,
+              inside,
+              alias: contentAlias
+            }
+          }
+        };
+      }
+      function createT4(insideLang) {
+        var grammar = Prism2.languages[insideLang];
+        var className = "language-" + insideLang;
+        return {
+          block: {
+            pattern: /<#[\s\S]+?#>/,
+            inside: {
+              directive: createBlock("@", {
+                "attr-value": {
+                  pattern: /=(?:("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|[^\s'">=]+)/,
+                  inside: {
+                    punctuation: /^=|^["']|["']$/
+                  }
+                },
+                keyword: /\b\w+(?=\s)/,
+                "attr-name": /\b\w+/
+              }),
+              expression: createBlock("=", grammar, className),
+              "class-feature": createBlock("\\+", grammar, className),
+              standard: createBlock("", grammar, className)
+            }
+          }
+        };
+      }
+      Prism2.languages["t4-templating"] = Object.defineProperty({}, "createT4", {
+        value: createT4
+      });
+    })(Prism);
+  }
+  return t4Templating_1;
+}
+export {
+  requireT4Templating as r
+};
+//# sourceMappingURL=t4-templating-BGmVz2pK.js.map

package/dist/t4-templating-BGmVz2pK.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"t4-templating-BGmVz2pK.js","sources":["../node_modules/refractor/lang/t4-templating.js"],"sourcesContent":["'use strict'\n\nmodule.exports = t4Templating\nt4Templating.displayName = 't4Templating'\nt4Templating.aliases = []\nfunction t4Templating(Prism) {\n  ;(function (Prism) {\n    function createBlock(prefix, inside, contentAlias) {\n      return {\n        pattern: RegExp('<#' + prefix + '[\\\\s\\\\S]*?#>'),\n        alias: 'block',\n        inside: {\n          delimiter: {\n            pattern: RegExp('^<#' + prefix + '|#>$'),\n            alias: 'important'\n          },\n          content: {\n            pattern: /[\\s\\S]+/,\n            inside: inside,\n            alias: contentAlias\n          }\n        }\n      }\n    }\n    function createT4(insideLang) {\n      var grammar = Prism.languages[insideLang]\n      var className = 'language-' + insideLang\n      return {\n        block: {\n          pattern: /<#[\\s\\S]+?#>/,\n          inside: {\n            directive: createBlock('@', {\n              'attr-value': {\n                pattern: /=(?:(\"|')(?:\\\\[\\s\\S]|(?!\\1)[^\\\\])*\\1|[^\\s'\">=]+)/,\n                inside: {\n                  punctuation: /^=|^[\"']|[\"']$/\n                }\n              },\n              keyword: /\\b\\w+(?=\\s)/,\n              'attr-name': /\\b\\w+/\n            }),\n            expression: createBlock('=', grammar, className),\n            'class-feature': createBlock('\\\\+', grammar, className),\n            standard: createBlock('', grammar, className)\n          }\n        }\n      }\n    }\n    Prism.languages['t4-templating'] = Object.defineProperty({}, 'createT4', {\n      value: createT4\n    })\n  })(Prism)\n}\n"],"names":["Prism"],"mappings":";;;;;AAEA,mBAAiB;AACjB,eAAa,cAAc;AAC3B,eAAa,UAAU,CAAA;AACvB,WAAS,aAAa,OAAO;AAC1B,KAAC,SAAUA,QAAO;AACjB,eAAS,YAAY,QAAQ,QAAQ,cAAc;AACjD,eAAO;AAAA,UACL,SAAS,OAAO,OAAO,SAAS,cAAc;AAAA,UAC9C,OAAO;AAAA,UACP,QAAQ;AAAA,YACN,WAAW;AAAA,cACT,SAAS,OAAO,QAAQ,SAAS,MAAM;AAAA,cACvC,OAAO;AAAA;YAET,SAAS;AAAA,cACP,SAAS;AAAA,cACT;AAAA,cACA,OAAO;AAAA;;;MAInB;AACI,eAAS,SAAS,YAAY;AAC5B,YAAI,UAAUA,OAAM,UAAU,UAAU;AACxC,YAAI,YAAY,cAAc;AAC9B,eAAO;AAAA,UACL,OAAO;AAAA,YACL,SAAS;AAAA,YACT,QAAQ;AAAA,cACN,WAAW,YAAY,KAAK;AAAA,gBAC1B,cAAc;AAAA,kBACZ,SAAS;AAAA,kBACT,QAAQ;AAAA,oBACN,aAAa;AAAA;;gBAGjB,SAAS;AAAA,gBACT,aAAa;AAAA,cAC3B,CAAa;AAAA,cACD,YAAY,YAAY,KAAK,SAAS,SAAS;AAAA,cAC/C,iBAAiB,YAAY,OAAO,SAAS,SAAS;AAAA,cACtD,UAAU,YAAY,IAAI,SAAS,SAAS;AAAA;;;MAIxD;AACI,MAAAA,OAAM,UAAU,eAAe,IAAI,OAAO,eAAe,CAAA,GAAI,YAAY;AAAA,QACvE,OAAO;AAAA,MACb,CAAK;AAAA,IACL,GAAK,KAAK;AAAA,EACV;;;","x_google_ignoreList":[0]}

package/dist/t4-templating-CQ3kgiQu.js

@@ -0,0 +1,31 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+import { r as requireT4Templating } from "./t4-templating-BGmVz2pK.js";
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: () => e[k]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var t4TemplatingExports = requireT4Templating();
+const t4Templating = /* @__PURE__ */ getDefaultExportFromCjs(t4TemplatingExports);
+const t4Templating$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: t4Templating
+}, [t4TemplatingExports]);
+export {
+  t4Templating$1 as t
+};
+//# sourceMappingURL=t4-templating-CQ3kgiQu.js.map

package/dist/t4-templating-CQ3kgiQu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"t4-templating-CQ3kgiQu.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/t4-vb-ByKd44S2.js

@@ -0,0 +1,49 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+import { r as requireT4Templating } from "./t4-templating-BGmVz2pK.js";
+import { r as requireVbnet } from "./vbnet-D0GSTx4W.js";
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: () => e[k]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var t4Vb_1;
+var hasRequiredT4Vb;
+function requireT4Vb() {
+  if (hasRequiredT4Vb) return t4Vb_1;
+  hasRequiredT4Vb = 1;
+  var refractorT4Templating = requireT4Templating();
+  var refractorVbnet = requireVbnet();
+  t4Vb_1 = t4Vb2;
+  t4Vb2.displayName = "t4Vb";
+  t4Vb2.aliases = [];
+  function t4Vb2(Prism) {
+    Prism.register(refractorT4Templating);
+    Prism.register(refractorVbnet);
+    Prism.languages["t4-vb"] = Prism.languages["t4-templating"].createT4("vbnet");
+  }
+  return t4Vb_1;
+}
+var t4VbExports = requireT4Vb();
+const t4Vb = /* @__PURE__ */ getDefaultExportFromCjs(t4VbExports);
+const t4Vb$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: t4Vb
+}, [t4VbExports]);
+export {
+  t4Vb$1 as t
+};
+//# sourceMappingURL=t4-vb-ByKd44S2.js.map

package/dist/t4-vb-ByKd44S2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"t4-vb-ByKd44S2.js","sources":["../node_modules/refractor/lang/t4-vb.js"],"sourcesContent":["'use strict'\nvar refractorT4Templating = require('./t4-templating.js')\nvar refractorVbnet = require('./vbnet.js')\nmodule.exports = t4Vb\nt4Vb.displayName = 't4Vb'\nt4Vb.aliases = []\nfunction t4Vb(Prism) {\n  Prism.register(refractorT4Templating)\n  Prism.register(refractorVbnet)\n  Prism.languages['t4-vb'] = Prism.languages['t4-templating'].createT4('vbnet')\n}\n"],"names":["require$$0","require$$1","t4Vb"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,MAAI,wBAAwBA,oBAAA;AAC5B,MAAI,iBAAiBC,aAAA;AACrB,WAAiBC;AACjB,EAAAA,MAAK,cAAc;AACnB,EAAAA,MAAK,UAAU,CAAA;AACf,WAASA,MAAK,OAAO;AACnB,UAAM,SAAS,qBAAqB;AACpC,UAAM,SAAS,cAAc;AAC7B,UAAM,UAAU,OAAO,IAAI,MAAM,UAAU,eAAe,EAAE,SAAS,OAAO;AAAA,EAC9E;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/tap-CRJigZER.js

@@ -0,0 +1,65 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+import { r as requireYaml } from "./yaml-hSvfQRm2.js";
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: () => e[k]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var tap_1;
+var hasRequiredTap;
+function requireTap() {
+  if (hasRequiredTap) return tap_1;
+  hasRequiredTap = 1;
+  var refractorYaml = requireYaml();
+  tap_1 = tap2;
+  tap2.displayName = "tap";
+  tap2.aliases = [];
+  function tap2(Prism) {
+    Prism.register(refractorYaml);
+    Prism.languages.tap = {
+      fail: /not ok[^#{\n\r]*/,
+      pass: /ok[^#{\n\r]*/,
+      pragma: /pragma [+-][a-z]+/,
+      bailout: /bail out!.*/i,
+      version: /TAP version \d+/i,
+      plan: /\b\d+\.\.\d+(?: +#.*)?/,
+      subtest: {
+        pattern: /# Subtest(?:: .*)?/,
+        greedy: true
+      },
+      punctuation: /[{}]/,
+      directive: /#.*/,
+      yamlish: {
+        pattern: /(^[ \t]*)---[\s\S]*?[\r\n][ \t]*\.\.\.$/m,
+        lookbehind: true,
+        inside: Prism.languages.yaml,
+        alias: "language-yaml"
+      }
+    };
+  }
+  return tap_1;
+}
+var tapExports = requireTap();
+const tap = /* @__PURE__ */ getDefaultExportFromCjs(tapExports);
+const tap$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: tap
+}, [tapExports]);
+export {
+  tap$1 as t
+};
+//# sourceMappingURL=tap-CRJigZER.js.map

package/dist/tap-CRJigZER.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tap-CRJigZER.js","sources":["../node_modules/refractor/lang/tap.js"],"sourcesContent":["'use strict'\nvar refractorYaml = require('./yaml.js')\nmodule.exports = tap\ntap.displayName = 'tap'\ntap.aliases = []\nfunction tap(Prism) {\n  Prism.register(refractorYaml)\n  // https://en.wikipedia.org/wiki/Test_Anything_Protocol\n  Prism.languages.tap = {\n    fail: /not ok[^#{\\n\\r]*/,\n    pass: /ok[^#{\\n\\r]*/,\n    pragma: /pragma [+-][a-z]+/,\n    bailout: /bail out!.*/i,\n    version: /TAP version \\d+/i,\n    plan: /\\b\\d+\\.\\.\\d+(?: +#.*)?/,\n    subtest: {\n      pattern: /# Subtest(?:: .*)?/,\n      greedy: true\n    },\n    punctuation: /[{}]/,\n    directive: /#.*/,\n    yamlish: {\n      pattern: /(^[ \\t]*)---[\\s\\S]*?[\\r\\n][ \\t]*\\.\\.\\.$/m,\n      lookbehind: true,\n      inside: Prism.languages.yaml,\n      alias: 'language-yaml'\n    }\n  }\n}\n"],"names":["require$$0","tap"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AACA,MAAI,gBAAgBA,YAAA;AACpB,UAAiBC;AACjB,EAAAA,KAAI,cAAc;AAClB,EAAAA,KAAI,UAAU,CAAA;AACd,WAASA,KAAI,OAAO;AAClB,UAAM,SAAS,aAAa;AAE5B,UAAM,UAAU,MAAM;AAAA,MACpB,MAAM;AAAA,MACN,MAAM;AAAA,MACN,QAAQ;AAAA,MACR,SAAS;AAAA,MACT,SAAS;AAAA,MACT,MAAM;AAAA,MACN,SAAS;AAAA,QACP,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,aAAa;AAAA,MACb,WAAW;AAAA,MACX,SAAS;AAAA,QACP,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,QAAQ,MAAM,UAAU;AAAA,QACxB,OAAO;AAAA;;EAGb;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/tcl-nTdHwEfu.js

@@ -0,0 +1,88 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+function _mergeNamespaces(n, m) {
+  for (var i = 0; i < m.length; i++) {
+    const e = m[i];
+    if (typeof e !== "string" && !Array.isArray(e)) {
+      for (const k in e) {
+        if (k !== "default" && !(k in n)) {
+          const d = Object.getOwnPropertyDescriptor(e, k);
+          if (d) {
+            Object.defineProperty(n, k, d.get ? d : {
+              enumerable: true,
+              get: () => e[k]
+            });
+          }
+        }
+      }
+    }
+  }
+  return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: "Module" }));
+}
+var tcl_1;
+var hasRequiredTcl;
+function requireTcl() {
+  if (hasRequiredTcl) return tcl_1;
+  hasRequiredTcl = 1;
+  tcl_1 = tcl2;
+  tcl2.displayName = "tcl";
+  tcl2.aliases = [];
+  function tcl2(Prism) {
+    Prism.languages.tcl = {
+      comment: {
+        pattern: /(^|[^\\])#.*/,
+        lookbehind: true
+      },
+      string: {
+        pattern: /"(?:[^"\\\r\n]|\\(?:\r\n|[\s\S]))*"/,
+        greedy: true
+      },
+      variable: [
+        {
+          pattern: /(\$)(?:::)?(?:[a-zA-Z0-9]+::)*\w+/,
+          lookbehind: true
+        },
+        {
+          pattern: /(\$)\{[^}]+\}/,
+          lookbehind: true
+        },
+        {
+          pattern: /(^[\t ]*set[ \t]+)(?:::)?(?:[a-zA-Z0-9]+::)*\w+/m,
+          lookbehind: true
+        }
+      ],
+      function: {
+        pattern: /(^[\t ]*proc[ \t]+)\S+/m,
+        lookbehind: true
+      },
+      builtin: [
+        {
+          pattern: /(^[\t ]*)(?:break|class|continue|error|eval|exit|for|foreach|if|proc|return|switch|while)\b/m,
+          lookbehind: true
+        },
+        /\b(?:else|elseif)\b/
+      ],
+      scope: {
+        pattern: /(^[\t ]*)(?:global|upvar|variable)\b/m,
+        lookbehind: true,
+        alias: "constant"
+      },
+      keyword: {
+        pattern: /(^[\t ]*|\[)(?:Safe_Base|Tcl|after|append|apply|array|auto_(?:execok|import|load|mkindex|qualify|reset)|automkindex_old|bgerror|binary|catch|cd|chan|clock|close|concat|dde|dict|encoding|eof|exec|expr|fblocked|fconfigure|fcopy|file(?:event|name)?|flush|gets|glob|history|http|incr|info|interp|join|lappend|lassign|lindex|linsert|list|llength|load|lrange|lrepeat|lreplace|lreverse|lsearch|lset|lsort|math(?:func|op)|memory|msgcat|namespace|open|package|parray|pid|pkg_mkIndex|platform|puts|pwd|re_syntax|read|refchan|regexp|registry|regsub|rename|scan|seek|set|socket|source|split|string|subst|tcl(?:_endOfWord|_findLibrary|startOf(?:Next|Previous)Word|test|vars|wordBreak(?:After|Before))|tell|time|tm|trace|unknown|unload|unset|update|uplevel|vwait)\b/m,
+        lookbehind: true
+      },
+      operator: /!=?|\*\*?|==|&&?|\|\|?|<[=<]?|>[=>]?|[-+~\/%?^]|\b(?:eq|in|ne|ni)\b/,
+      punctuation: /[{}()\[\]]/
+    };
+  }
+  return tcl_1;
+}
+var tclExports = requireTcl();
+const tcl = /* @__PURE__ */ getDefaultExportFromCjs(tclExports);
+const tcl$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: tcl
+}, [tclExports]);
+export {
+  tcl$1 as t
+};
+//# sourceMappingURL=tcl-nTdHwEfu.js.map