@oscloudlab/knowledge-card 0.0.1 → 0.0.2

package/dist/naniscript-DtHo8Sfl.js

@@ -0,0 +1,165 @@
+import { g as y } from "./index-Sj89RFCY.js";
+function h(i, p) {
+  for (var a = 0; a < p.length; a++) {
+    const t = p[a];
+    if (typeof t != "string" && !Array.isArray(t)) {
+      for (const n in t)
+        if (n !== "default" && !(n in i)) {
+          const s = Object.getOwnPropertyDescriptor(t, n);
+          s && Object.defineProperty(i, n, s.get ? s : {
+            enumerable: !0,
+            get: () => t[n]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(i, Symbol.toStringTag, { value: "Module" }));
+}
+var d, f;
+function b() {
+  if (f) return d;
+  f = 1, d = i, i.displayName = "naniscript", i.aliases = [];
+  function i(p) {
+    (function(a) {
+      var t = /\{[^\r\n\[\]{}]*\}/, n = {
+        "quoted-string": {
+          pattern: /"(?:[^"\\]|\\.)*"/,
+          alias: "operator"
+        },
+        "command-param-id": {
+          pattern: /(\s)\w+:/,
+          lookbehind: !0,
+          alias: "property"
+        },
+        "command-param-value": [
+          {
+            pattern: t,
+            alias: "selector"
+          },
+          {
+            pattern: /([\t ])\S+/,
+            lookbehind: !0,
+            greedy: !0,
+            alias: "operator"
+          },
+          {
+            pattern: /\S(?:.*\S)?/,
+            alias: "operator"
+          }
+        ]
+      };
+      a.languages.naniscript = {
+        // ; ...
+        comment: {
+          pattern: /^([\t ]*);.*/m,
+          lookbehind: !0
+        },
+        // > ...
+        // Define is a control line starting with '>' followed by a word, a space and a text.
+        define: {
+          pattern: /^>.+/m,
+          alias: "tag",
+          inside: {
+            value: {
+              pattern: /(^>\w+[\t ]+)(?!\s)[^{}\r\n]+/,
+              lookbehind: !0,
+              alias: "operator"
+            },
+            key: {
+              pattern: /(^>)\w+/,
+              lookbehind: !0
+            }
+          }
+        },
+        // # ...
+        label: {
+          pattern: /^([\t ]*)#[\t ]*\w+[\t ]*$/m,
+          lookbehind: !0,
+          alias: "regex"
+        },
+        command: {
+          pattern: /^([\t ]*)@\w+(?=[\t ]|$).*/m,
+          lookbehind: !0,
+          alias: "function",
+          inside: {
+            "command-name": /^@\w+/,
+            expression: {
+              pattern: t,
+              greedy: !0,
+              alias: "selector"
+            },
+            "command-params": {
+              pattern: /\s*\S[\s\S]*/,
+              inside: n
+            }
+          }
+        },
+        // Generic is any line that doesn't start with operators: ;>#@
+        "generic-text": {
+          pattern: /(^[ \t]*)[^#@>;\s].*/m,
+          lookbehind: !0,
+          alias: "punctuation",
+          inside: {
+            // \{ ... \} ... \[ ... \] ... \"
+            "escaped-char": /\\[{}\[\]"]/,
+            expression: {
+              pattern: t,
+              greedy: !0,
+              alias: "selector"
+            },
+            "inline-command": {
+              pattern: /\[[\t ]*\w[^\r\n\[\]]*\]/,
+              greedy: !0,
+              alias: "function",
+              inside: {
+                "command-params": {
+                  pattern: /(^\[[\t ]*\w+\b)[\s\S]+(?=\]$)/,
+                  lookbehind: !0,
+                  inside: n
+                },
+                "command-param-name": {
+                  pattern: /^(\[[\t ]*)\w+/,
+                  lookbehind: !0,
+                  alias: "name"
+                },
+                "start-stop-char": /[\[\]]/
+              }
+            }
+          }
+        }
+      }, a.languages.nani = a.languages.naniscript, a.hooks.add("after-tokenize", function(e) {
+        var u = e.tokens;
+        u.forEach(function(r) {
+          if (typeof r != "string" && r.type === "generic-text") {
+            var o = c(r);
+            s(o) || (r.type = "bad-line", r.content = o);
+          }
+        });
+      });
+      function s(e) {
+        for (var u = "[]{}", r = [], o = 0; o < e.length; o++) {
+          var g = e[o], l = u.indexOf(g);
+          if (l !== -1) {
+            if (l % 2 === 0)
+              r.push(l + 1);
+            else if (r.pop() !== l)
+              return !1;
+          }
+        }
+        return r.length === 0;
+      }
+      function c(e) {
+        return typeof e == "string" ? e : Array.isArray(e) ? e.map(c).join("") : c(e.content);
+      }
+    })(p);
+  }
+  return d;
+}
+var m = b();
+const v = /* @__PURE__ */ y(m), k = /* @__PURE__ */ h({
+  __proto__: null,
+  default: v
+}, [m]);
+export {
+  k as n
+};

package/dist/nasm-gJZT8LPh.js

@@ -0,0 +1,57 @@
+import { g as m } from "./index-Sj89RFCY.js";
+function f(e, a) {
+  for (var n = 0; n < a.length; n++) {
+    const r = a[n];
+    if (typeof r != "string" && !Array.isArray(r)) {
+      for (const t in r)
+        if (t !== "default" && !(t in e)) {
+          const s = Object.getOwnPropertyDescriptor(r, t);
+          s && Object.defineProperty(e, t, s.get ? s : {
+            enumerable: !0,
+            get: () => r[t]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var o, d;
+function l() {
+  if (d) return o;
+  d = 1, o = e, e.displayName = "nasm", e.aliases = [];
+  function e(a) {
+    a.languages.nasm = {
+      comment: /;.*$/m,
+      string: /(["'`])(?:\\.|(?!\1)[^\\\r\n])*\1/,
+      label: {
+        pattern: /(^\s*)[A-Za-z._?$][\w.?$@~#]*:/m,
+        lookbehind: !0,
+        alias: "function"
+      },
+      keyword: [
+        /\[?BITS (?:16|32|64)\]?/,
+        {
+          pattern: /(^\s*)section\s*[a-z.]+:?/im,
+          lookbehind: !0
+        },
+        /(?:extern|global)[^;\r\n]*/i,
+        /(?:CPU|DEFAULT|FLOAT).*$/m
+      ],
+      register: {
+        pattern: /\b(?:st\d|[xyz]mm\d\d?|[cdt]r\d|r\d\d?[bwd]?|[er]?[abcd]x|[abcd][hl]|[er]?(?:bp|di|si|sp)|[cdefgs]s)\b/i,
+        alias: "variable"
+      },
+      number: /(?:\b|(?=\$))(?:0[hx](?:\.[\da-f]+|[\da-f]+(?:\.[\da-f]+)?)(?:p[+-]?\d+)?|\d[\da-f]+[hx]|\$\d[\da-f]*|0[oq][0-7]+|[0-7]+[oq]|0[by][01]+|[01]+[by]|0[dt]\d+|(?:\d+(?:\.\d+)?|\.\d+)(?:\.?e[+-]?\d+)?[dt]?)\b/i,
+      operator: /[\[\]*+\-\/%<>=&|$!]/
+    };
+  }
+  return o;
+}
+var i = l();
+const b = /* @__PURE__ */ m(i), u = /* @__PURE__ */ f({
+  __proto__: null,
+  default: b
+}, [i]);
+export {
+  u as n
+};

package/dist/neon-SaMGcsnU.js

@@ -0,0 +1,73 @@
+import { g as u } from "./index-Sj89RFCY.js";
+function l(e, n) {
+  for (var o = 0; o < n.length; o++) {
+    const t = n[o];
+    if (typeof t != "string" && !Array.isArray(t)) {
+      for (const r in t)
+        if (r !== "default" && !(r in e)) {
+          const s = Object.getOwnPropertyDescriptor(t, r);
+          s && Object.defineProperty(e, r, s.get ? s : {
+            enumerable: !0,
+            get: () => t[r]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var a, d;
+function p() {
+  if (d) return a;
+  d = 1, a = e, e.displayName = "neon", e.aliases = [];
+  function e(n) {
+    n.languages.neon = {
+      comment: {
+        pattern: /#.*/,
+        greedy: !0
+      },
+      datetime: {
+        pattern: /(^|[[{(=:,\s])\d\d\d\d-\d\d?-\d\d?(?:(?:[Tt]| +)\d\d?:\d\d:\d\d(?:\.\d*)? *(?:Z|[-+]\d\d?(?::?\d\d)?)?)?(?=$|[\]}),\s])/,
+        lookbehind: !0,
+        alias: "number"
+      },
+      key: {
+        pattern: /(^|[[{(,\s])[^,:=[\]{}()'"\s]+(?=\s*:(?:$|[\]}),\s])|\s*=)/,
+        lookbehind: !0,
+        alias: "atrule"
+      },
+      number: {
+        pattern: /(^|[[{(=:,\s])[+-]?(?:0x[\da-fA-F]+|0o[0-7]+|0b[01]+|(?:\d+(?:\.\d*)?|\.?\d+)(?:[eE][+-]?\d+)?)(?=$|[\]}),:=\s])/,
+        lookbehind: !0
+      },
+      boolean: {
+        pattern: /(^|[[{(=:,\s])(?:false|no|true|yes)(?=$|[\]}),:=\s])/i,
+        lookbehind: !0
+      },
+      null: {
+        pattern: /(^|[[{(=:,\s])(?:null)(?=$|[\]}),:=\s])/i,
+        lookbehind: !0,
+        alias: "keyword"
+      },
+      string: {
+        pattern: /(^|[[{(=:,\s])(?:('''|""")\r?\n(?:(?:[^\r\n]|\r?\n(?![\t ]*\2))*\r?\n)?[\t ]*\2|'[^'\r\n]*'|"(?:\\.|[^\\"\r\n])*")/,
+        lookbehind: !0,
+        greedy: !0
+      },
+      literal: {
+        pattern: /(^|[[{(=:,\s])(?:[^#"',:=[\]{}()\s`-]|[:-][^"',=[\]{}()\s])(?:[^,:=\]})(\s]|:(?![\s,\]})]|$)|[ \t]+[^#,:=\]})(\s])*/,
+        lookbehind: !0,
+        alias: "string"
+      },
+      punctuation: /[,:=[\]{}()-]/
+    };
+  }
+  return a;
+}
+var i = p();
+const f = /* @__PURE__ */ u(i), c = /* @__PURE__ */ l({
+  __proto__: null,
+  default: f
+}, [i]);
+export {
+  c as n
+};

package/dist/nevod-Dqvto6vw.js

@@ -0,0 +1,158 @@
+import { g as l } from "./index-Sj89RFCY.js";
+function d(a, n) {
+  for (var r = 0; r < n.length; r++) {
+    const e = n[r];
+    if (typeof e != "string" && !Array.isArray(e)) {
+      for (const t in e)
+        if (t !== "default" && !(t in a)) {
+          const s = Object.getOwnPropertyDescriptor(e, t);
+          s && Object.defineProperty(a, t, s.get ? s : {
+            enumerable: !0,
+            get: () => e[t]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(a, Symbol.toStringTag, { value: "Module" }));
+}
+var i, o;
+function u() {
+  if (o) return i;
+  o = 1, i = a, a.displayName = "nevod", a.aliases = [];
+  function a(n) {
+    n.languages.nevod = {
+      comment: /\/\/.*|(?:\/\*[\s\S]*?(?:\*\/|$))/,
+      string: {
+        pattern: /(?:"(?:""|[^"])*"(?!")|'(?:''|[^'])*'(?!'))!?\*?/,
+        greedy: !0,
+        inside: {
+          "string-attrs": /!$|!\*$|\*$/
+        }
+      },
+      namespace: {
+        pattern: /(@namespace\s+)[a-zA-Z0-9\-.]+(?=\s*\{)/,
+        lookbehind: !0
+      },
+      pattern: {
+        pattern: /(@pattern\s+)?#?[a-zA-Z0-9\-.]+(?:\s*\(\s*(?:~\s*)?[a-zA-Z0-9\-.]+\s*(?:,\s*(?:~\s*)?[a-zA-Z0-9\-.]*)*\))?(?=\s*=)/,
+        lookbehind: !0,
+        inside: {
+          "pattern-name": {
+            pattern: /^#?[a-zA-Z0-9\-.]+/,
+            alias: "class-name"
+          },
+          fields: {
+            pattern: /\(.*\)/,
+            inside: {
+              "field-name": {
+                pattern: /[a-zA-Z0-9\-.]+/,
+                alias: "variable"
+              },
+              punctuation: /[,()]/,
+              operator: {
+                pattern: /~/,
+                alias: "field-hidden-mark"
+              }
+            }
+          }
+        }
+      },
+      search: {
+        pattern: /(@search\s+|#)[a-zA-Z0-9\-.]+(?:\.\*)?(?=\s*;)/,
+        alias: "function",
+        lookbehind: !0
+      },
+      keyword: /@(?:having|inside|namespace|outside|pattern|require|search|where)\b/,
+      "standard-pattern": {
+        pattern: /\b(?:Alpha|AlphaNum|Any|Blank|End|LineBreak|Num|NumAlpha|Punct|Space|Start|Symbol|Word|WordBreak)\b(?:\([a-zA-Z0-9\-.,\s+]*\))?/,
+        inside: {
+          "standard-pattern-name": {
+            pattern: /^[a-zA-Z0-9\-.]+/,
+            alias: "builtin"
+          },
+          quantifier: {
+            pattern: /\b\d+(?:\s*\+|\s*-\s*\d+)?(?!\w)/,
+            alias: "number"
+          },
+          "standard-pattern-attr": {
+            pattern: /[a-zA-Z0-9\-.]+/,
+            alias: "builtin"
+          },
+          punctuation: /[,()]/
+        }
+      },
+      quantifier: {
+        pattern: /\b\d+(?:\s*\+|\s*-\s*\d+)?(?!\w)/,
+        alias: "number"
+      },
+      operator: [
+        {
+          pattern: /=/,
+          alias: "pattern-def"
+        },
+        {
+          pattern: /&/,
+          alias: "conjunction"
+        },
+        {
+          pattern: /~/,
+          alias: "exception"
+        },
+        {
+          pattern: /\?/,
+          alias: "optionality"
+        },
+        {
+          pattern: /[[\]]/,
+          alias: "repetition"
+        },
+        {
+          pattern: /[{}]/,
+          alias: "variation"
+        },
+        {
+          pattern: /[+_]/,
+          alias: "sequence"
+        },
+        {
+          pattern: /\.{2,3}/,
+          alias: "span"
+        }
+      ],
+      "field-capture": [
+        {
+          pattern: /([a-zA-Z0-9\-.]+\s*\()\s*[a-zA-Z0-9\-.]+\s*:\s*[a-zA-Z0-9\-.]+(?:\s*,\s*[a-zA-Z0-9\-.]+\s*:\s*[a-zA-Z0-9\-.]+)*(?=\s*\))/,
+          lookbehind: !0,
+          inside: {
+            "field-name": {
+              pattern: /[a-zA-Z0-9\-.]+/,
+              alias: "variable"
+            },
+            colon: /:/
+          }
+        },
+        {
+          pattern: /[a-zA-Z0-9\-.]+\s*:/,
+          inside: {
+            "field-name": {
+              pattern: /[a-zA-Z0-9\-.]+/,
+              alias: "variable"
+            },
+            colon: /:/
+          }
+        }
+      ],
+      punctuation: /[:;,()]/,
+      name: /[a-zA-Z0-9\-.]+/
+    };
+  }
+  return i;
+}
+var p = u();
+const c = /* @__PURE__ */ l(p), m = /* @__PURE__ */ d({
+  __proto__: null,
+  default: c
+}, [p]);
+export {
+  m as n
+};

package/dist/nginx-Cp89qRQy.js

@@ -0,0 +1,82 @@
+import { g } from "./index-Sj89RFCY.js";
+function d(t, i) {
+  for (var r = 0; r < i.length; r++) {
+    const e = i[r];
+    if (typeof e != "string" && !Array.isArray(e)) {
+      for (const n in e)
+        if (n !== "default" && !(n in t)) {
+          const o = Object.getOwnPropertyDescriptor(e, n);
+          o && Object.defineProperty(t, n, o.get ? o : {
+            enumerable: !0,
+            get: () => e[n]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }));
+}
+var a, s;
+function l() {
+  if (s) return a;
+  s = 1, a = t, t.displayName = "nginx", t.aliases = [];
+  function t(i) {
+    (function(r) {
+      var e = /\$(?:\w[a-z\d]*(?:_[^\x00-\x1F\s"'\\()$]*)?|\{[^}\s"'\\]+\})/i;
+      r.languages.nginx = {
+        comment: {
+          pattern: /(^|[\s{};])#.*/,
+          lookbehind: !0,
+          greedy: !0
+        },
+        directive: {
+          pattern: /(^|\s)\w(?:[^;{}"'\\\s]|\\.|"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|\s+(?:#.*(?!.)|(?![#\s])))*?(?=\s*[;{])/,
+          lookbehind: !0,
+          greedy: !0,
+          inside: {
+            string: {
+              pattern: /((?:^|[^\\])(?:\\\\)*)(?:"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')/,
+              lookbehind: !0,
+              greedy: !0,
+              inside: {
+                escape: {
+                  pattern: /\\["'\\nrt]/,
+                  alias: "entity"
+                },
+                variable: e
+              }
+            },
+            comment: {
+              pattern: /(\s)#.*/,
+              lookbehind: !0,
+              greedy: !0
+            },
+            keyword: {
+              pattern: /^\S+/,
+              greedy: !0
+            },
+            // other patterns
+            boolean: {
+              pattern: /(\s)(?:off|on)(?!\S)/,
+              lookbehind: !0
+            },
+            number: {
+              pattern: /(\s)\d+[a-z]*(?!\S)/i,
+              lookbehind: !0
+            },
+            variable: e
+          }
+        },
+        punctuation: /[{};]/
+      };
+    })(i);
+  }
+  return a;
+}
+var u = l();
+const p = /* @__PURE__ */ g(u), f = /* @__PURE__ */ d({
+  __proto__: null,
+  default: p
+}, [u]);
+export {
+  f as n
+};

package/dist/nim-CdGVC6Mb.js

@@ -0,0 +1,75 @@
+import { g as c } from "./index-Sj89RFCY.js";
+function u(e, n) {
+  for (var i = 0; i < n.length; i++) {
+    const t = n[i];
+    if (typeof t != "string" && !Array.isArray(t)) {
+      for (const r in t)
+        if (r !== "default" && !(r in e)) {
+          const o = Object.getOwnPropertyDescriptor(t, r);
+          o && Object.defineProperty(e, r, o.get ? o : {
+            enumerable: !0,
+            get: () => t[r]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var a, d;
+function f() {
+  if (d) return a;
+  d = 1, a = e, e.displayName = "nim", e.aliases = [];
+  function e(n) {
+    n.languages.nim = {
+      comment: {
+        pattern: /#.*/,
+        greedy: !0
+      },
+      string: {
+        // Double-quoted strings can be prefixed by an identifier (Generalized raw string literals)
+        pattern: /(?:\b(?!\d)(?:\w|\\x[89a-fA-F][0-9a-fA-F])+)?(?:"""[\s\S]*?"""(?!")|"(?:\\[\s\S]|""|[^"\\])*")/,
+        greedy: !0
+      },
+      char: {
+        // Character literals are handled specifically to prevent issues with numeric type suffixes
+        pattern: /'(?:\\(?:\d+|x[\da-fA-F]{0,2}|.)|[^'])'/,
+        greedy: !0
+      },
+      function: {
+        pattern: /(?:(?!\d)(?:\w|\\x[89a-fA-F][0-9a-fA-F])+|`[^`\r\n]+`)\*?(?:\[[^\]]+\])?(?=\s*\()/,
+        greedy: !0,
+        inside: {
+          operator: /\*$/
+        }
+      },
+      // We don't want to highlight operators (and anything really) inside backticks
+      identifier: {
+        pattern: /`[^`\r\n]+`/,
+        greedy: !0,
+        inside: {
+          punctuation: /`/
+        }
+      },
+      // The negative look ahead prevents wrong highlighting of the .. operator
+      number: /\b(?:0[xXoObB][\da-fA-F_]+|\d[\d_]*(?:(?!\.\.)\.[\d_]*)?(?:[eE][+-]?\d[\d_]*)?)(?:'?[iuf]\d*)?/,
+      keyword: /\b(?:addr|as|asm|atomic|bind|block|break|case|cast|concept|const|continue|converter|defer|discard|distinct|do|elif|else|end|enum|except|export|finally|for|from|func|generic|if|import|include|interface|iterator|let|macro|method|mixin|nil|object|out|proc|ptr|raise|ref|return|static|template|try|tuple|type|using|var|when|while|with|without|yield)\b/,
+      operator: {
+        // Look behind and look ahead prevent wrong highlighting of punctuations [. .] {. .} (. .)
+        // but allow the slice operator .. to take precedence over them
+        // One can define his own operators in Nim so all combination of operators might be an operator.
+        pattern: /(^|[({\[](?=\.\.)|(?![({\[]\.).)(?:(?:[=+\-*\/<>@$~&%|!?^:\\]|\.\.|\.(?![)}\]]))+|\b(?:and|div|in|is|isnot|mod|not|notin|of|or|shl|shr|xor)\b)/m,
+        lookbehind: !0
+      },
+      punctuation: /[({\[]\.|\.[)}\]]|[`(){}\[\],:]/
+    };
+  }
+  return a;
+}
+var s = f();
+const p = /* @__PURE__ */ c(s), l = /* @__PURE__ */ u({
+  __proto__: null,
+  default: p
+}, [s]);
+export {
+  l as n
+};

package/dist/nix-jnfiSyYI.js

@@ -0,0 +1,69 @@
+import { g as u } from "./index-Sj89RFCY.js";
+function g(t, e) {
+  for (var i = 0; i < e.length; i++) {
+    const r = e[i];
+    if (typeof r != "string" && !Array.isArray(r)) {
+      for (const n in r)
+        if (n !== "default" && !(n in t)) {
+          const a = Object.getOwnPropertyDescriptor(r, n);
+          a && Object.defineProperty(t, n, a.get ? a : {
+            enumerable: !0,
+            get: () => r[n]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }));
+}
+var s, o;
+function p() {
+  if (o) return s;
+  o = 1, s = t, t.displayName = "nix", t.aliases = [];
+  function t(e) {
+    e.languages.nix = {
+      comment: {
+        pattern: /\/\*[\s\S]*?\*\/|#.*/,
+        greedy: !0
+      },
+      string: {
+        pattern: /"(?:[^"\\]|\\[\s\S])*"|''(?:(?!'')[\s\S]|''(?:'|\\|\$\{))*''/,
+        greedy: !0,
+        inside: {
+          interpolation: {
+            // The lookbehind ensures the ${} is not preceded by \ or ''
+            pattern: /(^|(?:^|(?!'').)[^\\])\$\{(?:[^{}]|\{[^}]*\})*\}/,
+            lookbehind: !0,
+            inside: null
+            // see below
+          }
+        }
+      },
+      url: [
+        /\b(?:[a-z]{3,7}:\/\/)[\w\-+%~\/.:#=?&]+/,
+        {
+          pattern: /([^\/])(?:[\w\-+%~.:#=?&]*(?!\/\/)[\w\-+%~\/.:#=?&])?(?!\/\/)\/[\w\-+%~\/.:#=?&]*/,
+          lookbehind: !0
+        }
+      ],
+      antiquotation: {
+        pattern: /\$(?=\{)/,
+        alias: "important"
+      },
+      number: /\b\d+\b/,
+      keyword: /\b(?:assert|builtins|else|if|in|inherit|let|null|or|then|with)\b/,
+      function: /\b(?:abort|add|all|any|attrNames|attrValues|baseNameOf|compareVersions|concatLists|currentSystem|deepSeq|derivation|dirOf|div|elem(?:At)?|fetch(?:Tarball|url)|filter(?:Source)?|fromJSON|genList|getAttr|getEnv|hasAttr|hashString|head|import|intersectAttrs|is(?:Attrs|Bool|Function|Int|List|Null|String)|length|lessThan|listToAttrs|map|mul|parseDrvName|pathExists|read(?:Dir|File)|removeAttrs|replaceStrings|seq|sort|stringLength|sub(?:string)?|tail|throw|to(?:File|JSON|Path|String|XML)|trace|typeOf)\b|\bfoldl'\B/,
+      boolean: /\b(?:false|true)\b/,
+      operator: /[=!<>]=?|\+\+?|\|\||&&|\/\/|->?|[?@]/,
+      punctuation: /[{}()[\].,:;]/
+    }, e.languages.nix.string.inside.interpolation.inside = e.languages.nix;
+  }
+  return s;
+}
+var l = p();
+const c = /* @__PURE__ */ u(l), f = /* @__PURE__ */ g({
+  __proto__: null,
+  default: c
+}, [l]);
+export {
+  f as n
+};