@oscloudlab/knowledge-card 0.0.1 → 0.0.3

package/dist/jolie-Qbbnf2Y8.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jolie-Qbbnf2Y8.js","sources":["../node_modules/refractor/lang/jolie.js"],"sourcesContent":["'use strict'\n\nmodule.exports = jolie\njolie.displayName = 'jolie'\njolie.aliases = []\nfunction jolie(Prism) {\n  Prism.languages.jolie = Prism.languages.extend('clike', {\n    string: {\n      pattern: /(^|[^\\\\])\"(?:\\\\[\\s\\S]|[^\"\\\\])*\"/,\n      lookbehind: true,\n      greedy: true\n    },\n    'class-name': {\n      pattern:\n        /((?:\\b(?:as|courier|embed|in|inputPort|outputPort|service)\\b|@)[ \\t]*)\\w+/,\n      lookbehind: true\n    },\n    keyword:\n      /\\b(?:as|cH|comp|concurrent|constants|courier|cset|csets|default|define|else|embed|embedded|execution|exit|extender|for|foreach|forward|from|global|if|import|in|include|init|inputPort|install|instanceof|interface|is_defined|linkIn|linkOut|main|new|nullProcess|outputPort|over|private|provide|public|scope|sequential|service|single|spawn|synchronized|this|throw|throws|type|undef|until|while|with)\\b/,\n    function: /\\b[a-z_]\\w*(?=[ \\t]*[@(])/i,\n    number: /(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:e[+-]?\\d+)?l?/i,\n    operator: /-[-=>]?|\\+[+=]?|<[<=]?|[>=*!]=?|&&|\\|\\||[?\\/%^@|]/,\n    punctuation: /[()[\\]{},;.:]/,\n    builtin:\n      /\\b(?:Byte|any|bool|char|double|enum|float|int|length|long|ranges|regex|string|undefined|void)\\b/\n  })\n  Prism.languages.insertBefore('jolie', 'keyword', {\n    aggregates: {\n      pattern:\n        /(\\bAggregates\\s*:\\s*)(?:\\w+(?:\\s+with\\s+\\w+)?\\s*,\\s*)*\\w+(?:\\s+with\\s+\\w+)?/,\n      lookbehind: true,\n      inside: {\n        keyword: /\\bwith\\b/,\n        'class-name': /\\w+/,\n        punctuation: /,/\n      }\n    },\n    redirects: {\n      pattern:\n        /(\\bRedirects\\s*:\\s*)(?:\\w+\\s*=>\\s*\\w+\\s*,\\s*)*(?:\\w+\\s*=>\\s*\\w+)/,\n      lookbehind: true,\n      inside: {\n        punctuation: /,/,\n        'class-name': /\\w+/,\n        operator: /=>/\n      }\n    },\n    property: {\n      pattern:\n        /\\b(?:Aggregates|[Ii]nterfaces|Java|Javascript|Jolie|[Ll]ocation|OneWay|[Pp]rotocol|Redirects|RequestResponse)\\b(?=[ \\t]*:)/\n    }\n  })\n}\n"],"names":["jolie"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,YAAiBA;AACjB,EAAAA,OAAM,cAAc;AACpB,EAAAA,OAAM,UAAU,CAAA;AAChB,WAASA,OAAM,OAAO;AACpB,UAAM,UAAU,QAAQ,MAAM,UAAU,OAAO,SAAS;AAAA,MACtD,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,QAAQ;AAAA;MAEV,cAAc;AAAA,QACZ,SACE;AAAA,QACF,YAAY;AAAA;MAEd,SACE;AAAA,MACF,UAAU;AAAA,MACV,QAAQ;AAAA,MACR,UAAU;AAAA,MACV,aAAa;AAAA,MACb,SACE;AAAA,IACN,CAAG;AACD,UAAM,UAAU,aAAa,SAAS,WAAW;AAAA,MAC/C,YAAY;AAAA,QACV,SACE;AAAA,QACF,YAAY;AAAA,QACZ,QAAQ;AAAA,UACN,SAAS;AAAA,UACT,cAAc;AAAA,UACd,aAAa;AAAA;;MAGjB,WAAW;AAAA,QACT,SACE;AAAA,QACF,YAAY;AAAA,QACZ,QAAQ;AAAA,UACN,aAAa;AAAA,UACb,cAAc;AAAA,UACd,UAAU;AAAA;;MAGd,UAAU;AAAA,QACR,SACE;AAAA;IAER,CAAG;AAAA,EACH;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/jq-EEM9FnQy.js

@@ -0,0 +1,112 @@
+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 jq_1;
+var hasRequiredJq;
+function requireJq() {
+  if (hasRequiredJq) return jq_1;
+  hasRequiredJq = 1;
+  jq_1 = jq2;
+  jq2.displayName = "jq";
+  jq2.aliases = [];
+  function jq2(Prism) {
+    (function(Prism2) {
+      var interpolation = /\\\((?:[^()]|\([^()]*\))*\)/.source;
+      var string = RegExp(
+        /(^|[^\\])"(?:[^"\r\n\\]|\\[^\r\n(]|__)*"/.source.replace(
+          /__/g,
+          function() {
+            return interpolation;
+          }
+        )
+      );
+      var stringInterpolation = {
+        interpolation: {
+          pattern: RegExp(/((?:^|[^\\])(?:\\{2})*)/.source + interpolation),
+          lookbehind: true,
+          inside: {
+            content: {
+              pattern: /^(\\\()[\s\S]+(?=\)$)/,
+              lookbehind: true,
+              inside: null
+              // see below
+            },
+            punctuation: /^\\\(|\)$/
+          }
+        }
+      };
+      var jq3 = Prism2.languages.jq = {
+        comment: /#.*/,
+        property: {
+          pattern: RegExp(string.source + /(?=\s*:(?!:))/.source),
+          lookbehind: true,
+          greedy: true,
+          inside: stringInterpolation
+        },
+        string: {
+          pattern: string,
+          lookbehind: true,
+          greedy: true,
+          inside: stringInterpolation
+        },
+        function: {
+          pattern: /(\bdef\s+)[a-z_]\w+/i,
+          lookbehind: true
+        },
+        variable: /\B\$\w+/,
+        "property-literal": {
+          pattern: /\b[a-z_]\w*(?=\s*:(?!:))/i,
+          alias: "property"
+        },
+        keyword: /\b(?:as|break|catch|def|elif|else|end|foreach|if|import|include|label|module|modulemeta|null|reduce|then|try|while)\b/,
+        boolean: /\b(?:false|true)\b/,
+        number: /(?:\b\d+\.|\B\.)?\b\d+(?:[eE][+-]?\d+)?\b/,
+        operator: [
+          {
+            pattern: /\|=?/,
+            alias: "pipe"
+          },
+          /\.\.|[!=<>]?=|\?\/\/|\/\/=?|[-+*/%]=?|[<>?]|\b(?:and|not|or)\b/
+        ],
+        "c-style-function": {
+          pattern: /\b[a-z_]\w*(?=\s*\()/i,
+          alias: "function"
+        },
+        punctuation: /::|[()\[\]{},:;]|\.(?=\s*[\[\w$])/,
+        dot: {
+          pattern: /\./,
+          alias: "important"
+        }
+      };
+      stringInterpolation.interpolation.inside.content.inside = jq3;
+    })(Prism);
+  }
+  return jq_1;
+}
+var jqExports = requireJq();
+const jq = /* @__PURE__ */ getDefaultExportFromCjs(jqExports);
+const jq$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: jq
+}, [jqExports]);
+export {
+  jq$1 as j
+};
+//# sourceMappingURL=jq-EEM9FnQy.js.map

package/dist/jq-EEM9FnQy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jq-EEM9FnQy.js","sources":["../node_modules/refractor/lang/jq.js"],"sourcesContent":["'use strict'\n\nmodule.exports = jq\njq.displayName = 'jq'\njq.aliases = []\nfunction jq(Prism) {\n  ;(function (Prism) {\n    var interpolation = /\\\\\\((?:[^()]|\\([^()]*\\))*\\)/.source\n    var string = RegExp(\n      /(^|[^\\\\])\"(?:[^\"\\r\\n\\\\]|\\\\[^\\r\\n(]|__)*\"/.source.replace(\n        /__/g,\n        function () {\n          return interpolation\n        }\n      )\n    )\n    var stringInterpolation = {\n      interpolation: {\n        pattern: RegExp(/((?:^|[^\\\\])(?:\\\\{2})*)/.source + interpolation),\n        lookbehind: true,\n        inside: {\n          content: {\n            pattern: /^(\\\\\\()[\\s\\S]+(?=\\)$)/,\n            lookbehind: true,\n            inside: null // see below\n          },\n          punctuation: /^\\\\\\(|\\)$/\n        }\n      }\n    }\n    var jq = (Prism.languages.jq = {\n      comment: /#.*/,\n      property: {\n        pattern: RegExp(string.source + /(?=\\s*:(?!:))/.source),\n        lookbehind: true,\n        greedy: true,\n        inside: stringInterpolation\n      },\n      string: {\n        pattern: string,\n        lookbehind: true,\n        greedy: true,\n        inside: stringInterpolation\n      },\n      function: {\n        pattern: /(\\bdef\\s+)[a-z_]\\w+/i,\n        lookbehind: true\n      },\n      variable: /\\B\\$\\w+/,\n      'property-literal': {\n        pattern: /\\b[a-z_]\\w*(?=\\s*:(?!:))/i,\n        alias: 'property'\n      },\n      keyword:\n        /\\b(?:as|break|catch|def|elif|else|end|foreach|if|import|include|label|module|modulemeta|null|reduce|then|try|while)\\b/,\n      boolean: /\\b(?:false|true)\\b/,\n      number: /(?:\\b\\d+\\.|\\B\\.)?\\b\\d+(?:[eE][+-]?\\d+)?\\b/,\n      operator: [\n        {\n          pattern: /\\|=?/,\n          alias: 'pipe'\n        },\n        /\\.\\.|[!=<>]?=|\\?\\/\\/|\\/\\/=?|[-+*/%]=?|[<>?]|\\b(?:and|not|or)\\b/\n      ],\n      'c-style-function': {\n        pattern: /\\b[a-z_]\\w*(?=\\s*\\()/i,\n        alias: 'function'\n      },\n      punctuation: /::|[()\\[\\]{},:;]|\\.(?=\\s*[\\[\\w$])/,\n      dot: {\n        pattern: /\\./,\n        alias: 'important'\n      }\n    })\n    stringInterpolation.interpolation.inside.content.inside = jq\n  })(Prism)\n}\n"],"names":["jq","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,SAAiBA;AACjB,EAAAA,IAAG,cAAc;AACjB,EAAAA,IAAG,UAAU,CAAA;AACb,WAASA,IAAG,OAAO;AAChB,KAAC,SAAUC,QAAO;AACjB,UAAI,gBAAgB,8BAA8B;AAClD,UAAI,SAAS;AAAA,QACX,2CAA2C,OAAO;AAAA,UAChD;AAAA,UACA,WAAY;AACV,mBAAO;AAAA,UACjB;AAAA;;AAGI,UAAI,sBAAsB;AAAA,QACxB,eAAe;AAAA,UACb,SAAS,OAAO,0BAA0B,SAAS,aAAa;AAAA,UAChE,YAAY;AAAA,UACZ,QAAQ;AAAA,YACN,SAAS;AAAA,cACP,SAAS;AAAA,cACT,YAAY;AAAA,cACZ,QAAQ;AAAA;AAAA;YAEV,aAAa;AAAA;;;AAInB,UAAID,MAAMC,OAAM,UAAU,KAAK;AAAA,QAC7B,SAAS;AAAA,QACT,UAAU;AAAA,UACR,SAAS,OAAO,OAAO,SAAS,gBAAgB,MAAM;AAAA,UACtD,YAAY;AAAA,UACZ,QAAQ;AAAA,UACR,QAAQ;AAAA;QAEV,QAAQ;AAAA,UACN,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,QAAQ;AAAA,UACR,QAAQ;AAAA;QAEV,UAAU;AAAA,UACR,SAAS;AAAA,UACT,YAAY;AAAA;QAEd,UAAU;AAAA,QACV,oBAAoB;AAAA,UAClB,SAAS;AAAA,UACT,OAAO;AAAA;QAET,SACE;AAAA,QACF,SAAS;AAAA,QACT,QAAQ;AAAA,QACR,UAAU;AAAA,UACR;AAAA,YACE,SAAS;AAAA,YACT,OAAO;AAAA;UAET;AAAA;QAEF,oBAAoB;AAAA,UAClB,SAAS;AAAA,UACT,OAAO;AAAA;QAET,aAAa;AAAA,QACb,KAAK;AAAA,UACH,SAAS;AAAA,UACT,OAAO;AAAA;MAEf;AACI,0BAAoB,cAAc,OAAO,QAAQ,SAASD;AAAA,IAC9D,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/js-extras-CFriKWFZ.js

@@ -0,0 +1,169 @@
+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 jsExtras_1;
+var hasRequiredJsExtras;
+function requireJsExtras() {
+  if (hasRequiredJsExtras) return jsExtras_1;
+  hasRequiredJsExtras = 1;
+  jsExtras_1 = jsExtras2;
+  jsExtras2.displayName = "jsExtras";
+  jsExtras2.aliases = [];
+  function jsExtras2(Prism) {
+    (function(Prism2) {
+      Prism2.languages.insertBefore("javascript", "function-variable", {
+        "method-variable": {
+          pattern: RegExp(
+            "(\\.\\s*)" + Prism2.languages.javascript["function-variable"].pattern.source
+          ),
+          lookbehind: true,
+          alias: ["function-variable", "method", "function", "property-access"]
+        }
+      });
+      Prism2.languages.insertBefore("javascript", "function", {
+        method: {
+          pattern: RegExp(
+            "(\\.\\s*)" + Prism2.languages.javascript["function"].source
+          ),
+          lookbehind: true,
+          alias: ["function", "property-access"]
+        }
+      });
+      Prism2.languages.insertBefore("javascript", "constant", {
+        "known-class-name": [
+          {
+            // standard built-ins
+            // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects
+            pattern: /\b(?:(?:Float(?:32|64)|(?:Int|Uint)(?:8|16|32)|Uint8Clamped)?Array|ArrayBuffer|BigInt|Boolean|DataView|Date|Error|Function|Intl|JSON|(?:Weak)?(?:Map|Set)|Math|Number|Object|Promise|Proxy|Reflect|RegExp|String|Symbol|WebAssembly)\b/,
+            alias: "class-name"
+          },
+          {
+            // errors
+            pattern: /\b(?:[A-Z]\w*)Error\b/,
+            alias: "class-name"
+          }
+        ]
+      });
+      function withId(source, flags) {
+        return RegExp(
+          source.replace(/<ID>/g, function() {
+            return /(?!\s)[_$a-zA-Z\xA0-\uFFFF](?:(?!\s)[$\w\xA0-\uFFFF])*/.source;
+          }),
+          flags
+        );
+      }
+      Prism2.languages.insertBefore("javascript", "keyword", {
+        imports: {
+          // https://tc39.es/ecma262/#sec-imports
+          pattern: withId(
+            /(\bimport\b\s*)(?:<ID>(?:\s*,\s*(?:\*\s*as\s+<ID>|\{[^{}]*\}))?|\*\s*as\s+<ID>|\{[^{}]*\})(?=\s*\bfrom\b)/.source
+          ),
+          lookbehind: true,
+          inside: Prism2.languages.javascript
+        },
+        exports: {
+          // https://tc39.es/ecma262/#sec-exports
+          pattern: withId(
+            /(\bexport\b\s*)(?:\*(?:\s*as\s+<ID>)?(?=\s*\bfrom\b)|\{[^{}]*\})/.source
+          ),
+          lookbehind: true,
+          inside: Prism2.languages.javascript
+        }
+      });
+      Prism2.languages.javascript["keyword"].unshift(
+        {
+          pattern: /\b(?:as|default|export|from|import)\b/,
+          alias: "module"
+        },
+        {
+          pattern: /\b(?:await|break|catch|continue|do|else|finally|for|if|return|switch|throw|try|while|yield)\b/,
+          alias: "control-flow"
+        },
+        {
+          pattern: /\bnull\b/,
+          alias: ["null", "nil"]
+        },
+        {
+          pattern: /\bundefined\b/,
+          alias: "nil"
+        }
+      );
+      Prism2.languages.insertBefore("javascript", "operator", {
+        spread: {
+          pattern: /\.{3}/,
+          alias: "operator"
+        },
+        arrow: {
+          pattern: /=>/,
+          alias: "operator"
+        }
+      });
+      Prism2.languages.insertBefore("javascript", "punctuation", {
+        "property-access": {
+          pattern: withId(/(\.\s*)#?<ID>/.source),
+          lookbehind: true
+        },
+        "maybe-class-name": {
+          pattern: /(^|[^$\w\xA0-\uFFFF])[A-Z][$\w\xA0-\uFFFF]+/,
+          lookbehind: true
+        },
+        dom: {
+          // this contains only a few commonly used DOM variables
+          pattern: /\b(?:document|(?:local|session)Storage|location|navigator|performance|window)\b/,
+          alias: "variable"
+        },
+        console: {
+          pattern: /\bconsole(?=\s*\.)/,
+          alias: "class-name"
+        }
+      });
+      var maybeClassNameTokens = [
+        "function",
+        "function-variable",
+        "method",
+        "method-variable",
+        "property-access"
+      ];
+      for (var i = 0; i < maybeClassNameTokens.length; i++) {
+        var token = maybeClassNameTokens[i];
+        var value = Prism2.languages.javascript[token];
+        if (Prism2.util.type(value) === "RegExp") {
+          value = Prism2.languages.javascript[token] = {
+            pattern: value
+          };
+        }
+        var inside = value.inside || {};
+        value.inside = inside;
+        inside["maybe-class-name"] = /^[A-Z][\s\S]*/;
+      }
+    })(Prism);
+  }
+  return jsExtras_1;
+}
+var jsExtrasExports = requireJsExtras();
+const jsExtras = /* @__PURE__ */ getDefaultExportFromCjs(jsExtrasExports);
+const jsExtras$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: jsExtras
+}, [jsExtrasExports]);
+export {
+  jsExtras$1 as j
+};
+//# sourceMappingURL=js-extras-CFriKWFZ.js.map

package/dist/js-extras-CFriKWFZ.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"js-extras-CFriKWFZ.js","sources":["../node_modules/refractor/lang/js-extras.js"],"sourcesContent":["'use strict'\n\nmodule.exports = jsExtras\njsExtras.displayName = 'jsExtras'\njsExtras.aliases = []\nfunction jsExtras(Prism) {\n  ;(function (Prism) {\n    Prism.languages.insertBefore('javascript', 'function-variable', {\n      'method-variable': {\n        pattern: RegExp(\n          '(\\\\.\\\\s*)' +\n            Prism.languages.javascript['function-variable'].pattern.source\n        ),\n        lookbehind: true,\n        alias: ['function-variable', 'method', 'function', 'property-access']\n      }\n    })\n    Prism.languages.insertBefore('javascript', 'function', {\n      method: {\n        pattern: RegExp(\n          '(\\\\.\\\\s*)' + Prism.languages.javascript['function'].source\n        ),\n        lookbehind: true,\n        alias: ['function', 'property-access']\n      }\n    })\n    Prism.languages.insertBefore('javascript', 'constant', {\n      'known-class-name': [\n        {\n          // standard built-ins\n          // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects\n          pattern:\n            /\\b(?:(?:Float(?:32|64)|(?:Int|Uint)(?:8|16|32)|Uint8Clamped)?Array|ArrayBuffer|BigInt|Boolean|DataView|Date|Error|Function|Intl|JSON|(?:Weak)?(?:Map|Set)|Math|Number|Object|Promise|Proxy|Reflect|RegExp|String|Symbol|WebAssembly)\\b/,\n          alias: 'class-name'\n        },\n        {\n          // errors\n          pattern: /\\b(?:[A-Z]\\w*)Error\\b/,\n          alias: 'class-name'\n        }\n      ]\n    })\n    /**\n     * Replaces the `<ID>` placeholder in the given pattern with a pattern for general JS identifiers.\n     *\n     * @param {string} source\n     * @param {string} [flags]\n     * @returns {RegExp}\n     */\n    function withId(source, flags) {\n      return RegExp(\n        source.replace(/<ID>/g, function () {\n          return /(?!\\s)[_$a-zA-Z\\xA0-\\uFFFF](?:(?!\\s)[$\\w\\xA0-\\uFFFF])*/.source\n        }),\n        flags\n      )\n    }\n    Prism.languages.insertBefore('javascript', 'keyword', {\n      imports: {\n        // https://tc39.es/ecma262/#sec-imports\n        pattern: withId(\n          /(\\bimport\\b\\s*)(?:<ID>(?:\\s*,\\s*(?:\\*\\s*as\\s+<ID>|\\{[^{}]*\\}))?|\\*\\s*as\\s+<ID>|\\{[^{}]*\\})(?=\\s*\\bfrom\\b)/\n            .source\n        ),\n        lookbehind: true,\n        inside: Prism.languages.javascript\n      },\n      exports: {\n        // https://tc39.es/ecma262/#sec-exports\n        pattern: withId(\n          /(\\bexport\\b\\s*)(?:\\*(?:\\s*as\\s+<ID>)?(?=\\s*\\bfrom\\b)|\\{[^{}]*\\})/\n            .source\n        ),\n        lookbehind: true,\n        inside: Prism.languages.javascript\n      }\n    })\n    Prism.languages.javascript['keyword'].unshift(\n      {\n        pattern: /\\b(?:as|default|export|from|import)\\b/,\n        alias: 'module'\n      },\n      {\n        pattern:\n          /\\b(?:await|break|catch|continue|do|else|finally|for|if|return|switch|throw|try|while|yield)\\b/,\n        alias: 'control-flow'\n      },\n      {\n        pattern: /\\bnull\\b/,\n        alias: ['null', 'nil']\n      },\n      {\n        pattern: /\\bundefined\\b/,\n        alias: 'nil'\n      }\n    )\n    Prism.languages.insertBefore('javascript', 'operator', {\n      spread: {\n        pattern: /\\.{3}/,\n        alias: 'operator'\n      },\n      arrow: {\n        pattern: /=>/,\n        alias: 'operator'\n      }\n    })\n    Prism.languages.insertBefore('javascript', 'punctuation', {\n      'property-access': {\n        pattern: withId(/(\\.\\s*)#?<ID>/.source),\n        lookbehind: true\n      },\n      'maybe-class-name': {\n        pattern: /(^|[^$\\w\\xA0-\\uFFFF])[A-Z][$\\w\\xA0-\\uFFFF]+/,\n        lookbehind: true\n      },\n      dom: {\n        // this contains only a few commonly used DOM variables\n        pattern:\n          /\\b(?:document|(?:local|session)Storage|location|navigator|performance|window)\\b/,\n        alias: 'variable'\n      },\n      console: {\n        pattern: /\\bconsole(?=\\s*\\.)/,\n        alias: 'class-name'\n      }\n    }) // add 'maybe-class-name' to tokens which might be a class name\n    var maybeClassNameTokens = [\n      'function',\n      'function-variable',\n      'method',\n      'method-variable',\n      'property-access'\n    ]\n    for (var i = 0; i < maybeClassNameTokens.length; i++) {\n      var token = maybeClassNameTokens[i]\n      var value = Prism.languages.javascript[token] // convert regex to object\n      if (Prism.util.type(value) === 'RegExp') {\n        value = Prism.languages.javascript[token] = {\n          pattern: value\n        }\n      } // keep in mind that we don't support arrays\n      var inside = value.inside || {}\n      value.inside = inside\n      inside['maybe-class-name'] = /^[A-Z][\\s\\S]*/\n    }\n  })(Prism)\n}\n"],"names":["jsExtras","Prism"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/js-templates-CJ8FEAj5.js

@@ -0,0 +1,262 @@
+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 jsTemplates_1;
+var hasRequiredJsTemplates;
+function requireJsTemplates() {
+  if (hasRequiredJsTemplates) return jsTemplates_1;
+  hasRequiredJsTemplates = 1;
+  jsTemplates_1 = jsTemplates2;
+  jsTemplates2.displayName = "jsTemplates";
+  jsTemplates2.aliases = [];
+  function jsTemplates2(Prism) {
+    (function(Prism2) {
+      var templateString = Prism2.languages.javascript["template-string"];
+      var templateLiteralPattern = templateString.pattern.source;
+      var interpolationObject = templateString.inside["interpolation"];
+      var interpolationPunctuationObject = interpolationObject.inside["interpolation-punctuation"];
+      var interpolationPattern = interpolationObject.pattern.source;
+      function createTemplate(language, tag) {
+        if (!Prism2.languages[language]) {
+          return void 0;
+        }
+        return {
+          pattern: RegExp("((?:" + tag + ")\\s*)" + templateLiteralPattern),
+          lookbehind: true,
+          greedy: true,
+          inside: {
+            "template-punctuation": {
+              pattern: /^`|`$/,
+              alias: "string"
+            },
+            "embedded-code": {
+              pattern: /[\s\S]+/,
+              alias: language
+            }
+          }
+        };
+      }
+      Prism2.languages.javascript["template-string"] = [
+        // styled-jsx:
+        //   css`a { color: #25F; }`
+        // styled-components:
+        //   styled.h1`color: red;`
+        createTemplate(
+          "css",
+          /\b(?:styled(?:\([^)]*\))?(?:\s*\.\s*\w+(?:\([^)]*\))*)*|css(?:\s*\.\s*(?:global|resolve))?|createGlobalStyle|keyframes)/.source
+        ),
+        // html`<p></p>`
+        // div.innerHTML = `<p></p>`
+        createTemplate("html", /\bhtml|\.\s*(?:inner|outer)HTML\s*\+?=/.source),
+        // svg`<path fill="#fff" d="M55.37 ..."/>`
+        createTemplate("svg", /\bsvg/.source),
+        // md`# h1`, markdown`## h2`
+        createTemplate("markdown", /\b(?:markdown|md)/.source),
+        // gql`...`, graphql`...`, graphql.experimental`...`
+        createTemplate(
+          "graphql",
+          /\b(?:gql|graphql(?:\s*\.\s*experimental)?)/.source
+        ),
+        // sql`...`
+        createTemplate("sql", /\bsql/.source),
+        // vanilla template string
+        templateString
+      ].filter(Boolean);
+      function getPlaceholder(counter, language) {
+        return "___" + language.toUpperCase() + "_" + counter + "___";
+      }
+      function tokenizeWithHooks(code, grammar, language) {
+        var env = {
+          code,
+          grammar,
+          language
+        };
+        Prism2.hooks.run("before-tokenize", env);
+        env.tokens = Prism2.tokenize(env.code, env.grammar);
+        Prism2.hooks.run("after-tokenize", env);
+        return env.tokens;
+      }
+      function tokenizeInterpolationExpression(expression) {
+        var tempGrammar = {};
+        tempGrammar["interpolation-punctuation"] = interpolationPunctuationObject;
+        var tokens = Prism2.tokenize(expression, tempGrammar);
+        if (tokens.length === 3) {
+          var args = [1, 1];
+          args.push.apply(
+            args,
+            tokenizeWithHooks(tokens[1], Prism2.languages.javascript, "javascript")
+          );
+          tokens.splice.apply(tokens, args);
+        }
+        return new Prism2.Token(
+          "interpolation",
+          tokens,
+          interpolationObject.alias,
+          expression
+        );
+      }
+      function tokenizeEmbedded(code, grammar, language) {
+        var _tokens = Prism2.tokenize(code, {
+          interpolation: {
+            pattern: RegExp(interpolationPattern),
+            lookbehind: true
+          }
+        });
+        var placeholderCounter = 0;
+        var placeholderMap = {};
+        var embeddedCode = _tokens.map(function(token) {
+          if (typeof token === "string") {
+            return token;
+          } else {
+            var interpolationExpression = token.content;
+            var placeholder;
+            while (code.indexOf(
+              placeholder = getPlaceholder(placeholderCounter++, language)
+            ) !== -1) {
+            }
+            placeholderMap[placeholder] = interpolationExpression;
+            return placeholder;
+          }
+        }).join("");
+        var embeddedTokens = tokenizeWithHooks(embeddedCode, grammar, language);
+        var placeholders = Object.keys(placeholderMap);
+        placeholderCounter = 0;
+        function walkTokens(tokens) {
+          for (var i = 0; i < tokens.length; i++) {
+            if (placeholderCounter >= placeholders.length) {
+              return;
+            }
+            var token = tokens[i];
+            if (typeof token === "string" || typeof token.content === "string") {
+              var placeholder = placeholders[placeholderCounter];
+              var s = typeof token === "string" ? token : (
+                /** @type {string} */
+                token.content
+              );
+              var index = s.indexOf(placeholder);
+              if (index !== -1) {
+                ++placeholderCounter;
+                var before = s.substring(0, index);
+                var middle = tokenizeInterpolationExpression(
+                  placeholderMap[placeholder]
+                );
+                var after = s.substring(index + placeholder.length);
+                var replacement = [];
+                if (before) {
+                  replacement.push(before);
+                }
+                replacement.push(middle);
+                if (after) {
+                  var afterTokens = [after];
+                  walkTokens(afterTokens);
+                  replacement.push.apply(replacement, afterTokens);
+                }
+                if (typeof token === "string") {
+                  tokens.splice.apply(tokens, [i, 1].concat(replacement));
+                  i += replacement.length - 1;
+                } else {
+                  token.content = replacement;
+                }
+              }
+            } else {
+              var content = token.content;
+              if (Array.isArray(content)) {
+                walkTokens(content);
+              } else {
+                walkTokens([content]);
+              }
+            }
+          }
+        }
+        walkTokens(embeddedTokens);
+        return new Prism2.Token(
+          language,
+          embeddedTokens,
+          "language-" + language,
+          code
+        );
+      }
+      var supportedLanguages = {
+        javascript: true,
+        js: true,
+        typescript: true,
+        ts: true,
+        jsx: true,
+        tsx: true
+      };
+      Prism2.hooks.add("after-tokenize", function(env) {
+        if (!(env.language in supportedLanguages)) {
+          return;
+        }
+        function findTemplateStrings(tokens) {
+          for (var i = 0, l = tokens.length; i < l; i++) {
+            var token = tokens[i];
+            if (typeof token === "string") {
+              continue;
+            }
+            var content = token.content;
+            if (!Array.isArray(content)) {
+              if (typeof content !== "string") {
+                findTemplateStrings([content]);
+              }
+              continue;
+            }
+            if (token.type === "template-string") {
+              var embedded = content[1];
+              if (content.length === 3 && typeof embedded !== "string" && embedded.type === "embedded-code") {
+                var code = stringContent(embedded);
+                var alias = embedded.alias;
+                var language = Array.isArray(alias) ? alias[0] : alias;
+                var grammar = Prism2.languages[language];
+                if (!grammar) {
+                  continue;
+                }
+                content[1] = tokenizeEmbedded(code, grammar, language);
+              }
+            } else {
+              findTemplateStrings(content);
+            }
+          }
+        }
+        findTemplateStrings(env.tokens);
+      });
+      function stringContent(value) {
+        if (typeof value === "string") {
+          return value;
+        } else if (Array.isArray(value)) {
+          return value.map(stringContent).join("");
+        } else {
+          return stringContent(value.content);
+        }
+      }
+    })(Prism);
+  }
+  return jsTemplates_1;
+}
+var jsTemplatesExports = requireJsTemplates();
+const jsTemplates = /* @__PURE__ */ getDefaultExportFromCjs(jsTemplatesExports);
+const jsTemplates$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: jsTemplates
+}, [jsTemplatesExports]);
+export {
+  jsTemplates$1 as j
+};
+//# sourceMappingURL=js-templates-CJ8FEAj5.js.map

package/dist/js-templates-CJ8FEAj5.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"js-templates-CJ8FEAj5.js","sources":["../node_modules/refractor/lang/js-templates.js"],"sourcesContent":["'use strict'\n\nmodule.exports = jsTemplates\njsTemplates.displayName = 'jsTemplates'\njsTemplates.aliases = []\nfunction jsTemplates(Prism) {\n  ;(function (Prism) {\n    var templateString = Prism.languages.javascript['template-string'] // see the pattern in prism-javascript.js\n    var templateLiteralPattern = templateString.pattern.source\n    var interpolationObject = templateString.inside['interpolation']\n    var interpolationPunctuationObject =\n      interpolationObject.inside['interpolation-punctuation']\n    var interpolationPattern = interpolationObject.pattern.source\n    /**\n     * Creates a new pattern to match a template string with a special tag.\n     *\n     * This will return `undefined` if there is no grammar with the given language id.\n     *\n     * @param {string} language The language id of the embedded language. E.g. `markdown`.\n     * @param {string} tag The regex pattern to match the tag.\n     * @returns {object | undefined}\n     * @example\n     * createTemplate('css', /\\bcss/.source);\n     */\n    function createTemplate(language, tag) {\n      if (!Prism.languages[language]) {\n        return undefined\n      }\n      return {\n        pattern: RegExp('((?:' + tag + ')\\\\s*)' + templateLiteralPattern),\n        lookbehind: true,\n        greedy: true,\n        inside: {\n          'template-punctuation': {\n            pattern: /^`|`$/,\n            alias: 'string'\n          },\n          'embedded-code': {\n            pattern: /[\\s\\S]+/,\n            alias: language\n          }\n        }\n      }\n    }\n    Prism.languages.javascript['template-string'] = [\n      // styled-jsx:\n      //   css`a { color: #25F; }`\n      // styled-components:\n      //   styled.h1`color: red;`\n      createTemplate(\n        'css',\n        /\\b(?:styled(?:\\([^)]*\\))?(?:\\s*\\.\\s*\\w+(?:\\([^)]*\\))*)*|css(?:\\s*\\.\\s*(?:global|resolve))?|createGlobalStyle|keyframes)/\n          .source\n      ), // html`<p></p>`\n      // div.innerHTML = `<p></p>`\n      createTemplate('html', /\\bhtml|\\.\\s*(?:inner|outer)HTML\\s*\\+?=/.source), // svg`<path fill=\"#fff\" d=\"M55.37 ...\"/>`\n      createTemplate('svg', /\\bsvg/.source), // md`# h1`, markdown`## h2`\n      createTemplate('markdown', /\\b(?:markdown|md)/.source), // gql`...`, graphql`...`, graphql.experimental`...`\n      createTemplate(\n        'graphql',\n        /\\b(?:gql|graphql(?:\\s*\\.\\s*experimental)?)/.source\n      ), // sql`...`\n      createTemplate('sql', /\\bsql/.source), // vanilla template string\n      templateString\n    ].filter(Boolean)\n    /**\n     * Returns a specific placeholder literal for the given language.\n     *\n     * @param {number} counter\n     * @param {string} language\n     * @returns {string}\n     */\n    function getPlaceholder(counter, language) {\n      return '___' + language.toUpperCase() + '_' + counter + '___'\n    }\n    /**\n     * Returns the tokens of `Prism.tokenize` but also runs the `before-tokenize` and `after-tokenize` hooks.\n     *\n     * @param {string} code\n     * @param {any} grammar\n     * @param {string} language\n     * @returns {(string|Token)[]}\n     */\n    function tokenizeWithHooks(code, grammar, language) {\n      var env = {\n        code: code,\n        grammar: grammar,\n        language: language\n      }\n      Prism.hooks.run('before-tokenize', env)\n      env.tokens = Prism.tokenize(env.code, env.grammar)\n      Prism.hooks.run('after-tokenize', env)\n      return env.tokens\n    }\n    /**\n     * Returns the token of the given JavaScript interpolation expression.\n     *\n     * @param {string} expression The code of the expression. E.g. `\"${42}\"`\n     * @returns {Token}\n     */\n    function tokenizeInterpolationExpression(expression) {\n      var tempGrammar = {}\n      tempGrammar['interpolation-punctuation'] = interpolationPunctuationObject\n      /** @type {Array} */\n      var tokens = Prism.tokenize(expression, tempGrammar)\n      if (tokens.length === 3) {\n        /**\n         * The token array will look like this\n         * [\n         *     [\"interpolation-punctuation\", \"${\"]\n         *     \"...\" // JavaScript expression of the interpolation\n         *     [\"interpolation-punctuation\", \"}\"]\n         * ]\n         */\n        var args = [1, 1]\n        args.push.apply(\n          args,\n          tokenizeWithHooks(tokens[1], Prism.languages.javascript, 'javascript')\n        )\n        tokens.splice.apply(tokens, args)\n      }\n      return new Prism.Token(\n        'interpolation',\n        tokens,\n        interpolationObject.alias,\n        expression\n      )\n    }\n    /**\n     * Tokenizes the given code with support for JavaScript interpolation expressions mixed in.\n     *\n     * This function has 3 phases:\n     *\n     * 1. Replace all JavaScript interpolation expression with a placeholder.\n     *    The placeholder will have the syntax of a identify of the target language.\n     * 2. Tokenize the code with placeholders.\n     * 3. Tokenize the interpolation expressions and re-insert them into the tokenize code.\n     *    The insertion only works if a placeholder hasn't been \"ripped apart\" meaning that the placeholder has been\n     *    tokenized as two tokens by the grammar of the embedded language.\n     *\n     * @param {string} code\n     * @param {object} grammar\n     * @param {string} language\n     * @returns {Token}\n     */\n    function tokenizeEmbedded(code, grammar, language) {\n      // 1. First filter out all interpolations\n      // because they might be escaped, we need a lookbehind, so we use Prism\n      /** @type {(Token|string)[]} */\n      var _tokens = Prism.tokenize(code, {\n        interpolation: {\n          pattern: RegExp(interpolationPattern),\n          lookbehind: true\n        }\n      }) // replace all interpolations with a placeholder which is not in the code already\n      var placeholderCounter = 0\n      /** @type {Object<string, string>} */\n      var placeholderMap = {}\n      var embeddedCode = _tokens\n        .map(function (token) {\n          if (typeof token === 'string') {\n            return token\n          } else {\n            var interpolationExpression = token.content\n            var placeholder\n            while (\n              code.indexOf(\n                (placeholder = getPlaceholder(placeholderCounter++, language))\n              ) !== -1\n            ) {\n              /* noop */\n            }\n            placeholderMap[placeholder] = interpolationExpression\n            return placeholder\n          }\n        })\n        .join('') // 2. Tokenize the embedded code\n      var embeddedTokens = tokenizeWithHooks(embeddedCode, grammar, language) // 3. Re-insert the interpolation\n      var placeholders = Object.keys(placeholderMap)\n      placeholderCounter = 0\n      /**\n       *\n       * @param {(Token|string)[]} tokens\n       * @returns {void}\n       */\n      function walkTokens(tokens) {\n        for (var i = 0; i < tokens.length; i++) {\n          if (placeholderCounter >= placeholders.length) {\n            return\n          }\n          var token = tokens[i]\n          if (typeof token === 'string' || typeof token.content === 'string') {\n            var placeholder = placeholders[placeholderCounter]\n            var s =\n              typeof token === 'string'\n                ? token\n                : /** @type {string} */\n                  token.content\n            var index = s.indexOf(placeholder)\n            if (index !== -1) {\n              ++placeholderCounter\n              var before = s.substring(0, index)\n              var middle = tokenizeInterpolationExpression(\n                placeholderMap[placeholder]\n              )\n              var after = s.substring(index + placeholder.length)\n              var replacement = []\n              if (before) {\n                replacement.push(before)\n              }\n              replacement.push(middle)\n              if (after) {\n                var afterTokens = [after]\n                walkTokens(afterTokens)\n                replacement.push.apply(replacement, afterTokens)\n              }\n              if (typeof token === 'string') {\n                tokens.splice.apply(tokens, [i, 1].concat(replacement))\n                i += replacement.length - 1\n              } else {\n                token.content = replacement\n              }\n            }\n          } else {\n            var content = token.content\n            if (Array.isArray(content)) {\n              walkTokens(content)\n            } else {\n              walkTokens([content])\n            }\n          }\n        }\n      }\n      walkTokens(embeddedTokens)\n      return new Prism.Token(\n        language,\n        embeddedTokens,\n        'language-' + language,\n        code\n      )\n    }\n    /**\n     * The languages for which JS templating will handle tagged template literals.\n     *\n     * JS templating isn't active for only JavaScript but also related languages like TypeScript, JSX, and TSX.\n     */\n    var supportedLanguages = {\n      javascript: true,\n      js: true,\n      typescript: true,\n      ts: true,\n      jsx: true,\n      tsx: true\n    }\n    Prism.hooks.add('after-tokenize', function (env) {\n      if (!(env.language in supportedLanguages)) {\n        return\n      }\n      /**\n       * Finds and tokenizes all template strings with an embedded languages.\n       *\n       * @param {(Token | string)[]} tokens\n       * @returns {void}\n       */\n      function findTemplateStrings(tokens) {\n        for (var i = 0, l = tokens.length; i < l; i++) {\n          var token = tokens[i]\n          if (typeof token === 'string') {\n            continue\n          }\n          var content = token.content\n          if (!Array.isArray(content)) {\n            if (typeof content !== 'string') {\n              findTemplateStrings([content])\n            }\n            continue\n          }\n          if (token.type === 'template-string') {\n            /**\n             * A JavaScript template-string token will look like this:\n             *\n             * [\"template-string\", [\n             *     [\"template-punctuation\", \"`\"],\n             *     (\n             *         An array of \"string\" and \"interpolation\" tokens. This is the simple string case.\n             *         or\n             *         [\"embedded-code\", \"...\"] This is the token containing the embedded code.\n             *                                  It also has an alias which is the language of the embedded code.\n             *     ),\n             *     [\"template-punctuation\", \"`\"]\n             * ]]\n             */\n            var embedded = content[1]\n            if (\n              content.length === 3 &&\n              typeof embedded !== 'string' &&\n              embedded.type === 'embedded-code'\n            ) {\n              // get string content\n              var code = stringContent(embedded)\n              var alias = embedded.alias\n              var language = Array.isArray(alias) ? alias[0] : alias\n              var grammar = Prism.languages[language]\n              if (!grammar) {\n                // the embedded language isn't registered.\n                continue\n              }\n              content[1] = tokenizeEmbedded(code, grammar, language)\n            }\n          } else {\n            findTemplateStrings(content)\n          }\n        }\n      }\n      findTemplateStrings(env.tokens)\n    })\n    /**\n     * Returns the string content of a token or token stream.\n     *\n     * @param {string | Token | (string | Token)[]} value\n     * @returns {string}\n     */\n    function stringContent(value) {\n      if (typeof value === 'string') {\n        return value\n      } else if (Array.isArray(value)) {\n        return value.map(stringContent).join('')\n      } else {\n        return stringContent(value.content)\n      }\n    }\n  })(Prism)\n}\n"],"names":["jsTemplates","Prism"],"mappings":"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","x_google_ignoreList":[0]}