@oscloudlab/knowledge-card 0.0.1 → 0.0.2

package/dist/dart-CHER8X1l.js

@@ -0,0 +1,101 @@
+import { g as c } from "./index-Sj89RFCY.js";
+function l(a, s) {
+  for (var e = 0; e < s.length; e++) {
+    const t = s[e];
+    if (typeof t != "string" && !Array.isArray(t)) {
+      for (const r in t)
+        if (r !== "default" && !(r in a)) {
+          const n = Object.getOwnPropertyDescriptor(t, r);
+          n && Object.defineProperty(a, r, n.get ? n : {
+            enumerable: !0,
+            get: () => t[r]
+          });
+        }
+    }
+  }
+  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 = "dart", a.aliases = [];
+  function a(s) {
+    (function(e) {
+      var t = [
+        /\b(?:async|sync|yield)\*/,
+        /\b(?:abstract|assert|async|await|break|case|catch|class|const|continue|covariant|default|deferred|do|dynamic|else|enum|export|extends|extension|external|factory|final|finally|for|get|hide|if|implements|import|in|interface|library|mixin|new|null|on|operator|part|rethrow|return|set|show|static|super|switch|sync|this|throw|try|typedef|var|void|while|with|yield)\b/
+      ], r = /(^|[^\w.])(?:[a-z]\w*\s*\.\s*)*(?:[A-Z]\w*\s*\.\s*)*/.source, n = {
+        pattern: RegExp(r + /[A-Z](?:[\d_A-Z]*[a-z]\w*)?\b/.source),
+        lookbehind: !0,
+        inside: {
+          namespace: {
+            pattern: /^[a-z]\w*(?:\s*\.\s*[a-z]\w*)*(?:\s*\.)?/,
+            inside: {
+              punctuation: /\./
+            }
+          }
+        }
+      };
+      e.languages.dart = e.languages.extend("clike", {
+        "class-name": [
+          n,
+          {
+            // variables and parameters
+            // this to support class names (or generic parameters) which do not contain a lower case letter (also works for methods)
+            pattern: RegExp(
+              r + /[A-Z]\w*(?=\s+\w+\s*[;,=()])/.source
+            ),
+            lookbehind: !0,
+            inside: n.inside
+          }
+        ],
+        keyword: t,
+        operator: /\bis!|\b(?:as|is)\b|\+\+|--|&&|\|\||<<=?|>>=?|~(?:\/=?)?|[+\-*\/%&^|=!<>]=?|\?/
+      }), e.languages.insertBefore("dart", "string", {
+        "string-literal": {
+          pattern: /r?(?:("""|''')[\s\S]*?\1|(["'])(?:\\.|(?!\2)[^\\\r\n])*\2(?!\2))/,
+          greedy: !0,
+          inside: {
+            interpolation: {
+              pattern: /((?:^|[^\\])(?:\\{2})*)\$(?:\w+|\{(?:[^{}]|\{[^{}]*\})*\})/,
+              lookbehind: !0,
+              inside: {
+                punctuation: /^\$\{?|\}$/,
+                expression: {
+                  pattern: /[\s\S]+/,
+                  inside: e.languages.dart
+                }
+              }
+            },
+            string: /[\s\S]+/
+          }
+        },
+        string: void 0
+      }), e.languages.insertBefore("dart", "class-name", {
+        metadata: {
+          pattern: /@\w+/,
+          alias: "function"
+        }
+      }), e.languages.insertBefore("dart", "class-name", {
+        generics: {
+          pattern: /<(?:[\w\s,.&?]|<(?:[\w\s,.&?]|<(?:[\w\s,.&?]|<[\w\s,.&?]*>)*>)*>)*>/,
+          inside: {
+            "class-name": n,
+            keyword: t,
+            punctuation: /[<>(),.:]/,
+            operator: /[?&|]/
+          }
+        }
+      });
+    })(s);
+  }
+  return i;
+}
+var d = u();
+const p = /* @__PURE__ */ c(d), g = /* @__PURE__ */ l({
+  __proto__: null,
+  default: p
+}, [d]);
+export {
+  g as d
+};

package/dist/dataweave-DL_Y2LqP.js

@@ -0,0 +1,73 @@
+import { g as s } from "./index-Sj89RFCY.js";
+function p(e, n) {
+  for (var t = 0; t < n.length; t++) {
+    const r = n[t];
+    if (typeof r != "string" && !Array.isArray(r)) {
+      for (const a in r)
+        if (a !== "default" && !(a in e)) {
+          const o = Object.getOwnPropertyDescriptor(r, a);
+          o && Object.defineProperty(e, a, o.get ? o : {
+            enumerable: !0,
+            get: () => r[a]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var u, i;
+function l() {
+  if (i) return u;
+  i = 1, u = e, e.displayName = "dataweave", e.aliases = [];
+  function e(n) {
+    (function(t) {
+      t.languages.dataweave = {
+        url: /\b[A-Za-z]+:\/\/[\w/:.?=&-]+|\burn:[\w:.?=&-]+/,
+        property: {
+          pattern: /(?:\b\w+#)?(?:"(?:\\.|[^\\"\r\n])*"|\b\w+)(?=\s*[:@])/,
+          greedy: !0
+        },
+        string: {
+          pattern: /(["'`])(?:\\[\s\S]|(?!\1)[^\\])*\1/,
+          greedy: !0
+        },
+        "mime-type": /\b(?:application|audio|image|multipart|text|video)\/[\w+-]+/,
+        date: {
+          pattern: /\|[\w:+-]+\|/,
+          greedy: !0
+        },
+        comment: [
+          {
+            pattern: /(^|[^\\])\/\*[\s\S]*?(?:\*\/|$)/,
+            lookbehind: !0,
+            greedy: !0
+          },
+          {
+            pattern: /(^|[^\\:])\/\/.*/,
+            lookbehind: !0,
+            greedy: !0
+          }
+        ],
+        regex: {
+          pattern: /\/(?:[^\\\/\r\n]|\\[^\r\n])+\//,
+          greedy: !0
+        },
+        keyword: /\b(?:and|as|at|case|do|else|fun|if|input|is|match|not|ns|null|or|output|type|unless|update|using|var)\b/,
+        function: /\b[A-Z_]\w*(?=\s*\()/i,
+        number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
+        punctuation: /[{}[\];(),.:@]/,
+        operator: /<<|>>|->|[<>~=]=?|!=|--?-?|\+\+?|!|\?/,
+        boolean: /\b(?:false|true)\b/
+      };
+    })(n);
+  }
+  return u;
+}
+var d = l();
+const b = /* @__PURE__ */ s(d), g = /* @__PURE__ */ p({
+  __proto__: null,
+  default: b
+}, [d]);
+export {
+  g as d
+};

package/dist/dax-D27J9qU6.js

@@ -0,0 +1,60 @@
+import { g as C } from "./index-Sj89RFCY.js";
+function D(E, N) {
+  for (var R = 0; R < N.length; R++) {
+    const T = N[R];
+    if (typeof T != "string" && !Array.isArray(T)) {
+      for (const A in T)
+        if (A !== "default" && !(A in E)) {
+          const S = Object.getOwnPropertyDescriptor(T, A);
+          S && Object.defineProperty(E, A, S.get ? S : {
+            enumerable: !0,
+            get: () => T[A]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(E, Symbol.toStringTag, { value: "Module" }));
+}
+var O, I;
+function U() {
+  if (I) return O;
+  I = 1, O = E, E.displayName = "dax", E.aliases = [];
+  function E(N) {
+    N.languages.dax = {
+      comment: {
+        pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:--|\/\/).*)/,
+        lookbehind: !0
+      },
+      "data-field": {
+        pattern: /'(?:[^']|'')*'(?!')(?:\[[ \w\xA0-\uFFFF]+\])?|\w+\[[ \w\xA0-\uFFFF]+\]/,
+        alias: "symbol"
+      },
+      measure: {
+        pattern: /\[[ \w\xA0-\uFFFF]+\]/,
+        alias: "constant"
+      },
+      string: {
+        pattern: /"(?:[^"]|"")*"(?!")/,
+        greedy: !0
+      },
+      function: /\b(?:ABS|ACOS|ACOSH|ACOT|ACOTH|ADDCOLUMNS|ADDMISSINGITEMS|ALL|ALLCROSSFILTERED|ALLEXCEPT|ALLNOBLANKROW|ALLSELECTED|AND|APPROXIMATEDISTINCTCOUNT|ASIN|ASINH|ATAN|ATANH|AVERAGE|AVERAGEA|AVERAGEX|BETA\.DIST|BETA\.INV|BLANK|CALCULATE|CALCULATETABLE|CALENDAR|CALENDARAUTO|CEILING|CHISQ\.DIST|CHISQ\.DIST\.RT|CHISQ\.INV|CHISQ\.INV\.RT|CLOSINGBALANCEMONTH|CLOSINGBALANCEQUARTER|CLOSINGBALANCEYEAR|COALESCE|COMBIN|COMBINA|COMBINEVALUES|CONCATENATE|CONCATENATEX|CONFIDENCE\.NORM|CONFIDENCE\.T|CONTAINS|CONTAINSROW|CONTAINSSTRING|CONTAINSSTRINGEXACT|CONVERT|COS|COSH|COT|COTH|COUNT|COUNTA|COUNTAX|COUNTBLANK|COUNTROWS|COUNTX|CROSSFILTER|CROSSJOIN|CURRENCY|CURRENTGROUP|CUSTOMDATA|DATATABLE|DATE|DATEADD|DATEDIFF|DATESBETWEEN|DATESINPERIOD|DATESMTD|DATESQTD|DATESYTD|DATEVALUE|DAY|DEGREES|DETAILROWS|DISTINCT|DISTINCTCOUNT|DISTINCTCOUNTNOBLANK|DIVIDE|EARLIER|EARLIEST|EDATE|ENDOFMONTH|ENDOFQUARTER|ENDOFYEAR|EOMONTH|ERROR|EVEN|EXACT|EXCEPT|EXP|EXPON\.DIST|FACT|FALSE|FILTER|FILTERS|FIND|FIRSTDATE|FIRSTNONBLANK|FIRSTNONBLANKVALUE|FIXED|FLOOR|FORMAT|GCD|GENERATE|GENERATEALL|GENERATESERIES|GEOMEAN|GEOMEANX|GROUPBY|HASONEFILTER|HASONEVALUE|HOUR|IF|IF\.EAGER|IFERROR|IGNORE|INT|INTERSECT|ISBLANK|ISCROSSFILTERED|ISEMPTY|ISERROR|ISEVEN|ISFILTERED|ISINSCOPE|ISLOGICAL|ISNONTEXT|ISNUMBER|ISO\.CEILING|ISODD|ISONORAFTER|ISSELECTEDMEASURE|ISSUBTOTAL|ISTEXT|KEEPFILTERS|KEYWORDMATCH|LASTDATE|LASTNONBLANK|LASTNONBLANKVALUE|LCM|LEFT|LEN|LN|LOG|LOG10|LOOKUPVALUE|LOWER|MAX|MAXA|MAXX|MEDIAN|MEDIANX|MID|MIN|MINA|MINUTE|MINX|MOD|MONTH|MROUND|NATURALINNERJOIN|NATURALLEFTOUTERJOIN|NEXTDAY|NEXTMONTH|NEXTQUARTER|NEXTYEAR|NONVISUAL|NORM\.DIST|NORM\.INV|NORM\.S\.DIST|NORM\.S\.INV|NOT|NOW|ODD|OPENINGBALANCEMONTH|OPENINGBALANCEQUARTER|OPENINGBALANCEYEAR|OR|PARALLELPERIOD|PATH|PATHCONTAINS|PATHITEM|PATHITEMREVERSE|PATHLENGTH|PERCENTILE\.EXC|PERCENTILE\.INC|PERCENTILEX\.EXC|PERCENTILEX\.INC|PERMUT|PI|POISSON\.DIST|POWER|PREVIOUSDAY|PREVIOUSMONTH|PREVIOUSQUARTER|PREVIOUSYEAR|PRODUCT|PRODUCTX|QUARTER|QUOTIENT|RADIANS|RAND|RANDBETWEEN|RANK\.EQ|RANKX|RELATED|RELATEDTABLE|REMOVEFILTERS|REPLACE|REPT|RIGHT|ROLLUP|ROLLUPADDISSUBTOTAL|ROLLUPGROUP|ROLLUPISSUBTOTAL|ROUND|ROUNDDOWN|ROUNDUP|ROW|SAMEPERIODLASTYEAR|SAMPLE|SEARCH|SECOND|SELECTCOLUMNS|SELECTEDMEASURE|SELECTEDMEASUREFORMATSTRING|SELECTEDMEASURENAME|SELECTEDVALUE|SIGN|SIN|SINH|SQRT|SQRTPI|STARTOFMONTH|STARTOFQUARTER|STARTOFYEAR|STDEV\.P|STDEV\.S|STDEVX\.P|STDEVX\.S|SUBSTITUTE|SUBSTITUTEWITHINDEX|SUM|SUMMARIZE|SUMMARIZECOLUMNS|SUMX|SWITCH|T\.DIST|T\.DIST\.2T|T\.DIST\.RT|T\.INV|T\.INV\.2T|TAN|TANH|TIME|TIMEVALUE|TODAY|TOPN|TOPNPERLEVEL|TOPNSKIP|TOTALMTD|TOTALQTD|TOTALYTD|TREATAS|TRIM|TRUE|TRUNC|UNICHAR|UNICODE|UNION|UPPER|USERELATIONSHIP|USERNAME|USEROBJECTID|USERPRINCIPALNAME|UTCNOW|UTCTODAY|VALUE|VALUES|VAR\.P|VAR\.S|VARX\.P|VARX\.S|WEEKDAY|WEEKNUM|XIRR|XNPV|YEAR|YEARFRAC)(?=\s*\()/i,
+      keyword: /\b(?:DEFINE|EVALUATE|MEASURE|ORDER\s+BY|RETURN|VAR|START\s+AT|ASC|DESC)\b/i,
+      boolean: {
+        pattern: /\b(?:FALSE|NULL|TRUE)\b/i,
+        alias: "constant"
+      },
+      number: /\b\d+(?:\.\d*)?|\B\.\d+\b/,
+      operator: /:=|[-+*\/=^]|&&?|\|\||<(?:=>?|<|>)?|>[>=]?|\b(?:IN|NOT)\b/i,
+      punctuation: /[;\[\](){}`,.]/
+    };
+  }
+  return O;
+}
+var L = U();
+const M = /* @__PURE__ */ C(L), e = /* @__PURE__ */ D({
+  __proto__: null,
+  default: M
+}, [L]);
+export {
+  e as d
+};

package/dist/dhall-C-Dtjrdj.js

@@ -0,0 +1,95 @@
+import { g as u } from "./index-Sj89RFCY.js";
+function d(e, t) {
+  for (var r = 0; r < t.length; r++) {
+    const a = t[r];
+    if (typeof a != "string" && !Array.isArray(a)) {
+      for (const n in a)
+        if (n !== "default" && !(n in e)) {
+          const l = Object.getOwnPropertyDescriptor(a, n);
+          l && Object.defineProperty(e, n, l.get ? l : {
+            enumerable: !0,
+            get: () => a[n]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var i, o;
+function b() {
+  if (o) return i;
+  o = 1, i = e, e.displayName = "dhall", e.aliases = [];
+  function e(t) {
+    t.languages.dhall = {
+      // Multi-line comments can be nested. E.g. {- foo {- bar -} -}
+      // The multi-line pattern is essentially this:
+      //   \{-(?:[^-{]|-(?!\})|\{(?!-)|<SELF>)*-\}
+      comment: /--.*|\{-(?:[^-{]|-(?!\})|\{(?!-)|\{-(?:[^-{]|-(?!\})|\{(?!-))*-\})*-\}/,
+      string: {
+        pattern: /"(?:[^"\\]|\\.)*"|''(?:[^']|'(?!')|'''|''\$\{)*''(?!'|\$)/,
+        greedy: !0,
+        inside: {
+          interpolation: {
+            pattern: /\$\{[^{}]*\}/,
+            inside: {
+              expression: {
+                pattern: /(^\$\{)[\s\S]+(?=\}$)/,
+                lookbehind: !0,
+                alias: "language-dhall",
+                inside: null
+                // see blow
+              },
+              punctuation: /\$\{|\}/
+            }
+          }
+        }
+      },
+      label: {
+        pattern: /`[^`]*`/,
+        greedy: !0
+      },
+      url: {
+        // https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L596
+        pattern: /\bhttps?:\/\/[\w.:%!$&'*+;=@~-]+(?:\/[\w.:%!$&'*+;=@~-]*)*(?:\?[/?\w.:%!$&'*+;=@~-]*)?/,
+        greedy: !0
+      },
+      env: {
+        // https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L661
+        pattern: /\benv:(?:(?!\d)\w+|"(?:[^"\\=]|\\.)*")/,
+        greedy: !0,
+        inside: {
+          function: /^env/,
+          operator: /^:/,
+          variable: /[\s\S]+/
+        }
+      },
+      hash: {
+        // https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L725
+        pattern: /\bsha256:[\da-fA-F]{64}\b/,
+        inside: {
+          function: /sha256/,
+          operator: /:/,
+          number: /[\da-fA-F]{64}/
+        }
+      },
+      // https://github.com/dhall-lang/dhall-lang/blob/5fde8ef1bead6fb4e999d3c1ffe7044cd019d63a/standard/dhall.abnf#L359
+      keyword: /\b(?:as|assert|else|forall|if|in|let|merge|missing|then|toMap|using|with)\b|\u2200/,
+      builtin: /\b(?:None|Some)\b/,
+      boolean: /\b(?:False|True)\b/,
+      number: /\bNaN\b|-?\bInfinity\b|[+-]?\b(?:0x[\da-fA-F]+|\d+(?:\.\d+)?(?:e[+-]?\d+)?)\b/,
+      operator: /\/\\|\/\/\\\\|&&|\|\||===|[!=]=|\/\/|->|\+\+|::|[+*#@=:?<>|\\\u2227\u2a53\u2261\u2afd\u03bb\u2192]/,
+      punctuation: /\.\.|[{}\[\](),./]/,
+      // we'll just assume that every capital word left is a type name
+      "class-name": /\b[A-Z]\w*\b/
+    }, t.languages.dhall.string.inside.interpolation.inside.expression.inside = t.languages.dhall;
+  }
+  return i;
+}
+var s = b();
+const p = /* @__PURE__ */ u(s), f = /* @__PURE__ */ d({
+  __proto__: null,
+  default: p
+}, [s]);
+export {
+  f as d
+};

package/dist/diff-Dg1kV9wC.js

@@ -0,0 +1,78 @@
+import { g as u } from "./index-Sj89RFCY.js";
+function l(t, n) {
+  for (var f = 0; f < n.length; f++) {
+    const r = n[f];
+    if (typeof r != "string" && !Array.isArray(r)) {
+      for (const e in r)
+        if (e !== "default" && !(e in t)) {
+          const i = Object.getOwnPropertyDescriptor(r, e);
+          i && Object.defineProperty(t, e, i.get ? i : {
+            enumerable: !0,
+            get: () => r[e]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }));
+}
+var o, s;
+function c() {
+  if (s) return o;
+  s = 1, o = t, t.displayName = "diff", t.aliases = [];
+  function t(n) {
+    (function(f) {
+      f.languages.diff = {
+        coord: [
+          // Match all kinds of coord lines (prefixed by "+++", "---" or "***").
+          /^(?:\*{3}|-{3}|\+{3}).*$/m,
+          // Match "@@ ... @@" coord lines in unified diff.
+          /^@@.*@@$/m,
+          // Match coord lines in normal diff (starts with a number).
+          /^\d.*$/m
+        ]
+        // deleted, inserted, unchanged, diff
+      };
+      var r = {
+        "deleted-sign": "-",
+        "deleted-arrow": "<",
+        "inserted-sign": "+",
+        "inserted-arrow": ">",
+        unchanged: " ",
+        diff: "!"
+      };
+      Object.keys(r).forEach(function(e) {
+        var i = r[e], a = [];
+        /^\w+$/.test(e) || a.push(/\w+/.exec(e)[0]), e === "diff" && a.push("bold"), f.languages.diff[e] = {
+          pattern: RegExp(
+            "^(?:[" + i + `].*(?:\r
+?|
+|(?![\\s\\S])))+`,
+            "m"
+          ),
+          alias: a,
+          inside: {
+            line: {
+              pattern: /(.)(?=[\s\S]).*(?:\r\n?|\n)?/,
+              lookbehind: !0
+            },
+            prefix: {
+              pattern: /[\s\S]/,
+              alias: /\w+/.exec(e)[0]
+            }
+          }
+        };
+      }), Object.defineProperty(f.languages.diff, "PREFIXES", {
+        value: r
+      });
+    })(n);
+  }
+  return o;
+}
+var d = c();
+const p = /* @__PURE__ */ u(d), b = /* @__PURE__ */ l({
+  __proto__: null,
+  default: p
+}, [d]);
+export {
+  b as d
+};

package/dist/django-LEJ_YyjH.js

@@ -0,0 +1,81 @@
+import { g as d } from "./index-Sj89RFCY.js";
+import { r as g } from "./markup-templating-CVTxtFGH.js";
+function f(i, 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 i)) {
+          const o = Object.getOwnPropertyDescriptor(e, t);
+          o && Object.defineProperty(i, t, o.get ? o : {
+            enumerable: !0,
+            get: () => e[t]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(i, Symbol.toStringTag, { value: "Module" }));
+}
+var u, l;
+function p() {
+  if (l) return u;
+  l = 1;
+  var i = g();
+  u = n, n.displayName = "django", n.aliases = ["jinja2"];
+  function n(r) {
+    r.register(i), function(e) {
+      e.languages.django = {
+        comment: /^\{#[\s\S]*?#\}$/,
+        tag: {
+          pattern: /(^\{%[+-]?\s*)\w+/,
+          lookbehind: !0,
+          alias: "keyword"
+        },
+        delimiter: {
+          pattern: /^\{[{%][+-]?|[+-]?[}%]\}$/,
+          alias: "punctuation"
+        },
+        string: {
+          pattern: /("|')(?:\\.|(?!\1)[^\\\r\n])*\1/,
+          greedy: !0
+        },
+        filter: {
+          pattern: /(\|)\w+/,
+          lookbehind: !0,
+          alias: "function"
+        },
+        test: {
+          pattern: /(\bis\s+(?:not\s+)?)(?!not\b)\w+/,
+          lookbehind: !0,
+          alias: "function"
+        },
+        function: /\b[a-z_]\w+(?=\s*\()/i,
+        keyword: /\b(?:and|as|by|else|for|if|import|in|is|loop|not|or|recursive|with|without)\b/,
+        operator: /[-+%=]=?|!=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]/,
+        number: /\b\d+(?:\.\d+)?\b/,
+        boolean: /[Ff]alse|[Nn]one|[Tt]rue/,
+        variable: /\b\w+\b/,
+        punctuation: /[{}[\](),.:;]/
+      };
+      var t = /\{\{[\s\S]*?\}\}|\{%[\s\S]*?%\}|\{#[\s\S]*?#\}/g, o = e.languages["markup-templating"];
+      e.hooks.add("before-tokenize", function(a) {
+        o.buildPlaceholders(a, "django", t);
+      }), e.hooks.add("after-tokenize", function(a) {
+        o.tokenizePlaceholders(a, "django");
+      }), e.languages.jinja2 = e.languages.django, e.hooks.add("before-tokenize", function(a) {
+        o.buildPlaceholders(a, "jinja2", t);
+      }), e.hooks.add("after-tokenize", function(a) {
+        o.tokenizePlaceholders(a, "jinja2");
+      });
+    }(r);
+  }
+  return u;
+}
+var s = p();
+const c = /* @__PURE__ */ d(s), k = /* @__PURE__ */ f({
+  __proto__: null,
+  default: c
+}, [s]);
+export {
+  k as d
+};

package/dist/dns-zone-file-CX7rXdX2.js

@@ -0,0 +1,64 @@
+import { g as S } from "./index-Sj89RFCY.js";
+function N(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, i;
+function A() {
+  if (i) return a;
+  i = 1, a = e, e.displayName = "dnsZoneFile", e.aliases = [];
+  function e(n) {
+    n.languages["dns-zone-file"] = {
+      comment: /;.*/,
+      string: {
+        pattern: /"(?:\\.|[^"\\\r\n])*"/,
+        greedy: !0
+      },
+      variable: [
+        {
+          pattern: /(^\$ORIGIN[ \t]+)\S+/m,
+          lookbehind: !0
+        },
+        {
+          pattern: /(^|\s)@(?=\s|$)/,
+          lookbehind: !0
+        }
+      ],
+      keyword: /^\$(?:INCLUDE|ORIGIN|TTL)(?=\s|$)/m,
+      class: {
+        // https://tools.ietf.org/html/rfc1035#page-13
+        pattern: /(^|\s)(?:CH|CS|HS|IN)(?=\s|$)/,
+        lookbehind: !0,
+        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: !0,
+        alias: "keyword"
+      },
+      punctuation: /[()]/
+    }, n.languages["dns-zone"] = n.languages["dns-zone-file"];
+  }
+  return a;
+}
+var l = A();
+const d = /* @__PURE__ */ S(l), I = /* @__PURE__ */ N({
+  __proto__: null,
+  default: d
+}, [l]);
+export {
+  I as d
+};

package/dist/docker-CtY3JCLx.js

@@ -0,0 +1,127 @@
+import { g as f } from "./index-Sj89RFCY.js";
+function P(e, u) {
+  for (var r = 0; r < u.length; r++) {
+    const t = u[r];
+    if (typeof t != "string" && !Array.isArray(t)) {
+      for (const n in t)
+        if (n !== "default" && !(n in e)) {
+          const o = Object.getOwnPropertyDescriptor(t, n);
+          o && Object.defineProperty(e, n, o.get ? o : {
+            enumerable: !0,
+            get: () => t[n]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }));
+}
+var c, p;
+function O() {
+  if (p) return c;
+  p = 1, c = e, e.displayName = "docker", e.aliases = ["dockerfile"];
+  function e(u) {
+    (function(r) {
+      var t = /\\[\r\n](?:\s|\\[\r\n]|#.*(?!.))*(?![\s#]|\\[\r\n])/.source, n = /(?:[ \t]+(?![ \t])(?:<SP_BS>)?|<SP_BS>)/.source.replace(
+        /<SP_BS>/g,
+        function() {
+          return t;
+        }
+      ), o = /"(?:[^"\\\r\n]|\\(?:\r\n|[\s\S]))*"|'(?:[^'\\\r\n]|\\(?:\r\n|[\s\S]))*'/.source, l = /--[\w-]+=(?:<STR>|(?!["'])(?:[^\s\\]|\\.)+)/.source.replace(
+        /<STR>/g,
+        function() {
+          return o;
+        }
+      ), s = {
+        pattern: RegExp(o),
+        greedy: !0
+      }, d = {
+        pattern: /(^[ \t]*)#.*/m,
+        lookbehind: !0,
+        greedy: !0
+      };
+      function a(i, S) {
+        return i = i.replace(/<OPT>/g, function() {
+          return l;
+        }).replace(/<SP>/g, function() {
+          return n;
+        }), RegExp(i, S);
+      }
+      r.languages.docker = {
+        instruction: {
+          pattern: /(^[ \t]*)(?:ADD|ARG|CMD|COPY|ENTRYPOINT|ENV|EXPOSE|FROM|HEALTHCHECK|LABEL|MAINTAINER|ONBUILD|RUN|SHELL|STOPSIGNAL|USER|VOLUME|WORKDIR)(?=\s)(?:\\.|[^\r\n\\])*(?:\\$(?:\s|#.*$)*(?![\s#])(?:\\.|[^\r\n\\])*)*/im,
+          lookbehind: !0,
+          greedy: !0,
+          inside: {
+            options: {
+              pattern: a(
+                /(^(?:ONBUILD<SP>)?\w+<SP>)<OPT>(?:<SP><OPT>)*/.source,
+                "i"
+              ),
+              lookbehind: !0,
+              greedy: !0,
+              inside: {
+                property: {
+                  pattern: /(^|\s)--[\w-]+/,
+                  lookbehind: !0
+                },
+                string: [
+                  s,
+                  {
+                    pattern: /(=)(?!["'])(?:[^\s\\]|\\.)+/,
+                    lookbehind: !0
+                  }
+                ],
+                operator: /\\$/m,
+                punctuation: /=/
+              }
+            },
+            keyword: [
+              {
+                // https://docs.docker.com/engine/reference/builder/#healthcheck
+                pattern: a(
+                  /(^(?:ONBUILD<SP>)?HEALTHCHECK<SP>(?:<OPT><SP>)*)(?:CMD|NONE)\b/.source,
+                  "i"
+                ),
+                lookbehind: !0,
+                greedy: !0
+              },
+              {
+                // https://docs.docker.com/engine/reference/builder/#from
+                pattern: a(
+                  /(^(?:ONBUILD<SP>)?FROM<SP>(?:<OPT><SP>)*(?!--)[^ \t\\]+<SP>)AS/.source,
+                  "i"
+                ),
+                lookbehind: !0,
+                greedy: !0
+              },
+              {
+                // https://docs.docker.com/engine/reference/builder/#onbuild
+                pattern: a(/(^ONBUILD<SP>)\w+/.source, "i"),
+                lookbehind: !0,
+                greedy: !0
+              },
+              {
+                pattern: /^\w+/,
+                greedy: !0
+              }
+            ],
+            comment: d,
+            string: s,
+            variable: /\$(?:\w+|\{[^{}"'\\]*\})/,
+            operator: /\\$/m
+          }
+        },
+        comment: d
+      }, r.languages.dockerfile = r.languages.docker;
+    })(u);
+  }
+  return c;
+}
+var g = O();
+const k = /* @__PURE__ */ f(g), E = /* @__PURE__ */ P({
+  __proto__: null,
+  default: k
+}, [g]);
+export {
+  E as d
+};