@oscloudlab/knowledge-card 0.0.1 → 0.0.3

package/dist/smarty-CNnHhPeW.js

@@ -0,0 +1,171 @@
+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 smarty_1;
+var hasRequiredSmarty;
+function requireSmarty() {
+  if (hasRequiredSmarty) return smarty_1;
+  hasRequiredSmarty = 1;
+  var refractorMarkupTemplating = requireMarkupTemplating();
+  smarty_1 = smarty2;
+  smarty2.displayName = "smarty";
+  smarty2.aliases = [];
+  function smarty2(Prism) {
+    Prism.register(refractorMarkupTemplating);
+    (function(Prism2) {
+      Prism2.languages.smarty = {
+        comment: {
+          pattern: /^\{\*[\s\S]*?\*\}/,
+          greedy: true
+        },
+        "embedded-php": {
+          pattern: /^\{php\}[\s\S]*?\{\/php\}/,
+          greedy: true,
+          inside: {
+            smarty: {
+              pattern: /^\{php\}|\{\/php\}$/,
+              inside: null
+              // see below
+            },
+            php: {
+              pattern: /[\s\S]+/,
+              alias: "language-php",
+              inside: Prism2.languages.php
+            }
+          }
+        },
+        string: [
+          {
+            pattern: /"(?:\\.|[^"\\\r\n])*"/,
+            greedy: true,
+            inside: {
+              interpolation: {
+                pattern: /\{[^{}]*\}|`[^`]*`/,
+                inside: {
+                  "interpolation-punctuation": {
+                    pattern: /^[{`]|[`}]$/,
+                    alias: "punctuation"
+                  },
+                  expression: {
+                    pattern: /[\s\S]+/,
+                    inside: null
+                    // see below
+                  }
+                }
+              },
+              variable: /\$\w+/
+            }
+          },
+          {
+            pattern: /'(?:\\.|[^'\\\r\n])*'/,
+            greedy: true
+          }
+        ],
+        keyword: {
+          pattern: /(^\{\/?)[a-z_]\w*\b(?!\()/i,
+          lookbehind: true,
+          greedy: true
+        },
+        delimiter: {
+          pattern: /^\{\/?|\}$/,
+          greedy: true,
+          alias: "punctuation"
+        },
+        number: /\b0x[\dA-Fa-f]+|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee][-+]?\d+)?/,
+        variable: [
+          /\$(?!\d)\w+/,
+          /#(?!\d)\w+#/,
+          {
+            pattern: /(\.|->|\w\s*=)(?!\d)\w+\b(?!\()/,
+            lookbehind: true
+          },
+          {
+            pattern: /(\[)(?!\d)\w+(?=\])/,
+            lookbehind: true
+          }
+        ],
+        function: {
+          pattern: /(\|\s*)@?[a-z_]\w*|\b[a-z_]\w*(?=\()/i,
+          lookbehind: true
+        },
+        "attr-name": /\b[a-z_]\w*(?=\s*=)/i,
+        boolean: /\b(?:false|no|off|on|true|yes)\b/,
+        punctuation: /[\[\](){}.,:`]|->/,
+        operator: [
+          /[+\-*\/%]|==?=?|[!<>]=?|&&|\|\|?/,
+          /\bis\s+(?:not\s+)?(?:div|even|odd)(?:\s+by)?\b/,
+          /\b(?:and|eq|gt?e|gt|lt?e|lt|mod|neq?|not|or)\b/
+        ]
+      };
+      Prism2.languages.smarty["embedded-php"].inside.smarty.inside = Prism2.languages.smarty;
+      Prism2.languages.smarty.string[0].inside.interpolation.inside.expression.inside = Prism2.languages.smarty;
+      var string = /"(?:\\.|[^"\\\r\n])*"|'(?:\\.|[^'\\\r\n])*'/;
+      var smartyPattern = RegExp(
+        // comments
+        /\{\*[\s\S]*?\*\}/.source + "|" + // php tags
+        /\{php\}[\s\S]*?\{\/php\}/.source + "|" + // smarty blocks
+        /\{(?:[^{}"']|<str>|\{(?:[^{}"']|<str>|\{(?:[^{}"']|<str>)*\})*\})*\}/.source.replace(
+          /<str>/g,
+          function() {
+            return string.source;
+          }
+        ),
+        "g"
+      );
+      Prism2.hooks.add("before-tokenize", function(env) {
+        var smartyLiteralStart = "{literal}";
+        var smartyLiteralEnd = "{/literal}";
+        var smartyLiteralMode = false;
+        Prism2.languages["markup-templating"].buildPlaceholders(
+          env,
+          "smarty",
+          smartyPattern,
+          function(match) {
+            if (match === smartyLiteralEnd) {
+              smartyLiteralMode = false;
+            }
+            if (!smartyLiteralMode) {
+              if (match === smartyLiteralStart) {
+                smartyLiteralMode = true;
+              }
+              return true;
+            }
+            return false;
+          }
+        );
+      });
+      Prism2.hooks.add("after-tokenize", function(env) {
+        Prism2.languages["markup-templating"].tokenizePlaceholders(env, "smarty");
+      });
+    })(Prism);
+  }
+  return smarty_1;
+}
+var smartyExports = requireSmarty();
+const smarty = /* @__PURE__ */ getDefaultExportFromCjs(smartyExports);
+const smarty$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: smarty
+}, [smartyExports]);
+export {
+  smarty$1 as s
+};
+//# sourceMappingURL=smarty-CNnHhPeW.js.map

