@oscloudlab/knowledge-card 0.0.1 → 0.0.3

package/dist/kusto-Rp4enH3h.js

@@ -0,0 +1,80 @@
+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 kusto_1;
+var hasRequiredKusto;
+function requireKusto() {
+  if (hasRequiredKusto) return kusto_1;
+  hasRequiredKusto = 1;
+  kusto_1 = kusto2;
+  kusto2.displayName = "kusto";
+  kusto2.aliases = [];
+  function kusto2(Prism) {
+    Prism.languages.kusto = {
+      comment: {
+        pattern: /\/\/.*/,
+        greedy: true
+      },
+      string: {
+        pattern: /```[\s\S]*?```|[hH]?(?:"(?:[^\r\n\\"]|\\.)*"|'(?:[^\r\n\\']|\\.)*'|@(?:"[^\r\n"]*"|'[^\r\n']*'))/,
+        greedy: true
+      },
+      verb: {
+        pattern: /(\|\s*)[a-z][\w-]*/i,
+        lookbehind: true,
+        alias: "keyword"
+      },
+      command: {
+        pattern: /\.[a-z][a-z\d-]*\b/,
+        alias: "keyword"
+      },
+      "class-name": /\b(?:bool|datetime|decimal|dynamic|guid|int|long|real|string|timespan)\b/,
+      keyword: /\b(?:access|alias|and|anti|as|asc|auto|between|by|(?:contains|(?:ends|starts)with|has(?:perfix|suffix)?)(?:_cs)?|database|declare|desc|external|from|fullouter|has_all|in|ingestion|inline|inner|innerunique|into|(?:left|right)(?:anti(?:semi)?|inner|outer|semi)?|let|like|local|not|of|on|or|pattern|print|query_parameters|range|restrict|schema|set|step|table|tables|to|view|where|with|matches\s+regex|nulls\s+(?:first|last))(?![\w-])/,
+      boolean: /\b(?:false|null|true)\b/,
+      function: /\b[a-z_]\w*(?=\s*\()/,
+      datetime: [
+        {
+          // RFC 822 + RFC 850
+          pattern: /\b(?:(?:Fri|Friday|Mon|Monday|Sat|Saturday|Sun|Sunday|Thu|Thursday|Tue|Tuesday|Wed|Wednesday)\s*,\s*)?\d{1,2}(?:\s+|-)(?:Apr|Aug|Dec|Feb|Jan|Jul|Jun|Mar|May|Nov|Oct|Sep)(?:\s+|-)\d{2}\s+\d{2}:\d{2}(?::\d{2})?(?:\s*(?:\b(?:[A-Z]|(?:[ECMT][DS]|GM|U)T)|[+-]\d{4}))?\b/,
+          alias: "number"
+        },
+        {
+          // ISO 8601
+          pattern: /[+-]?\b(?:\d{4}-\d{2}-\d{2}(?:[ T]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?)?|\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?)Z?/,
+          alias: "number"
+        }
+      ],
+      number: /\b(?:0x[0-9A-Fa-f]+|\d+(?:\.\d+)?(?:[Ee][+-]?\d+)?)(?:(?:min|sec|[mnµ]s|[dhms]|microsecond|tick)\b)?|[+-]?\binf\b/,
+      operator: /=>|[!=]~|[!=<>]=?|[-+*/%|]|\.\./,
+      punctuation: /[()\[\]{},;.:]/
+    };
+  }
+  return kusto_1;
+}
+var kustoExports = requireKusto();
+const kusto = /* @__PURE__ */ getDefaultExportFromCjs(kustoExports);
+const kusto$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: kusto
+}, [kustoExports]);
+export {
+  kusto$1 as k
+};
+//# sourceMappingURL=kusto-Rp4enH3h.js.map

