@oscloudlab/knowledge-card 0.0.1 → 0.0.3

package/dist/tcl-nTdHwEfu.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tcl-nTdHwEfu.js","sources":["../node_modules/refractor/lang/tcl.js"],"sourcesContent":["'use strict'\n\nmodule.exports = tcl\ntcl.displayName = 'tcl'\ntcl.aliases = []\nfunction tcl(Prism) {\n  Prism.languages.tcl = {\n    comment: {\n      pattern: /(^|[^\\\\])#.*/,\n      lookbehind: true\n    },\n    string: {\n      pattern: /\"(?:[^\"\\\\\\r\\n]|\\\\(?:\\r\\n|[\\s\\S]))*\"/,\n      greedy: true\n    },\n    variable: [\n      {\n        pattern: /(\\$)(?:::)?(?:[a-zA-Z0-9]+::)*\\w+/,\n        lookbehind: true\n      },\n      {\n        pattern: /(\\$)\\{[^}]+\\}/,\n        lookbehind: true\n      },\n      {\n        pattern: /(^[\\t ]*set[ \\t]+)(?:::)?(?:[a-zA-Z0-9]+::)*\\w+/m,\n        lookbehind: true\n      }\n    ],\n    function: {\n      pattern: /(^[\\t ]*proc[ \\t]+)\\S+/m,\n      lookbehind: true\n    },\n    builtin: [\n      {\n        pattern:\n          /(^[\\t ]*)(?:break|class|continue|error|eval|exit|for|foreach|if|proc|return|switch|while)\\b/m,\n        lookbehind: true\n      },\n      /\\b(?:else|elseif)\\b/\n    ],\n    scope: {\n      pattern: /(^[\\t ]*)(?:global|upvar|variable)\\b/m,\n      lookbehind: true,\n      alias: 'constant'\n    },\n    keyword: {\n      pattern:\n        /(^[\\t ]*|\\[)(?:Safe_Base|Tcl|after|append|apply|array|auto_(?:execok|import|load|mkindex|qualify|reset)|automkindex_old|bgerror|binary|catch|cd|chan|clock|close|concat|dde|dict|encoding|eof|exec|expr|fblocked|fconfigure|fcopy|file(?:event|name)?|flush|gets|glob|history|http|incr|info|interp|join|lappend|lassign|lindex|linsert|list|llength|load|lrange|lrepeat|lreplace|lreverse|lsearch|lset|lsort|math(?:func|op)|memory|msgcat|namespace|open|package|parray|pid|pkg_mkIndex|platform|puts|pwd|re_syntax|read|refchan|regexp|registry|regsub|rename|scan|seek|set|socket|source|split|string|subst|tcl(?:_endOfWord|_findLibrary|startOf(?:Next|Previous)Word|test|vars|wordBreak(?:After|Before))|tell|time|tm|trace|unknown|unload|unset|update|uplevel|vwait)\\b/m,\n      lookbehind: true\n    },\n    operator:\n      /!=?|\\*\\*?|==|&&?|\\|\\|?|<[=<]?|>[=>]?|[-+~\\/%?^]|\\b(?:eq|in|ne|ni)\\b/,\n    punctuation: /[{}()\\[\\]]/\n  }\n}\n"],"names":["tcl"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,UAAiBA;AACjB,EAAAA,KAAI,cAAc;AAClB,EAAAA,KAAI,UAAU,CAAA;AACd,WAASA,KAAI,OAAO;AAClB,UAAM,UAAU,MAAM;AAAA,MACpB,SAAS;AAAA,QACP,SAAS;AAAA,QACT,YAAY;AAAA;MAEd,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,UAAU;AAAA,QACR;AAAA,UACE,SAAS;AAAA,UACT,YAAY;AAAA;QAEd;AAAA,UACE,SAAS;AAAA,UACT,YAAY;AAAA;QAEd;AAAA,UACE,SAAS;AAAA,UACT,YAAY;AAAA;;MAGhB,UAAU;AAAA,QACR,SAAS;AAAA,QACT,YAAY;AAAA;MAEd,SAAS;AAAA,QACP;AAAA,UACE,SACE;AAAA,UACF,YAAY;AAAA;QAEd;AAAA;MAEF,OAAO;AAAA,QACL,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,OAAO;AAAA;MAET,SAAS;AAAA,QACP,SACE;AAAA,QACF,YAAY;AAAA;MAEd,UACE;AAAA,MACF,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/textile-B3LIn7fY.js

@@ -0,0 +1,311 @@
+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 textile_1;
+var hasRequiredTextile;
+function requireTextile() {
+  if (hasRequiredTextile) return textile_1;
+  hasRequiredTextile = 1;
+  textile_1 = textile2;
+  textile2.displayName = "textile";
+  textile2.aliases = [];
+  function textile2(Prism) {
+    (function(Prism2) {
+      var modifierRegex = /\([^|()\n]+\)|\[[^\]\n]+\]|\{[^}\n]+\}/.source;
+      var parenthesesRegex = /\)|\((?![^|()\n]+\))/.source;
+      function withModifier(source, flags) {
+        return RegExp(
+          source.replace(/<MOD>/g, function() {
+            return "(?:" + modifierRegex + ")";
+          }).replace(/<PAR>/g, function() {
+            return "(?:" + parenthesesRegex + ")";
+          }),
+          flags || ""
+        );
+      }
+      var modifierTokens = {
+        css: {
+          pattern: /\{[^{}]+\}/,
+          inside: {
+            rest: Prism2.languages.css
+          }
+        },
+        "class-id": {
+          pattern: /(\()[^()]+(?=\))/,
+          lookbehind: true,
+          alias: "attr-value"
+        },
+        lang: {
+          pattern: /(\[)[^\[\]]+(?=\])/,
+          lookbehind: true,
+          alias: "attr-value"
+        },
+        // Anything else is punctuation (the first pattern is for row/col spans inside tables)
+        punctuation: /[\\\/]\d+|\S/
+      };
+      var textile3 = Prism2.languages.textile = Prism2.languages.extend("markup", {
+        phrase: {
+          pattern: /(^|\r|\n)\S[\s\S]*?(?=$|\r?\n\r?\n|\r\r)/,
+          lookbehind: true,
+          inside: {
+            // h1. Header 1
+            "block-tag": {
+              pattern: withModifier(/^[a-z]\w*(?:<MOD>|<PAR>|[<>=])*\./.source),
+              inside: {
+                modifier: {
+                  pattern: withModifier(
+                    /(^[a-z]\w*)(?:<MOD>|<PAR>|[<>=])+(?=\.)/.source
+                  ),
+                  lookbehind: true,
+                  inside: modifierTokens
+                },
+                tag: /^[a-z]\w*/,
+                punctuation: /\.$/
+              }
+            },
+            // # List item
+            // * List item
+            list: {
+              pattern: withModifier(/^[*#]+<MOD>*\s+\S.*/.source, "m"),
+              inside: {
+                modifier: {
+                  pattern: withModifier(/(^[*#]+)<MOD>+/.source),
+                  lookbehind: true,
+                  inside: modifierTokens
+                },
+                punctuation: /^[*#]+/
+              }
+            },
+            // | cell | cell | cell |
+            table: {
+              // Modifiers can be applied to the row: {color:red}.|1|2|3|
+              // or the cell: |{color:red}.1|2|3|
+              pattern: withModifier(
+                /^(?:(?:<MOD>|<PAR>|[<>=^~])+\.\s*)?(?:\|(?:(?:<MOD>|<PAR>|[<>=^~_]|[\\/]\d+)+\.|(?!(?:<MOD>|<PAR>|[<>=^~_]|[\\/]\d+)+\.))[^|]*)+\|/.source,
+                "m"
+              ),
+              inside: {
+                modifier: {
+                  // Modifiers for rows after the first one are
+                  // preceded by a pipe and a line feed
+                  pattern: withModifier(
+                    /(^|\|(?:\r?\n|\r)?)(?:<MOD>|<PAR>|[<>=^~_]|[\\/]\d+)+(?=\.)/.source
+                  ),
+                  lookbehind: true,
+                  inside: modifierTokens
+                },
+                punctuation: /\||^\./
+              }
+            },
+            inline: {
+              // eslint-disable-next-line regexp/no-super-linear-backtracking
+              pattern: withModifier(
+                /(^|[^a-zA-Z\d])(\*\*|__|\?\?|[*_%@+\-^~])<MOD>*.+?\2(?![a-zA-Z\d])/.source
+              ),
+              lookbehind: true,
+              inside: {
+                // Note: superscripts and subscripts are not handled specifically
+                // *bold*, **bold**
+                bold: {
+                  // eslint-disable-next-line regexp/no-super-linear-backtracking
+                  pattern: withModifier(/(^(\*\*?)<MOD>*).+?(?=\2)/.source),
+                  lookbehind: true
+                },
+                // _italic_, __italic__
+                italic: {
+                  // eslint-disable-next-line regexp/no-super-linear-backtracking
+                  pattern: withModifier(/(^(__?)<MOD>*).+?(?=\2)/.source),
+                  lookbehind: true
+                },
+                // ??cite??
+                cite: {
+                  // eslint-disable-next-line regexp/no-super-linear-backtracking
+                  pattern: withModifier(/(^\?\?<MOD>*).+?(?=\?\?)/.source),
+                  lookbehind: true,
+                  alias: "string"
+                },
+                // @code@
+                code: {
+                  // eslint-disable-next-line regexp/no-super-linear-backtracking
+                  pattern: withModifier(/(^@<MOD>*).+?(?=@)/.source),
+                  lookbehind: true,
+                  alias: "keyword"
+                },
+                // +inserted+
+                inserted: {
+                  // eslint-disable-next-line regexp/no-super-linear-backtracking
+                  pattern: withModifier(/(^\+<MOD>*).+?(?=\+)/.source),
+                  lookbehind: true
+                },
+                // -deleted-
+                deleted: {
+                  // eslint-disable-next-line regexp/no-super-linear-backtracking
+                  pattern: withModifier(/(^-<MOD>*).+?(?=-)/.source),
+                  lookbehind: true
+                },
+                // %span%
+                span: {
+                  // eslint-disable-next-line regexp/no-super-linear-backtracking
+                  pattern: withModifier(/(^%<MOD>*).+?(?=%)/.source),
+                  lookbehind: true
+                },
+                modifier: {
+                  pattern: withModifier(
+                    /(^\*\*|__|\?\?|[*_%@+\-^~])<MOD>+/.source
+                  ),
+                  lookbehind: true,
+                  inside: modifierTokens
+                },
+                punctuation: /[*_%?@+\-^~]+/
+              }
+            },
+            // [alias]http://example.com
+            "link-ref": {
+              pattern: /^\[[^\]]+\]\S+$/m,
+              inside: {
+                string: {
+                  pattern: /(^\[)[^\]]+(?=\])/,
+                  lookbehind: true
+                },
+                url: {
+                  pattern: /(^\])\S+$/,
+                  lookbehind: true
+                },
+                punctuation: /[\[\]]/
+              }
+            },
+            // "text":http://example.com
+            // "text":link-ref
+            link: {
+              // eslint-disable-next-line regexp/no-super-linear-backtracking
+              pattern: withModifier(
+                /"<MOD>*[^"]+":.+?(?=[^\w/]?(?:\s|$))/.source
+              ),
+              inside: {
+                text: {
+                  // eslint-disable-next-line regexp/no-super-linear-backtracking
+                  pattern: withModifier(/(^"<MOD>*)[^"]+(?=")/.source),
+                  lookbehind: true
+                },
+                modifier: {
+                  pattern: withModifier(/(^")<MOD>+/.source),
+                  lookbehind: true,
+                  inside: modifierTokens
+                },
+                url: {
+                  pattern: /(:).+/,
+                  lookbehind: true
+                },
+                punctuation: /[":]/
+              }
+            },
+            // !image.jpg!
+            // !image.jpg(Title)!:http://example.com
+            image: {
+              pattern: withModifier(
+                /!(?:<MOD>|<PAR>|[<>=])*(?![<>=])[^!\s()]+(?:\([^)]+\))?!(?::.+?(?=[^\w/]?(?:\s|$)))?/.source
+              ),
+              inside: {
+                source: {
+                  pattern: withModifier(
+                    /(^!(?:<MOD>|<PAR>|[<>=])*)(?![<>=])[^!\s()]+(?:\([^)]+\))?(?=!)/.source
+                  ),
+                  lookbehind: true,
+                  alias: "url"
+                },
+                modifier: {
+                  pattern: withModifier(/(^!)(?:<MOD>|<PAR>|[<>=])+/.source),
+                  lookbehind: true,
+                  inside: modifierTokens
+                },
+                url: {
+                  pattern: /(:).+/,
+                  lookbehind: true
+                },
+                punctuation: /[!:]/
+              }
+            },
+            // Footnote[1]
+            footnote: {
+              pattern: /\b\[\d+\]/,
+              alias: "comment",
+              inside: {
+                punctuation: /\[|\]/
+              }
+            },
+            // CSS(Cascading Style Sheet)
+            acronym: {
+              pattern: /\b[A-Z\d]+\([^)]+\)/,
+              inside: {
+                comment: {
+                  pattern: /(\()[^()]+(?=\))/,
+                  lookbehind: true
+                },
+                punctuation: /[()]/
+              }
+            },
+            // Prism(C)
+            mark: {
+              pattern: /\b\((?:C|R|TM)\)/,
+              alias: "comment",
+              inside: {
+                punctuation: /[()]/
+              }
+            }
+          }
+        }
+      });
+      var phraseInside = textile3["phrase"].inside;
+      var nestedPatterns = {
+        inline: phraseInside["inline"],
+        link: phraseInside["link"],
+        image: phraseInside["image"],
+        footnote: phraseInside["footnote"],
+        acronym: phraseInside["acronym"],
+        mark: phraseInside["mark"]
+      };
+      textile3.tag.pattern = /<\/?(?!\d)[a-z0-9]+(?:\s+[^\s>\/=]+(?:=(?:("|')(?:\\[\s\S]|(?!\1)[^\\])*\1|[^\s'">=]+))?)*\s*\/?>/i;
+      var phraseInlineInside = phraseInside["inline"].inside;
+      phraseInlineInside["bold"].inside = nestedPatterns;
+      phraseInlineInside["italic"].inside = nestedPatterns;
+      phraseInlineInside["inserted"].inside = nestedPatterns;
+      phraseInlineInside["deleted"].inside = nestedPatterns;
+      phraseInlineInside["span"].inside = nestedPatterns;
+      var phraseTableInside = phraseInside["table"].inside;
+      phraseTableInside["inline"] = nestedPatterns["inline"];
+      phraseTableInside["link"] = nestedPatterns["link"];
+      phraseTableInside["image"] = nestedPatterns["image"];
+      phraseTableInside["footnote"] = nestedPatterns["footnote"];
+      phraseTableInside["acronym"] = nestedPatterns["acronym"];
+      phraseTableInside["mark"] = nestedPatterns["mark"];
+    })(Prism);
+  }
+  return textile_1;
+}
+var textileExports = requireTextile();
+const textile = /* @__PURE__ */ getDefaultExportFromCjs(textileExports);
+const textile$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: textile
+}, [textileExports]);
+export {
+  textile$1 as t
+};
+//# sourceMappingURL=textile-B3LIn7fY.js.map

package/dist/textile-B3LIn7fY.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"textile-B3LIn7fY.js","sources":["../node_modules/refractor/lang/textile.js"],"sourcesContent":["'use strict'\n\nmodule.exports = textile\ntextile.displayName = 'textile'\ntextile.aliases = []\nfunction textile(Prism) {\n  ;(function (Prism) {\n    // We don't allow for pipes inside parentheses\n    // to not break table pattern |(. foo |). bar |\n    var modifierRegex = /\\([^|()\\n]+\\)|\\[[^\\]\\n]+\\]|\\{[^}\\n]+\\}/.source // Opening and closing parentheses which are not a modifier\n    // This pattern is necessary to prevent exponential backtracking\n    var parenthesesRegex = /\\)|\\((?![^|()\\n]+\\))/.source\n    /**\n     * @param {string} source\n     * @param {string} [flags]\n     */\n    function withModifier(source, flags) {\n      return RegExp(\n        source\n          .replace(/<MOD>/g, function () {\n            return '(?:' + modifierRegex + ')'\n          })\n          .replace(/<PAR>/g, function () {\n            return '(?:' + parenthesesRegex + ')'\n          }),\n        flags || ''\n      )\n    }\n    var modifierTokens = {\n      css: {\n        pattern: /\\{[^{}]+\\}/,\n        inside: {\n          rest: Prism.languages.css\n        }\n      },\n      'class-id': {\n        pattern: /(\\()[^()]+(?=\\))/,\n        lookbehind: true,\n        alias: 'attr-value'\n      },\n      lang: {\n        pattern: /(\\[)[^\\[\\]]+(?=\\])/,\n        lookbehind: true,\n        alias: 'attr-value'\n      },\n      // Anything else is punctuation (the first pattern is for row/col spans inside tables)\n      punctuation: /[\\\\\\/]\\d+|\\S/\n    }\n    var textile = (Prism.languages.textile = Prism.languages.extend('markup', {\n      phrase: {\n        pattern: /(^|\\r|\\n)\\S[\\s\\S]*?(?=$|\\r?\\n\\r?\\n|\\r\\r)/,\n        lookbehind: true,\n        inside: {\n          // h1. Header 1\n          'block-tag': {\n            pattern: withModifier(/^[a-z]\\w*(?:<MOD>|<PAR>|[<>=])*\\./.source),\n            inside: {\n              modifier: {\n                pattern: withModifier(\n                  /(^[a-z]\\w*)(?:<MOD>|<PAR>|[<>=])+(?=\\.)/.source\n                ),\n                lookbehind: true,\n                inside: modifierTokens\n              },\n              tag: /^[a-z]\\w*/,\n              punctuation: /\\.$/\n            }\n          },\n          // # List item\n          // * List item\n          list: {\n            pattern: withModifier(/^[*#]+<MOD>*\\s+\\S.*/.source, 'm'),\n            inside: {\n              modifier: {\n                pattern: withModifier(/(^[*#]+)<MOD>+/.source),\n                lookbehind: true,\n                inside: modifierTokens\n              },\n              punctuation: /^[*#]+/\n            }\n          },\n          // | cell | cell | cell |\n          table: {\n            // Modifiers can be applied to the row: {color:red}.|1|2|3|\n            // or the cell: |{color:red}.1|2|3|\n            pattern: withModifier(\n              /^(?:(?:<MOD>|<PAR>|[<>=^~])+\\.\\s*)?(?:\\|(?:(?:<MOD>|<PAR>|[<>=^~_]|[\\\\/]\\d+)+\\.|(?!(?:<MOD>|<PAR>|[<>=^~_]|[\\\\/]\\d+)+\\.))[^|]*)+\\|/\n                .source,\n              'm'\n            ),\n            inside: {\n              modifier: {\n                // Modifiers for rows after the first one are\n                // preceded by a pipe and a line feed\n                pattern: withModifier(\n                  /(^|\\|(?:\\r?\\n|\\r)?)(?:<MOD>|<PAR>|[<>=^~_]|[\\\\/]\\d+)+(?=\\.)/\n                    .source\n                ),\n                lookbehind: true,\n                inside: modifierTokens\n              },\n              punctuation: /\\||^\\./\n            }\n          },\n          inline: {\n            // eslint-disable-next-line regexp/no-super-linear-backtracking\n            pattern: withModifier(\n              /(^|[^a-zA-Z\\d])(\\*\\*|__|\\?\\?|[*_%@+\\-^~])<MOD>*.+?\\2(?![a-zA-Z\\d])/\n                .source\n            ),\n            lookbehind: true,\n            inside: {\n              // Note: superscripts and subscripts are not handled specifically\n              // *bold*, **bold**\n              bold: {\n                // eslint-disable-next-line regexp/no-super-linear-backtracking\n                pattern: withModifier(/(^(\\*\\*?)<MOD>*).+?(?=\\2)/.source),\n                lookbehind: true\n              },\n              // _italic_, __italic__\n              italic: {\n                // eslint-disable-next-line regexp/no-super-linear-backtracking\n                pattern: withModifier(/(^(__?)<MOD>*).+?(?=\\2)/.source),\n                lookbehind: true\n              },\n              // ??cite??\n              cite: {\n                // eslint-disable-next-line regexp/no-super-linear-backtracking\n                pattern: withModifier(/(^\\?\\?<MOD>*).+?(?=\\?\\?)/.source),\n                lookbehind: true,\n                alias: 'string'\n              },\n              // @code@\n              code: {\n                // eslint-disable-next-line regexp/no-super-linear-backtracking\n                pattern: withModifier(/(^@<MOD>*).+?(?=@)/.source),\n                lookbehind: true,\n                alias: 'keyword'\n              },\n              // +inserted+\n              inserted: {\n                // eslint-disable-next-line regexp/no-super-linear-backtracking\n                pattern: withModifier(/(^\\+<MOD>*).+?(?=\\+)/.source),\n                lookbehind: true\n              },\n              // -deleted-\n              deleted: {\n                // eslint-disable-next-line regexp/no-super-linear-backtracking\n                pattern: withModifier(/(^-<MOD>*).+?(?=-)/.source),\n                lookbehind: true\n              },\n              // %span%\n              span: {\n                // eslint-disable-next-line regexp/no-super-linear-backtracking\n                pattern: withModifier(/(^%<MOD>*).+?(?=%)/.source),\n                lookbehind: true\n              },\n              modifier: {\n                pattern: withModifier(\n                  /(^\\*\\*|__|\\?\\?|[*_%@+\\-^~])<MOD>+/.source\n                ),\n                lookbehind: true,\n                inside: modifierTokens\n              },\n              punctuation: /[*_%?@+\\-^~]+/\n            }\n          },\n          // [alias]http://example.com\n          'link-ref': {\n            pattern: /^\\[[^\\]]+\\]\\S+$/m,\n            inside: {\n              string: {\n                pattern: /(^\\[)[^\\]]+(?=\\])/,\n                lookbehind: true\n              },\n              url: {\n                pattern: /(^\\])\\S+$/,\n                lookbehind: true\n              },\n              punctuation: /[\\[\\]]/\n            }\n          },\n          // \"text\":http://example.com\n          // \"text\":link-ref\n          link: {\n            // eslint-disable-next-line regexp/no-super-linear-backtracking\n            pattern: withModifier(\n              /\"<MOD>*[^\"]+\":.+?(?=[^\\w/]?(?:\\s|$))/.source\n            ),\n            inside: {\n              text: {\n                // eslint-disable-next-line regexp/no-super-linear-backtracking\n                pattern: withModifier(/(^\"<MOD>*)[^\"]+(?=\")/.source),\n                lookbehind: true\n              },\n              modifier: {\n                pattern: withModifier(/(^\")<MOD>+/.source),\n                lookbehind: true,\n                inside: modifierTokens\n              },\n              url: {\n                pattern: /(:).+/,\n                lookbehind: true\n              },\n              punctuation: /[\":]/\n            }\n          },\n          // !image.jpg!\n          // !image.jpg(Title)!:http://example.com\n          image: {\n            pattern: withModifier(\n              /!(?:<MOD>|<PAR>|[<>=])*(?![<>=])[^!\\s()]+(?:\\([^)]+\\))?!(?::.+?(?=[^\\w/]?(?:\\s|$)))?/\n                .source\n            ),\n            inside: {\n              source: {\n                pattern: withModifier(\n                  /(^!(?:<MOD>|<PAR>|[<>=])*)(?![<>=])[^!\\s()]+(?:\\([^)]+\\))?(?=!)/\n                    .source\n                ),\n                lookbehind: true,\n                alias: 'url'\n              },\n              modifier: {\n                pattern: withModifier(/(^!)(?:<MOD>|<PAR>|[<>=])+/.source),\n                lookbehind: true,\n                inside: modifierTokens\n              },\n              url: {\n                pattern: /(:).+/,\n                lookbehind: true\n              },\n              punctuation: /[!:]/\n            }\n          },\n          // Footnote[1]\n          footnote: {\n            pattern: /\\b\\[\\d+\\]/,\n            alias: 'comment',\n            inside: {\n              punctuation: /\\[|\\]/\n            }\n          },\n          // CSS(Cascading Style Sheet)\n          acronym: {\n            pattern: /\\b[A-Z\\d]+\\([^)]+\\)/,\n            inside: {\n              comment: {\n                pattern: /(\\()[^()]+(?=\\))/,\n                lookbehind: true\n              },\n              punctuation: /[()]/\n            }\n          },\n          // Prism(C)\n          mark: {\n            pattern: /\\b\\((?:C|R|TM)\\)/,\n            alias: 'comment',\n            inside: {\n              punctuation: /[()]/\n            }\n          }\n        }\n      }\n    }))\n    var phraseInside = textile['phrase'].inside\n    var nestedPatterns = {\n      inline: phraseInside['inline'],\n      link: phraseInside['link'],\n      image: phraseInside['image'],\n      footnote: phraseInside['footnote'],\n      acronym: phraseInside['acronym'],\n      mark: phraseInside['mark']\n    } // Only allow alpha-numeric HTML tags, not XML tags\n    textile.tag.pattern =\n      /<\\/?(?!\\d)[a-z0-9]+(?:\\s+[^\\s>\\/=]+(?:=(?:(\"|')(?:\\\\[\\s\\S]|(?!\\1)[^\\\\])*\\1|[^\\s'\">=]+))?)*\\s*\\/?>/i // Allow some nesting\n    var phraseInlineInside = phraseInside['inline'].inside\n    phraseInlineInside['bold'].inside = nestedPatterns\n    phraseInlineInside['italic'].inside = nestedPatterns\n    phraseInlineInside['inserted'].inside = nestedPatterns\n    phraseInlineInside['deleted'].inside = nestedPatterns\n    phraseInlineInside['span'].inside = nestedPatterns // Allow some styles inside table cells\n    var phraseTableInside = phraseInside['table'].inside\n    phraseTableInside['inline'] = nestedPatterns['inline']\n    phraseTableInside['link'] = nestedPatterns['link']\n    phraseTableInside['image'] = nestedPatterns['image']\n    phraseTableInside['footnote'] = nestedPatterns['footnote']\n    phraseTableInside['acronym'] = nestedPatterns['acronym']\n    phraseTableInside['mark'] = nestedPatterns['mark']\n  })(Prism)\n}\n"],"names":["textile","Prism"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/toml-BFIv8R_U.js

@@ -0,0 +1,95 @@
+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 toml_1;
+var hasRequiredToml;
+function requireToml() {
+  if (hasRequiredToml) return toml_1;
+  hasRequiredToml = 1;
+  toml_1 = toml2;
+  toml2.displayName = "toml";
+  toml2.aliases = [];
+  function toml2(Prism) {
+    (function(Prism2) {
+      var key = /(?:[\w-]+|'[^'\n\r]*'|"(?:\\.|[^\\"\r\n])*")/.source;
+      function insertKey(pattern) {
+        return pattern.replace(/__/g, function() {
+          return key;
+        });
+      }
+      Prism2.languages.toml = {
+        comment: {
+          pattern: /#.*/,
+          greedy: true
+        },
+        table: {
+          pattern: RegExp(
+            insertKey(
+              /(^[\t ]*\[\s*(?:\[\s*)?)__(?:\s*\.\s*__)*(?=\s*\])/.source
+            ),
+            "m"
+          ),
+          lookbehind: true,
+          greedy: true,
+          alias: "class-name"
+        },
+        key: {
+          pattern: RegExp(
+            insertKey(/(^[\t ]*|[{,]\s*)__(?:\s*\.\s*__)*(?=\s*=)/.source),
+            "m"
+          ),
+          lookbehind: true,
+          greedy: true,
+          alias: "property"
+        },
+        string: {
+          pattern: /"""(?:\\[\s\S]|[^\\])*?"""|'''[\s\S]*?'''|'[^'\n\r]*'|"(?:\\.|[^\\"\r\n])*"/,
+          greedy: true
+        },
+        date: [
+          {
+            // Offset Date-Time, Local Date-Time, Local Date
+            pattern: /\b\d{4}-\d{2}-\d{2}(?:[T\s]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?)?\b/i,
+            alias: "number"
+          },
+          {
+            // Local Time
+            pattern: /\b\d{2}:\d{2}:\d{2}(?:\.\d+)?\b/,
+            alias: "number"
+          }
+        ],
+        number: /(?:\b0(?:x[\da-zA-Z]+(?:_[\da-zA-Z]+)*|o[0-7]+(?:_[0-7]+)*|b[10]+(?:_[10]+)*))\b|[-+]?\b\d+(?:_\d+)*(?:\.\d+(?:_\d+)*)?(?:[eE][+-]?\d+(?:_\d+)*)?\b|[-+]?\b(?:inf|nan)\b/,
+        boolean: /\b(?:false|true)\b/,
+        punctuation: /[.,=[\]{}]/
+      };
+    })(Prism);
+  }
+  return toml_1;
+}
+var tomlExports = requireToml();
+const toml = /* @__PURE__ */ getDefaultExportFromCjs(tomlExports);
+const toml$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: toml
+}, [tomlExports]);
+export {
+  toml$1 as t
+};
+//# sourceMappingURL=toml-BFIv8R_U.js.map

package/dist/toml-BFIv8R_U.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"toml-BFIv8R_U.js","sources":["../node_modules/refractor/lang/toml.js"],"sourcesContent":["'use strict'\n\nmodule.exports = toml\ntoml.displayName = 'toml'\ntoml.aliases = []\nfunction toml(Prism) {\n  ;(function (Prism) {\n    var key = /(?:[\\w-]+|'[^'\\n\\r]*'|\"(?:\\\\.|[^\\\\\"\\r\\n])*\")/.source\n    /**\n     * @param {string} pattern\n     */\n    function insertKey(pattern) {\n      return pattern.replace(/__/g, function () {\n        return key\n      })\n    }\n    Prism.languages.toml = {\n      comment: {\n        pattern: /#.*/,\n        greedy: true\n      },\n      table: {\n        pattern: RegExp(\n          insertKey(\n            /(^[\\t ]*\\[\\s*(?:\\[\\s*)?)__(?:\\s*\\.\\s*__)*(?=\\s*\\])/.source\n          ),\n          'm'\n        ),\n        lookbehind: true,\n        greedy: true,\n        alias: 'class-name'\n      },\n      key: {\n        pattern: RegExp(\n          insertKey(/(^[\\t ]*|[{,]\\s*)__(?:\\s*\\.\\s*__)*(?=\\s*=)/.source),\n          'm'\n        ),\n        lookbehind: true,\n        greedy: true,\n        alias: 'property'\n      },\n      string: {\n        pattern:\n          /\"\"\"(?:\\\\[\\s\\S]|[^\\\\])*?\"\"\"|'''[\\s\\S]*?'''|'[^'\\n\\r]*'|\"(?:\\\\.|[^\\\\\"\\r\\n])*\"/,\n        greedy: true\n      },\n      date: [\n        {\n          // Offset Date-Time, Local Date-Time, Local Date\n          pattern:\n            /\\b\\d{4}-\\d{2}-\\d{2}(?:[T\\s]\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?(?:Z|[+-]\\d{2}:\\d{2})?)?\\b/i,\n          alias: 'number'\n        },\n        {\n          // Local Time\n          pattern: /\\b\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?\\b/,\n          alias: 'number'\n        }\n      ],\n      number:\n        /(?:\\b0(?:x[\\da-zA-Z]+(?:_[\\da-zA-Z]+)*|o[0-7]+(?:_[0-7]+)*|b[10]+(?:_[10]+)*))\\b|[-+]?\\b\\d+(?:_\\d+)*(?:\\.\\d+(?:_\\d+)*)?(?:[eE][+-]?\\d+(?:_\\d+)*)?\\b|[-+]?\\b(?:inf|nan)\\b/,\n      boolean: /\\b(?:false|true)\\b/,\n      punctuation: /[.,=[\\]{}]/\n    }\n  })(Prism)\n}\n"],"names":["toml","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,WAAiBA;AACjB,EAAAA,MAAK,cAAc;AACnB,EAAAA,MAAK,UAAU,CAAA;AACf,WAASA,MAAK,OAAO;AAClB,KAAC,SAAUC,QAAO;AACjB,UAAI,MAAM,+CAA+C;AAIzD,eAAS,UAAU,SAAS;AAC1B,eAAO,QAAQ,QAAQ,OAAO,WAAY;AACxC,iBAAO;AAAA,QACf,CAAO;AAAA,MACP;AACI,MAAAA,OAAM,UAAU,OAAO;AAAA,QACrB,SAAS;AAAA,UACP,SAAS;AAAA,UACT,QAAQ;AAAA;QAEV,OAAO;AAAA,UACL,SAAS;AAAA,YACP;AAAA,cACE,qDAAqD;AAAA;YAEvD;AAAA;UAEF,YAAY;AAAA,UACZ,QAAQ;AAAA,UACR,OAAO;AAAA;QAET,KAAK;AAAA,UACH,SAAS;AAAA,YACP,UAAU,6CAA6C,MAAM;AAAA,YAC7D;AAAA;UAEF,YAAY;AAAA,UACZ,QAAQ;AAAA,UACR,OAAO;AAAA;QAET,QAAQ;AAAA,UACN,SACE;AAAA,UACF,QAAQ;AAAA;QAEV,MAAM;AAAA,UACJ;AAAA;AAAA,YAEE,SACE;AAAA,YACF,OAAO;AAAA;UAET;AAAA;AAAA,YAEE,SAAS;AAAA,YACT,OAAO;AAAA;;QAGX,QACE;AAAA,QACF,SAAS;AAAA,QACT,aAAa;AAAA;IAEnB,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/tremor-BhknNNX8.js

@@ -0,0 +1,101 @@
+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 tremor_1;
+var hasRequiredTremor;
+function requireTremor() {
+  if (hasRequiredTremor) return tremor_1;
+  hasRequiredTremor = 1;
+  tremor_1 = tremor2;
+  tremor2.displayName = "tremor";
+  tremor2.aliases = [];
+  function tremor2(Prism) {
+    (function(Prism2) {
+      Prism2.languages.tremor = {
+        comment: {
+          pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|(?:--|\/\/|#).*)/,
+          lookbehind: true
+        },
+        "interpolated-string": null,
+        // see below
+        extractor: {
+          pattern: /\b[a-z_]\w*\|(?:[^\r\n\\|]|\\(?:\r\n|[\s\S]))*\|/i,
+          greedy: true,
+          inside: {
+            regex: {
+              pattern: /(^re)\|[\s\S]+/,
+              lookbehind: true
+            },
+            function: /^\w+/,
+            value: /\|[\s\S]+/
+          }
+        },
+        identifier: {
+          pattern: /`[^`]*`/,
+          greedy: true
+        },
+        function: /\b[a-z_]\w*(?=\s*(?:::\s*<|\())\b/,
+        keyword: /\b(?:args|as|by|case|config|connect|connector|const|copy|create|default|define|deploy|drop|each|emit|end|erase|event|flow|fn|for|from|group|having|insert|into|intrinsic|let|links|match|merge|mod|move|of|operator|patch|pipeline|recur|script|select|set|sliding|state|stream|to|tumbling|update|use|when|where|window|with)\b/,
+        boolean: /\b(?:false|null|true)\b/i,
+        number: /\b(?:0b[01_]*|0x[0-9a-fA-F_]*|\d[\d_]*(?:\.\d[\d_]*)?(?:[Ee][+-]?[\d_]+)?)\b/,
+        "pattern-punctuation": {
+          pattern: /%(?=[({[])/,
+          alias: "punctuation"
+        },
+        operator: /[-+*\/%~!^]=?|=[=>]?|&[&=]?|\|[|=]?|<<?=?|>>?>?=?|(?:absent|and|not|or|present|xor)\b/,
+        punctuation: /::|[;\[\]()\{\},.:]/
+      };
+      var interpolationPattern = /#\{(?:[^"{}]|\{[^{}]*\}|"(?:[^"\\\r\n]|\\(?:\r\n|[\s\S]))*")*\}/.source;
+      Prism2.languages.tremor["interpolated-string"] = {
+        pattern: RegExp(
+          /(^|[^\\])/.source + '(?:"""(?:' + /[^"\\#]|\\[\s\S]|"(?!"")|#(?!\{)/.source + "|" + interpolationPattern + ')*"""|"(?:' + /[^"\\\r\n#]|\\(?:\r\n|[\s\S])|#(?!\{)/.source + "|" + interpolationPattern + ')*")'
+        ),
+        lookbehind: true,
+        greedy: true,
+        inside: {
+          interpolation: {
+            pattern: RegExp(interpolationPattern),
+            inside: {
+              punctuation: /^#\{|\}$/,
+              expression: {
+                pattern: /[\s\S]+/,
+                inside: Prism2.languages.tremor
+              }
+            }
+          },
+          string: /[\s\S]+/
+        }
+      };
+      Prism2.languages.troy = Prism2.languages["tremor"];
+      Prism2.languages.trickle = Prism2.languages["tremor"];
+    })(Prism);
+  }
+  return tremor_1;
+}
+var tremorExports = requireTremor();
+const tremor = /* @__PURE__ */ getDefaultExportFromCjs(tremorExports);
+const tremor$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: tremor
+}, [tremorExports]);
+export {
+  tremor$1 as t
+};
+//# sourceMappingURL=tremor-BhknNNX8.js.map

package/dist/tremor-BhknNNX8.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tremor-BhknNNX8.js","sources":["../node_modules/refractor/lang/tremor.js"],"sourcesContent":["'use strict'\n\nmodule.exports = tremor\ntremor.displayName = 'tremor'\ntremor.aliases = []\nfunction tremor(Prism) {\n  ;(function (Prism) {\n    Prism.languages.tremor = {\n      comment: {\n        pattern: /(^|[^\\\\])(?:\\/\\*[\\s\\S]*?\\*\\/|(?:--|\\/\\/|#).*)/,\n        lookbehind: true\n      },\n      'interpolated-string': null,\n      // see below\n      extractor: {\n        pattern: /\\b[a-z_]\\w*\\|(?:[^\\r\\n\\\\|]|\\\\(?:\\r\\n|[\\s\\S]))*\\|/i,\n        greedy: true,\n        inside: {\n          regex: {\n            pattern: /(^re)\\|[\\s\\S]+/,\n            lookbehind: true\n          },\n          function: /^\\w+/,\n          value: /\\|[\\s\\S]+/\n        }\n      },\n      identifier: {\n        pattern: /`[^`]*`/,\n        greedy: true\n      },\n      function: /\\b[a-z_]\\w*(?=\\s*(?:::\\s*<|\\())\\b/,\n      keyword:\n        /\\b(?:args|as|by|case|config|connect|connector|const|copy|create|default|define|deploy|drop|each|emit|end|erase|event|flow|fn|for|from|group|having|insert|into|intrinsic|let|links|match|merge|mod|move|of|operator|patch|pipeline|recur|script|select|set|sliding|state|stream|to|tumbling|update|use|when|where|window|with)\\b/,\n      boolean: /\\b(?:false|null|true)\\b/i,\n      number:\n        /\\b(?:0b[01_]*|0x[0-9a-fA-F_]*|\\d[\\d_]*(?:\\.\\d[\\d_]*)?(?:[Ee][+-]?[\\d_]+)?)\\b/,\n      'pattern-punctuation': {\n        pattern: /%(?=[({[])/,\n        alias: 'punctuation'\n      },\n      operator:\n        /[-+*\\/%~!^]=?|=[=>]?|&[&=]?|\\|[|=]?|<<?=?|>>?>?=?|(?:absent|and|not|or|present|xor)\\b/,\n      punctuation: /::|[;\\[\\]()\\{\\},.:]/\n    }\n    var interpolationPattern =\n      /#\\{(?:[^\"{}]|\\{[^{}]*\\}|\"(?:[^\"\\\\\\r\\n]|\\\\(?:\\r\\n|[\\s\\S]))*\")*\\}/.source\n    Prism.languages.tremor['interpolated-string'] = {\n      pattern: RegExp(\n        /(^|[^\\\\])/.source +\n          '(?:' +\n          '\"\"\"(?:' +\n          /[^\"\\\\#]|\\\\[\\s\\S]|\"(?!\"\")|#(?!\\{)/.source +\n          '|' +\n          interpolationPattern +\n          ')*\"\"\"' +\n          '|' +\n          '\"(?:' +\n          /[^\"\\\\\\r\\n#]|\\\\(?:\\r\\n|[\\s\\S])|#(?!\\{)/.source +\n          '|' +\n          interpolationPattern +\n          ')*\"' +\n          ')'\n      ),\n      lookbehind: true,\n      greedy: true,\n      inside: {\n        interpolation: {\n          pattern: RegExp(interpolationPattern),\n          inside: {\n            punctuation: /^#\\{|\\}$/,\n            expression: {\n              pattern: /[\\s\\S]+/,\n              inside: Prism.languages.tremor\n            }\n          }\n        },\n        string: /[\\s\\S]+/\n      }\n    }\n    Prism.languages.troy = Prism.languages['tremor']\n    Prism.languages.trickle = Prism.languages['tremor']\n  })(Prism)\n}\n"],"names":["tremor","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,aAAiBA;AACjB,EAAAA,QAAO,cAAc;AACrB,EAAAA,QAAO,UAAU,CAAA;AACjB,WAASA,QAAO,OAAO;AACpB,KAAC,SAAUC,QAAO;AACjB,MAAAA,OAAM,UAAU,SAAS;AAAA,QACvB,SAAS;AAAA,UACP,SAAS;AAAA,UACT,YAAY;AAAA;QAEd,uBAAuB;AAAA;AAAA,QAEvB,WAAW;AAAA,UACT,SAAS;AAAA,UACT,QAAQ;AAAA,UACR,QAAQ;AAAA,YACN,OAAO;AAAA,cACL,SAAS;AAAA,cACT,YAAY;AAAA;YAEd,UAAU;AAAA,YACV,OAAO;AAAA;;QAGX,YAAY;AAAA,UACV,SAAS;AAAA,UACT,QAAQ;AAAA;QAEV,UAAU;AAAA,QACV,SACE;AAAA,QACF,SAAS;AAAA,QACT,QACE;AAAA,QACF,uBAAuB;AAAA,UACrB,SAAS;AAAA,UACT,OAAO;AAAA;QAET,UACE;AAAA,QACF,aAAa;AAAA;AAEf,UAAI,uBACF,kEAAkE;AACpE,MAAAA,OAAM,UAAU,OAAO,qBAAqB,IAAI;AAAA,QAC9C,SAAS;AAAA,UACP,YAAY,SACV,cAEA,mCAAmC,SACnC,MACA,uBACA,eAGA,wCAAwC,SACxC,MACA,uBACA;AAAA;QAGJ,YAAY;AAAA,QACZ,QAAQ;AAAA,QACR,QAAQ;AAAA,UACN,eAAe;AAAA,YACb,SAAS,OAAO,oBAAoB;AAAA,YACpC,QAAQ;AAAA,cACN,aAAa;AAAA,cACb,YAAY;AAAA,gBACV,SAAS;AAAA,gBACT,QAAQA,OAAM,UAAU;AAAA;;;UAI9B,QAAQ;AAAA;;AAGZ,MAAAA,OAAM,UAAU,OAAOA,OAAM,UAAU,QAAQ;AAC/C,MAAAA,OAAM,UAAU,UAAUA,OAAM,UAAU,QAAQ;AAAA,IACtD,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/tsx-DEAPEmtC.js

@@ -0,0 +1,60 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+import { r as requireJsx } from "./jsx-C1qRCugV.js";
+import { r as requireTypescript } from "./typescript-e-gwqYt9.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 tsx_1;
+var hasRequiredTsx;
+function requireTsx() {
+  if (hasRequiredTsx) return tsx_1;
+  hasRequiredTsx = 1;
+  var refractorJsx = requireJsx();
+  var refractorTypescript = requireTypescript();
+  tsx_1 = tsx2;
+  tsx2.displayName = "tsx";
+  tsx2.aliases = [];
+  function tsx2(Prism) {
+    Prism.register(refractorJsx);
+    Prism.register(refractorTypescript);
+    (function(Prism2) {
+      var typescript = Prism2.util.clone(Prism2.languages.typescript);
+      Prism2.languages.tsx = Prism2.languages.extend("jsx", typescript);
+      delete Prism2.languages.tsx["parameter"];
+      delete Prism2.languages.tsx["literal-property"];
+      var tag = Prism2.languages.tsx.tag;
+      tag.pattern = RegExp(
+        /(^|[^\w$]|(?=<\/))/.source + "(?:" + tag.pattern.source + ")",
+        tag.pattern.flags
+      );
+      tag.lookbehind = true;
+    })(Prism);
+  }
+  return tsx_1;
+}
+var tsxExports = requireTsx();
+const tsx = /* @__PURE__ */ getDefaultExportFromCjs(tsxExports);
+const tsx$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: tsx
+}, [tsxExports]);
+export {
+  tsx$1 as t
+};
+//# sourceMappingURL=tsx-DEAPEmtC.js.map

package/dist/tsx-DEAPEmtC.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tsx-DEAPEmtC.js","sources":["../node_modules/refractor/lang/tsx.js"],"sourcesContent":["'use strict'\nvar refractorJsx = require('./jsx.js')\nvar refractorTypescript = require('./typescript.js')\nmodule.exports = tsx\ntsx.displayName = 'tsx'\ntsx.aliases = []\nfunction tsx(Prism) {\n  Prism.register(refractorJsx)\n  Prism.register(refractorTypescript)\n  ;(function (Prism) {\n    var typescript = Prism.util.clone(Prism.languages.typescript)\n    Prism.languages.tsx = Prism.languages.extend('jsx', typescript) // doesn't work with TS because TS is too complex\n    delete Prism.languages.tsx['parameter']\n    delete Prism.languages.tsx['literal-property'] // This will prevent collisions between TSX tags and TS generic types.\n    // Idea by https://github.com/karlhorky\n    // Discussion: https://github.com/PrismJS/prism/issues/2594#issuecomment-710666928\n    var tag = Prism.languages.tsx.tag\n    tag.pattern = RegExp(\n      /(^|[^\\w$]|(?=<\\/))/.source + '(?:' + tag.pattern.source + ')',\n      tag.pattern.flags\n    )\n    tag.lookbehind = true\n  })(Prism)\n}\n"],"names":["require$$0","require$$1","tsx","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,MAAI,eAAeA,WAAA;AACnB,MAAI,sBAAsBC,kBAAA;AAC1B,UAAiBC;AACjB,EAAAA,KAAI,cAAc;AAClB,EAAAA,KAAI,UAAU,CAAA;AACd,WAASA,KAAI,OAAO;AAClB,UAAM,SAAS,YAAY;AAC3B,UAAM,SAAS,mBAAmB;AACjC,KAAC,SAAUC,QAAO;AACjB,UAAI,aAAaA,OAAM,KAAK,MAAMA,OAAM,UAAU,UAAU;AAC5D,MAAAA,OAAM,UAAU,MAAMA,OAAM,UAAU,OAAO,OAAO,UAAU;AAC9D,aAAOA,OAAM,UAAU,IAAI,WAAW;AACtC,aAAOA,OAAM,UAAU,IAAI,kBAAkB;AAG7C,UAAI,MAAMA,OAAM,UAAU,IAAI;AAC9B,UAAI,UAAU;AAAA,QACZ,qBAAqB,SAAS,QAAQ,IAAI,QAAQ,SAAS;AAAA,QAC3D,IAAI,QAAQ;AAAA;AAEd,UAAI,aAAa;AAAA,IACrB,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}