@oscloudlab/knowledge-card 0.0.1 → 0.0.3

package/dist/graphql-CyglQi10.js

@@ -0,0 +1,189 @@
+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 graphql_1;
+var hasRequiredGraphql;
+function requireGraphql() {
+  if (hasRequiredGraphql) return graphql_1;
+  hasRequiredGraphql = 1;
+  graphql_1 = graphql2;
+  graphql2.displayName = "graphql";
+  graphql2.aliases = [];
+  function graphql2(Prism) {
+    Prism.languages.graphql = {
+      comment: /#.*/,
+      description: {
+        pattern: /(?:"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*")(?=\s*[a-z_])/i,
+        greedy: true,
+        alias: "string",
+        inside: {
+          "language-markdown": {
+            pattern: /(^"(?:"")?)(?!\1)[\s\S]+(?=\1$)/,
+            lookbehind: true,
+            inside: Prism.languages.markdown
+          }
+        }
+      },
+      string: {
+        pattern: /"""(?:[^"]|(?!""")")*"""|"(?:\\.|[^\\"\r\n])*"/,
+        greedy: true
+      },
+      number: /(?:\B-|\b)\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
+      boolean: /\b(?:false|true)\b/,
+      variable: /\$[a-z_]\w*/i,
+      directive: {
+        pattern: /@[a-z_]\w*/i,
+        alias: "function"
+      },
+      "attr-name": {
+        pattern: /\b[a-z_]\w*(?=\s*(?:\((?:[^()"]|"(?:\\.|[^\\"\r\n])*")*\))?:)/i,
+        greedy: true
+      },
+      "atom-input": {
+        pattern: /\b[A-Z]\w*Input\b/,
+        alias: "class-name"
+      },
+      scalar: /\b(?:Boolean|Float|ID|Int|String)\b/,
+      constant: /\b[A-Z][A-Z_\d]*\b/,
+      "class-name": {
+        pattern: /(\b(?:enum|implements|interface|on|scalar|type|union)\s+|&\s*|:\s*|\[)[A-Z_]\w*/,
+        lookbehind: true
+      },
+      fragment: {
+        pattern: /(\bfragment\s+|\.{3}\s*(?!on\b))[a-zA-Z_]\w*/,
+        lookbehind: true,
+        alias: "function"
+      },
+      "definition-mutation": {
+        pattern: /(\bmutation\s+)[a-zA-Z_]\w*/,
+        lookbehind: true,
+        alias: "function"
+      },
+      "definition-query": {
+        pattern: /(\bquery\s+)[a-zA-Z_]\w*/,
+        lookbehind: true,
+        alias: "function"
+      },
+      keyword: /\b(?:directive|enum|extend|fragment|implements|input|interface|mutation|on|query|repeatable|scalar|schema|subscription|type|union)\b/,
+      operator: /[!=|&]|\.{3}/,
+      "property-query": /\w+(?=\s*\()/,
+      object: /\w+(?=\s*\{)/,
+      punctuation: /[!(){}\[\]:=,]/,
+      property: /\w+/
+    };
+    Prism.hooks.add("after-tokenize", function afterTokenizeGraphql(env) {
+      if (env.language !== "graphql") {
+        return;
+      }
+      var validTokens = env.tokens.filter(function(token) {
+        return typeof token !== "string" && token.type !== "comment" && token.type !== "scalar";
+      });
+      var currentIndex = 0;
+      function getToken(offset) {
+        return validTokens[currentIndex + offset];
+      }
+      function isTokenType(types, offset) {
+        offset = offset || 0;
+        for (var i2 = 0; i2 < types.length; i2++) {
+          var token = getToken(i2 + offset);
+          if (!token || token.type !== types[i2]) {
+            return false;
+          }
+        }
+        return true;
+      }
+      function findClosingBracket(open, close) {
+        var stackHeight = 1;
+        for (var i2 = currentIndex; i2 < validTokens.length; i2++) {
+          var token = validTokens[i2];
+          var content = token.content;
+          if (token.type === "punctuation" && typeof content === "string") {
+            if (open.test(content)) {
+              stackHeight++;
+            } else if (close.test(content)) {
+              stackHeight--;
+              if (stackHeight === 0) {
+                return i2;
+              }
+            }
+          }
+        }
+        return -1;
+      }
+      function addAlias(token, alias) {
+        var aliases = token.alias;
+        if (!aliases) {
+          token.alias = aliases = [];
+        } else if (!Array.isArray(aliases)) {
+          token.alias = aliases = [aliases];
+        }
+        aliases.push(alias);
+      }
+      for (; currentIndex < validTokens.length; ) {
+        var startToken = validTokens[currentIndex++];
+        if (startToken.type === "keyword" && startToken.content === "mutation") {
+          var inputVariables = [];
+          if (isTokenType(["definition-mutation", "punctuation"]) && getToken(1).content === "(") {
+            currentIndex += 2;
+            var definitionEnd = findClosingBracket(/^\($/, /^\)$/);
+            if (definitionEnd === -1) {
+              continue;
+            }
+            for (; currentIndex < definitionEnd; currentIndex++) {
+              var t = getToken(0);
+              if (t.type === "variable") {
+                addAlias(t, "variable-input");
+                inputVariables.push(t.content);
+              }
+            }
+            currentIndex = definitionEnd + 1;
+          }
+          if (isTokenType(["punctuation", "property-query"]) && getToken(0).content === "{") {
+            currentIndex++;
+            addAlias(getToken(0), "property-mutation");
+            if (inputVariables.length > 0) {
+              var mutationEnd = findClosingBracket(/^\{$/, /^\}$/);
+              if (mutationEnd === -1) {
+                continue;
+              }
+              for (var i = currentIndex; i < mutationEnd; i++) {
+                var varToken = validTokens[i];
+                if (varToken.type === "variable" && inputVariables.indexOf(varToken.content) >= 0) {
+                  addAlias(varToken, "variable-input");
+                }
+              }
+            }
+          }
+        }
+      }
+    });
+  }
+  return graphql_1;
+}
+var graphqlExports = requireGraphql();
+const graphql = /* @__PURE__ */ getDefaultExportFromCjs(graphqlExports);
+const graphql$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: graphql
+}, [graphqlExports]);
+export {
+  graphql$1 as g
+};
+//# sourceMappingURL=graphql-CyglQi10.js.map

package/dist/graphql-CyglQi10.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql-CyglQi10.js","sources":["../node_modules/refractor/lang/graphql.js"],"sourcesContent":["'use strict'\n\nmodule.exports = graphql\ngraphql.displayName = 'graphql'\ngraphql.aliases = []\nfunction graphql(Prism) {\n  Prism.languages.graphql = {\n    comment: /#.*/,\n    description: {\n      pattern:\n        /(?:\"\"\"(?:[^\"]|(?!\"\"\")\")*\"\"\"|\"(?:\\\\.|[^\\\\\"\\r\\n])*\")(?=\\s*[a-z_])/i,\n      greedy: true,\n      alias: 'string',\n      inside: {\n        'language-markdown': {\n          pattern: /(^\"(?:\"\")?)(?!\\1)[\\s\\S]+(?=\\1$)/,\n          lookbehind: true,\n          inside: Prism.languages.markdown\n        }\n      }\n    },\n    string: {\n      pattern: /\"\"\"(?:[^\"]|(?!\"\"\")\")*\"\"\"|\"(?:\\\\.|[^\\\\\"\\r\\n])*\"/,\n      greedy: true\n    },\n    number: /(?:\\B-|\\b)\\d+(?:\\.\\d+)?(?:e[+-]?\\d+)?\\b/i,\n    boolean: /\\b(?:false|true)\\b/,\n    variable: /\\$[a-z_]\\w*/i,\n    directive: {\n      pattern: /@[a-z_]\\w*/i,\n      alias: 'function'\n    },\n    'attr-name': {\n      pattern: /\\b[a-z_]\\w*(?=\\s*(?:\\((?:[^()\"]|\"(?:\\\\.|[^\\\\\"\\r\\n])*\")*\\))?:)/i,\n      greedy: true\n    },\n    'atom-input': {\n      pattern: /\\b[A-Z]\\w*Input\\b/,\n      alias: 'class-name'\n    },\n    scalar: /\\b(?:Boolean|Float|ID|Int|String)\\b/,\n    constant: /\\b[A-Z][A-Z_\\d]*\\b/,\n    'class-name': {\n      pattern:\n        /(\\b(?:enum|implements|interface|on|scalar|type|union)\\s+|&\\s*|:\\s*|\\[)[A-Z_]\\w*/,\n      lookbehind: true\n    },\n    fragment: {\n      pattern: /(\\bfragment\\s+|\\.{3}\\s*(?!on\\b))[a-zA-Z_]\\w*/,\n      lookbehind: true,\n      alias: 'function'\n    },\n    'definition-mutation': {\n      pattern: /(\\bmutation\\s+)[a-zA-Z_]\\w*/,\n      lookbehind: true,\n      alias: 'function'\n    },\n    'definition-query': {\n      pattern: /(\\bquery\\s+)[a-zA-Z_]\\w*/,\n      lookbehind: true,\n      alias: 'function'\n    },\n    keyword:\n      /\\b(?:directive|enum|extend|fragment|implements|input|interface|mutation|on|query|repeatable|scalar|schema|subscription|type|union)\\b/,\n    operator: /[!=|&]|\\.{3}/,\n    'property-query': /\\w+(?=\\s*\\()/,\n    object: /\\w+(?=\\s*\\{)/,\n    punctuation: /[!(){}\\[\\]:=,]/,\n    property: /\\w+/\n  }\n  Prism.hooks.add('after-tokenize', function afterTokenizeGraphql(env) {\n    if (env.language !== 'graphql') {\n      return\n    }\n    /**\n     * get the graphql token stream that we want to customize\n     *\n     * @typedef {InstanceType<import(\"./prism-core\")[\"Token\"]>} Token\n     * @type {Token[]}\n     */\n    var validTokens = env.tokens.filter(function (token) {\n      return (\n        typeof token !== 'string' &&\n        token.type !== 'comment' &&\n        token.type !== 'scalar'\n      )\n    })\n    var currentIndex = 0\n    /**\n     * Returns whether the token relative to the current index has the given type.\n     *\n     * @param {number} offset\n     * @returns {Token | undefined}\n     */\n    function getToken(offset) {\n      return validTokens[currentIndex + offset]\n    }\n    /**\n     * Returns whether the token relative to the current index has the given type.\n     *\n     * @param {readonly string[]} types\n     * @param {number} [offset=0]\n     * @returns {boolean}\n     */\n    function isTokenType(types, offset) {\n      offset = offset || 0\n      for (var i = 0; i < types.length; i++) {\n        var token = getToken(i + offset)\n        if (!token || token.type !== types[i]) {\n          return false\n        }\n      }\n      return true\n    }\n    /**\n     * Returns the index of the closing bracket to an opening bracket.\n     *\n     * It is assumed that `token[currentIndex - 1]` is an opening bracket.\n     *\n     * If no closing bracket could be found, `-1` will be returned.\n     *\n     * @param {RegExp} open\n     * @param {RegExp} close\n     * @returns {number}\n     */\n    function findClosingBracket(open, close) {\n      var stackHeight = 1\n      for (var i = currentIndex; i < validTokens.length; i++) {\n        var token = validTokens[i]\n        var content = token.content\n        if (token.type === 'punctuation' && typeof content === 'string') {\n          if (open.test(content)) {\n            stackHeight++\n          } else if (close.test(content)) {\n            stackHeight--\n            if (stackHeight === 0) {\n              return i\n            }\n          }\n        }\n      }\n      return -1\n    }\n    /**\n     * Adds an alias to the given token.\n     *\n     * @param {Token} token\n     * @param {string} alias\n     * @returns {void}\n     */\n    function addAlias(token, alias) {\n      var aliases = token.alias\n      if (!aliases) {\n        token.alias = aliases = []\n      } else if (!Array.isArray(aliases)) {\n        token.alias = aliases = [aliases]\n      }\n      aliases.push(alias)\n    }\n    for (; currentIndex < validTokens.length; ) {\n      var startToken = validTokens[currentIndex++] // add special aliases for mutation tokens\n      if (startToken.type === 'keyword' && startToken.content === 'mutation') {\n        // any array of the names of all input variables (if any)\n        var inputVariables = []\n        if (\n          isTokenType(['definition-mutation', 'punctuation']) &&\n          getToken(1).content === '('\n        ) {\n          // definition\n          currentIndex += 2 // skip 'definition-mutation' and 'punctuation'\n          var definitionEnd = findClosingBracket(/^\\($/, /^\\)$/)\n          if (definitionEnd === -1) {\n            continue\n          } // find all input variables\n          for (; currentIndex < definitionEnd; currentIndex++) {\n            var t = getToken(0)\n            if (t.type === 'variable') {\n              addAlias(t, 'variable-input')\n              inputVariables.push(t.content)\n            }\n          }\n          currentIndex = definitionEnd + 1\n        }\n        if (\n          isTokenType(['punctuation', 'property-query']) &&\n          getToken(0).content === '{'\n        ) {\n          currentIndex++ // skip opening bracket\n          addAlias(getToken(0), 'property-mutation')\n          if (inputVariables.length > 0) {\n            var mutationEnd = findClosingBracket(/^\\{$/, /^\\}$/)\n            if (mutationEnd === -1) {\n              continue\n            } // give references to input variables a special alias\n            for (var i = currentIndex; i < mutationEnd; i++) {\n              var varToken = validTokens[i]\n              if (\n                varToken.type === 'variable' &&\n                inputVariables.indexOf(varToken.content) >= 0\n              ) {\n                addAlias(varToken, 'variable-input')\n              }\n            }\n          }\n        }\n      }\n    }\n  })\n}\n"],"names":["graphql","i"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/groovy-DyYa2Q97.js

@@ -0,0 +1,100 @@
+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 groovy_1;
+var hasRequiredGroovy;
+function requireGroovy() {
+  if (hasRequiredGroovy) return groovy_1;
+  hasRequiredGroovy = 1;
+  groovy_1 = groovy2;
+  groovy2.displayName = "groovy";
+  groovy2.aliases = [];
+  function groovy2(Prism) {
+    Prism.languages.groovy = Prism.languages.extend("clike", {
+      string: [
+        {
+          // https://groovy-lang.org/syntax.html#_dollar_slashy_string
+          pattern: /("""|''')(?:[^\\]|\\[\s\S])*?\1|\$\/(?:[^/$]|\$(?:[/$]|(?![/$]))|\/(?!\$))*\/\$/,
+          greedy: true
+        },
+        {
+          // TODO: Slash strings (e.g. /foo/) can contain line breaks but this will cause a lot of trouble with
+          // simple division (see JS regex), so find a fix maybe?
+          pattern: /(["'/])(?:\\.|(?!\1)[^\\\r\n])*\1/,
+          greedy: true
+        }
+      ],
+      keyword: /\b(?:abstract|as|assert|boolean|break|byte|case|catch|char|class|const|continue|def|default|do|double|else|enum|extends|final|finally|float|for|goto|if|implements|import|in|instanceof|int|interface|long|native|new|package|private|protected|public|return|short|static|strictfp|super|switch|synchronized|this|throw|throws|trait|transient|try|void|volatile|while)\b/,
+      number: /\b(?:0b[01_]+|0x[\da-f_]+(?:\.[\da-f_p\-]+)?|[\d_]+(?:\.[\d_]+)?(?:e[+-]?\d+)?)[glidf]?\b/i,
+      operator: {
+        pattern: /(^|[^.])(?:~|==?~?|\?[.:]?|\*(?:[.=]|\*=?)?|\.[@&]|\.\.<|\.\.(?!\.)|-[-=>]?|\+[+=]?|!=?|<(?:<=?|=>?)?|>(?:>>?=?|=)?|&[&=]?|\|[|=]?|\/=?|\^=?|%=?)/,
+        lookbehind: true
+      },
+      punctuation: /\.+|[{}[\];(),:$]/
+    });
+    Prism.languages.insertBefore("groovy", "string", {
+      shebang: {
+        pattern: /#!.+/,
+        alias: "comment"
+      }
+    });
+    Prism.languages.insertBefore("groovy", "punctuation", {
+      "spock-block": /\b(?:and|cleanup|expect|given|setup|then|when|where):/
+    });
+    Prism.languages.insertBefore("groovy", "function", {
+      annotation: {
+        pattern: /(^|[^.])@\w+/,
+        lookbehind: true,
+        alias: "punctuation"
+      }
+    });
+    Prism.hooks.add("wrap", function(env) {
+      if (env.language === "groovy" && env.type === "string") {
+        var delimiter = env.content.value[0];
+        if (delimiter != "'") {
+          var pattern = /([^\\])(?:\$(?:\{.*?\}|[\w.]+))/;
+          if (delimiter === "$") {
+            pattern = /([^\$])(?:\$(?:\{.*?\}|[\w.]+))/;
+          }
+          env.content.value = env.content.value.replace(/&lt;/g, "<").replace(/&amp;/g, "&");
+          env.content = Prism.highlight(env.content.value, {
+            expression: {
+              pattern,
+              lookbehind: true,
+              inside: Prism.languages.groovy
+            }
+          });
+          env.classes.push(delimiter === "/" ? "regex" : "gstring");
+        }
+      }
+    });
+  }
+  return groovy_1;
+}
+var groovyExports = requireGroovy();
+const groovy = /* @__PURE__ */ getDefaultExportFromCjs(groovyExports);
+const groovy$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: groovy
+}, [groovyExports]);
+export {
+  groovy$1 as g
+};
+//# sourceMappingURL=groovy-DyYa2Q97.js.map

package/dist/groovy-DyYa2Q97.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"groovy-DyYa2Q97.js","sources":["../node_modules/refractor/lang/groovy.js"],"sourcesContent":["'use strict'\n\nmodule.exports = groovy\ngroovy.displayName = 'groovy'\ngroovy.aliases = []\nfunction groovy(Prism) {\n  Prism.languages.groovy = Prism.languages.extend('clike', {\n    string: [\n      {\n        // https://groovy-lang.org/syntax.html#_dollar_slashy_string\n        pattern:\n          /(\"\"\"|''')(?:[^\\\\]|\\\\[\\s\\S])*?\\1|\\$\\/(?:[^/$]|\\$(?:[/$]|(?![/$]))|\\/(?!\\$))*\\/\\$/,\n        greedy: true\n      },\n      {\n        // TODO: Slash strings (e.g. /foo/) can contain line breaks but this will cause a lot of trouble with\n        // simple division (see JS regex), so find a fix maybe?\n        pattern: /([\"'/])(?:\\\\.|(?!\\1)[^\\\\\\r\\n])*\\1/,\n        greedy: true\n      }\n    ],\n    keyword:\n      /\\b(?:abstract|as|assert|boolean|break|byte|case|catch|char|class|const|continue|def|default|do|double|else|enum|extends|final|finally|float|for|goto|if|implements|import|in|instanceof|int|interface|long|native|new|package|private|protected|public|return|short|static|strictfp|super|switch|synchronized|this|throw|throws|trait|transient|try|void|volatile|while)\\b/,\n    number:\n      /\\b(?:0b[01_]+|0x[\\da-f_]+(?:\\.[\\da-f_p\\-]+)?|[\\d_]+(?:\\.[\\d_]+)?(?:e[+-]?\\d+)?)[glidf]?\\b/i,\n    operator: {\n      pattern:\n        /(^|[^.])(?:~|==?~?|\\?[.:]?|\\*(?:[.=]|\\*=?)?|\\.[@&]|\\.\\.<|\\.\\.(?!\\.)|-[-=>]?|\\+[+=]?|!=?|<(?:<=?|=>?)?|>(?:>>?=?|=)?|&[&=]?|\\|[|=]?|\\/=?|\\^=?|%=?)/,\n      lookbehind: true\n    },\n    punctuation: /\\.+|[{}[\\];(),:$]/\n  })\n  Prism.languages.insertBefore('groovy', 'string', {\n    shebang: {\n      pattern: /#!.+/,\n      alias: 'comment'\n    }\n  })\n  Prism.languages.insertBefore('groovy', 'punctuation', {\n    'spock-block': /\\b(?:and|cleanup|expect|given|setup|then|when|where):/\n  })\n  Prism.languages.insertBefore('groovy', 'function', {\n    annotation: {\n      pattern: /(^|[^.])@\\w+/,\n      lookbehind: true,\n      alias: 'punctuation'\n    }\n  }) // Handle string interpolation\n  Prism.hooks.add('wrap', function (env) {\n    if (env.language === 'groovy' && env.type === 'string') {\n      var delimiter = env.content.value[0]\n      if (delimiter != \"'\") {\n        var pattern = /([^\\\\])(?:\\$(?:\\{.*?\\}|[\\w.]+))/\n        if (delimiter === '$') {\n          pattern = /([^\\$])(?:\\$(?:\\{.*?\\}|[\\w.]+))/\n        } // To prevent double HTML-encoding we have to decode env.content first\n        env.content.value = env.content.value\n          .replace(/&lt;/g, '<')\n          .replace(/&amp;/g, '&')\n        env.content = Prism.highlight(env.content.value, {\n          expression: {\n            pattern: pattern,\n            lookbehind: true,\n            inside: Prism.languages.groovy\n          }\n        })\n        env.classes.push(delimiter === '/' ? 'regex' : 'gstring')\n      }\n    }\n  })\n}\n"],"names":["groovy"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,aAAiBA;AACjB,EAAAA,QAAO,cAAc;AACrB,EAAAA,QAAO,UAAU,CAAA;AACjB,WAASA,QAAO,OAAO;AACrB,UAAM,UAAU,SAAS,MAAM,UAAU,OAAO,SAAS;AAAA,MACvD,QAAQ;AAAA,QACN;AAAA;AAAA,UAEE,SACE;AAAA,UACF,QAAQ;AAAA;QAEV;AAAA;AAAA;AAAA,UAGE,SAAS;AAAA,UACT,QAAQ;AAAA;;MAGZ,SACE;AAAA,MACF,QACE;AAAA,MACF,UAAU;AAAA,QACR,SACE;AAAA,QACF,YAAY;AAAA;MAEd,aAAa;AAAA,IACjB,CAAG;AACD,UAAM,UAAU,aAAa,UAAU,UAAU;AAAA,MAC/C,SAAS;AAAA,QACP,SAAS;AAAA,QACT,OAAO;AAAA;IAEb,CAAG;AACD,UAAM,UAAU,aAAa,UAAU,eAAe;AAAA,MACpD,eAAe;AAAA,IACnB,CAAG;AACD,UAAM,UAAU,aAAa,UAAU,YAAY;AAAA,MACjD,YAAY;AAAA,QACV,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,OAAO;AAAA;IAEb,CAAG;AACD,UAAM,MAAM,IAAI,QAAQ,SAAU,KAAK;AACrC,UAAI,IAAI,aAAa,YAAY,IAAI,SAAS,UAAU;AACtD,YAAI,YAAY,IAAI,QAAQ,MAAM,CAAC;AACnC,YAAI,aAAa,KAAK;AACpB,cAAI,UAAU;AACd,cAAI,cAAc,KAAK;AACrB,sBAAU;AAAA,UACpB;AACQ,cAAI,QAAQ,QAAQ,IAAI,QAAQ,MAC7B,QAAQ,SAAS,GAAG,EACpB,QAAQ,UAAU,GAAG;AACxB,cAAI,UAAU,MAAM,UAAU,IAAI,QAAQ,OAAO;AAAA,YAC/C,YAAY;AAAA,cACV;AAAA,cACA,YAAY;AAAA,cACZ,QAAQ,MAAM,UAAU;AAAA;UAEpC,CAAS;AACD,cAAI,QAAQ,KAAK,cAAc,MAAM,UAAU,SAAS;AAAA,QAChE;AAAA,MACA;AAAA,IACA,CAAG;AAAA,EACH;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/haml-DMNl1y2c.js

@@ -0,0 +1,187 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+import { r as requireRuby } from "./ruby-BhyE9auN.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 haml_1;
+var hasRequiredHaml;
+function requireHaml() {
+  if (hasRequiredHaml) return haml_1;
+  hasRequiredHaml = 1;
+  var refractorRuby = requireRuby();
+  haml_1 = haml2;
+  haml2.displayName = "haml";
+  haml2.aliases = [];
+  function haml2(Prism) {
+    Prism.register(refractorRuby);
+    (function(Prism2) {
+      Prism2.languages.haml = {
+        // Multiline stuff should appear before the rest
+        "multiline-comment": {
+          pattern: /((?:^|\r?\n|\r)([\t ]*))(?:\/|-#).*(?:(?:\r?\n|\r)\2[\t ].+)*/,
+          lookbehind: true,
+          alias: "comment"
+        },
+        "multiline-code": [
+          {
+            pattern: /((?:^|\r?\n|\r)([\t ]*)(?:[~-]|[&!]?=)).*,[\t ]*(?:(?:\r?\n|\r)\2[\t ].*,[\t ]*)*(?:(?:\r?\n|\r)\2[\t ].+)/,
+            lookbehind: true,
+            inside: Prism2.languages.ruby
+          },
+          {
+            pattern: /((?:^|\r?\n|\r)([\t ]*)(?:[~-]|[&!]?=)).*\|[\t ]*(?:(?:\r?\n|\r)\2[\t ].*\|[\t ]*)*/,
+            lookbehind: true,
+            inside: Prism2.languages.ruby
+          }
+        ],
+        // See at the end of the file for known filters
+        filter: {
+          pattern: /((?:^|\r?\n|\r)([\t ]*)):[\w-]+(?:(?:\r?\n|\r)(?:\2[\t ].+|\s*?(?=\r?\n|\r)))+/,
+          lookbehind: true,
+          inside: {
+            "filter-name": {
+              pattern: /^:[\w-]+/,
+              alias: "symbol"
+            }
+          }
+        },
+        markup: {
+          pattern: /((?:^|\r?\n|\r)[\t ]*)<.+/,
+          lookbehind: true,
+          inside: Prism2.languages.markup
+        },
+        doctype: {
+          pattern: /((?:^|\r?\n|\r)[\t ]*)!!!(?: .+)?/,
+          lookbehind: true
+        },
+        tag: {
+          // Allows for one nested group of braces
+          pattern: /((?:^|\r?\n|\r)[\t ]*)[%.#][\w\-#.]*[\w\-](?:\([^)]+\)|\{(?:\{[^}]+\}|[^{}])+\}|\[[^\]]+\])*[\/<>]*/,
+          lookbehind: true,
+          inside: {
+            attributes: [
+              {
+                // Lookbehind tries to prevent interpolations from breaking it all
+                // Allows for one nested group of braces
+                pattern: /(^|[^#])\{(?:\{[^}]+\}|[^{}])+\}/,
+                lookbehind: true,
+                inside: Prism2.languages.ruby
+              },
+              {
+                pattern: /\([^)]+\)/,
+                inside: {
+                  "attr-value": {
+                    pattern: /(=\s*)(?:"(?:\\.|[^\\"\r\n])*"|[^)\s]+)/,
+                    lookbehind: true
+                  },
+                  "attr-name": /[\w:-]+(?=\s*!?=|\s*[,)])/,
+                  punctuation: /[=(),]/
+                }
+              },
+              {
+                pattern: /\[[^\]]+\]/,
+                inside: Prism2.languages.ruby
+              }
+            ],
+            punctuation: /[<>]/
+          }
+        },
+        code: {
+          pattern: /((?:^|\r?\n|\r)[\t ]*(?:[~-]|[&!]?=)).+/,
+          lookbehind: true,
+          inside: Prism2.languages.ruby
+        },
+        // Interpolations in plain text
+        interpolation: {
+          pattern: /#\{[^}]+\}/,
+          inside: {
+            delimiter: {
+              pattern: /^#\{|\}$/,
+              alias: "punctuation"
+            },
+            ruby: {
+              pattern: /[\s\S]+/,
+              inside: Prism2.languages.ruby
+            }
+          }
+        },
+        punctuation: {
+          pattern: /((?:^|\r?\n|\r)[\t ]*)[~=\-&!]+/,
+          lookbehind: true
+        }
+      };
+      var filter_pattern = "((?:^|\\r?\\n|\\r)([\\t ]*)):{{filter_name}}(?:(?:\\r?\\n|\\r)(?:\\2[\\t ].+|\\s*?(?=\\r?\\n|\\r)))+";
+      var filters = [
+        "css",
+        {
+          filter: "coffee",
+          language: "coffeescript"
+        },
+        "erb",
+        "javascript",
+        "less",
+        "markdown",
+        "ruby",
+        "scss",
+        "textile"
+      ];
+      var all_filters = {};
+      for (var i = 0, l = filters.length; i < l; i++) {
+        var filter = filters[i];
+        filter = typeof filter === "string" ? {
+          filter,
+          language: filter
+        } : filter;
+        if (Prism2.languages[filter.language]) {
+          all_filters["filter-" + filter.filter] = {
+            pattern: RegExp(
+              filter_pattern.replace("{{filter_name}}", function() {
+                return filter.filter;
+              })
+            ),
+            lookbehind: true,
+            inside: {
+              "filter-name": {
+                pattern: /^:[\w-]+/,
+                alias: "symbol"
+              },
+              text: {
+                pattern: /[\s\S]+/,
+                alias: [filter.language, "language-" + filter.language],
+                inside: Prism2.languages[filter.language]
+              }
+            }
+          };
+        }
+      }
+      Prism2.languages.insertBefore("haml", "filter", all_filters);
+    })(Prism);
+  }
+  return haml_1;
+}
+var hamlExports = requireHaml();
+const haml = /* @__PURE__ */ getDefaultExportFromCjs(hamlExports);
+const haml$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: haml
+}, [hamlExports]);
+export {
+  haml$1 as h
+};
+//# sourceMappingURL=haml-DMNl1y2c.js.map

package/dist/haml-DMNl1y2c.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"haml-DMNl1y2c.js","sources":["../node_modules/refractor/lang/haml.js"],"sourcesContent":["'use strict'\nvar refractorRuby = require('./ruby.js')\nmodule.exports = haml\nhaml.displayName = 'haml'\nhaml.aliases = []\nfunction haml(Prism) {\n  Prism.register(refractorRuby)\n  /* TODO\nHandle multiline code after tag\n%foo= some |\nmultiline |\ncode |\n*/\n  ;(function (Prism) {\n    Prism.languages.haml = {\n      // Multiline stuff should appear before the rest\n      'multiline-comment': {\n        pattern:\n          /((?:^|\\r?\\n|\\r)([\\t ]*))(?:\\/|-#).*(?:(?:\\r?\\n|\\r)\\2[\\t ].+)*/,\n        lookbehind: true,\n        alias: 'comment'\n      },\n      'multiline-code': [\n        {\n          pattern:\n            /((?:^|\\r?\\n|\\r)([\\t ]*)(?:[~-]|[&!]?=)).*,[\\t ]*(?:(?:\\r?\\n|\\r)\\2[\\t ].*,[\\t ]*)*(?:(?:\\r?\\n|\\r)\\2[\\t ].+)/,\n          lookbehind: true,\n          inside: Prism.languages.ruby\n        },\n        {\n          pattern:\n            /((?:^|\\r?\\n|\\r)([\\t ]*)(?:[~-]|[&!]?=)).*\\|[\\t ]*(?:(?:\\r?\\n|\\r)\\2[\\t ].*\\|[\\t ]*)*/,\n          lookbehind: true,\n          inside: Prism.languages.ruby\n        }\n      ],\n      // See at the end of the file for known filters\n      filter: {\n        pattern:\n          /((?:^|\\r?\\n|\\r)([\\t ]*)):[\\w-]+(?:(?:\\r?\\n|\\r)(?:\\2[\\t ].+|\\s*?(?=\\r?\\n|\\r)))+/,\n        lookbehind: true,\n        inside: {\n          'filter-name': {\n            pattern: /^:[\\w-]+/,\n            alias: 'symbol'\n          }\n        }\n      },\n      markup: {\n        pattern: /((?:^|\\r?\\n|\\r)[\\t ]*)<.+/,\n        lookbehind: true,\n        inside: Prism.languages.markup\n      },\n      doctype: {\n        pattern: /((?:^|\\r?\\n|\\r)[\\t ]*)!!!(?: .+)?/,\n        lookbehind: true\n      },\n      tag: {\n        // Allows for one nested group of braces\n        pattern:\n          /((?:^|\\r?\\n|\\r)[\\t ]*)[%.#][\\w\\-#.]*[\\w\\-](?:\\([^)]+\\)|\\{(?:\\{[^}]+\\}|[^{}])+\\}|\\[[^\\]]+\\])*[\\/<>]*/,\n        lookbehind: true,\n        inside: {\n          attributes: [\n            {\n              // Lookbehind tries to prevent interpolations from breaking it all\n              // Allows for one nested group of braces\n              pattern: /(^|[^#])\\{(?:\\{[^}]+\\}|[^{}])+\\}/,\n              lookbehind: true,\n              inside: Prism.languages.ruby\n            },\n            {\n              pattern: /\\([^)]+\\)/,\n              inside: {\n                'attr-value': {\n                  pattern: /(=\\s*)(?:\"(?:\\\\.|[^\\\\\"\\r\\n])*\"|[^)\\s]+)/,\n                  lookbehind: true\n                },\n                'attr-name': /[\\w:-]+(?=\\s*!?=|\\s*[,)])/,\n                punctuation: /[=(),]/\n              }\n            },\n            {\n              pattern: /\\[[^\\]]+\\]/,\n              inside: Prism.languages.ruby\n            }\n          ],\n          punctuation: /[<>]/\n        }\n      },\n      code: {\n        pattern: /((?:^|\\r?\\n|\\r)[\\t ]*(?:[~-]|[&!]?=)).+/,\n        lookbehind: true,\n        inside: Prism.languages.ruby\n      },\n      // Interpolations in plain text\n      interpolation: {\n        pattern: /#\\{[^}]+\\}/,\n        inside: {\n          delimiter: {\n            pattern: /^#\\{|\\}$/,\n            alias: 'punctuation'\n          },\n          ruby: {\n            pattern: /[\\s\\S]+/,\n            inside: Prism.languages.ruby\n          }\n        }\n      },\n      punctuation: {\n        pattern: /((?:^|\\r?\\n|\\r)[\\t ]*)[~=\\-&!]+/,\n        lookbehind: true\n      }\n    }\n    var filter_pattern =\n      '((?:^|\\\\r?\\\\n|\\\\r)([\\\\t ]*)):{{filter_name}}(?:(?:\\\\r?\\\\n|\\\\r)(?:\\\\2[\\\\t ].+|\\\\s*?(?=\\\\r?\\\\n|\\\\r)))+' // Non exhaustive list of available filters and associated languages\n    var filters = [\n      'css',\n      {\n        filter: 'coffee',\n        language: 'coffeescript'\n      },\n      'erb',\n      'javascript',\n      'less',\n      'markdown',\n      'ruby',\n      'scss',\n      'textile'\n    ]\n    var all_filters = {}\n    for (var i = 0, l = filters.length; i < l; i++) {\n      var filter = filters[i]\n      filter =\n        typeof filter === 'string'\n          ? {\n              filter: filter,\n              language: filter\n            }\n          : filter\n      if (Prism.languages[filter.language]) {\n        all_filters['filter-' + filter.filter] = {\n          pattern: RegExp(\n            filter_pattern.replace('{{filter_name}}', function () {\n              return filter.filter\n            })\n          ),\n          lookbehind: true,\n          inside: {\n            'filter-name': {\n              pattern: /^:[\\w-]+/,\n              alias: 'symbol'\n            },\n            text: {\n              pattern: /[\\s\\S]+/,\n              alias: [filter.language, 'language-' + filter.language],\n              inside: Prism.languages[filter.language]\n            }\n          }\n        }\n      }\n    }\n    Prism.languages.insertBefore('haml', 'filter', all_filters)\n  })(Prism)\n}\n"],"names":["require$$0","haml","Prism"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/handlebars-DjusewrR.js

@@ -0,0 +1,86 @@
+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 handlebars_1;
+var hasRequiredHandlebars;
+function requireHandlebars() {
+  if (hasRequiredHandlebars) return handlebars_1;
+  hasRequiredHandlebars = 1;
+  var refractorMarkupTemplating = requireMarkupTemplating();
+  handlebars_1 = handlebars2;
+  handlebars2.displayName = "handlebars";
+  handlebars2.aliases = ["hbs"];
+  function handlebars2(Prism) {
+    Prism.register(refractorMarkupTemplating);
+    (function(Prism2) {
+      Prism2.languages.handlebars = {
+        comment: /\{\{![\s\S]*?\}\}/,
+        delimiter: {
+          pattern: /^\{\{\{?|\}\}\}?$/,
+          alias: "punctuation"
+        },
+        string: /(["'])(?:\\.|(?!\1)[^\\\r\n])*\1/,
+        number: /\b0x[\dA-Fa-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee][+-]?\d+)?/,
+        boolean: /\b(?:false|true)\b/,
+        block: {
+          pattern: /^(\s*(?:~\s*)?)[#\/]\S+?(?=\s*(?:~\s*)?$|\s)/,
+          lookbehind: true,
+          alias: "keyword"
+        },
+        brackets: {
+          pattern: /\[[^\]]+\]/,
+          inside: {
+            punctuation: /\[|\]/,
+            variable: /[\s\S]+/
+          }
+        },
+        punctuation: /[!"#%&':()*+,.\/;<=>@\[\\\]^`{|}~]/,
+        variable: /[^!"#%&'()*+,\/;<=>@\[\\\]^`{|}~\s]+/
+      };
+      Prism2.hooks.add("before-tokenize", function(env) {
+        var handlebarsPattern = /\{\{\{[\s\S]+?\}\}\}|\{\{[\s\S]+?\}\}/g;
+        Prism2.languages["markup-templating"].buildPlaceholders(
+          env,
+          "handlebars",
+          handlebarsPattern
+        );
+      });
+      Prism2.hooks.add("after-tokenize", function(env) {
+        Prism2.languages["markup-templating"].tokenizePlaceholders(
+          env,
+          "handlebars"
+        );
+      });
+      Prism2.languages.hbs = Prism2.languages.handlebars;
+    })(Prism);
+  }
+  return handlebars_1;
+}
+var handlebarsExports = requireHandlebars();
+const handlebars = /* @__PURE__ */ getDefaultExportFromCjs(handlebarsExports);
+const handlebars$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: handlebars
+}, [handlebarsExports]);
+export {
+  handlebars$1 as h
+};
+//# sourceMappingURL=handlebars-DjusewrR.js.map

package/dist/handlebars-DjusewrR.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlebars-DjusewrR.js","sources":["../node_modules/refractor/lang/handlebars.js"],"sourcesContent":["'use strict'\nvar refractorMarkupTemplating = require('./markup-templating.js')\nmodule.exports = handlebars\nhandlebars.displayName = 'handlebars'\nhandlebars.aliases = ['hbs']\nfunction handlebars(Prism) {\n  Prism.register(refractorMarkupTemplating)\n  ;(function (Prism) {\n    Prism.languages.handlebars = {\n      comment: /\\{\\{![\\s\\S]*?\\}\\}/,\n      delimiter: {\n        pattern: /^\\{\\{\\{?|\\}\\}\\}?$/,\n        alias: 'punctuation'\n      },\n      string: /([\"'])(?:\\\\.|(?!\\1)[^\\\\\\r\\n])*\\1/,\n      number: /\\b0x[\\dA-Fa-f]+\\b|(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:[Ee][+-]?\\d+)?/,\n      boolean: /\\b(?:false|true)\\b/,\n      block: {\n        pattern: /^(\\s*(?:~\\s*)?)[#\\/]\\S+?(?=\\s*(?:~\\s*)?$|\\s)/,\n        lookbehind: true,\n        alias: 'keyword'\n      },\n      brackets: {\n        pattern: /\\[[^\\]]+\\]/,\n        inside: {\n          punctuation: /\\[|\\]/,\n          variable: /[\\s\\S]+/\n        }\n      },\n      punctuation: /[!\"#%&':()*+,.\\/;<=>@\\[\\\\\\]^`{|}~]/,\n      variable: /[^!\"#%&'()*+,\\/;<=>@\\[\\\\\\]^`{|}~\\s]+/\n    }\n    Prism.hooks.add('before-tokenize', function (env) {\n      var handlebarsPattern = /\\{\\{\\{[\\s\\S]+?\\}\\}\\}|\\{\\{[\\s\\S]+?\\}\\}/g\n      Prism.languages['markup-templating'].buildPlaceholders(\n        env,\n        'handlebars',\n        handlebarsPattern\n      )\n    })\n    Prism.hooks.add('after-tokenize', function (env) {\n      Prism.languages['markup-templating'].tokenizePlaceholders(\n        env,\n        'handlebars'\n      )\n    })\n    Prism.languages.hbs = Prism.languages.handlebars\n  })(Prism)\n}\n"],"names":["require$$0","handlebars","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AACA,MAAI,4BAA4BA,wBAAA;AAChC,iBAAiBC;AACjB,EAAAA,YAAW,cAAc;AACzB,EAAAA,YAAW,UAAU,CAAC,KAAK;AAC3B,WAASA,YAAW,OAAO;AACzB,UAAM,SAAS,yBAAyB;AACvC,KAAC,SAAUC,QAAO;AACjB,MAAAA,OAAM,UAAU,aAAa;AAAA,QAC3B,SAAS;AAAA,QACT,WAAW;AAAA,UACT,SAAS;AAAA,UACT,OAAO;AAAA;QAET,QAAQ;AAAA,QACR,QAAQ;AAAA,QACR,SAAS;AAAA,QACT,OAAO;AAAA,UACL,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,OAAO;AAAA;QAET,UAAU;AAAA,UACR,SAAS;AAAA,UACT,QAAQ;AAAA,YACN,aAAa;AAAA,YACb,UAAU;AAAA;;QAGd,aAAa;AAAA,QACb,UAAU;AAAA;AAEZ,MAAAA,OAAM,MAAM,IAAI,mBAAmB,SAAU,KAAK;AAChD,YAAI,oBAAoB;AACxB,QAAAA,OAAM,UAAU,mBAAmB,EAAE;AAAA,UACnC;AAAA,UACA;AAAA,UACA;AAAA;MAER,CAAK;AACD,MAAAA,OAAM,MAAM,IAAI,kBAAkB,SAAU,KAAK;AAC/C,QAAAA,OAAM,UAAU,mBAAmB,EAAE;AAAA,UACnC;AAAA,UACA;AAAA;MAER,CAAK;AACD,MAAAA,OAAM,UAAU,MAAMA,OAAM,UAAU;AAAA,IAC1C,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/haskell-D7nTVCb2.js

@@ -0,0 +1,31 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+import { r as requireHaskell } from "./haskell-JxV6F6a2.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 haskellExports = requireHaskell();
+const haskell = /* @__PURE__ */ getDefaultExportFromCjs(haskellExports);
+const haskell$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: haskell
+}, [haskellExports]);
+export {
+  haskell$1 as h
+};
+//# sourceMappingURL=haskell-D7nTVCb2.js.map

package/dist/haskell-D7nTVCb2.js.map

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