package/dist/kusto-Rp4enH3h.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kusto-Rp4enH3h.js","sources":["../node_modules/refractor/lang/kusto.js"],"sourcesContent":["'use strict'\n\nmodule.exports = kusto\nkusto.displayName = 'kusto'\nkusto.aliases = []\nfunction kusto(Prism) {\n  Prism.languages.kusto = {\n    comment: {\n      pattern: /\\/\\/.*/,\n      greedy: true\n    },\n    string: {\n      pattern:\n        /```[\\s\\S]*?```|[hH]?(?:\"(?:[^\\r\\n\\\\\"]|\\\\.)*\"|'(?:[^\\r\\n\\\\']|\\\\.)*'|@(?:\"[^\\r\\n\"]*\"|'[^\\r\\n']*'))/,\n      greedy: true\n    },\n    verb: {\n      pattern: /(\\|\\s*)[a-z][\\w-]*/i,\n      lookbehind: true,\n      alias: 'keyword'\n    },\n    command: {\n      pattern: /\\.[a-z][a-z\\d-]*\\b/,\n      alias: 'keyword'\n    },\n    'class-name':\n      /\\b(?:bool|datetime|decimal|dynamic|guid|int|long|real|string|timespan)\\b/,\n    keyword:\n      /\\b(?:access|alias|and|anti|as|asc|auto|between|by|(?:contains|(?:ends|starts)with|has(?:perfix|suffix)?)(?:_cs)?|database|declare|desc|external|from|fullouter|has_all|in|ingestion|inline|inner|innerunique|into|(?:left|right)(?:anti(?:semi)?|inner|outer|semi)?|let|like|local|not|of|on|or|pattern|print|query_parameters|range|restrict|schema|set|step|table|tables|to|view|where|with|matches\\s+regex|nulls\\s+(?:first|last))(?![\\w-])/,\n    boolean: /\\b(?:false|null|true)\\b/,\n    function: /\\b[a-z_]\\w*(?=\\s*\\()/,\n    datetime: [\n      {\n        // RFC 822 + RFC 850\n        pattern:\n          /\\b(?:(?:Fri|Friday|Mon|Monday|Sat|Saturday|Sun|Sunday|Thu|Thursday|Tue|Tuesday|Wed|Wednesday)\\s*,\\s*)?\\d{1,2}(?:\\s+|-)(?:Apr|Aug|Dec|Feb|Jan|Jul|Jun|Mar|May|Nov|Oct|Sep)(?:\\s+|-)\\d{2}\\s+\\d{2}:\\d{2}(?::\\d{2})?(?:\\s*(?:\\b(?:[A-Z]|(?:[ECMT][DS]|GM|U)T)|[+-]\\d{4}))?\\b/,\n        alias: 'number'\n      },\n      {\n        // ISO 8601\n        pattern:\n          /[+-]?\\b(?:\\d{4}-\\d{2}-\\d{2}(?:[ T]\\d{2}:\\d{2}(?::\\d{2}(?:\\.\\d+)?)?)?|\\d{2}:\\d{2}(?::\\d{2}(?:\\.\\d+)?)?)Z?/,\n        alias: 'number'\n      }\n    ],\n    number:\n      /\\b(?:0x[0-9A-Fa-f]+|\\d+(?:\\.\\d+)?(?:[Ee][+-]?\\d+)?)(?:(?:min|sec|[mnµ]s|[dhms]|microsecond|tick)\\b)?|[+-]?\\binf\\b/,\n    operator: /=>|[!=]~|[!=<>]=?|[-+*/%|]|\\.\\./,\n    punctuation: /[()\\[\\]{},;.:]/\n  }\n}\n"],"names":["kusto"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,YAAiBA;AACjB,EAAAA,OAAM,cAAc;AACpB,EAAAA,OAAM,UAAU,CAAA;AAChB,WAASA,OAAM,OAAO;AACpB,UAAM,UAAU,QAAQ;AAAA,MACtB,SAAS;AAAA,QACP,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,QAAQ;AAAA,QACN,SACE;AAAA,QACF,QAAQ;AAAA;MAEV,MAAM;AAAA,QACJ,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,OAAO;AAAA;MAET,SAAS;AAAA,QACP,SAAS;AAAA,QACT,OAAO;AAAA;MAET,cACE;AAAA,MACF,SACE;AAAA,MACF,SAAS;AAAA,MACT,UAAU;AAAA,MACV,UAAU;AAAA,QACR;AAAA;AAAA,UAEE,SACE;AAAA,UACF,OAAO;AAAA;QAET;AAAA;AAAA,UAEE,SACE;AAAA,UACF,OAAO;AAAA;;MAGX,QACE;AAAA,MACF,UAAU;AAAA,MACV,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/latex-DNFHXG7b.js

@@ -0,0 +1,104 @@
+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 latex_1;
+var hasRequiredLatex;
+function requireLatex() {
+  if (hasRequiredLatex) return latex_1;
+  hasRequiredLatex = 1;
+  latex_1 = latex2;
+  latex2.displayName = "latex";
+  latex2.aliases = ["tex", "context"];
+  function latex2(Prism) {
+    (function(Prism2) {
+      var funcPattern = /\\(?:[^a-z()[\]]|[a-z*]+)/i;
+      var insideEqu = {
+        "equation-command": {
+          pattern: funcPattern,
+          alias: "regex"
+        }
+      };
+      Prism2.languages.latex = {
+        comment: /%.*/,
+        // the verbatim environment prints whitespace to the document
+        cdata: {
+          pattern: /(\\begin\{((?:lstlisting|verbatim)\*?)\})[\s\S]*?(?=\\end\{\2\})/,
+          lookbehind: true
+        },
+        /*
+         * equations can be between $$ $$ or $ $ or \( \) or \[ \]
+         * (all are multiline)
+         */
+        equation: [
+          {
+            pattern: /\$\$(?:\\[\s\S]|[^\\$])+\$\$|\$(?:\\[\s\S]|[^\\$])+\$|\\\([\s\S]*?\\\)|\\\[[\s\S]*?\\\]/,
+            inside: insideEqu,
+            alias: "string"
+          },
+          {
+            pattern: /(\\begin\{((?:align|eqnarray|equation|gather|math|multline)\*?)\})[\s\S]*?(?=\\end\{\2\})/,
+            lookbehind: true,
+            inside: insideEqu,
+            alias: "string"
+          }
+        ],
+        /*
+         * arguments which are keywords or references are highlighted
+         * as keywords
+         */
+        keyword: {
+          pattern: /(\\(?:begin|cite|documentclass|end|label|ref|usepackage)(?:\[[^\]]+\])?\{)[^}]+(?=\})/,
+          lookbehind: true
+        },
+        url: {
+          pattern: /(\\url\{)[^}]+(?=\})/,
+          lookbehind: true
+        },
+        /*
+         * section or chapter headlines are highlighted as bold so that
+         * they stand out more
+         */
+        headline: {
+          pattern: /(\\(?:chapter|frametitle|paragraph|part|section|subparagraph|subsection|subsubparagraph|subsubsection|subsubsubparagraph)\*?(?:\[[^\]]+\])?\{)[^}]+(?=\})/,
+          lookbehind: true,
+          alias: "class-name"
+        },
+        function: {
+          pattern: funcPattern,
+          alias: "selector"
+        },
+        punctuation: /[[\]{}&]/
+      };
+      Prism2.languages.tex = Prism2.languages.latex;
+      Prism2.languages.context = Prism2.languages.latex;
+    })(Prism);
+  }
+  return latex_1;
+}
+var latexExports = requireLatex();
+const latex = /* @__PURE__ */ getDefaultExportFromCjs(latexExports);
+const latex$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: latex
+}, [latexExports]);
+export {
+  latex$1 as l
+};
+//# sourceMappingURL=latex-DNFHXG7b.js.map

