@oscloudlab/knowledge-card 0.0.1 → 0.0.3

package/dist/http-CaopWVDH.js

@@ -0,0 +1,170 @@
+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 http_1;
+var hasRequiredHttp;
+function requireHttp() {
+  if (hasRequiredHttp) return http_1;
+  hasRequiredHttp = 1;
+  http_1 = http2;
+  http2.displayName = "http";
+  http2.aliases = [];
+  function http2(Prism) {
+    (function(Prism2) {
+      function headerValueOf(name) {
+        return RegExp("(^(?:" + name + "):[ 	]*(?![ 	]))[^]+", "i");
+      }
+      Prism2.languages.http = {
+        "request-line": {
+          pattern: /^(?:CONNECT|DELETE|GET|HEAD|OPTIONS|PATCH|POST|PRI|PUT|SEARCH|TRACE)\s(?:https?:\/\/|\/)\S*\sHTTP\/[\d.]+/m,
+          inside: {
+            // HTTP Method
+            method: {
+              pattern: /^[A-Z]+\b/,
+              alias: "property"
+            },
+            // Request Target e.g. http://example.com, /path/to/file
+            "request-target": {
+              pattern: /^(\s)(?:https?:\/\/|\/)\S*(?=\s)/,
+              lookbehind: true,
+              alias: "url",
+              inside: Prism2.languages.uri
+            },
+            // HTTP Version
+            "http-version": {
+              pattern: /^(\s)HTTP\/[\d.]+/,
+              lookbehind: true,
+              alias: "property"
+            }
+          }
+        },
+        "response-status": {
+          pattern: /^HTTP\/[\d.]+ \d+ .+/m,
+          inside: {
+            // HTTP Version
+            "http-version": {
+              pattern: /^HTTP\/[\d.]+/,
+              alias: "property"
+            },
+            // Status Code
+            "status-code": {
+              pattern: /^(\s)\d+(?=\s)/,
+              lookbehind: true,
+              alias: "number"
+            },
+            // Reason Phrase
+            "reason-phrase": {
+              pattern: /^(\s).+/,
+              lookbehind: true,
+              alias: "string"
+            }
+          }
+        },
+        header: {
+          pattern: /^[\w-]+:.+(?:(?:\r\n?|\n)[ \t].+)*/m,
+          inside: {
+            "header-value": [
+              {
+                pattern: headerValueOf(/Content-Security-Policy/.source),
+                lookbehind: true,
+                alias: ["csp", "languages-csp"],
+                inside: Prism2.languages.csp
+              },
+              {
+                pattern: headerValueOf(/Public-Key-Pins(?:-Report-Only)?/.source),
+                lookbehind: true,
+                alias: ["hpkp", "languages-hpkp"],
+                inside: Prism2.languages.hpkp
+              },
+              {
+                pattern: headerValueOf(/Strict-Transport-Security/.source),
+                lookbehind: true,
+                alias: ["hsts", "languages-hsts"],
+                inside: Prism2.languages.hsts
+              },
+              {
+                pattern: headerValueOf(/[^:]+/.source),
+                lookbehind: true
+              }
+            ],
+            "header-name": {
+              pattern: /^[^:]+/,
+              alias: "keyword"
+            },
+            punctuation: /^:/
+          }
+        }
+      };
+      var langs = Prism2.languages;
+      var httpLanguages = {
+        "application/javascript": langs.javascript,
+        "application/json": langs.json || langs.javascript,
+        "application/xml": langs.xml,
+        "text/xml": langs.xml,
+        "text/html": langs.html,
+        "text/css": langs.css,
+        "text/plain": langs.plain
+      };
+      var suffixTypes = {
+        "application/json": true,
+        "application/xml": true
+      };
+      function getSuffixPattern(contentType2) {
+        var suffix = contentType2.replace(/^[a-z]+\//, "");
+        var suffixPattern = "\\w+/(?:[\\w.-]+\\+)+" + suffix + "(?![+\\w.-])";
+        return "(?:" + contentType2 + "|" + suffixPattern + ")";
+      }
+      var options;
+      for (var contentType in httpLanguages) {
+        if (httpLanguages[contentType]) {
+          options = options || {};
+          var pattern = suffixTypes[contentType] ? getSuffixPattern(contentType) : contentType;
+          options[contentType.replace(/\//g, "-")] = {
+            pattern: RegExp(
+              "(" + /content-type:\s*/.source + pattern + /(?:(?:\r\n?|\n)[\w-].*)*(?:\r(?:\n|(?!\n))|\n)/.source + ")" + // This is a little interesting:
+              // The HTTP format spec required 1 empty line before the body to make everything unambiguous.
+              // However, when writing code by hand (e.g. to display on a website) people can forget about this,
+              // so we want to be liberal here. We will allow the empty line to be omitted if the first line of
+              // the body does not start with a [\w-] character (as headers do).
+              /[^ \t\w-][\s\S]*/.source,
+              "i"
+            ),
+            lookbehind: true,
+            inside: httpLanguages[contentType]
+          };
+        }
+      }
+      if (options) {
+        Prism2.languages.insertBefore("http", "header", options);
+      }
+    })(Prism);
+  }
+  return http_1;
+}
+var httpExports = requireHttp();
+const http = /* @__PURE__ */ getDefaultExportFromCjs(httpExports);
+const http$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: http
+}, [httpExports]);
+export {
+  http$1 as h
+};
+//# sourceMappingURL=http-CaopWVDH.js.map