package/dist/smarty-CNnHhPeW.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"smarty-CNnHhPeW.js","sources":["../node_modules/refractor/lang/smarty.js"],"sourcesContent":["'use strict'\nvar refractorMarkupTemplating = require('./markup-templating.js')\nmodule.exports = smarty\nsmarty.displayName = 'smarty'\nsmarty.aliases = []\nfunction smarty(Prism) {\n  Prism.register(refractorMarkupTemplating)\n  ;(function (Prism) {\n    Prism.languages.smarty = {\n      comment: {\n        pattern: /^\\{\\*[\\s\\S]*?\\*\\}/,\n        greedy: true\n      },\n      'embedded-php': {\n        pattern: /^\\{php\\}[\\s\\S]*?\\{\\/php\\}/,\n        greedy: true,\n        inside: {\n          smarty: {\n            pattern: /^\\{php\\}|\\{\\/php\\}$/,\n            inside: null // see below\n          },\n          php: {\n            pattern: /[\\s\\S]+/,\n            alias: 'language-php',\n            inside: Prism.languages.php\n          }\n        }\n      },\n      string: [\n        {\n          pattern: /\"(?:\\\\.|[^\"\\\\\\r\\n])*\"/,\n          greedy: true,\n          inside: {\n            interpolation: {\n              pattern: /\\{[^{}]*\\}|`[^`]*`/,\n              inside: {\n                'interpolation-punctuation': {\n                  pattern: /^[{`]|[`}]$/,\n                  alias: 'punctuation'\n                },\n                expression: {\n                  pattern: /[\\s\\S]+/,\n                  inside: null // see below\n                }\n              }\n            },\n            variable: /\\$\\w+/\n          }\n        },\n        {\n          pattern: /'(?:\\\\.|[^'\\\\\\r\\n])*'/,\n          greedy: true\n        }\n      ],\n      keyword: {\n        pattern: /(^\\{\\/?)[a-z_]\\w*\\b(?!\\()/i,\n        lookbehind: true,\n        greedy: true\n      },\n      delimiter: {\n        pattern: /^\\{\\/?|\\}$/,\n        greedy: true,\n        alias: 'punctuation'\n      },\n      number: /\\b0x[\\dA-Fa-f]+|(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:[Ee][-+]?\\d+)?/,\n      variable: [\n        /\\$(?!\\d)\\w+/,\n        /#(?!\\d)\\w+#/,\n        {\n          pattern: /(\\.|->|\\w\\s*=)(?!\\d)\\w+\\b(?!\\()/,\n          lookbehind: true\n        },\n        {\n          pattern: /(\\[)(?!\\d)\\w+(?=\\])/,\n          lookbehind: true\n        }\n      ],\n      function: {\n        pattern: /(\\|\\s*)@?[a-z_]\\w*|\\b[a-z_]\\w*(?=\\()/i,\n        lookbehind: true\n      },\n      'attr-name': /\\b[a-z_]\\w*(?=\\s*=)/i,\n      boolean: /\\b(?:false|no|off|on|true|yes)\\b/,\n      punctuation: /[\\[\\](){}.,:`]|->/,\n      operator: [\n        /[+\\-*\\/%]|==?=?|[!<>]=?|&&|\\|\\|?/,\n        /\\bis\\s+(?:not\\s+)?(?:div|even|odd)(?:\\s+by)?\\b/,\n        /\\b(?:and|eq|gt?e|gt|lt?e|lt|mod|neq?|not|or)\\b/\n      ]\n    }\n    Prism.languages.smarty['embedded-php'].inside.smarty.inside =\n      Prism.languages.smarty\n    Prism.languages.smarty.string[0].inside.interpolation.inside.expression.inside =\n      Prism.languages.smarty\n    var string = /\"(?:\\\\.|[^\"\\\\\\r\\n])*\"|'(?:\\\\.|[^'\\\\\\r\\n])*'/\n    var smartyPattern = RegExp(\n      // comments\n      /\\{\\*[\\s\\S]*?\\*\\}/.source +\n        '|' + // php tags\n        /\\{php\\}[\\s\\S]*?\\{\\/php\\}/.source +\n        '|' + // smarty blocks\n        /\\{(?:[^{}\"']|<str>|\\{(?:[^{}\"']|<str>|\\{(?:[^{}\"']|<str>)*\\})*\\})*\\}/.source.replace(\n          /<str>/g,\n          function () {\n            return string.source\n          }\n        ),\n      'g'\n    ) // Tokenize all inline Smarty expressions\n    Prism.hooks.add('before-tokenize', function (env) {\n      var smartyLiteralStart = '{literal}'\n      var smartyLiteralEnd = '{/literal}'\n      var smartyLiteralMode = false\n      Prism.languages['markup-templating'].buildPlaceholders(\n        env,\n        'smarty',\n        smartyPattern,\n        function (match) {\n          // Smarty tags inside {literal} block are ignored\n          if (match === smartyLiteralEnd) {\n            smartyLiteralMode = false\n          }\n          if (!smartyLiteralMode) {\n            if (match === smartyLiteralStart) {\n              smartyLiteralMode = true\n            }\n            return true\n          }\n          return false\n        }\n      )\n    }) // Re-insert the tokens after tokenizing\n    Prism.hooks.add('after-tokenize', function (env) {\n      Prism.languages['markup-templating'].tokenizePlaceholders(env, 'smarty')\n    })\n  })(Prism)\n}\n"],"names":["require$$0","smarty","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AACA,MAAI,4BAA4BA,wBAAA;AAChC,aAAiBC;AACjB,EAAAA,QAAO,cAAc;AACrB,EAAAA,QAAO,UAAU,CAAA;AACjB,WAASA,QAAO,OAAO;AACrB,UAAM,SAAS,yBAAyB;AACvC,KAAC,SAAUC,QAAO;AACjB,MAAAA,OAAM,UAAU,SAAS;AAAA,QACvB,SAAS;AAAA,UACP,SAAS;AAAA,UACT,QAAQ;AAAA;QAEV,gBAAgB;AAAA,UACd,SAAS;AAAA,UACT,QAAQ;AAAA,UACR,QAAQ;AAAA,YACN,QAAQ;AAAA,cACN,SAAS;AAAA,cACT,QAAQ;AAAA;AAAA;YAEV,KAAK;AAAA,cACH,SAAS;AAAA,cACT,OAAO;AAAA,cACP,QAAQA,OAAM,UAAU;AAAA;;;QAI9B,QAAQ;AAAA,UACN;AAAA,YACE,SAAS;AAAA,YACT,QAAQ;AAAA,YACR,QAAQ;AAAA,cACN,eAAe;AAAA,gBACb,SAAS;AAAA,gBACT,QAAQ;AAAA,kBACN,6BAA6B;AAAA,oBAC3B,SAAS;AAAA,oBACT,OAAO;AAAA;kBAET,YAAY;AAAA,oBACV,SAAS;AAAA,oBACT,QAAQ;AAAA;AAAA;;;cAId,UAAU;AAAA;;UAGd;AAAA,YACE,SAAS;AAAA,YACT,QAAQ;AAAA;;QAGZ,SAAS;AAAA,UACP,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,QAAQ;AAAA;QAEV,WAAW;AAAA,UACT,SAAS;AAAA,UACT,QAAQ;AAAA,UACR,OAAO;AAAA;QAET,QAAQ;AAAA,QACR,UAAU;AAAA,UACR;AAAA,UACA;AAAA,UACA;AAAA,YACE,SAAS;AAAA,YACT,YAAY;AAAA;UAEd;AAAA,YACE,SAAS;AAAA,YACT,YAAY;AAAA;;QAGhB,UAAU;AAAA,UACR,SAAS;AAAA,UACT,YAAY;AAAA;QAEd,aAAa;AAAA,QACb,SAAS;AAAA,QACT,aAAa;AAAA,QACb,UAAU;AAAA,UACR;AAAA,UACA;AAAA,UACA;AAAA;;AAGJ,MAAAA,OAAM,UAAU,OAAO,cAAc,EAAE,OAAO,OAAO,SACnDA,OAAM,UAAU;AAClB,MAAAA,OAAM,UAAU,OAAO,OAAO,CAAC,EAAE,OAAO,cAAc,OAAO,WAAW,SACtEA,OAAM,UAAU;AAClB,UAAI,SAAS;AACb,UAAI,gBAAgB;AAAA;AAAA,QAElB,mBAAmB,SACjB;AAAA,QACA,2BAA2B,SAC3B;AAAA,QACA,uEAAuE,OAAO;AAAA,UAC5E;AAAA,UACA,WAAY;AACV,mBAAO,OAAO;AAAA,UAC1B;AAAA;QAEM;AAAA;AAEF,MAAAA,OAAM,MAAM,IAAI,mBAAmB,SAAU,KAAK;AAChD,YAAI,qBAAqB;AACzB,YAAI,mBAAmB;AACvB,YAAI,oBAAoB;AACxB,QAAAA,OAAM,UAAU,mBAAmB,EAAE;AAAA,UACnC;AAAA,UACA;AAAA,UACA;AAAA,UACA,SAAU,OAAO;AAEf,gBAAI,UAAU,kBAAkB;AAC9B,kCAAoB;AAAA,YAChC;AACU,gBAAI,CAAC,mBAAmB;AACtB,kBAAI,UAAU,oBAAoB;AAChC,oCAAoB;AAAA,cAClC;AACY,qBAAO;AAAA,YACnB;AACU,mBAAO;AAAA,UACjB;AAAA;MAEA,CAAK;AACD,MAAAA,OAAM,MAAM,IAAI,kBAAkB,SAAU,KAAK;AAC/C,QAAAA,OAAM,UAAU,mBAAmB,EAAE,qBAAqB,KAAK,QAAQ;AAAA,MAC7E,CAAK;AAAA,IACL,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/sml-D0AOYgn7.js

@@ -0,0 +1,102 @@
+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 sml_1;
+var hasRequiredSml;
+function requireSml() {
+  if (hasRequiredSml) return sml_1;
+  hasRequiredSml = 1;
+  sml_1 = sml2;
+  sml2.displayName = "sml";
+  sml2.aliases = ["smlnj"];
+  function sml2(Prism) {
+    (function(Prism2) {
+      var keywords = /\b(?:abstype|and|andalso|as|case|datatype|do|else|end|eqtype|exception|fn|fun|functor|handle|if|in|include|infix|infixr|let|local|nonfix|of|op|open|orelse|raise|rec|sharing|sig|signature|struct|structure|then|type|val|where|while|with|withtype)\b/i;
+      Prism2.languages.sml = {
+        // allow one level of nesting
+        comment: /\(\*(?:[^*(]|\*(?!\))|\((?!\*)|\(\*(?:[^*(]|\*(?!\))|\((?!\*))*\*\))*\*\)/,
+        string: {
+          pattern: /#?"(?:[^"\\]|\\.)*"/,
+          greedy: true
+        },
+        "class-name": [
+          {
+            // This is only an approximation since the real grammar is context-free
+            //
+            // Why the main loop so complex?
+            // The main loop is approximately the same as /(?:\s*(?:[*,]|->)\s*<TERMINAL>)*/ which is, obviously, a lot
+            // simpler. The difference is that if a comma is the last iteration of the loop, then the terminal must be
+            // followed by a long identifier.
+            pattern: RegExp(
+              /((?:^|[^:]):\s*)<TERMINAL>(?:\s*(?:(?:\*|->)\s*<TERMINAL>|,\s*<TERMINAL>(?:(?=<NOT-LAST>)|(?!<NOT-LAST>)\s+<LONG-ID>)))*/.source.replace(/<NOT-LAST>/g, function() {
+                return /\s*(?:[*,]|->)/.source;
+              }).replace(/<TERMINAL>/g, function() {
+                return /(?:'[\w']*|<LONG-ID>|\((?:[^()]|\([^()]*\))*\)|\{(?:[^{}]|\{[^{}]*\})*\})(?:\s+<LONG-ID>)*/.source;
+              }).replace(/<LONG-ID>/g, function() {
+                return /(?!<KEYWORD>)[a-z\d_][\w'.]*/.source;
+              }).replace(/<KEYWORD>/g, function() {
+                return keywords.source;
+              }),
+              "i"
+            ),
+            lookbehind: true,
+            greedy: true,
+            inside: null
+            // see below
+          },
+          {
+            pattern: /((?:^|[^\w'])(?:datatype|exception|functor|signature|structure|type)\s+)[a-z_][\w'.]*/i,
+            lookbehind: true
+          }
+        ],
+        function: {
+          pattern: /((?:^|[^\w'])fun\s+)[a-z_][\w'.]*/i,
+          lookbehind: true
+        },
+        keyword: keywords,
+        variable: {
+          pattern: /(^|[^\w'])'[\w']*/,
+          lookbehind: true
+        },
+        number: /~?\b(?:\d+(?:\.\d+)?(?:e~?\d+)?|0x[\da-f]+)\b/i,
+        word: {
+          pattern: /\b0w(?:\d+|x[\da-f]+)\b/i,
+          alias: "constant"
+        },
+        boolean: /\b(?:false|true)\b/i,
+        operator: /\.\.\.|:[>=:]|=>?|->|[<>]=?|[!+\-*/^#|@~]/,
+        punctuation: /[(){}\[\].:,;]/
+      };
+      Prism2.languages.sml["class-name"][0].inside = Prism2.languages.sml;
+      Prism2.languages.smlnj = Prism2.languages.sml;
+    })(Prism);
+  }
+  return sml_1;
+}
+var smlExports = requireSml();
+const sml = /* @__PURE__ */ getDefaultExportFromCjs(smlExports);
+const sml$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: sml
+}, [smlExports]);
+export {
+  sml$1 as s
+};
+//# sourceMappingURL=sml-D0AOYgn7.js.map

package/dist/sml-D0AOYgn7.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sml-D0AOYgn7.js","sources":["../node_modules/refractor/lang/sml.js"],"sourcesContent":["'use strict'\n\nmodule.exports = sml\nsml.displayName = 'sml'\nsml.aliases = ['smlnj']\nfunction sml(Prism) {\n  // https://smlfamily.github.io/sml97-defn.pdf\n  // https://people.mpi-sws.org/~rossberg/sml.html\n  ;(function (Prism) {\n    var keywords =\n      /\\b(?:abstype|and|andalso|as|case|datatype|do|else|end|eqtype|exception|fn|fun|functor|handle|if|in|include|infix|infixr|let|local|nonfix|of|op|open|orelse|raise|rec|sharing|sig|signature|struct|structure|then|type|val|where|while|with|withtype)\\b/i\n    Prism.languages.sml = {\n      // allow one level of nesting\n      comment:\n        /\\(\\*(?:[^*(]|\\*(?!\\))|\\((?!\\*)|\\(\\*(?:[^*(]|\\*(?!\\))|\\((?!\\*))*\\*\\))*\\*\\)/,\n      string: {\n        pattern: /#?\"(?:[^\"\\\\]|\\\\.)*\"/,\n        greedy: true\n      },\n      'class-name': [\n        {\n          // This is only an approximation since the real grammar is context-free\n          //\n          // Why the main loop so complex?\n          // The main loop is approximately the same as /(?:\\s*(?:[*,]|->)\\s*<TERMINAL>)*/ which is, obviously, a lot\n          // simpler. The difference is that if a comma is the last iteration of the loop, then the terminal must be\n          // followed by a long identifier.\n          pattern: RegExp(\n            /((?:^|[^:]):\\s*)<TERMINAL>(?:\\s*(?:(?:\\*|->)\\s*<TERMINAL>|,\\s*<TERMINAL>(?:(?=<NOT-LAST>)|(?!<NOT-LAST>)\\s+<LONG-ID>)))*/.source\n              .replace(/<NOT-LAST>/g, function () {\n                return /\\s*(?:[*,]|->)/.source\n              })\n              .replace(/<TERMINAL>/g, function () {\n                return /(?:'[\\w']*|<LONG-ID>|\\((?:[^()]|\\([^()]*\\))*\\)|\\{(?:[^{}]|\\{[^{}]*\\})*\\})(?:\\s+<LONG-ID>)*/\n                  .source\n              })\n              .replace(/<LONG-ID>/g, function () {\n                return /(?!<KEYWORD>)[a-z\\d_][\\w'.]*/.source\n              })\n              .replace(/<KEYWORD>/g, function () {\n                return keywords.source\n              }),\n            'i'\n          ),\n          lookbehind: true,\n          greedy: true,\n          inside: null // see below\n        },\n        {\n          pattern:\n            /((?:^|[^\\w'])(?:datatype|exception|functor|signature|structure|type)\\s+)[a-z_][\\w'.]*/i,\n          lookbehind: true\n        }\n      ],\n      function: {\n        pattern: /((?:^|[^\\w'])fun\\s+)[a-z_][\\w'.]*/i,\n        lookbehind: true\n      },\n      keyword: keywords,\n      variable: {\n        pattern: /(^|[^\\w'])'[\\w']*/,\n        lookbehind: true\n      },\n      number: /~?\\b(?:\\d+(?:\\.\\d+)?(?:e~?\\d+)?|0x[\\da-f]+)\\b/i,\n      word: {\n        pattern: /\\b0w(?:\\d+|x[\\da-f]+)\\b/i,\n        alias: 'constant'\n      },\n      boolean: /\\b(?:false|true)\\b/i,\n      operator: /\\.\\.\\.|:[>=:]|=>?|->|[<>]=?|[!+\\-*/^#|@~]/,\n      punctuation: /[(){}\\[\\].:,;]/\n    }\n    Prism.languages.sml['class-name'][0].inside = Prism.languages.sml\n    Prism.languages.smlnj = Prism.languages.sml\n  })(Prism)\n}\n"],"names":["sml","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,UAAiBA;AACjB,EAAAA,KAAI,cAAc;AAClB,EAAAA,KAAI,UAAU,CAAC,OAAO;AACtB,WAASA,KAAI,OAAO;AAGjB,KAAC,SAAUC,QAAO;AACjB,UAAI,WACF;AACF,MAAAA,OAAM,UAAU,MAAM;AAAA;AAAA,QAEpB,SACE;AAAA,QACF,QAAQ;AAAA,UACN,SAAS;AAAA,UACT,QAAQ;AAAA;QAEV,cAAc;AAAA,UACZ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,YAOE,SAAS;AAAA,cACP,2HAA2H,OACxH,QAAQ,eAAe,WAAY;AAClC,uBAAO,iBAAiB;AAAA,cACxC,CAAe,EACA,QAAQ,eAAe,WAAY;AAClC,uBAAO,6FACJ;AAAA,cACnB,CAAe,EACA,QAAQ,cAAc,WAAY;AACjC,uBAAO,+BAA+B;AAAA,cACtD,CAAe,EACA,QAAQ,cAAc,WAAY;AACjC,uBAAO,SAAS;AAAA,cAChC,CAAe;AAAA,cACH;AAAA;YAEF,YAAY;AAAA,YACZ,QAAQ;AAAA,YACR,QAAQ;AAAA;AAAA;UAEV;AAAA,YACE,SACE;AAAA,YACF,YAAY;AAAA;;QAGhB,UAAU;AAAA,UACR,SAAS;AAAA,UACT,YAAY;AAAA;QAEd,SAAS;AAAA,QACT,UAAU;AAAA,UACR,SAAS;AAAA,UACT,YAAY;AAAA;QAEd,QAAQ;AAAA,QACR,MAAM;AAAA,UACJ,SAAS;AAAA,UACT,OAAO;AAAA;QAET,SAAS;AAAA,QACT,UAAU;AAAA,QACV,aAAa;AAAA;AAEf,MAAAA,OAAM,UAAU,IAAI,YAAY,EAAE,CAAC,EAAE,SAASA,OAAM,UAAU;AAC9D,MAAAA,OAAM,UAAU,QAAQA,OAAM,UAAU;AAAA,IAC5C,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/solidity-wNxM4SRR.js

@@ -0,0 +1,61 @@
+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 solidity_1;
+var hasRequiredSolidity;
+function requireSolidity() {
+  if (hasRequiredSolidity) return solidity_1;
+  hasRequiredSolidity = 1;
+  solidity_1 = solidity2;
+  solidity2.displayName = "solidity";
+  solidity2.aliases = ["sol"];
+  function solidity2(Prism) {
+    Prism.languages.solidity = Prism.languages.extend("clike", {
+      "class-name": {
+        pattern: /(\b(?:contract|enum|interface|library|new|struct|using)\s+)(?!\d)[\w$]+/,
+        lookbehind: true
+      },
+      keyword: /\b(?:_|anonymous|as|assembly|assert|break|calldata|case|constant|constructor|continue|contract|default|delete|do|else|emit|enum|event|external|for|from|function|if|import|indexed|inherited|interface|internal|is|let|library|mapping|memory|modifier|new|payable|pragma|private|public|pure|require|returns?|revert|selfdestruct|solidity|storage|struct|suicide|switch|this|throw|using|var|view|while)\b/,
+      operator: /=>|->|:=|=:|\*\*|\+\+|--|\|\||&&|<<=?|>>=?|[-+*/%^&|<>!=]=?|[~?]/
+    });
+    Prism.languages.insertBefore("solidity", "keyword", {
+      builtin: /\b(?:address|bool|byte|u?int(?:8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?|string|bytes(?:[1-9]|[12]\d|3[0-2])?)\b/
+    });
+    Prism.languages.insertBefore("solidity", "number", {
+      version: {
+        pattern: /([<>]=?|\^)\d+\.\d+\.\d+\b/,
+        lookbehind: true,
+        alias: "number"
+      }
+    });
+    Prism.languages.sol = Prism.languages.solidity;
+  }
+  return solidity_1;
+}
+var solidityExports = requireSolidity();
+const solidity = /* @__PURE__ */ getDefaultExportFromCjs(solidityExports);
+const solidity$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: solidity
+}, [solidityExports]);
+export {
+  solidity$1 as s
+};
+//# sourceMappingURL=solidity-wNxM4SRR.js.map

package/dist/solidity-wNxM4SRR.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"solidity-wNxM4SRR.js","sources":["../node_modules/refractor/lang/solidity.js"],"sourcesContent":["'use strict'\n\nmodule.exports = solidity\nsolidity.displayName = 'solidity'\nsolidity.aliases = ['sol']\nfunction solidity(Prism) {\n  Prism.languages.solidity = Prism.languages.extend('clike', {\n    'class-name': {\n      pattern:\n        /(\\b(?:contract|enum|interface|library|new|struct|using)\\s+)(?!\\d)[\\w$]+/,\n      lookbehind: true\n    },\n    keyword:\n      /\\b(?:_|anonymous|as|assembly|assert|break|calldata|case|constant|constructor|continue|contract|default|delete|do|else|emit|enum|event|external|for|from|function|if|import|indexed|inherited|interface|internal|is|let|library|mapping|memory|modifier|new|payable|pragma|private|public|pure|require|returns?|revert|selfdestruct|solidity|storage|struct|suicide|switch|this|throw|using|var|view|while)\\b/,\n    operator: /=>|->|:=|=:|\\*\\*|\\+\\+|--|\\|\\||&&|<<=?|>>=?|[-+*/%^&|<>!=]=?|[~?]/\n  })\n  Prism.languages.insertBefore('solidity', 'keyword', {\n    builtin:\n      /\\b(?:address|bool|byte|u?int(?:8|16|24|32|40|48|56|64|72|80|88|96|104|112|120|128|136|144|152|160|168|176|184|192|200|208|216|224|232|240|248|256)?|string|bytes(?:[1-9]|[12]\\d|3[0-2])?)\\b/\n  })\n  Prism.languages.insertBefore('solidity', 'number', {\n    version: {\n      pattern: /([<>]=?|\\^)\\d+\\.\\d+\\.\\d+\\b/,\n      lookbehind: true,\n      alias: 'number'\n    }\n  })\n  Prism.languages.sol = Prism.languages.solidity\n}\n"],"names":["solidity"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,eAAiBA;AACjB,EAAAA,UAAS,cAAc;AACvB,EAAAA,UAAS,UAAU,CAAC,KAAK;AACzB,WAASA,UAAS,OAAO;AACvB,UAAM,UAAU,WAAW,MAAM,UAAU,OAAO,SAAS;AAAA,MACzD,cAAc;AAAA,QACZ,SACE;AAAA,QACF,YAAY;AAAA;MAEd,SACE;AAAA,MACF,UAAU;AAAA,IACd,CAAG;AACD,UAAM,UAAU,aAAa,YAAY,WAAW;AAAA,MAClD,SACE;AAAA,IACN,CAAG;AACD,UAAM,UAAU,aAAa,YAAY,UAAU;AAAA,MACjD,SAAS;AAAA,QACP,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,OAAO;AAAA;IAEb,CAAG;AACD,UAAM,UAAU,MAAM,MAAM,UAAU;AAAA,EACxC;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/solution-file-DGyaXqLI.js

@@ -0,0 +1,89 @@
+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 solutionFile_1;
+var hasRequiredSolutionFile;
+function requireSolutionFile() {
+  if (hasRequiredSolutionFile) return solutionFile_1;
+  hasRequiredSolutionFile = 1;
+  solutionFile_1 = solutionFile2;
+  solutionFile2.displayName = "solutionFile";
+  solutionFile2.aliases = [];
+  function solutionFile2(Prism) {
+    (function(Prism2) {
+      var guid = {
+        // https://en.wikipedia.org/wiki/Universally_unique_identifier#Format
+        pattern: /\{[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}\}/i,
+        alias: "constant",
+        inside: {
+          punctuation: /[{}]/
+        }
+      };
+      Prism2.languages["solution-file"] = {
+        comment: {
+          pattern: /#.*/,
+          greedy: true
+        },
+        string: {
+          pattern: /"[^"\r\n]*"|'[^'\r\n]*'/,
+          greedy: true,
+          inside: {
+            guid
+          }
+        },
+        object: {
+          // Foo
+          //   Bar("abs") = 9
+          //   EndBar
+          //   Prop = TRUE
+          // EndFoo
+          pattern: /^([ \t]*)(?:([A-Z]\w*)\b(?=.*(?:\r\n?|\n)(?:\1[ \t].*(?:\r\n?|\n))*\1End\2(?=[ \t]*$))|End[A-Z]\w*(?=[ \t]*$))/m,
+          lookbehind: true,
+          greedy: true,
+          alias: "keyword"
+        },
+        property: {
+          pattern: /^([ \t]*)(?!\s)[^\r\n"#=()]*[^\s"#=()](?=\s*=)/m,
+          lookbehind: true,
+          inside: {
+            guid
+          }
+        },
+        guid,
+        number: /\b\d+(?:\.\d+)*\b/,
+        boolean: /\b(?:FALSE|TRUE)\b/,
+        operator: /=/,
+        punctuation: /[(),]/
+      };
+      Prism2.languages["sln"] = Prism2.languages["solution-file"];
+    })(Prism);
+  }
+  return solutionFile_1;
+}
+var solutionFileExports = requireSolutionFile();
+const solutionFile = /* @__PURE__ */ getDefaultExportFromCjs(solutionFileExports);
+const solutionFile$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: solutionFile
+}, [solutionFileExports]);
+export {
+  solutionFile$1 as s
+};
+//# sourceMappingURL=solution-file-DGyaXqLI.js.map

package/dist/solution-file-DGyaXqLI.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"solution-file-DGyaXqLI.js","sources":["../node_modules/refractor/lang/solution-file.js"],"sourcesContent":["'use strict'\n\nmodule.exports = solutionFile\nsolutionFile.displayName = 'solutionFile'\nsolutionFile.aliases = []\nfunction solutionFile(Prism) {\n  ;(function (Prism) {\n    var guid = {\n      // https://en.wikipedia.org/wiki/Universally_unique_identifier#Format\n      pattern: /\\{[\\da-f]{8}-[\\da-f]{4}-[\\da-f]{4}-[\\da-f]{4}-[\\da-f]{12}\\}/i,\n      alias: 'constant',\n      inside: {\n        punctuation: /[{}]/\n      }\n    }\n    Prism.languages['solution-file'] = {\n      comment: {\n        pattern: /#.*/,\n        greedy: true\n      },\n      string: {\n        pattern: /\"[^\"\\r\\n]*\"|'[^'\\r\\n]*'/,\n        greedy: true,\n        inside: {\n          guid: guid\n        }\n      },\n      object: {\n        // Foo\n        //   Bar(\"abs\") = 9\n        //   EndBar\n        //   Prop = TRUE\n        // EndFoo\n        pattern:\n          /^([ \\t]*)(?:([A-Z]\\w*)\\b(?=.*(?:\\r\\n?|\\n)(?:\\1[ \\t].*(?:\\r\\n?|\\n))*\\1End\\2(?=[ \\t]*$))|End[A-Z]\\w*(?=[ \\t]*$))/m,\n        lookbehind: true,\n        greedy: true,\n        alias: 'keyword'\n      },\n      property: {\n        pattern: /^([ \\t]*)(?!\\s)[^\\r\\n\"#=()]*[^\\s\"#=()](?=\\s*=)/m,\n        lookbehind: true,\n        inside: {\n          guid: guid\n        }\n      },\n      guid: guid,\n      number: /\\b\\d+(?:\\.\\d+)*\\b/,\n      boolean: /\\b(?:FALSE|TRUE)\\b/,\n      operator: /=/,\n      punctuation: /[(),]/\n    }\n    Prism.languages['sln'] = Prism.languages['solution-file']\n  })(Prism)\n}\n"],"names":["solutionFile","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,mBAAiBA;AACjB,EAAAA,cAAa,cAAc;AAC3B,EAAAA,cAAa,UAAU,CAAA;AACvB,WAASA,cAAa,OAAO;AAC1B,KAAC,SAAUC,QAAO;AACjB,UAAI,OAAO;AAAA;AAAA,QAET,SAAS;AAAA,QACT,OAAO;AAAA,QACP,QAAQ;AAAA,UACN,aAAa;AAAA;;AAGjB,MAAAA,OAAM,UAAU,eAAe,IAAI;AAAA,QACjC,SAAS;AAAA,UACP,SAAS;AAAA,UACT,QAAQ;AAAA;QAEV,QAAQ;AAAA,UACN,SAAS;AAAA,UACT,QAAQ;AAAA,UACR,QAAQ;AAAA,YACN;AAAA;;QAGJ,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UAMN,SACE;AAAA,UACF,YAAY;AAAA,UACZ,QAAQ;AAAA,UACR,OAAO;AAAA;QAET,UAAU;AAAA,UACR,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,QAAQ;AAAA,YACN;AAAA;;QAGJ;AAAA,QACA,QAAQ;AAAA,QACR,SAAS;AAAA,QACT,UAAU;AAAA,QACV,aAAa;AAAA;AAEf,MAAAA,OAAM,UAAU,KAAK,IAAIA,OAAM,UAAU,eAAe;AAAA,IAC5D,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/soy-31Xz5sto.js

@@ -0,0 +1,136 @@
+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 soy_1;
+var hasRequiredSoy;
+function requireSoy() {
+  if (hasRequiredSoy) return soy_1;
+  hasRequiredSoy = 1;
+  var refractorMarkupTemplating = requireMarkupTemplating();
+  soy_1 = soy2;
+  soy2.displayName = "soy";
+  soy2.aliases = [];
+  function soy2(Prism) {
+    Prism.register(refractorMarkupTemplating);
+    (function(Prism2) {
+      var stringPattern = /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/;
+      var numberPattern = /\b\d+(?:\.\d+)?(?:[eE][+-]?\d+)?\b|\b0x[\dA-F]+\b/;
+      Prism2.languages.soy = {
+        comment: [
+          /\/\*[\s\S]*?\*\//,
+          {
+            pattern: /(\s)\/\/.*/,
+            lookbehind: true,
+            greedy: true
+          }
+        ],
+        "command-arg": {
+          pattern: /(\{+\/?\s*(?:alias|call|delcall|delpackage|deltemplate|namespace|template)\s+)\.?[\w.]+/,
+          lookbehind: true,
+          alias: "string",
+          inside: {
+            punctuation: /\./
+          }
+        },
+        parameter: {
+          pattern: /(\{+\/?\s*@?param\??\s+)\.?[\w.]+/,
+          lookbehind: true,
+          alias: "variable"
+        },
+        keyword: [
+          {
+            pattern: /(\{+\/?[^\S\r\n]*)(?:\\[nrt]|alias|call|case|css|default|delcall|delpackage|deltemplate|else(?:if)?|fallbackmsg|for(?:each)?|if(?:empty)?|lb|let|literal|msg|namespace|nil|@?param\??|rb|sp|switch|template|xid)/,
+            lookbehind: true
+          },
+          /\b(?:any|as|attributes|bool|css|float|html|in|int|js|list|map|null|number|string|uri)\b/
+        ],
+        delimiter: {
+          pattern: /^\{+\/?|\/?\}+$/,
+          alias: "punctuation"
+        },
+        property: /\w+(?==)/,
+        variable: {
+          pattern: /\$[^\W\d]\w*(?:\??(?:\.\w+|\[[^\]]+\]))*/,
+          inside: {
+            string: {
+              pattern: stringPattern,
+              greedy: true
+            },
+            number: numberPattern,
+            punctuation: /[\[\].?]/
+          }
+        },
+        string: {
+          pattern: stringPattern,
+          greedy: true
+        },
+        function: [
+          /\w+(?=\()/,
+          {
+            pattern: /(\|[^\S\r\n]*)\w+/,
+            lookbehind: true
+          }
+        ],
+        boolean: /\b(?:false|true)\b/,
+        number: numberPattern,
+        operator: /\?:?|<=?|>=?|==?|!=|[+*/%-]|\b(?:and|not|or)\b/,
+        punctuation: /[{}()\[\]|.,:]/
+      };
+      Prism2.hooks.add("before-tokenize", function(env) {
+        var soyPattern = /\{\{.+?\}\}|\{.+?\}|\s\/\/.*|\/\*[\s\S]*?\*\//g;
+        var soyLitteralStart = "{literal}";
+        var soyLitteralEnd = "{/literal}";
+        var soyLitteralMode = false;
+        Prism2.languages["markup-templating"].buildPlaceholders(
+          env,
+          "soy",
+          soyPattern,
+          function(match) {
+            if (match === soyLitteralEnd) {
+              soyLitteralMode = false;
+            }
+            if (!soyLitteralMode) {
+              if (match === soyLitteralStart) {
+                soyLitteralMode = true;
+              }
+              return true;
+            }
+            return false;
+          }
+        );
+      });
+      Prism2.hooks.add("after-tokenize", function(env) {
+        Prism2.languages["markup-templating"].tokenizePlaceholders(env, "soy");
+      });
+    })(Prism);
+  }
+  return soy_1;
+}
+var soyExports = requireSoy();
+const soy = /* @__PURE__ */ getDefaultExportFromCjs(soyExports);
+const soy$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: soy
+}, [soyExports]);
+export {
+  soy$1 as s
+};
+//# sourceMappingURL=soy-31Xz5sto.js.map

package/dist/soy-31Xz5sto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"soy-31Xz5sto.js","sources":["../node_modules/refractor/lang/soy.js"],"sourcesContent":["'use strict'\nvar refractorMarkupTemplating = require('./markup-templating.js')\nmodule.exports = soy\nsoy.displayName = 'soy'\nsoy.aliases = []\nfunction soy(Prism) {\n  Prism.register(refractorMarkupTemplating)\n  ;(function (Prism) {\n    var stringPattern = /([\"'])(?:\\\\(?:\\r\\n|[\\s\\S])|(?!\\1)[^\\\\\\r\\n])*\\1/\n    var numberPattern = /\\b\\d+(?:\\.\\d+)?(?:[eE][+-]?\\d+)?\\b|\\b0x[\\dA-F]+\\b/\n    Prism.languages.soy = {\n      comment: [\n        /\\/\\*[\\s\\S]*?\\*\\//,\n        {\n          pattern: /(\\s)\\/\\/.*/,\n          lookbehind: true,\n          greedy: true\n        }\n      ],\n      'command-arg': {\n        pattern:\n          /(\\{+\\/?\\s*(?:alias|call|delcall|delpackage|deltemplate|namespace|template)\\s+)\\.?[\\w.]+/,\n        lookbehind: true,\n        alias: 'string',\n        inside: {\n          punctuation: /\\./\n        }\n      },\n      parameter: {\n        pattern: /(\\{+\\/?\\s*@?param\\??\\s+)\\.?[\\w.]+/,\n        lookbehind: true,\n        alias: 'variable'\n      },\n      keyword: [\n        {\n          pattern:\n            /(\\{+\\/?[^\\S\\r\\n]*)(?:\\\\[nrt]|alias|call|case|css|default|delcall|delpackage|deltemplate|else(?:if)?|fallbackmsg|for(?:each)?|if(?:empty)?|lb|let|literal|msg|namespace|nil|@?param\\??|rb|sp|switch|template|xid)/,\n          lookbehind: true\n        },\n        /\\b(?:any|as|attributes|bool|css|float|html|in|int|js|list|map|null|number|string|uri)\\b/\n      ],\n      delimiter: {\n        pattern: /^\\{+\\/?|\\/?\\}+$/,\n        alias: 'punctuation'\n      },\n      property: /\\w+(?==)/,\n      variable: {\n        pattern: /\\$[^\\W\\d]\\w*(?:\\??(?:\\.\\w+|\\[[^\\]]+\\]))*/,\n        inside: {\n          string: {\n            pattern: stringPattern,\n            greedy: true\n          },\n          number: numberPattern,\n          punctuation: /[\\[\\].?]/\n        }\n      },\n      string: {\n        pattern: stringPattern,\n        greedy: true\n      },\n      function: [\n        /\\w+(?=\\()/,\n        {\n          pattern: /(\\|[^\\S\\r\\n]*)\\w+/,\n          lookbehind: true\n        }\n      ],\n      boolean: /\\b(?:false|true)\\b/,\n      number: numberPattern,\n      operator: /\\?:?|<=?|>=?|==?|!=|[+*/%-]|\\b(?:and|not|or)\\b/,\n      punctuation: /[{}()\\[\\]|.,:]/\n    } // Tokenize all inline Soy expressions\n    Prism.hooks.add('before-tokenize', function (env) {\n      var soyPattern = /\\{\\{.+?\\}\\}|\\{.+?\\}|\\s\\/\\/.*|\\/\\*[\\s\\S]*?\\*\\//g\n      var soyLitteralStart = '{literal}'\n      var soyLitteralEnd = '{/literal}'\n      var soyLitteralMode = false\n      Prism.languages['markup-templating'].buildPlaceholders(\n        env,\n        'soy',\n        soyPattern,\n        function (match) {\n          // Soy tags inside {literal} block are ignored\n          if (match === soyLitteralEnd) {\n            soyLitteralMode = false\n          }\n          if (!soyLitteralMode) {\n            if (match === soyLitteralStart) {\n              soyLitteralMode = true\n            }\n            return true\n          }\n          return false\n        }\n      )\n    }) // Re-insert the tokens after tokenizing\n    Prism.hooks.add('after-tokenize', function (env) {\n      Prism.languages['markup-templating'].tokenizePlaceholders(env, 'soy')\n    })\n  })(Prism)\n}\n"],"names":["require$$0","soy","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AACA,MAAI,4BAA4BA,wBAAA;AAChC,UAAiBC;AACjB,EAAAA,KAAI,cAAc;AAClB,EAAAA,KAAI,UAAU,CAAA;AACd,WAASA,KAAI,OAAO;AAClB,UAAM,SAAS,yBAAyB;AACvC,KAAC,SAAUC,QAAO;AACjB,UAAI,gBAAgB;AACpB,UAAI,gBAAgB;AACpB,MAAAA,OAAM,UAAU,MAAM;AAAA,QACpB,SAAS;AAAA,UACP;AAAA,UACA;AAAA,YACE,SAAS;AAAA,YACT,YAAY;AAAA,YACZ,QAAQ;AAAA;;QAGZ,eAAe;AAAA,UACb,SACE;AAAA,UACF,YAAY;AAAA,UACZ,OAAO;AAAA,UACP,QAAQ;AAAA,YACN,aAAa;AAAA;;QAGjB,WAAW;AAAA,UACT,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,OAAO;AAAA;QAET,SAAS;AAAA,UACP;AAAA,YACE,SACE;AAAA,YACF,YAAY;AAAA;UAEd;AAAA;QAEF,WAAW;AAAA,UACT,SAAS;AAAA,UACT,OAAO;AAAA;QAET,UAAU;AAAA,QACV,UAAU;AAAA,UACR,SAAS;AAAA,UACT,QAAQ;AAAA,YACN,QAAQ;AAAA,cACN,SAAS;AAAA,cACT,QAAQ;AAAA;YAEV,QAAQ;AAAA,YACR,aAAa;AAAA;;QAGjB,QAAQ;AAAA,UACN,SAAS;AAAA,UACT,QAAQ;AAAA;QAEV,UAAU;AAAA,UACR;AAAA,UACA;AAAA,YACE,SAAS;AAAA,YACT,YAAY;AAAA;;QAGhB,SAAS;AAAA,QACT,QAAQ;AAAA,QACR,UAAU;AAAA,QACV,aAAa;AAAA;AAEf,MAAAA,OAAM,MAAM,IAAI,mBAAmB,SAAU,KAAK;AAChD,YAAI,aAAa;AACjB,YAAI,mBAAmB;AACvB,YAAI,iBAAiB;AACrB,YAAI,kBAAkB;AACtB,QAAAA,OAAM,UAAU,mBAAmB,EAAE;AAAA,UACnC;AAAA,UACA;AAAA,UACA;AAAA,UACA,SAAU,OAAO;AAEf,gBAAI,UAAU,gBAAgB;AAC5B,gCAAkB;AAAA,YAC9B;AACU,gBAAI,CAAC,iBAAiB;AACpB,kBAAI,UAAU,kBAAkB;AAC9B,kCAAkB;AAAA,cAChC;AACY,qBAAO;AAAA,YACnB;AACU,mBAAO;AAAA,UACjB;AAAA;MAEA,CAAK;AACD,MAAAA,OAAM,MAAM,IAAI,kBAAkB,SAAU,KAAK;AAC/C,QAAAA,OAAM,UAAU,mBAAmB,EAAE,qBAAqB,KAAK,KAAK;AAAA,MAC1E,CAAK;AAAA,IACL,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}