package/dist/latex-DNFHXG7b.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"latex-DNFHXG7b.js","sources":["../node_modules/refractor/lang/latex.js"],"sourcesContent":["'use strict'\n\nmodule.exports = latex\nlatex.displayName = 'latex'\nlatex.aliases = ['tex', 'context']\nfunction latex(Prism) {\n  ;(function (Prism) {\n    var funcPattern = /\\\\(?:[^a-z()[\\]]|[a-z*]+)/i\n    var insideEqu = {\n      'equation-command': {\n        pattern: funcPattern,\n        alias: 'regex'\n      }\n    }\n    Prism.languages.latex = {\n      comment: /%.*/,\n      // the verbatim environment prints whitespace to the document\n      cdata: {\n        pattern:\n          /(\\\\begin\\{((?:lstlisting|verbatim)\\*?)\\})[\\s\\S]*?(?=\\\\end\\{\\2\\})/,\n        lookbehind: true\n      },\n      /*\n       * equations can be between $$ $$ or $ $ or \\( \\) or \\[ \\]\n       * (all are multiline)\n       */\n      equation: [\n        {\n          pattern:\n            /\\$\\$(?:\\\\[\\s\\S]|[^\\\\$])+\\$\\$|\\$(?:\\\\[\\s\\S]|[^\\\\$])+\\$|\\\\\\([\\s\\S]*?\\\\\\)|\\\\\\[[\\s\\S]*?\\\\\\]/,\n          inside: insideEqu,\n          alias: 'string'\n        },\n        {\n          pattern:\n            /(\\\\begin\\{((?:align|eqnarray|equation|gather|math|multline)\\*?)\\})[\\s\\S]*?(?=\\\\end\\{\\2\\})/,\n          lookbehind: true,\n          inside: insideEqu,\n          alias: 'string'\n        }\n      ],\n      /*\n       * arguments which are keywords or references are highlighted\n       * as keywords\n       */\n      keyword: {\n        pattern:\n          /(\\\\(?:begin|cite|documentclass|end|label|ref|usepackage)(?:\\[[^\\]]+\\])?\\{)[^}]+(?=\\})/,\n        lookbehind: true\n      },\n      url: {\n        pattern: /(\\\\url\\{)[^}]+(?=\\})/,\n        lookbehind: true\n      },\n      /*\n       * section or chapter headlines are highlighted as bold so that\n       * they stand out more\n       */\n      headline: {\n        pattern:\n          /(\\\\(?:chapter|frametitle|paragraph|part|section|subparagraph|subsection|subsubparagraph|subsubsection|subsubsubparagraph)\\*?(?:\\[[^\\]]+\\])?\\{)[^}]+(?=\\})/,\n        lookbehind: true,\n        alias: 'class-name'\n      },\n      function: {\n        pattern: funcPattern,\n        alias: 'selector'\n      },\n      punctuation: /[[\\]{}&]/\n    }\n    Prism.languages.tex = Prism.languages.latex\n    Prism.languages.context = Prism.languages.latex\n  })(Prism)\n}\n"],"names":["latex","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,YAAiBA;AACjB,EAAAA,OAAM,cAAc;AACpB,EAAAA,OAAM,UAAU,CAAC,OAAO,SAAS;AACjC,WAASA,OAAM,OAAO;AACnB,KAAC,SAAUC,QAAO;AACjB,UAAI,cAAc;AAClB,UAAI,YAAY;AAAA,QACd,oBAAoB;AAAA,UAClB,SAAS;AAAA,UACT,OAAO;AAAA;;AAGX,MAAAA,OAAM,UAAU,QAAQ;AAAA,QACtB,SAAS;AAAA;AAAA,QAET,OAAO;AAAA,UACL,SACE;AAAA,UACF,YAAY;AAAA;;;;;QAMd,UAAU;AAAA,UACR;AAAA,YACE,SACE;AAAA,YACF,QAAQ;AAAA,YACR,OAAO;AAAA;UAET;AAAA,YACE,SACE;AAAA,YACF,YAAY;AAAA,YACZ,QAAQ;AAAA,YACR,OAAO;AAAA;;;;;;QAOX,SAAS;AAAA,UACP,SACE;AAAA,UACF,YAAY;AAAA;QAEd,KAAK;AAAA,UACH,SAAS;AAAA,UACT,YAAY;AAAA;;;;;QAMd,UAAU;AAAA,UACR,SACE;AAAA,UACF,YAAY;AAAA,UACZ,OAAO;AAAA;QAET,UAAU;AAAA,UACR,SAAS;AAAA,UACT,OAAO;AAAA;QAET,aAAa;AAAA;AAEf,MAAAA,OAAM,UAAU,MAAMA,OAAM,UAAU;AACtC,MAAAA,OAAM,UAAU,UAAUA,OAAM,UAAU;AAAA,IAC9C,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/latte-CSKquiW8.js

@@ -0,0 +1,116 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+import { r as requireMarkupTemplating } from "./markup-templating-hY-QSL53.js";
+import { r as requirePhp } from "./php-BBLqus8v.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 latte_1;
+var hasRequiredLatte;
+function requireLatte() {
+  if (hasRequiredLatte) return latte_1;
+  hasRequiredLatte = 1;
+  var refractorMarkupTemplating = requireMarkupTemplating();
+  var refractorPhp = requirePhp();
+  latte_1 = latte2;
+  latte2.displayName = "latte";
+  latte2.aliases = [];
+  function latte2(Prism) {
+    Prism.register(refractorMarkupTemplating);
+    Prism.register(refractorPhp);
+    (function(Prism2) {
+      Prism2.languages.latte = {
+        comment: /^\{\*[\s\S]*/,
+        "latte-tag": {
+          // https://latte.nette.org/en/tags
+          pattern: /(^\{(?:\/(?=[a-z]))?)(?:[=_]|[a-z]\w*\b(?!\())/i,
+          lookbehind: true,
+          alias: "important"
+        },
+        delimiter: {
+          pattern: /^\{\/?|\}$/,
+          alias: "punctuation"
+        },
+        php: {
+          pattern: /\S(?:[\s\S]*\S)?/,
+          alias: "language-php",
+          inside: Prism2.languages.php
+        }
+      };
+      var markupLatte = Prism2.languages.extend("markup", {});
+      Prism2.languages.insertBefore(
+        "inside",
+        "attr-value",
+        {
+          "n-attr": {
+            pattern: /n:[\w-]+(?:\s*=\s*(?:"[^"]*"|'[^']*'|[^\s'">=]+))?/,
+            inside: {
+              "attr-name": {
+                pattern: /^[^\s=]+/,
+                alias: "important"
+              },
+              "attr-value": {
+                pattern: /=[\s\S]+/,
+                inside: {
+                  punctuation: [
+                    /^=/,
+                    {
+                      pattern: /^(\s*)["']|["']$/,
+                      lookbehind: true
+                    }
+                  ],
+                  php: {
+                    pattern: /\S(?:[\s\S]*\S)?/,
+                    inside: Prism2.languages.php
+                  }
+                }
+              }
+            }
+          }
+        },
+        markupLatte.tag
+      );
+      Prism2.hooks.add("before-tokenize", function(env) {
+        if (env.language !== "latte") {
+          return;
+        }
+        var lattePattern = /\{\*[\s\S]*?\*\}|\{[^'"\s{}*](?:[^"'/{}]|\/(?![*/])|("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|\/\*(?:[^*]|\*(?!\/))*\*\/)*\}/g;
+        Prism2.languages["markup-templating"].buildPlaceholders(
+          env,
+          "latte",
+          lattePattern
+        );
+        env.grammar = markupLatte;
+      });
+      Prism2.hooks.add("after-tokenize", function(env) {
+        Prism2.languages["markup-templating"].tokenizePlaceholders(env, "latte");
+      });
+    })(Prism);
+  }
+  return latte_1;
+}
+var latteExports = requireLatte();
+const latte = /* @__PURE__ */ getDefaultExportFromCjs(latteExports);
+const latte$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: latte
+}, [latteExports]);
+export {
+  latte$1 as l
+};
+//# sourceMappingURL=latte-CSKquiW8.js.map

package/dist/latte-CSKquiW8.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"latte-CSKquiW8.js","sources":["../node_modules/refractor/lang/latte.js"],"sourcesContent":["'use strict'\nvar refractorMarkupTemplating = require('./markup-templating.js')\nvar refractorPhp = require('./php.js')\nmodule.exports = latte\nlatte.displayName = 'latte'\nlatte.aliases = []\nfunction latte(Prism) {\n  Prism.register(refractorMarkupTemplating)\n  Prism.register(refractorPhp)\n  ;(function (Prism) {\n    Prism.languages.latte = {\n      comment: /^\\{\\*[\\s\\S]*/,\n      'latte-tag': {\n        // https://latte.nette.org/en/tags\n        pattern: /(^\\{(?:\\/(?=[a-z]))?)(?:[=_]|[a-z]\\w*\\b(?!\\())/i,\n        lookbehind: true,\n        alias: 'important'\n      },\n      delimiter: {\n        pattern: /^\\{\\/?|\\}$/,\n        alias: 'punctuation'\n      },\n      php: {\n        pattern: /\\S(?:[\\s\\S]*\\S)?/,\n        alias: 'language-php',\n        inside: Prism.languages.php\n      }\n    }\n    var markupLatte = Prism.languages.extend('markup', {})\n    Prism.languages.insertBefore(\n      'inside',\n      'attr-value',\n      {\n        'n-attr': {\n          pattern: /n:[\\w-]+(?:\\s*=\\s*(?:\"[^\"]*\"|'[^']*'|[^\\s'\">=]+))?/,\n          inside: {\n            'attr-name': {\n              pattern: /^[^\\s=]+/,\n              alias: 'important'\n            },\n            'attr-value': {\n              pattern: /=[\\s\\S]+/,\n              inside: {\n                punctuation: [\n                  /^=/,\n                  {\n                    pattern: /^(\\s*)[\"']|[\"']$/,\n                    lookbehind: true\n                  }\n                ],\n                php: {\n                  pattern: /\\S(?:[\\s\\S]*\\S)?/,\n                  inside: Prism.languages.php\n                }\n              }\n            }\n          }\n        }\n      },\n      markupLatte.tag\n    )\n    Prism.hooks.add('before-tokenize', function (env) {\n      if (env.language !== 'latte') {\n        return\n      }\n      var lattePattern =\n        /\\{\\*[\\s\\S]*?\\*\\}|\\{[^'\"\\s{}*](?:[^\"'/{}]|\\/(?![*/])|(\"|')(?:\\\\[\\s\\S]|(?!\\1)[^\\\\])*\\1|\\/\\*(?:[^*]|\\*(?!\\/))*\\*\\/)*\\}/g\n      Prism.languages['markup-templating'].buildPlaceholders(\n        env,\n        'latte',\n        lattePattern\n      )\n      env.grammar = markupLatte\n    })\n    Prism.hooks.add('after-tokenize', function (env) {\n      Prism.languages['markup-templating'].tokenizePlaceholders(env, 'latte')\n    })\n  })(Prism)\n}\n"],"names":["require$$0","require$$1","latte","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,MAAI,4BAA4BA,wBAAA;AAChC,MAAI,eAAeC,WAAA;AACnB,YAAiBC;AACjB,EAAAA,OAAM,cAAc;AACpB,EAAAA,OAAM,UAAU,CAAA;AAChB,WAASA,OAAM,OAAO;AACpB,UAAM,SAAS,yBAAyB;AACxC,UAAM,SAAS,YAAY;AAC1B,KAAC,SAAUC,QAAO;AACjB,MAAAA,OAAM,UAAU,QAAQ;AAAA,QACtB,SAAS;AAAA,QACT,aAAa;AAAA;AAAA,UAEX,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,OAAO;AAAA;QAET,WAAW;AAAA,UACT,SAAS;AAAA,UACT,OAAO;AAAA;QAET,KAAK;AAAA,UACH,SAAS;AAAA,UACT,OAAO;AAAA,UACP,QAAQA,OAAM,UAAU;AAAA;;AAG5B,UAAI,cAAcA,OAAM,UAAU,OAAO,UAAU,CAAA,CAAE;AACrD,MAAAA,OAAM,UAAU;AAAA,QACd;AAAA,QACA;AAAA,QACA;AAAA,UACE,UAAU;AAAA,YACR,SAAS;AAAA,YACT,QAAQ;AAAA,cACN,aAAa;AAAA,gBACX,SAAS;AAAA,gBACT,OAAO;AAAA;cAET,cAAc;AAAA,gBACZ,SAAS;AAAA,gBACT,QAAQ;AAAA,kBACN,aAAa;AAAA,oBACX;AAAA,oBACA;AAAA,sBACE,SAAS;AAAA,sBACT,YAAY;AAAA;;kBAGhB,KAAK;AAAA,oBACH,SAAS;AAAA,oBACT,QAAQA,OAAM,UAAU;AAAA;;;;;;QAOpC,YAAY;AAAA;AAEd,MAAAA,OAAM,MAAM,IAAI,mBAAmB,SAAU,KAAK;AAChD,YAAI,IAAI,aAAa,SAAS;AAC5B;AAAA,QACR;AACM,YAAI,eACF;AACF,QAAAA,OAAM,UAAU,mBAAmB,EAAE;AAAA,UACnC;AAAA,UACA;AAAA,UACA;AAAA;AAEF,YAAI,UAAU;AAAA,MACpB,CAAK;AACD,MAAAA,OAAM,MAAM,IAAI,kBAAkB,SAAU,KAAK;AAC/C,QAAAA,OAAM,UAAU,mBAAmB,EAAE,qBAAqB,KAAK,OAAO;AAAA,MAC5E,CAAK;AAAA,IACL,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/less-AcrwgCri.js

@@ -0,0 +1,85 @@
+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 less_1;
+var hasRequiredLess;
+function requireLess() {
+  if (hasRequiredLess) return less_1;
+  hasRequiredLess = 1;
+  less_1 = less2;
+  less2.displayName = "less";
+  less2.aliases = [];
+  function less2(Prism) {
+    Prism.languages.less = Prism.languages.extend("css", {
+      comment: [
+        /\/\*[\s\S]*?\*\//,
+        {
+          pattern: /(^|[^\\])\/\/.*/,
+          lookbehind: true
+        }
+      ],
+      atrule: {
+        pattern: /@[\w-](?:\((?:[^(){}]|\([^(){}]*\))*\)|[^(){};\s]|\s+(?!\s))*?(?=\s*\{)/,
+        inside: {
+          punctuation: /[:()]/
+        }
+      },
+      // selectors and mixins are considered the same
+      selector: {
+        pattern: /(?:@\{[\w-]+\}|[^{};\s@])(?:@\{[\w-]+\}|\((?:[^(){}]|\([^(){}]*\))*\)|[^(){};@\s]|\s+(?!\s))*?(?=\s*\{)/,
+        inside: {
+          // mixin parameters
+          variable: /@+[\w-]+/
+        }
+      },
+      property: /(?:@\{[\w-]+\}|[\w-])+(?:\+_?)?(?=\s*:)/,
+      operator: /[+\-*\/]/
+    });
+    Prism.languages.insertBefore("less", "property", {
+      variable: [
+        // Variable declaration (the colon must be consumed!)
+        {
+          pattern: /@[\w-]+\s*:/,
+          inside: {
+            punctuation: /:/
+          }
+        },
+        // Variable usage
+        /@@?[\w-]+/
+      ],
+      "mixin-usage": {
+        pattern: /([{;]\s*)[.#](?!\d)[\w-].*?(?=[(;])/,
+        lookbehind: true,
+        alias: "function"
+      }
+    });
+  }
+  return less_1;
+}
+var lessExports = requireLess();
+const less = /* @__PURE__ */ getDefaultExportFromCjs(lessExports);
+const less$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: less
+}, [lessExports]);
+export {
+  less$1 as l
+};
+//# sourceMappingURL=less-AcrwgCri.js.map

package/dist/less-AcrwgCri.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"less-AcrwgCri.js","sources":["../node_modules/refractor/lang/less.js"],"sourcesContent":["'use strict'\n\nmodule.exports = less\nless.displayName = 'less'\nless.aliases = []\nfunction less(Prism) {\n  /* FIXME :\n:extend() is not handled specifically : its highlighting is buggy.\nMixin usage must be inside a ruleset to be highlighted.\nAt-rules (e.g. import) containing interpolations are buggy.\nDetached rulesets are highlighted as at-rules.\nA comment before a mixin usage prevents the latter to be properly highlighted.\n*/\n  Prism.languages.less = Prism.languages.extend('css', {\n    comment: [\n      /\\/\\*[\\s\\S]*?\\*\\//,\n      {\n        pattern: /(^|[^\\\\])\\/\\/.*/,\n        lookbehind: true\n      }\n    ],\n    atrule: {\n      pattern:\n        /@[\\w-](?:\\((?:[^(){}]|\\([^(){}]*\\))*\\)|[^(){};\\s]|\\s+(?!\\s))*?(?=\\s*\\{)/,\n      inside: {\n        punctuation: /[:()]/\n      }\n    },\n    // selectors and mixins are considered the same\n    selector: {\n      pattern:\n        /(?:@\\{[\\w-]+\\}|[^{};\\s@])(?:@\\{[\\w-]+\\}|\\((?:[^(){}]|\\([^(){}]*\\))*\\)|[^(){};@\\s]|\\s+(?!\\s))*?(?=\\s*\\{)/,\n      inside: {\n        // mixin parameters\n        variable: /@+[\\w-]+/\n      }\n    },\n    property: /(?:@\\{[\\w-]+\\}|[\\w-])+(?:\\+_?)?(?=\\s*:)/,\n    operator: /[+\\-*\\/]/\n  })\n  Prism.languages.insertBefore('less', 'property', {\n    variable: [\n      // Variable declaration (the colon must be consumed!)\n      {\n        pattern: /@[\\w-]+\\s*:/,\n        inside: {\n          punctuation: /:/\n        }\n      }, // Variable usage\n      /@@?[\\w-]+/\n    ],\n    'mixin-usage': {\n      pattern: /([{;]\\s*)[.#](?!\\d)[\\w-].*?(?=[(;])/,\n      lookbehind: true,\n      alias: 'function'\n    }\n  })\n}\n"],"names":["less"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,WAAiBA;AACjB,EAAAA,MAAK,cAAc;AACnB,EAAAA,MAAK,UAAU,CAAA;AACf,WAASA,MAAK,OAAO;AAQnB,UAAM,UAAU,OAAO,MAAM,UAAU,OAAO,OAAO;AAAA,MACnD,SAAS;AAAA,QACP;AAAA,QACA;AAAA,UACE,SAAS;AAAA,UACT,YAAY;AAAA;;MAGhB,QAAQ;AAAA,QACN,SACE;AAAA,QACF,QAAQ;AAAA,UACN,aAAa;AAAA;;;MAIjB,UAAU;AAAA,QACR,SACE;AAAA,QACF,QAAQ;AAAA;AAAA,UAEN,UAAU;AAAA;;MAGd,UAAU;AAAA,MACV,UAAU;AAAA,IACd,CAAG;AACD,UAAM,UAAU,aAAa,QAAQ,YAAY;AAAA,MAC/C,UAAU;AAAA;AAAA,QAER;AAAA,UACE,SAAS;AAAA,UACT,QAAQ;AAAA,YACN,aAAa;AAAA;;;QAGjB;AAAA;MAEF,eAAe;AAAA,QACb,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,OAAO;AAAA;IAEb,CAAG;AAAA,EACH;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/lilypond-D9l9sq_L.js

@@ -0,0 +1,117 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+import { r as requireScheme } from "./scheme-BIkXa0-K.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 lilypond_1;
+var hasRequiredLilypond;
+function requireLilypond() {
+  if (hasRequiredLilypond) return lilypond_1;
+  hasRequiredLilypond = 1;
+  var refractorScheme = requireScheme();
+  lilypond_1 = lilypond2;
+  lilypond2.displayName = "lilypond";
+  lilypond2.aliases = [];
+  function lilypond2(Prism) {
+    Prism.register(refractorScheme);
+    (function(Prism2) {
+      var schemeExpression = /\((?:[^();"#\\]|\\[\s\S]|;.*(?!.)|"(?:[^"\\]|\\.)*"|#(?:\{(?:(?!#\})[\s\S])*#\}|[^{])|<expr>)*\)/.source;
+      var recursivenessLog2 = 5;
+      for (var i = 0; i < recursivenessLog2; i++) {
+        schemeExpression = schemeExpression.replace(/<expr>/g, function() {
+          return schemeExpression;
+        });
+      }
+      schemeExpression = schemeExpression.replace(/<expr>/g, /[^\s\S]/.source);
+      var lilypond3 = Prism2.languages.lilypond = {
+        comment: /%(?:(?!\{).*|\{[\s\S]*?%\})/,
+        "embedded-scheme": {
+          pattern: RegExp(
+            /(^|[=\s])#(?:"(?:[^"\\]|\\.)*"|[^\s()"]*(?:[^\s()]|<expr>))/.source.replace(
+              /<expr>/g,
+              function() {
+                return schemeExpression;
+              }
+            ),
+            "m"
+          ),
+          lookbehind: true,
+          greedy: true,
+          inside: {
+            scheme: {
+              pattern: /^(#)[\s\S]+$/,
+              lookbehind: true,
+              alias: "language-scheme",
+              inside: {
+                "embedded-lilypond": {
+                  pattern: /#\{[\s\S]*?#\}/,
+                  greedy: true,
+                  inside: {
+                    punctuation: /^#\{|#\}$/,
+                    lilypond: {
+                      pattern: /[\s\S]+/,
+                      alias: "language-lilypond",
+                      inside: null
+                      // see below
+                    }
+                  }
+                },
+                rest: Prism2.languages.scheme
+              }
+            },
+            punctuation: /#/
+          }
+        },
+        string: {
+          pattern: /"(?:[^"\\]|\\.)*"/,
+          greedy: true
+        },
+        "class-name": {
+          pattern: /(\\new\s+)[\w-]+/,
+          lookbehind: true
+        },
+        keyword: {
+          pattern: /\\[a-z][-\w]*/i,
+          inside: {
+            punctuation: /^\\/
+          }
+        },
+        operator: /[=|]|<<|>>/,
+        punctuation: {
+          pattern: /(^|[a-z\d])(?:'+|,+|[_^]?-[_^]?(?:[-+^!>._]|(?=\d))|[_^]\.?|[.!])|[{}()[\]<>^~]|\\[()[\]<>\\!]|--|__/,
+          lookbehind: true
+        },
+        number: /\b\d+(?:\/\d+)?\b/
+      };
+      lilypond3["embedded-scheme"].inside["scheme"].inside["embedded-lilypond"].inside["lilypond"].inside = lilypond3;
+      Prism2.languages.ly = lilypond3;
+    })(Prism);
+  }
+  return lilypond_1;
+}
+var lilypondExports = requireLilypond();
+const lilypond = /* @__PURE__ */ getDefaultExportFromCjs(lilypondExports);
+const lilypond$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: lilypond
+}, [lilypondExports]);
+export {
+  lilypond$1 as l
+};
+//# sourceMappingURL=lilypond-D9l9sq_L.js.map

package/dist/lilypond-D9l9sq_L.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lilypond-D9l9sq_L.js","sources":["../node_modules/refractor/lang/lilypond.js"],"sourcesContent":["'use strict'\nvar refractorScheme = require('./scheme.js')\nmodule.exports = lilypond\nlilypond.displayName = 'lilypond'\nlilypond.aliases = []\nfunction lilypond(Prism) {\n  Prism.register(refractorScheme)\n  ;(function (Prism) {\n    var schemeExpression =\n      /\\((?:[^();\"#\\\\]|\\\\[\\s\\S]|;.*(?!.)|\"(?:[^\"\\\\]|\\\\.)*\"|#(?:\\{(?:(?!#\\})[\\s\\S])*#\\}|[^{])|<expr>)*\\)/\n        .source // allow for up to pow(2, recursivenessLog2) many levels of recursive brace expressions\n    // For some reason, this can't be 4\n    var recursivenessLog2 = 5\n    for (var i = 0; i < recursivenessLog2; i++) {\n      schemeExpression = schemeExpression.replace(/<expr>/g, function () {\n        return schemeExpression\n      })\n    }\n    schemeExpression = schemeExpression.replace(/<expr>/g, /[^\\s\\S]/.source)\n    var lilypond = (Prism.languages.lilypond = {\n      comment: /%(?:(?!\\{).*|\\{[\\s\\S]*?%\\})/,\n      'embedded-scheme': {\n        pattern: RegExp(\n          /(^|[=\\s])#(?:\"(?:[^\"\\\\]|\\\\.)*\"|[^\\s()\"]*(?:[^\\s()]|<expr>))/.source.replace(\n            /<expr>/g,\n            function () {\n              return schemeExpression\n            }\n          ),\n          'm'\n        ),\n        lookbehind: true,\n        greedy: true,\n        inside: {\n          scheme: {\n            pattern: /^(#)[\\s\\S]+$/,\n            lookbehind: true,\n            alias: 'language-scheme',\n            inside: {\n              'embedded-lilypond': {\n                pattern: /#\\{[\\s\\S]*?#\\}/,\n                greedy: true,\n                inside: {\n                  punctuation: /^#\\{|#\\}$/,\n                  lilypond: {\n                    pattern: /[\\s\\S]+/,\n                    alias: 'language-lilypond',\n                    inside: null // see below\n                  }\n                }\n              },\n              rest: Prism.languages.scheme\n            }\n          },\n          punctuation: /#/\n        }\n      },\n      string: {\n        pattern: /\"(?:[^\"\\\\]|\\\\.)*\"/,\n        greedy: true\n      },\n      'class-name': {\n        pattern: /(\\\\new\\s+)[\\w-]+/,\n        lookbehind: true\n      },\n      keyword: {\n        pattern: /\\\\[a-z][-\\w]*/i,\n        inside: {\n          punctuation: /^\\\\/\n        }\n      },\n      operator: /[=|]|<<|>>/,\n      punctuation: {\n        pattern:\n          /(^|[a-z\\d])(?:'+|,+|[_^]?-[_^]?(?:[-+^!>._]|(?=\\d))|[_^]\\.?|[.!])|[{}()[\\]<>^~]|\\\\[()[\\]<>\\\\!]|--|__/,\n        lookbehind: true\n      },\n      number: /\\b\\d+(?:\\/\\d+)?\\b/\n    })\n    lilypond['embedded-scheme'].inside['scheme'].inside[\n      'embedded-lilypond'\n    ].inside['lilypond'].inside = lilypond\n    Prism.languages.ly = lilypond\n  })(Prism)\n}\n"],"names":["require$$0","lilypond","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AACA,MAAI,kBAAkBA,cAAA;AACtB,eAAiBC;AACjB,EAAAA,UAAS,cAAc;AACvB,EAAAA,UAAS,UAAU,CAAA;AACnB,WAASA,UAAS,OAAO;AACvB,UAAM,SAAS,eAAe;AAC7B,KAAC,SAAUC,QAAO;AACjB,UAAI,mBACF,mGACG;AAEL,UAAI,oBAAoB;AACxB,eAAS,IAAI,GAAG,IAAI,mBAAmB,KAAK;AAC1C,2BAAmB,iBAAiB,QAAQ,WAAW,WAAY;AACjE,iBAAO;AAAA,QACf,CAAO;AAAA,MACP;AACI,yBAAmB,iBAAiB,QAAQ,WAAW,UAAU,MAAM;AACvE,UAAID,YAAYC,OAAM,UAAU,WAAW;AAAA,QACzC,SAAS;AAAA,QACT,mBAAmB;AAAA,UACjB,SAAS;AAAA,YACP,8DAA8D,OAAO;AAAA,cACnE;AAAA,cACA,WAAY;AACV,uBAAO;AAAA,cACrB;AAAA;YAEU;AAAA;UAEF,YAAY;AAAA,UACZ,QAAQ;AAAA,UACR,QAAQ;AAAA,YACN,QAAQ;AAAA,cACN,SAAS;AAAA,cACT,YAAY;AAAA,cACZ,OAAO;AAAA,cACP,QAAQ;AAAA,gBACN,qBAAqB;AAAA,kBACnB,SAAS;AAAA,kBACT,QAAQ;AAAA,kBACR,QAAQ;AAAA,oBACN,aAAa;AAAA,oBACb,UAAU;AAAA,sBACR,SAAS;AAAA,sBACT,OAAO;AAAA,sBACP,QAAQ;AAAA;AAAA;;;gBAId,MAAMA,OAAM,UAAU;AAAA;;YAG1B,aAAa;AAAA;;QAGjB,QAAQ;AAAA,UACN,SAAS;AAAA,UACT,QAAQ;AAAA;QAEV,cAAc;AAAA,UACZ,SAAS;AAAA,UACT,YAAY;AAAA;QAEd,SAAS;AAAA,UACP,SAAS;AAAA,UACT,QAAQ;AAAA,YACN,aAAa;AAAA;;QAGjB,UAAU;AAAA,QACV,aAAa;AAAA,UACX,SACE;AAAA,UACF,YAAY;AAAA;QAEd,QAAQ;AAAA,MACd;AACI,MAAAD,UAAS,iBAAiB,EAAE,OAAO,QAAQ,EAAE,OAC3C,qBACA,OAAO,UAAU,EAAE,SAASA;AAC9B,MAAAC,OAAM,UAAU,KAAKD;AAAA,IACzB,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/liquid-Dkf7-nlZ.js

@@ -0,0 +1,112 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+import { r as requireMarkupTemplating } from "./markup-templating-hY-QSL53.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 liquid_1;
+var hasRequiredLiquid;
+function requireLiquid() {
+  if (hasRequiredLiquid) return liquid_1;
+  hasRequiredLiquid = 1;
+  var refractorMarkupTemplating = requireMarkupTemplating();
+  liquid_1 = liquid2;
+  liquid2.displayName = "liquid";
+  liquid2.aliases = [];
+  function liquid2(Prism) {
+    Prism.register(refractorMarkupTemplating);
+    Prism.languages.liquid = {
+      comment: {
+        pattern: /(^\{%\s*comment\s*%\})[\s\S]+(?=\{%\s*endcomment\s*%\}$)/,
+        lookbehind: true
+      },
+      delimiter: {
+        pattern: /^\{(?:\{\{|[%\{])-?|-?(?:\}\}|[%\}])\}$/,
+        alias: "punctuation"
+      },
+      string: {
+        pattern: /"[^"]*"|'[^']*'/,
+        greedy: true
+      },
+      keyword: /\b(?:as|assign|break|(?:end)?(?:capture|case|comment|for|form|if|paginate|raw|style|tablerow|unless)|continue|cycle|decrement|echo|else|elsif|in|include|increment|limit|liquid|offset|range|render|reversed|section|when|with)\b/,
+      object: /\b(?:address|all_country_option_tags|article|block|blog|cart|checkout|collection|color|country|country_option_tags|currency|current_page|current_tags|customer|customer_address|date|discount_allocation|discount_application|external_video|filter|filter_value|font|forloop|fulfillment|generic_file|gift_card|group|handle|image|line_item|link|linklist|localization|location|measurement|media|metafield|model|model_source|order|page|page_description|page_image|page_title|part|policy|product|product_option|recommendations|request|robots|routes|rule|script|search|selling_plan|selling_plan_allocation|selling_plan_group|shipping_method|shop|shop_locale|sitemap|store_availability|tax_line|template|theme|transaction|unit_price_measurement|user_agent|variant|video|video_source)\b/,
+      function: [
+        {
+          pattern: /(\|\s*)\w+/,
+          lookbehind: true,
+          alias: "filter"
+        },
+        {
+          // array functions
+          pattern: /(\.\s*)(?:first|last|size)/,
+          lookbehind: true
+        }
+      ],
+      boolean: /\b(?:false|nil|true)\b/,
+      range: {
+        pattern: /\.\./,
+        alias: "operator"
+      },
+      // https://github.com/Shopify/liquid/blob/698f5e0d967423e013f6169d9111bd969bd78337/lib/liquid/lexer.rb#L21
+      number: /\b\d+(?:\.\d+)?\b/,
+      operator: /[!=]=|<>|[<>]=?|[|?:=-]|\b(?:and|contains(?=\s)|or)\b/,
+      punctuation: /[.,\[\]()]/,
+      empty: {
+        pattern: /\bempty\b/,
+        alias: "keyword"
+      }
+    };
+    Prism.hooks.add("before-tokenize", function(env) {
+      var liquidPattern = /\{%\s*comment\s*%\}[\s\S]*?\{%\s*endcomment\s*%\}|\{(?:%[\s\S]*?%|\{\{[\s\S]*?\}\}|\{[\s\S]*?\})\}/g;
+      var insideRaw = false;
+      Prism.languages["markup-templating"].buildPlaceholders(
+        env,
+        "liquid",
+        liquidPattern,
+        function(match) {
+          var tagMatch = /^\{%-?\s*(\w+)/.exec(match);
+          if (tagMatch) {
+            var tag = tagMatch[1];
+            if (tag === "raw" && !insideRaw) {
+              insideRaw = true;
+              return true;
+            } else if (tag === "endraw") {
+              insideRaw = false;
+              return true;
+            }
+          }
+          return !insideRaw;
+        }
+      );
+    });
+    Prism.hooks.add("after-tokenize", function(env) {
+      Prism.languages["markup-templating"].tokenizePlaceholders(env, "liquid");
+    });
+  }
+  return liquid_1;
+}
+var liquidExports = requireLiquid();
+const liquid = /* @__PURE__ */ getDefaultExportFromCjs(liquidExports);
+const liquid$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: liquid
+}, [liquidExports]);
+export {
+  liquid$1 as l
+};
+//# sourceMappingURL=liquid-Dkf7-nlZ.js.map