package/dist/http-CaopWVDH.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-CaopWVDH.js","sources":["../node_modules/refractor/lang/http.js"],"sourcesContent":["'use strict'\n\nmodule.exports = http\nhttp.displayName = 'http'\nhttp.aliases = []\nfunction http(Prism) {\n  ;(function (Prism) {\n    /**\n     * @param {string} name\n     * @returns {RegExp}\n     */\n    function headerValueOf(name) {\n      return RegExp('(^(?:' + name + '):[ \\t]*(?![ \\t]))[^]+', 'i')\n    }\n    Prism.languages.http = {\n      'request-line': {\n        pattern:\n          /^(?:CONNECT|DELETE|GET|HEAD|OPTIONS|PATCH|POST|PRI|PUT|SEARCH|TRACE)\\s(?:https?:\\/\\/|\\/)\\S*\\sHTTP\\/[\\d.]+/m,\n        inside: {\n          // HTTP Method\n          method: {\n            pattern: /^[A-Z]+\\b/,\n            alias: 'property'\n          },\n          // Request Target e.g. http://example.com, /path/to/file\n          'request-target': {\n            pattern: /^(\\s)(?:https?:\\/\\/|\\/)\\S*(?=\\s)/,\n            lookbehind: true,\n            alias: 'url',\n            inside: Prism.languages.uri\n          },\n          // HTTP Version\n          'http-version': {\n            pattern: /^(\\s)HTTP\\/[\\d.]+/,\n            lookbehind: true,\n            alias: 'property'\n          }\n        }\n      },\n      'response-status': {\n        pattern: /^HTTP\\/[\\d.]+ \\d+ .+/m,\n        inside: {\n          // HTTP Version\n          'http-version': {\n            pattern: /^HTTP\\/[\\d.]+/,\n            alias: 'property'\n          },\n          // Status Code\n          'status-code': {\n            pattern: /^(\\s)\\d+(?=\\s)/,\n            lookbehind: true,\n            alias: 'number'\n          },\n          // Reason Phrase\n          'reason-phrase': {\n            pattern: /^(\\s).+/,\n            lookbehind: true,\n            alias: 'string'\n          }\n        }\n      },\n      header: {\n        pattern: /^[\\w-]+:.+(?:(?:\\r\\n?|\\n)[ \\t].+)*/m,\n        inside: {\n          'header-value': [\n            {\n              pattern: headerValueOf(/Content-Security-Policy/.source),\n              lookbehind: true,\n              alias: ['csp', 'languages-csp'],\n              inside: Prism.languages.csp\n            },\n            {\n              pattern: headerValueOf(/Public-Key-Pins(?:-Report-Only)?/.source),\n              lookbehind: true,\n              alias: ['hpkp', 'languages-hpkp'],\n              inside: Prism.languages.hpkp\n            },\n            {\n              pattern: headerValueOf(/Strict-Transport-Security/.source),\n              lookbehind: true,\n              alias: ['hsts', 'languages-hsts'],\n              inside: Prism.languages.hsts\n            },\n            {\n              pattern: headerValueOf(/[^:]+/.source),\n              lookbehind: true\n            }\n          ],\n          'header-name': {\n            pattern: /^[^:]+/,\n            alias: 'keyword'\n          },\n          punctuation: /^:/\n        }\n      }\n    } // Create a mapping of Content-Type headers to language definitions\n    var langs = Prism.languages\n    var httpLanguages = {\n      'application/javascript': langs.javascript,\n      'application/json': langs.json || langs.javascript,\n      'application/xml': langs.xml,\n      'text/xml': langs.xml,\n      'text/html': langs.html,\n      'text/css': langs.css,\n      'text/plain': langs.plain\n    } // Declare which types can also be suffixes\n    var suffixTypes = {\n      'application/json': true,\n      'application/xml': true\n    }\n    /**\n     * Returns a pattern for the given content type which matches it and any type which has it as a suffix.\n     *\n     * @param {string} contentType\n     * @returns {string}\n     */\n    function getSuffixPattern(contentType) {\n      var suffix = contentType.replace(/^[a-z]+\\//, '')\n      var suffixPattern = '\\\\w+/(?:[\\\\w.-]+\\\\+)+' + suffix + '(?![+\\\\w.-])'\n      return '(?:' + contentType + '|' + suffixPattern + ')'\n    } // Insert each content type parser that has its associated language\n    // currently loaded.\n    var options\n    for (var contentType in httpLanguages) {\n      if (httpLanguages[contentType]) {\n        options = options || {}\n        var pattern = suffixTypes[contentType]\n          ? getSuffixPattern(contentType)\n          : contentType\n        options[contentType.replace(/\\//g, '-')] = {\n          pattern: RegExp(\n            '(' +\n              /content-type:\\s*/.source +\n              pattern +\n              /(?:(?:\\r\\n?|\\n)[\\w-].*)*(?:\\r(?:\\n|(?!\\n))|\\n)/.source +\n              ')' + // This is a little interesting:\n              // The HTTP format spec required 1 empty line before the body to make everything unambiguous.\n              // However, when writing code by hand (e.g. to display on a website) people can forget about this,\n              // so we want to be liberal here. We will allow the empty line to be omitted if the first line of\n              // the body does not start with a [\\w-] character (as headers do).\n              /[^ \\t\\w-][\\s\\S]*/.source,\n            'i'\n          ),\n          lookbehind: true,\n          inside: httpLanguages[contentType]\n        }\n      }\n    }\n    if (options) {\n      Prism.languages.insertBefore('http', 'header', options)\n    }\n  })(Prism)\n}\n"],"names":["http","Prism","contentType"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/ichigojam-B2n3nEtO.js

@@ -0,0 +1,55 @@
+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 ichigojam_1;
+var hasRequiredIchigojam;
+function requireIchigojam() {
+  if (hasRequiredIchigojam) return ichigojam_1;
+  hasRequiredIchigojam = 1;
+  ichigojam_1 = ichigojam2;
+  ichigojam2.displayName = "ichigojam";
+  ichigojam2.aliases = [];
+  function ichigojam2(Prism) {
+    Prism.languages.ichigojam = {
+      comment: /(?:\B'|REM)(?:[^\n\r]*)/i,
+      string: {
+        pattern: /"(?:""|[!#$%&'()*,\/:;<=>?^\w +\-.])*"/,
+        greedy: true
+      },
+      number: /\B#[0-9A-F]+|\B`[01]+|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:E[+-]?\d+)?/i,
+      keyword: /\b(?:BEEP|BPS|CASE|CLEAR|CLK|CLO|CLP|CLS|CLT|CLV|CONT|COPY|ELSE|END|FILE|FILES|FOR|GOSUB|GOTO|GSB|IF|INPUT|KBD|LED|LET|LIST|LOAD|LOCATE|LRUN|NEW|NEXT|OUT|PLAY|POKE|PRINT|PWM|REM|RENUM|RESET|RETURN|RIGHT|RTN|RUN|SAVE|SCROLL|SLEEP|SRND|STEP|STOP|SUB|TEMPO|THEN|TO|UART|VIDEO|WAIT)(?:\$|\b)/i,
+      function: /\b(?:ABS|ANA|ASC|BIN|BTN|DEC|END|FREE|HELP|HEX|I2CR|I2CW|IN|INKEY|LEN|LINE|PEEK|RND|SCR|SOUND|STR|TICK|USR|VER|VPEEK|ZER)(?:\$|\b)/i,
+      label: /(?:\B@\S+)/,
+      operator: /<[=>]?|>=?|\|\||&&|[+\-*\/=|&^~!]|\b(?:AND|NOT|OR)\b/i,
+      punctuation: /[\[,;:()\]]/
+    };
+  }
+  return ichigojam_1;
+}
+var ichigojamExports = requireIchigojam();
+const ichigojam = /* @__PURE__ */ getDefaultExportFromCjs(ichigojamExports);
+const ichigojam$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: ichigojam
+}, [ichigojamExports]);
+export {
+  ichigojam$1 as i
+};
+//# sourceMappingURL=ichigojam-B2n3nEtO.js.map

package/dist/ichigojam-B2n3nEtO.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ichigojam-B2n3nEtO.js","sources":["../node_modules/refractor/lang/ichigojam.js"],"sourcesContent":["'use strict'\n\nmodule.exports = ichigojam\nichigojam.displayName = 'ichigojam'\nichigojam.aliases = []\nfunction ichigojam(Prism) {\n  // according to the offical reference (EN)\n  // https://ichigojam.net/IchigoJam-en.html\n  Prism.languages.ichigojam = {\n    comment: /(?:\\B'|REM)(?:[^\\n\\r]*)/i,\n    string: {\n      pattern: /\"(?:\"\"|[!#$%&'()*,\\/:;<=>?^\\w +\\-.])*\"/,\n      greedy: true\n    },\n    number: /\\B#[0-9A-F]+|\\B`[01]+|(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:E[+-]?\\d+)?/i,\n    keyword:\n      /\\b(?:BEEP|BPS|CASE|CLEAR|CLK|CLO|CLP|CLS|CLT|CLV|CONT|COPY|ELSE|END|FILE|FILES|FOR|GOSUB|GOTO|GSB|IF|INPUT|KBD|LED|LET|LIST|LOAD|LOCATE|LRUN|NEW|NEXT|OUT|PLAY|POKE|PRINT|PWM|REM|RENUM|RESET|RETURN|RIGHT|RTN|RUN|SAVE|SCROLL|SLEEP|SRND|STEP|STOP|SUB|TEMPO|THEN|TO|UART|VIDEO|WAIT)(?:\\$|\\b)/i,\n    function:\n      /\\b(?:ABS|ANA|ASC|BIN|BTN|DEC|END|FREE|HELP|HEX|I2CR|I2CW|IN|INKEY|LEN|LINE|PEEK|RND|SCR|SOUND|STR|TICK|USR|VER|VPEEK|ZER)(?:\\$|\\b)/i,\n    label: /(?:\\B@\\S+)/,\n    operator: /<[=>]?|>=?|\\|\\||&&|[+\\-*\\/=|&^~!]|\\b(?:AND|NOT|OR)\\b/i,\n    punctuation: /[\\[,;:()\\]]/\n  }\n}\n"],"names":["ichigojam"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,gBAAiBA;AACjB,EAAAA,WAAU,cAAc;AACxB,EAAAA,WAAU,UAAU,CAAA;AACpB,WAASA,WAAU,OAAO;AAGxB,UAAM,UAAU,YAAY;AAAA,MAC1B,SAAS;AAAA,MACT,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,QAAQ;AAAA,MACR,SACE;AAAA,MACF,UACE;AAAA,MACF,OAAO;AAAA,MACP,UAAU;AAAA,MACV,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/icon-C2Tsx7bx.js

@@ -0,0 +1,62 @@
+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 icon_1;
+var hasRequiredIcon;
+function requireIcon() {
+  if (hasRequiredIcon) return icon_1;
+  hasRequiredIcon = 1;
+  icon_1 = icon2;
+  icon2.displayName = "icon";
+  icon2.aliases = [];
+  function icon2(Prism) {
+    Prism.languages.icon = {
+      comment: /#.*/,
+      string: {
+        pattern: /(["'])(?:(?!\1)[^\\\r\n_]|\\.|_(?!\1)(?:\r\n|[\s\S]))*\1/,
+        greedy: true
+      },
+      number: /\b(?:\d+r[a-z\d]+|\d+(?:\.\d+)?(?:e[+-]?\d+)?)\b|\.\d+\b/i,
+      "builtin-keyword": {
+        pattern: /&(?:allocated|ascii|clock|collections|cset|current|date|dateline|digits|dump|e|error(?:number|text|value)?|errout|fail|features|file|host|input|lcase|letters|level|line|main|null|output|phi|pi|pos|progname|random|regions|source|storage|subject|time|trace|ucase|version)\b/,
+        alias: "variable"
+      },
+      directive: {
+        pattern: /\$\w+/,
+        alias: "builtin"
+      },
+      keyword: /\b(?:break|by|case|create|default|do|else|end|every|fail|global|if|initial|invocable|link|local|next|not|of|procedure|record|repeat|return|static|suspend|then|to|until|while)\b/,
+      function: /\b(?!\d)\w+(?=\s*[({]|\s*!\s*\[)/,
+      operator: /[+-]:(?!=)|(?:[\/?@^%&]|\+\+?|--?|==?=?|~==?=?|\*\*?|\|\|\|?|<(?:->?|<?=?)|>>?=?)(?::=)?|:(?:=:?)?|[!.\\|~]/,
+      punctuation: /[\[\](){},;]/
+    };
+  }
+  return icon_1;
+}
+var iconExports = requireIcon();
+const icon = /* @__PURE__ */ getDefaultExportFromCjs(iconExports);
+const icon$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: icon
+}, [iconExports]);
+export {
+  icon$1 as i
+};
+//# sourceMappingURL=icon-C2Tsx7bx.js.map

package/dist/icon-C2Tsx7bx.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"icon-C2Tsx7bx.js","sources":["../node_modules/refractor/lang/icon.js"],"sourcesContent":["'use strict'\n\nmodule.exports = icon\nicon.displayName = 'icon'\nicon.aliases = []\nfunction icon(Prism) {\n  Prism.languages.icon = {\n    comment: /#.*/,\n    string: {\n      pattern: /([\"'])(?:(?!\\1)[^\\\\\\r\\n_]|\\\\.|_(?!\\1)(?:\\r\\n|[\\s\\S]))*\\1/,\n      greedy: true\n    },\n    number: /\\b(?:\\d+r[a-z\\d]+|\\d+(?:\\.\\d+)?(?:e[+-]?\\d+)?)\\b|\\.\\d+\\b/i,\n    'builtin-keyword': {\n      pattern:\n        /&(?:allocated|ascii|clock|collections|cset|current|date|dateline|digits|dump|e|error(?:number|text|value)?|errout|fail|features|file|host|input|lcase|letters|level|line|main|null|output|phi|pi|pos|progname|random|regions|source|storage|subject|time|trace|ucase|version)\\b/,\n      alias: 'variable'\n    },\n    directive: {\n      pattern: /\\$\\w+/,\n      alias: 'builtin'\n    },\n    keyword:\n      /\\b(?:break|by|case|create|default|do|else|end|every|fail|global|if|initial|invocable|link|local|next|not|of|procedure|record|repeat|return|static|suspend|then|to|until|while)\\b/,\n    function: /\\b(?!\\d)\\w+(?=\\s*[({]|\\s*!\\s*\\[)/,\n    operator:\n      /[+-]:(?!=)|(?:[\\/?@^%&]|\\+\\+?|--?|==?=?|~==?=?|\\*\\*?|\\|\\|\\|?|<(?:->?|<?=?)|>>?=?)(?::=)?|:(?:=:?)?|[!.\\\\|~]/,\n    punctuation: /[\\[\\](){},;]/\n  }\n}\n"],"names":["icon"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,WAAiBA;AACjB,EAAAA,MAAK,cAAc;AACnB,EAAAA,MAAK,UAAU,CAAA;AACf,WAASA,MAAK,OAAO;AACnB,UAAM,UAAU,OAAO;AAAA,MACrB,SAAS;AAAA,MACT,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,QAAQ;AAAA,MACR,mBAAmB;AAAA,QACjB,SACE;AAAA,QACF,OAAO;AAAA;MAET,WAAW;AAAA,QACT,SAAS;AAAA,QACT,OAAO;AAAA;MAET,SACE;AAAA,MACF,UAAU;AAAA,MACV,UACE;AAAA,MACF,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/icu-message-format-Di068T_I.js

@@ -0,0 +1,184 @@
+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 icuMessageFormat_1;
+var hasRequiredIcuMessageFormat;
+function requireIcuMessageFormat() {
+  if (hasRequiredIcuMessageFormat) return icuMessageFormat_1;
+  hasRequiredIcuMessageFormat = 1;
+  icuMessageFormat_1 = icuMessageFormat2;
+  icuMessageFormat2.displayName = "icuMessageFormat";
+  icuMessageFormat2.aliases = [];
+  function icuMessageFormat2(Prism) {
+    (function(Prism2) {
+      function nested(source, level) {
+        if (level <= 0) {
+          return /[]/.source;
+        } else {
+          return source.replace(/<SELF>/g, function() {
+            return nested(source, level - 1);
+          });
+        }
+      }
+      var stringPattern = /'[{}:=,](?:[^']|'')*'(?!')/;
+      var escape = {
+        pattern: /''/,
+        greedy: true,
+        alias: "operator"
+      };
+      var string = {
+        pattern: stringPattern,
+        greedy: true,
+        inside: {
+          escape
+        }
+      };
+      var argumentSource = nested(
+        /\{(?:[^{}']|'(?![{},'])|''|<STR>|<SELF>)*\}/.source.replace(
+          /<STR>/g,
+          function() {
+            return stringPattern.source;
+          }
+        ),
+        8
+      );
+      var nestedMessage = {
+        pattern: RegExp(argumentSource),
+        inside: {
+          message: {
+            pattern: /^(\{)[\s\S]+(?=\}$)/,
+            lookbehind: true,
+            inside: null
+            // see below
+          },
+          "message-delimiter": {
+            pattern: /./,
+            alias: "punctuation"
+          }
+        }
+      };
+      Prism2.languages["icu-message-format"] = {
+        argument: {
+          pattern: RegExp(argumentSource),
+          greedy: true,
+          inside: {
+            content: {
+              pattern: /^(\{)[\s\S]+(?=\}$)/,
+              lookbehind: true,
+              inside: {
+                "argument-name": {
+                  pattern: /^(\s*)[^{}:=,\s]+/,
+                  lookbehind: true
+                },
+                "choice-style": {
+                  // https://unicode-org.github.io/icu-docs/apidoc/released/icu4c/classicu_1_1ChoiceFormat.html#details
+                  pattern: /^(\s*,\s*choice\s*,\s*)\S(?:[\s\S]*\S)?/,
+                  lookbehind: true,
+                  inside: {
+                    punctuation: /\|/,
+                    range: {
+                      pattern: /^(\s*)[+-]?(?:\d+(?:\.\d*)?|\u221e)\s*[<#\u2264]/,
+                      lookbehind: true,
+                      inside: {
+                        operator: /[<#\u2264]/,
+                        number: /\S+/
+                      }
+                    },
+                    rest: null
+                    // see below
+                  }
+                },
+                "plural-style": {
+                  // https://unicode-org.github.io/icu-docs/apidoc/released/icu4j/com/ibm/icu/text/PluralFormat.html#:~:text=Patterns%20and%20Their%20Interpretation
+                  pattern: /^(\s*,\s*(?:plural|selectordinal)\s*,\s*)\S(?:[\s\S]*\S)?/,
+                  lookbehind: true,
+                  inside: {
+                    offset: /^offset:\s*\d+/,
+                    "nested-message": nestedMessage,
+                    selector: {
+                      pattern: /=\d+|[^{}:=,\s]+/,
+                      inside: {
+                        keyword: /^(?:few|many|one|other|two|zero)$/
+                      }
+                    }
+                  }
+                },
+                "select-style": {
+                  // https://unicode-org.github.io/icu-docs/apidoc/released/icu4j/com/ibm/icu/text/SelectFormat.html#:~:text=Patterns%20and%20Their%20Interpretation
+                  pattern: /^(\s*,\s*select\s*,\s*)\S(?:[\s\S]*\S)?/,
+                  lookbehind: true,
+                  inside: {
+                    "nested-message": nestedMessage,
+                    selector: {
+                      pattern: /[^{}:=,\s]+/,
+                      inside: {
+                        keyword: /^other$/
+                      }
+                    }
+                  }
+                },
+                keyword: /\b(?:choice|plural|select|selectordinal)\b/,
+                "arg-type": {
+                  pattern: /\b(?:date|duration|number|ordinal|spellout|time)\b/,
+                  alias: "keyword"
+                },
+                "arg-skeleton": {
+                  pattern: /(,\s*)::[^{}:=,\s]+/,
+                  lookbehind: true
+                },
+                "arg-style": {
+                  pattern: /(,\s*)(?:currency|full|integer|long|medium|percent|short)(?=\s*$)/,
+                  lookbehind: true
+                },
+                "arg-style-text": {
+                  pattern: RegExp(
+                    /(^\s*,\s*(?=\S))/.source + nested(/(?:[^{}']|'[^']*'|\{(?:<SELF>)?\})+/.source, 8) + "$"
+                  ),
+                  lookbehind: true,
+                  alias: "string"
+                },
+                punctuation: /,/
+              }
+            },
+            "argument-delimiter": {
+              pattern: /./,
+              alias: "operator"
+            }
+          }
+        },
+        escape,
+        string
+      };
+      nestedMessage.inside.message.inside = Prism2.languages["icu-message-format"];
+      Prism2.languages["icu-message-format"].argument.inside.content.inside["choice-style"].inside.rest = Prism2.languages["icu-message-format"];
+    })(Prism);
+  }
+  return icuMessageFormat_1;
+}
+var icuMessageFormatExports = requireIcuMessageFormat();
+const icuMessageFormat = /* @__PURE__ */ getDefaultExportFromCjs(icuMessageFormatExports);
+const icuMessageFormat$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: icuMessageFormat
+}, [icuMessageFormatExports]);
+export {
+  icuMessageFormat$1 as i
+};
+//# sourceMappingURL=icu-message-format-Di068T_I.js.map

package/dist/icu-message-format-Di068T_I.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"icu-message-format-Di068T_I.js","sources":["../node_modules/refractor/lang/icu-message-format.js"],"sourcesContent":["'use strict'\n\nmodule.exports = icuMessageFormat\nicuMessageFormat.displayName = 'icuMessageFormat'\nicuMessageFormat.aliases = []\nfunction icuMessageFormat(Prism) {\n  // https://unicode-org.github.io/icu/userguide/format_parse/messages/\n  // https://unicode-org.github.io/icu-docs/apidoc/released/icu4j/com/ibm/icu/text/MessageFormat.html\n  ;(function (Prism) {\n    /**\n     * @param {string} source\n     * @param {number} level\n     * @returns {string}\n     */\n    function nested(source, level) {\n      if (level <= 0) {\n        return /[]/.source\n      } else {\n        return source.replace(/<SELF>/g, function () {\n          return nested(source, level - 1)\n        })\n      }\n    }\n    var stringPattern = /'[{}:=,](?:[^']|'')*'(?!')/\n    var escape = {\n      pattern: /''/,\n      greedy: true,\n      alias: 'operator'\n    }\n    var string = {\n      pattern: stringPattern,\n      greedy: true,\n      inside: {\n        escape: escape\n      }\n    }\n    var argumentSource = nested(\n      /\\{(?:[^{}']|'(?![{},'])|''|<STR>|<SELF>)*\\}/.source.replace(\n        /<STR>/g,\n        function () {\n          return stringPattern.source\n        }\n      ),\n      8\n    )\n    var nestedMessage = {\n      pattern: RegExp(argumentSource),\n      inside: {\n        message: {\n          pattern: /^(\\{)[\\s\\S]+(?=\\}$)/,\n          lookbehind: true,\n          inside: null // see below\n        },\n        'message-delimiter': {\n          pattern: /./,\n          alias: 'punctuation'\n        }\n      }\n    }\n    Prism.languages['icu-message-format'] = {\n      argument: {\n        pattern: RegExp(argumentSource),\n        greedy: true,\n        inside: {\n          content: {\n            pattern: /^(\\{)[\\s\\S]+(?=\\}$)/,\n            lookbehind: true,\n            inside: {\n              'argument-name': {\n                pattern: /^(\\s*)[^{}:=,\\s]+/,\n                lookbehind: true\n              },\n              'choice-style': {\n                // https://unicode-org.github.io/icu-docs/apidoc/released/icu4c/classicu_1_1ChoiceFormat.html#details\n                pattern: /^(\\s*,\\s*choice\\s*,\\s*)\\S(?:[\\s\\S]*\\S)?/,\n                lookbehind: true,\n                inside: {\n                  punctuation: /\\|/,\n                  range: {\n                    pattern: /^(\\s*)[+-]?(?:\\d+(?:\\.\\d*)?|\\u221e)\\s*[<#\\u2264]/,\n                    lookbehind: true,\n                    inside: {\n                      operator: /[<#\\u2264]/,\n                      number: /\\S+/\n                    }\n                  },\n                  rest: null // see below\n                }\n              },\n              'plural-style': {\n                // https://unicode-org.github.io/icu-docs/apidoc/released/icu4j/com/ibm/icu/text/PluralFormat.html#:~:text=Patterns%20and%20Their%20Interpretation\n                pattern:\n                  /^(\\s*,\\s*(?:plural|selectordinal)\\s*,\\s*)\\S(?:[\\s\\S]*\\S)?/,\n                lookbehind: true,\n                inside: {\n                  offset: /^offset:\\s*\\d+/,\n                  'nested-message': nestedMessage,\n                  selector: {\n                    pattern: /=\\d+|[^{}:=,\\s]+/,\n                    inside: {\n                      keyword: /^(?:few|many|one|other|two|zero)$/\n                    }\n                  }\n                }\n              },\n              'select-style': {\n                // https://unicode-org.github.io/icu-docs/apidoc/released/icu4j/com/ibm/icu/text/SelectFormat.html#:~:text=Patterns%20and%20Their%20Interpretation\n                pattern: /^(\\s*,\\s*select\\s*,\\s*)\\S(?:[\\s\\S]*\\S)?/,\n                lookbehind: true,\n                inside: {\n                  'nested-message': nestedMessage,\n                  selector: {\n                    pattern: /[^{}:=,\\s]+/,\n                    inside: {\n                      keyword: /^other$/\n                    }\n                  }\n                }\n              },\n              keyword: /\\b(?:choice|plural|select|selectordinal)\\b/,\n              'arg-type': {\n                pattern: /\\b(?:date|duration|number|ordinal|spellout|time)\\b/,\n                alias: 'keyword'\n              },\n              'arg-skeleton': {\n                pattern: /(,\\s*)::[^{}:=,\\s]+/,\n                lookbehind: true\n              },\n              'arg-style': {\n                pattern:\n                  /(,\\s*)(?:currency|full|integer|long|medium|percent|short)(?=\\s*$)/,\n                lookbehind: true\n              },\n              'arg-style-text': {\n                pattern: RegExp(\n                  /(^\\s*,\\s*(?=\\S))/.source +\n                    nested(/(?:[^{}']|'[^']*'|\\{(?:<SELF>)?\\})+/.source, 8) +\n                    '$'\n                ),\n                lookbehind: true,\n                alias: 'string'\n              },\n              punctuation: /,/\n            }\n          },\n          'argument-delimiter': {\n            pattern: /./,\n            alias: 'operator'\n          }\n        }\n      },\n      escape: escape,\n      string: string\n    }\n    nestedMessage.inside.message.inside = Prism.languages['icu-message-format']\n    Prism.languages['icu-message-format'].argument.inside.content.inside[\n      'choice-style'\n    ].inside.rest = Prism.languages['icu-message-format']\n  })(Prism)\n}\n"],"names":["icuMessageFormat","Prism"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/idris-0lPcDKiH.js

@@ -0,0 +1,62 @@
+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 idris_1;
+var hasRequiredIdris;
+function requireIdris() {
+  if (hasRequiredIdris) return idris_1;
+  hasRequiredIdris = 1;
+  var refractorHaskell = requireHaskell();
+  idris_1 = idris2;
+  idris2.displayName = "idris";
+  idris2.aliases = ["idr"];
+  function idris2(Prism) {
+    Prism.register(refractorHaskell);
+    Prism.languages.idris = Prism.languages.extend("haskell", {
+      comment: {
+        pattern: /(?:(?:--|\|\|\|).*$|\{-[\s\S]*?-\})/m
+      },
+      keyword: /\b(?:Type|case|class|codata|constructor|corecord|data|do|dsl|else|export|if|implementation|implicit|import|impossible|in|infix|infixl|infixr|instance|interface|let|module|mutual|namespace|of|parameters|partial|postulate|private|proof|public|quoteGoal|record|rewrite|syntax|then|total|using|where|with)\b/,
+      builtin: void 0
+    });
+    Prism.languages.insertBefore("idris", "keyword", {
+      "import-statement": {
+        pattern: /(^\s*import\s+)(?:[A-Z][\w']*)(?:\.[A-Z][\w']*)*/m,
+        lookbehind: true,
+        inside: {
+          punctuation: /\./
+        }
+      }
+    });
+    Prism.languages.idr = Prism.languages.idris;
+  }
+  return idris_1;
+}
+var idrisExports = requireIdris();
+const idris = /* @__PURE__ */ getDefaultExportFromCjs(idrisExports);
+const idris$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: idris
+}, [idrisExports]);
+export {
+  idris$1 as i
+};
+//# sourceMappingURL=idris-0lPcDKiH.js.map

package/dist/idris-0lPcDKiH.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"idris-0lPcDKiH.js","sources":["../node_modules/refractor/lang/idris.js"],"sourcesContent":["'use strict'\nvar refractorHaskell = require('./haskell.js')\nmodule.exports = idris\nidris.displayName = 'idris'\nidris.aliases = ['idr']\nfunction idris(Prism) {\n  Prism.register(refractorHaskell)\n  Prism.languages.idris = Prism.languages.extend('haskell', {\n    comment: {\n      pattern: /(?:(?:--|\\|\\|\\|).*$|\\{-[\\s\\S]*?-\\})/m\n    },\n    keyword:\n      /\\b(?:Type|case|class|codata|constructor|corecord|data|do|dsl|else|export|if|implementation|implicit|import|impossible|in|infix|infixl|infixr|instance|interface|let|module|mutual|namespace|of|parameters|partial|postulate|private|proof|public|quoteGoal|record|rewrite|syntax|then|total|using|where|with)\\b/,\n    builtin: undefined\n  })\n  Prism.languages.insertBefore('idris', 'keyword', {\n    'import-statement': {\n      pattern: /(^\\s*import\\s+)(?:[A-Z][\\w']*)(?:\\.[A-Z][\\w']*)*/m,\n      lookbehind: true,\n      inside: {\n        punctuation: /\\./\n      }\n    }\n  })\n  Prism.languages.idr = Prism.languages.idris\n}\n"],"names":["require$$0","idris"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AACA,MAAI,mBAAmBA,eAAA;AACvB,YAAiBC;AACjB,EAAAA,OAAM,cAAc;AACpB,EAAAA,OAAM,UAAU,CAAC,KAAK;AACtB,WAASA,OAAM,OAAO;AACpB,UAAM,SAAS,gBAAgB;AAC/B,UAAM,UAAU,QAAQ,MAAM,UAAU,OAAO,WAAW;AAAA,MACxD,SAAS;AAAA,QACP,SAAS;AAAA;MAEX,SACE;AAAA,MACF,SAAS;AAAA,IACb,CAAG;AACD,UAAM,UAAU,aAAa,SAAS,WAAW;AAAA,MAC/C,oBAAoB;AAAA,QAClB,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,QAAQ;AAAA,UACN,aAAa;AAAA;;IAGrB,CAAG;AACD,UAAM,UAAU,MAAM,MAAM,UAAU;AAAA,EACxC;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/iecst-Dr9NKVuq.js

@@ -0,0 +1,74 @@
+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 iecst_1;
+var hasRequiredIecst;
+function requireIecst() {
+  if (hasRequiredIecst) return iecst_1;
+  hasRequiredIecst = 1;
+  iecst_1 = iecst2;
+  iecst2.displayName = "iecst";
+  iecst2.aliases = [];
+  function iecst2(Prism) {
+    Prism.languages.iecst = {
+      comment: [
+        {
+          pattern: /(^|[^\\])(?:\/\*[\s\S]*?(?:\*\/|$)|\(\*[\s\S]*?(?:\*\)|$)|\{[\s\S]*?(?:\}|$))/,
+          lookbehind: true,
+          greedy: true
+        },
+        {
+          pattern: /(^|[^\\:])\/\/.*/,
+          lookbehind: true,
+          greedy: true
+        }
+      ],
+      string: {
+        pattern: /(["'])(?:\\(?:\r\n|[\s\S])|(?!\1)[^\\\r\n])*\1/,
+        greedy: true
+      },
+      keyword: [
+        /\b(?:END_)?(?:PROGRAM|CONFIGURATION|INTERFACE|FUNCTION_BLOCK|FUNCTION|ACTION|TRANSITION|TYPE|STRUCT|(?:INITIAL_)?STEP|NAMESPACE|LIBRARY|CHANNEL|FOLDER|RESOURCE|VAR_(?:ACCESS|CONFIG|EXTERNAL|GLOBAL|INPUT|IN_OUT|OUTPUT|TEMP)|VAR|METHOD|PROPERTY)\b/i,
+        /\b(?:AT|BY|(?:END_)?(?:CASE|FOR|IF|REPEAT|WHILE)|CONSTANT|CONTINUE|DO|ELSE|ELSIF|EXIT|EXTENDS|FROM|GET|GOTO|IMPLEMENTS|JMP|NON_RETAIN|OF|PRIVATE|PROTECTED|PUBLIC|RETAIN|RETURN|SET|TASK|THEN|TO|UNTIL|USING|WITH|__CATCH|__ENDTRY|__FINALLY|__TRY)\b/
+      ],
+      "class-name": /\b(?:ANY|ARRAY|BOOL|BYTE|U?(?:D|L|S)?INT|(?:D|L)?WORD|DATE(?:_AND_TIME)?|DT|L?REAL|POINTER|STRING|TIME(?:_OF_DAY)?|TOD)\b/,
+      address: {
+        pattern: /%[IQM][XBWDL][\d.]*|%[IQ][\d.]*/,
+        alias: "symbol"
+      },
+      number: /\b(?:16#[\da-f]+|2#[01_]+|0x[\da-f]+)\b|\b(?:D|DT|T|TOD)#[\d_shmd:]*|\b[A-Z]*#[\d.,_]*|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i,
+      boolean: /\b(?:FALSE|NULL|TRUE)\b/,
+      operator: /S?R?:?=>?|&&?|\*\*?|<[=>]?|>=?|[-:^/+#]|\b(?:AND|EQ|EXPT|GE|GT|LE|LT|MOD|NE|NOT|OR|XOR)\b/,
+      function: /\b[a-z_]\w*(?=\s*\()/i,
+      punctuation: /[()[\].,;]/
+    };
+  }
+  return iecst_1;
+}
+var iecstExports = requireIecst();
+const iecst = /* @__PURE__ */ getDefaultExportFromCjs(iecstExports);
+const iecst$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: iecst
+}, [iecstExports]);
+export {
+  iecst$1 as i
+};
+//# sourceMappingURL=iecst-Dr9NKVuq.js.map