@oscloudlab/knowledge-card 0.0.1 → 0.0.3

package/dist/scheme-BIkXa0-K.js

@@ -0,0 +1,128 @@
+var scheme_1;
+var hasRequiredScheme;
+function requireScheme() {
+  if (hasRequiredScheme) return scheme_1;
+  hasRequiredScheme = 1;
+  scheme_1 = scheme;
+  scheme.displayName = "scheme";
+  scheme.aliases = [];
+  function scheme(Prism) {
+    (function(Prism2) {
+      Prism2.languages.scheme = {
+        // this supports "normal" single-line comments:
+        //   ; comment
+        // and (potentially nested) multiline comments:
+        //   #| comment #| nested |# still comment |#
+        // (only 1 level of nesting is supported)
+        comment: /;.*|#;\s*(?:\((?:[^()]|\([^()]*\))*\)|\[(?:[^\[\]]|\[[^\[\]]*\])*\])|#\|(?:[^#|]|#(?!\|)|\|(?!#)|#\|(?:[^#|]|#(?!\|)|\|(?!#))*\|#)*\|#/,
+        string: {
+          pattern: /"(?:[^"\\]|\\.)*"/,
+          greedy: true
+        },
+        symbol: {
+          pattern: /'[^()\[\]#'\s]+/,
+          greedy: true
+        },
+        char: {
+          pattern: /#\\(?:[ux][a-fA-F\d]+\b|[-a-zA-Z]+\b|[\uD800-\uDBFF][\uDC00-\uDFFF]|\S)/,
+          greedy: true
+        },
+        "lambda-parameter": [
+          // https://www.cs.cmu.edu/Groups/AI/html/r4rs/r4rs_6.html#SEC30
+          {
+            pattern: /((?:^|[^'`#])[(\[]lambda\s+)(?:[^|()\[\]'\s]+|\|(?:[^\\|]|\\.)*\|)/,
+            lookbehind: true
+          },
+          {
+            pattern: /((?:^|[^'`#])[(\[]lambda\s+[(\[])[^()\[\]']+/,
+            lookbehind: true
+          }
+        ],
+        keyword: {
+          pattern: /((?:^|[^'`#])[(\[])(?:begin|case(?:-lambda)?|cond(?:-expand)?|define(?:-library|-macro|-record-type|-syntax|-values)?|defmacro|delay(?:-force)?|do|else|except|export|guard|if|import|include(?:-ci|-library-declarations)?|lambda|let(?:rec)?(?:-syntax|-values|\*)?|let\*-values|only|parameterize|prefix|(?:quasi-?)?quote|rename|set!|syntax-(?:case|rules)|unless|unquote(?:-splicing)?|when)(?=[()\[\]\s]|$)/,
+          lookbehind: true
+        },
+        builtin: {
+          // all functions of the base library of R7RS plus some of built-ins of R5Rs
+          pattern: /((?:^|[^'`#])[(\[])(?:abs|and|append|apply|assoc|ass[qv]|binary-port\?|boolean=?\?|bytevector(?:-append|-copy|-copy!|-length|-u8-ref|-u8-set!|\?)?|caar|cadr|call-with-(?:current-continuation|port|values)|call\/cc|car|cdar|cddr|cdr|ceiling|char(?:->integer|-ready\?|\?|<\?|<=\?|=\?|>\?|>=\?)|close-(?:input-port|output-port|port)|complex\?|cons|current-(?:error|input|output)-port|denominator|dynamic-wind|eof-object\??|eq\?|equal\?|eqv\?|error|error-object(?:-irritants|-message|\?)|eval|even\?|exact(?:-integer-sqrt|-integer\?|\?)?|expt|features|file-error\?|floor(?:-quotient|-remainder|\/)?|flush-output-port|for-each|gcd|get-output-(?:bytevector|string)|inexact\??|input-port(?:-open\?|\?)|integer(?:->char|\?)|lcm|length|list(?:->string|->vector|-copy|-ref|-set!|-tail|\?)?|make-(?:bytevector|list|parameter|string|vector)|map|max|member|memq|memv|min|modulo|negative\?|newline|not|null\?|number(?:->string|\?)|numerator|odd\?|open-(?:input|output)-(?:bytevector|string)|or|output-port(?:-open\?|\?)|pair\?|peek-char|peek-u8|port\?|positive\?|procedure\?|quotient|raise|raise-continuable|rational\?|rationalize|read-(?:bytevector|bytevector!|char|error\?|line|string|u8)|real\?|remainder|reverse|round|set-c[ad]r!|square|string(?:->list|->number|->symbol|->utf8|->vector|-append|-copy|-copy!|-fill!|-for-each|-length|-map|-ref|-set!|\?|<\?|<=\?|=\?|>\?|>=\?)?|substring|symbol(?:->string|\?|=\?)|syntax-error|textual-port\?|truncate(?:-quotient|-remainder|\/)?|u8-ready\?|utf8->string|values|vector(?:->list|->string|-append|-copy|-copy!|-fill!|-for-each|-length|-map|-ref|-set!|\?)?|with-exception-handler|write-(?:bytevector|char|string|u8)|zero\?)(?=[()\[\]\s]|$)/,
+          lookbehind: true
+        },
+        operator: {
+          pattern: /((?:^|[^'`#])[(\[])(?:[-+*%/]|[<>]=?|=>?)(?=[()\[\]\s]|$)/,
+          lookbehind: true
+        },
+        number: {
+          // The number pattern from [the R7RS spec](https://small.r7rs.org/attachment/r7rs.pdf).
+          //
+          // <number>      := <num 2>|<num 8>|<num 10>|<num 16>
+          // <num R>       := <prefix R><complex R>
+          // <complex R>   := <real R>(?:@<real R>|<imaginary R>)?|<imaginary R>
+          // <imaginary R> := [+-](?:<ureal R>|(?:inf|nan)\.0)?i
+          // <real R>      := [+-]?<ureal R>|[+-](?:inf|nan)\.0
+          // <ureal R>     := <uint R>(?:\/<uint R>)?
+          //                | <decimal R>
+          //
+          // <decimal 10>  := (?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?
+          // <uint R>      := <digit R>+
+          // <prefix R>    := <radix R>(?:#[ei])?|(?:#[ei])?<radix R>
+          // <radix 2>     := #b
+          // <radix 8>     := #o
+          // <radix 10>    := (?:#d)?
+          // <radix 16>    := #x
+          // <digit 2>     := [01]
+          // <digit 8>     := [0-7]
+          // <digit 10>    := \d
+          // <digit 16>    := [0-9a-f]
+          //
+          // The problem with this grammar is that the resulting regex is way to complex, so we simplify by grouping all
+          // non-decimal bases together. This results in a decimal (dec) and combined binary, octal, and hexadecimal (box)
+          // pattern:
+          pattern: RegExp(
+            SortedBNF({
+              "<ureal dec>": /\d+(?:\/\d+)|(?:\d+(?:\.\d*)?|\.\d+)(?:[esfdl][+-]?\d+)?/.source,
+              "<real dec>": /[+-]?<ureal dec>|[+-](?:inf|nan)\.0/.source,
+              "<imaginary dec>": /[+-](?:<ureal dec>|(?:inf|nan)\.0)?i/.source,
+              "<complex dec>": /<real dec>(?:@<real dec>|<imaginary dec>)?|<imaginary dec>/.source,
+              "<num dec>": /(?:#d(?:#[ei])?|#[ei](?:#d)?)?<complex dec>/.source,
+              "<ureal box>": /[0-9a-f]+(?:\/[0-9a-f]+)?/.source,
+              "<real box>": /[+-]?<ureal box>|[+-](?:inf|nan)\.0/.source,
+              "<imaginary box>": /[+-](?:<ureal box>|(?:inf|nan)\.0)?i/.source,
+              "<complex box>": /<real box>(?:@<real box>|<imaginary box>)?|<imaginary box>/.source,
+              "<num box>": /#[box](?:#[ei])?|(?:#[ei])?#[box]<complex box>/.source,
+              "<number>": /(^|[()\[\]\s])(?:<num dec>|<num box>)(?=[()\[\]\s]|$)/.source
+            }),
+            "i"
+          ),
+          lookbehind: true
+        },
+        boolean: {
+          pattern: /(^|[()\[\]\s])#(?:[ft]|false|true)(?=[()\[\]\s]|$)/,
+          lookbehind: true
+        },
+        function: {
+          pattern: /((?:^|[^'`#])[(\[])(?:[^|()\[\]'\s]+|\|(?:[^\\|]|\\.)*\|)(?=[()\[\]\s]|$)/,
+          lookbehind: true
+        },
+        identifier: {
+          pattern: /(^|[()\[\]\s])\|(?:[^\\|]|\\.)*\|(?=[()\[\]\s]|$)/,
+          lookbehind: true,
+          greedy: true
+        },
+        punctuation: /[()\[\]']/
+      };
+      function SortedBNF(grammar) {
+        for (var key in grammar) {
+          grammar[key] = grammar[key].replace(/<[\w\s]+>/g, function(key2) {
+            return "(?:" + grammar[key2].trim() + ")";
+          });
+        }
+        return grammar[key];
+      }
+    })(Prism);
+  }
+  return scheme_1;
+}
+export {
+  requireScheme as r
+};
+//# sourceMappingURL=scheme-BIkXa0-K.js.map

package/dist/scheme-BIkXa0-K.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheme-BIkXa0-K.js","sources":["../node_modules/refractor/lang/scheme.js"],"sourcesContent":["'use strict'\n\nmodule.exports = scheme\nscheme.displayName = 'scheme'\nscheme.aliases = []\nfunction scheme(Prism) {\n  ;(function (Prism) {\n    Prism.languages.scheme = {\n      // this supports \"normal\" single-line comments:\n      //   ; comment\n      // and (potentially nested) multiline comments:\n      //   #| comment #| nested |# still comment |#\n      // (only 1 level of nesting is supported)\n      comment:\n        /;.*|#;\\s*(?:\\((?:[^()]|\\([^()]*\\))*\\)|\\[(?:[^\\[\\]]|\\[[^\\[\\]]*\\])*\\])|#\\|(?:[^#|]|#(?!\\|)|\\|(?!#)|#\\|(?:[^#|]|#(?!\\|)|\\|(?!#))*\\|#)*\\|#/,\n      string: {\n        pattern: /\"(?:[^\"\\\\]|\\\\.)*\"/,\n        greedy: true\n      },\n      symbol: {\n        pattern: /'[^()\\[\\]#'\\s]+/,\n        greedy: true\n      },\n      char: {\n        pattern:\n          /#\\\\(?:[ux][a-fA-F\\d]+\\b|[-a-zA-Z]+\\b|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|\\S)/,\n        greedy: true\n      },\n      'lambda-parameter': [\n        // https://www.cs.cmu.edu/Groups/AI/html/r4rs/r4rs_6.html#SEC30\n        {\n          pattern:\n            /((?:^|[^'`#])[(\\[]lambda\\s+)(?:[^|()\\[\\]'\\s]+|\\|(?:[^\\\\|]|\\\\.)*\\|)/,\n          lookbehind: true\n        },\n        {\n          pattern: /((?:^|[^'`#])[(\\[]lambda\\s+[(\\[])[^()\\[\\]']+/,\n          lookbehind: true\n        }\n      ],\n      keyword: {\n        pattern:\n          /((?:^|[^'`#])[(\\[])(?:begin|case(?:-lambda)?|cond(?:-expand)?|define(?:-library|-macro|-record-type|-syntax|-values)?|defmacro|delay(?:-force)?|do|else|except|export|guard|if|import|include(?:-ci|-library-declarations)?|lambda|let(?:rec)?(?:-syntax|-values|\\*)?|let\\*-values|only|parameterize|prefix|(?:quasi-?)?quote|rename|set!|syntax-(?:case|rules)|unless|unquote(?:-splicing)?|when)(?=[()\\[\\]\\s]|$)/,\n        lookbehind: true\n      },\n      builtin: {\n        // all functions of the base library of R7RS plus some of built-ins of R5Rs\n        pattern:\n          /((?:^|[^'`#])[(\\[])(?:abs|and|append|apply|assoc|ass[qv]|binary-port\\?|boolean=?\\?|bytevector(?:-append|-copy|-copy!|-length|-u8-ref|-u8-set!|\\?)?|caar|cadr|call-with-(?:current-continuation|port|values)|call\\/cc|car|cdar|cddr|cdr|ceiling|char(?:->integer|-ready\\?|\\?|<\\?|<=\\?|=\\?|>\\?|>=\\?)|close-(?:input-port|output-port|port)|complex\\?|cons|current-(?:error|input|output)-port|denominator|dynamic-wind|eof-object\\??|eq\\?|equal\\?|eqv\\?|error|error-object(?:-irritants|-message|\\?)|eval|even\\?|exact(?:-integer-sqrt|-integer\\?|\\?)?|expt|features|file-error\\?|floor(?:-quotient|-remainder|\\/)?|flush-output-port|for-each|gcd|get-output-(?:bytevector|string)|inexact\\??|input-port(?:-open\\?|\\?)|integer(?:->char|\\?)|lcm|length|list(?:->string|->vector|-copy|-ref|-set!|-tail|\\?)?|make-(?:bytevector|list|parameter|string|vector)|map|max|member|memq|memv|min|modulo|negative\\?|newline|not|null\\?|number(?:->string|\\?)|numerator|odd\\?|open-(?:input|output)-(?:bytevector|string)|or|output-port(?:-open\\?|\\?)|pair\\?|peek-char|peek-u8|port\\?|positive\\?|procedure\\?|quotient|raise|raise-continuable|rational\\?|rationalize|read-(?:bytevector|bytevector!|char|error\\?|line|string|u8)|real\\?|remainder|reverse|round|set-c[ad]r!|square|string(?:->list|->number|->symbol|->utf8|->vector|-append|-copy|-copy!|-fill!|-for-each|-length|-map|-ref|-set!|\\?|<\\?|<=\\?|=\\?|>\\?|>=\\?)?|substring|symbol(?:->string|\\?|=\\?)|syntax-error|textual-port\\?|truncate(?:-quotient|-remainder|\\/)?|u8-ready\\?|utf8->string|values|vector(?:->list|->string|-append|-copy|-copy!|-fill!|-for-each|-length|-map|-ref|-set!|\\?)?|with-exception-handler|write-(?:bytevector|char|string|u8)|zero\\?)(?=[()\\[\\]\\s]|$)/,\n        lookbehind: true\n      },\n      operator: {\n        pattern: /((?:^|[^'`#])[(\\[])(?:[-+*%/]|[<>]=?|=>?)(?=[()\\[\\]\\s]|$)/,\n        lookbehind: true\n      },\n      number: {\n        // The number pattern from [the R7RS spec](https://small.r7rs.org/attachment/r7rs.pdf).\n        //\n        // <number>      := <num 2>|<num 8>|<num 10>|<num 16>\n        // <num R>       := <prefix R><complex R>\n        // <complex R>   := <real R>(?:@<real R>|<imaginary R>)?|<imaginary R>\n        // <imaginary R> := [+-](?:<ureal R>|(?:inf|nan)\\.0)?i\n        // <real R>      := [+-]?<ureal R>|[+-](?:inf|nan)\\.0\n        // <ureal R>     := <uint R>(?:\\/<uint R>)?\n        //                | <decimal R>\n        //\n        // <decimal 10>  := (?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?\n        // <uint R>      := <digit R>+\n        // <prefix R>    := <radix R>(?:#[ei])?|(?:#[ei])?<radix R>\n        // <radix 2>     := #b\n        // <radix 8>     := #o\n        // <radix 10>    := (?:#d)?\n        // <radix 16>    := #x\n        // <digit 2>     := [01]\n        // <digit 8>     := [0-7]\n        // <digit 10>    := \\d\n        // <digit 16>    := [0-9a-f]\n        //\n        // The problem with this grammar is that the resulting regex is way to complex, so we simplify by grouping all\n        // non-decimal bases together. This results in a decimal (dec) and combined binary, octal, and hexadecimal (box)\n        // pattern:\n        pattern: RegExp(\n          SortedBNF({\n            '<ureal dec>':\n              /\\d+(?:\\/\\d+)|(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:[esfdl][+-]?\\d+)?/.source,\n            '<real dec>': /[+-]?<ureal dec>|[+-](?:inf|nan)\\.0/.source,\n            '<imaginary dec>': /[+-](?:<ureal dec>|(?:inf|nan)\\.0)?i/.source,\n            '<complex dec>':\n              /<real dec>(?:@<real dec>|<imaginary dec>)?|<imaginary dec>/\n                .source,\n            '<num dec>': /(?:#d(?:#[ei])?|#[ei](?:#d)?)?<complex dec>/.source,\n            '<ureal box>': /[0-9a-f]+(?:\\/[0-9a-f]+)?/.source,\n            '<real box>': /[+-]?<ureal box>|[+-](?:inf|nan)\\.0/.source,\n            '<imaginary box>': /[+-](?:<ureal box>|(?:inf|nan)\\.0)?i/.source,\n            '<complex box>':\n              /<real box>(?:@<real box>|<imaginary box>)?|<imaginary box>/\n                .source,\n            '<num box>': /#[box](?:#[ei])?|(?:#[ei])?#[box]<complex box>/\n              .source,\n            '<number>': /(^|[()\\[\\]\\s])(?:<num dec>|<num box>)(?=[()\\[\\]\\s]|$)/\n              .source\n          }),\n          'i'\n        ),\n        lookbehind: true\n      },\n      boolean: {\n        pattern: /(^|[()\\[\\]\\s])#(?:[ft]|false|true)(?=[()\\[\\]\\s]|$)/,\n        lookbehind: true\n      },\n      function: {\n        pattern:\n          /((?:^|[^'`#])[(\\[])(?:[^|()\\[\\]'\\s]+|\\|(?:[^\\\\|]|\\\\.)*\\|)(?=[()\\[\\]\\s]|$)/,\n        lookbehind: true\n      },\n      identifier: {\n        pattern: /(^|[()\\[\\]\\s])\\|(?:[^\\\\|]|\\\\.)*\\|(?=[()\\[\\]\\s]|$)/,\n        lookbehind: true,\n        greedy: true\n      },\n      punctuation: /[()\\[\\]']/\n    }\n    /**\n     * Given a topologically sorted BNF grammar, this will return the RegExp source of last rule of the grammar.\n     *\n     * @param {Record<string, string>} grammar\n     * @returns {string}\n     */\n    function SortedBNF(grammar) {\n      for (var key in grammar) {\n        grammar[key] = grammar[key].replace(/<[\\w\\s]+>/g, function (key) {\n          return '(?:' + grammar[key].trim() + ')'\n        })\n      } // return the last item\n      return grammar[key]\n    }\n  })(Prism)\n}\n"],"names":["Prism","key"],"mappings":";;;;;AAEA,aAAiB;AACjB,SAAO,cAAc;AACrB,SAAO,UAAU,CAAA;AACjB,WAAS,OAAO,OAAO;AACpB,KAAC,SAAUA,QAAO;AACjB,MAAAA,OAAM,UAAU,SAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,QAMvB,SACE;AAAA,QACF,QAAQ;AAAA,UACN,SAAS;AAAA,UACT,QAAQ;AAAA;QAEV,QAAQ;AAAA,UACN,SAAS;AAAA,UACT,QAAQ;AAAA;QAEV,MAAM;AAAA,UACJ,SACE;AAAA,UACF,QAAQ;AAAA;QAEV,oBAAoB;AAAA;AAAA,UAElB;AAAA,YACE,SACE;AAAA,YACF,YAAY;AAAA;UAEd;AAAA,YACE,SAAS;AAAA,YACT,YAAY;AAAA;;QAGhB,SAAS;AAAA,UACP,SACE;AAAA,UACF,YAAY;AAAA;QAEd,SAAS;AAAA;AAAA,UAEP,SACE;AAAA,UACF,YAAY;AAAA;QAEd,UAAU;AAAA,UACR,SAAS;AAAA,UACT,YAAY;AAAA;QAEd,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,UA0BN,SAAS;AAAA,YACP,UAAU;AAAA,cACR,eACE,2DAA2D;AAAA,cAC7D,cAAc,sCAAsC;AAAA,cACpD,mBAAmB,uCAAuC;AAAA,cAC1D,iBACE,6DACG;AAAA,cACL,aAAa,8CAA8C;AAAA,cAC3D,eAAe,4BAA4B;AAAA,cAC3C,cAAc,sCAAsC;AAAA,cACpD,mBAAmB,uCAAuC;AAAA,cAC1D,iBACE,6DACG;AAAA,cACL,aAAa,iDACV;AAAA,cACH,YAAY,wDACT;AAAA,YACf,CAAW;AAAA,YACD;AAAA;UAEF,YAAY;AAAA;QAEd,SAAS;AAAA,UACP,SAAS;AAAA,UACT,YAAY;AAAA;QAEd,UAAU;AAAA,UACR,SACE;AAAA,UACF,YAAY;AAAA;QAEd,YAAY;AAAA,UACV,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,QAAQ;AAAA;QAEV,aAAa;AAAA;AAQf,eAAS,UAAU,SAAS;AAC1B,iBAAS,OAAO,SAAS;AACvB,kBAAQ,GAAG,IAAI,QAAQ,GAAG,EAAE,QAAQ,cAAc,SAAUC,MAAK;AAC/D,mBAAO,QAAQ,QAAQA,IAAG,EAAE,KAAI,IAAK;AAAA,UAC/C,CAAS;AAAA,QACT;AACM,eAAO,QAAQ,GAAG;AAAA,MACxB;AAAA,IACA,GAAK,KAAK;AAAA,EACV;;;","x_google_ignoreList":[0]}

package/dist/scheme-_Y1FSeBk.js

@@ -0,0 +1,31 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+import { r as requireScheme } from "./scheme-BIkXa0-K.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 schemeExports = requireScheme();
+const scheme = /* @__PURE__ */ getDefaultExportFromCjs(schemeExports);
+const scheme$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: scheme
+}, [schemeExports]);
+export {
+  scheme$1 as s
+};
+//# sourceMappingURL=scheme-_Y1FSeBk.js.map

package/dist/scheme-_Y1FSeBk.js.map

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

package/dist/scss-CQBD009x.js

@@ -0,0 +1,119 @@
+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 scss_1;
+var hasRequiredScss;
+function requireScss() {
+  if (hasRequiredScss) return scss_1;
+  hasRequiredScss = 1;
+  scss_1 = scss2;
+  scss2.displayName = "scss";
+  scss2.aliases = [];
+  function scss2(Prism) {
+    Prism.languages.scss = Prism.languages.extend("css", {
+      comment: {
+        pattern: /(^|[^\\])(?:\/\*[\s\S]*?\*\/|\/\/.*)/,
+        lookbehind: true
+      },
+      atrule: {
+        pattern: /@[\w-](?:\([^()]+\)|[^()\s]|\s+(?!\s))*?(?=\s+[{;])/,
+        inside: {
+          rule: /@[\w-]+/
+          // See rest below
+        }
+      },
+      // url, compassified
+      url: /(?:[-a-z]+-)?url(?=\()/i,
+      // CSS selector regex is not appropriate for Sass
+      // since there can be lot more things (var, @ directive, nesting..)
+      // a selector must start at the end of a property or after a brace (end of other rules or nesting)
+      // it can contain some characters that aren't used for defining rules or end of selector, & (parent selector), or interpolated variable
+      // the end of a selector is found when there is no rules in it ( {} or {\s}) or if there is a property (because an interpolated var
+      // can "pass" as a selector- e.g: proper#{$erty})
+      // this one was hard to do, so please be careful if you edit this one :)
+      selector: {
+        // Initial look-ahead is used to prevent matching of blank selectors
+        pattern: /(?=\S)[^@;{}()]?(?:[^@;{}()\s]|\s+(?!\s)|#\{\$[-\w]+\})+(?=\s*\{(?:\}|\s|[^}][^:{}]*[:{][^}]))/,
+        inside: {
+          parent: {
+            pattern: /&/,
+            alias: "important"
+          },
+          placeholder: /%[-\w]+/,
+          variable: /\$[-\w]+|#\{\$[-\w]+\}/
+        }
+      },
+      property: {
+        pattern: /(?:[-\w]|\$[-\w]|#\{\$[-\w]+\})+(?=\s*:)/,
+        inside: {
+          variable: /\$[-\w]+|#\{\$[-\w]+\}/
+        }
+      }
+    });
+    Prism.languages.insertBefore("scss", "atrule", {
+      keyword: [
+        /@(?:content|debug|each|else(?: if)?|extend|for|forward|function|if|import|include|mixin|return|use|warn|while)\b/i,
+        {
+          pattern: /( )(?:from|through)(?= )/,
+          lookbehind: true
+        }
+      ]
+    });
+    Prism.languages.insertBefore("scss", "important", {
+      // var and interpolated vars
+      variable: /\$[-\w]+|#\{\$[-\w]+\}/
+    });
+    Prism.languages.insertBefore("scss", "function", {
+      "module-modifier": {
+        pattern: /\b(?:as|hide|show|with)\b/i,
+        alias: "keyword"
+      },
+      placeholder: {
+        pattern: /%[-\w]+/,
+        alias: "selector"
+      },
+      statement: {
+        pattern: /\B!(?:default|optional)\b/i,
+        alias: "keyword"
+      },
+      boolean: /\b(?:false|true)\b/,
+      null: {
+        pattern: /\bnull\b/,
+        alias: "keyword"
+      },
+      operator: {
+        pattern: /(\s)(?:[-+*\/%]|[=!]=|<=?|>=?|and|not|or)(?=\s)/,
+        lookbehind: true
+      }
+    });
+    Prism.languages.scss["atrule"].inside.rest = Prism.languages.scss;
+  }
+  return scss_1;
+}
+var scssExports = requireScss();
+const scss = /* @__PURE__ */ getDefaultExportFromCjs(scssExports);
+const scss$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: scss
+}, [scssExports]);
+export {
+  scss$1 as s
+};
+//# sourceMappingURL=scss-CQBD009x.js.map

package/dist/scss-CQBD009x.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scss-CQBD009x.js","sources":["../node_modules/refractor/lang/scss.js"],"sourcesContent":["'use strict'\n\nmodule.exports = scss\nscss.displayName = 'scss'\nscss.aliases = []\nfunction scss(Prism) {\n  Prism.languages.scss = Prism.languages.extend('css', {\n    comment: {\n      pattern: /(^|[^\\\\])(?:\\/\\*[\\s\\S]*?\\*\\/|\\/\\/.*)/,\n      lookbehind: true\n    },\n    atrule: {\n      pattern: /@[\\w-](?:\\([^()]+\\)|[^()\\s]|\\s+(?!\\s))*?(?=\\s+[{;])/,\n      inside: {\n        rule: /@[\\w-]+/ // See rest below\n      }\n    },\n    // url, compassified\n    url: /(?:[-a-z]+-)?url(?=\\()/i,\n    // CSS selector regex is not appropriate for Sass\n    // since there can be lot more things (var, @ directive, nesting..)\n    // a selector must start at the end of a property or after a brace (end of other rules or nesting)\n    // it can contain some characters that aren't used for defining rules or end of selector, & (parent selector), or interpolated variable\n    // the end of a selector is found when there is no rules in it ( {} or {\\s}) or if there is a property (because an interpolated var\n    // can \"pass\" as a selector- e.g: proper#{$erty})\n    // this one was hard to do, so please be careful if you edit this one :)\n    selector: {\n      // Initial look-ahead is used to prevent matching of blank selectors\n      pattern:\n        /(?=\\S)[^@;{}()]?(?:[^@;{}()\\s]|\\s+(?!\\s)|#\\{\\$[-\\w]+\\})+(?=\\s*\\{(?:\\}|\\s|[^}][^:{}]*[:{][^}]))/,\n      inside: {\n        parent: {\n          pattern: /&/,\n          alias: 'important'\n        },\n        placeholder: /%[-\\w]+/,\n        variable: /\\$[-\\w]+|#\\{\\$[-\\w]+\\}/\n      }\n    },\n    property: {\n      pattern: /(?:[-\\w]|\\$[-\\w]|#\\{\\$[-\\w]+\\})+(?=\\s*:)/,\n      inside: {\n        variable: /\\$[-\\w]+|#\\{\\$[-\\w]+\\}/\n      }\n    }\n  })\n  Prism.languages.insertBefore('scss', 'atrule', {\n    keyword: [\n      /@(?:content|debug|each|else(?: if)?|extend|for|forward|function|if|import|include|mixin|return|use|warn|while)\\b/i,\n      {\n        pattern: /( )(?:from|through)(?= )/,\n        lookbehind: true\n      }\n    ]\n  })\n  Prism.languages.insertBefore('scss', 'important', {\n    // var and interpolated vars\n    variable: /\\$[-\\w]+|#\\{\\$[-\\w]+\\}/\n  })\n  Prism.languages.insertBefore('scss', 'function', {\n    'module-modifier': {\n      pattern: /\\b(?:as|hide|show|with)\\b/i,\n      alias: 'keyword'\n    },\n    placeholder: {\n      pattern: /%[-\\w]+/,\n      alias: 'selector'\n    },\n    statement: {\n      pattern: /\\B!(?:default|optional)\\b/i,\n      alias: 'keyword'\n    },\n    boolean: /\\b(?:false|true)\\b/,\n    null: {\n      pattern: /\\bnull\\b/,\n      alias: 'keyword'\n    },\n    operator: {\n      pattern: /(\\s)(?:[-+*\\/%]|[=!]=|<=?|>=?|and|not|or)(?=\\s)/,\n      lookbehind: true\n    }\n  })\n  Prism.languages.scss['atrule'].inside.rest = Prism.languages.scss\n}\n"],"names":["scss"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,WAAiBA;AACjB,EAAAA,MAAK,cAAc;AACnB,EAAAA,MAAK,UAAU,CAAA;AACf,WAASA,MAAK,OAAO;AACnB,UAAM,UAAU,OAAO,MAAM,UAAU,OAAO,OAAO;AAAA,MACnD,SAAS;AAAA,QACP,SAAS;AAAA,QACT,YAAY;AAAA;MAEd,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA,UACN,MAAM;AAAA;AAAA;;;MAIV,KAAK;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAQL,UAAU;AAAA;AAAA,QAER,SACE;AAAA,QACF,QAAQ;AAAA,UACN,QAAQ;AAAA,YACN,SAAS;AAAA,YACT,OAAO;AAAA;UAET,aAAa;AAAA,UACb,UAAU;AAAA;;MAGd,UAAU;AAAA,QACR,SAAS;AAAA,QACT,QAAQ;AAAA,UACN,UAAU;AAAA;;IAGlB,CAAG;AACD,UAAM,UAAU,aAAa,QAAQ,UAAU;AAAA,MAC7C,SAAS;AAAA,QACP;AAAA,QACA;AAAA,UACE,SAAS;AAAA,UACT,YAAY;AAAA;;IAGpB,CAAG;AACD,UAAM,UAAU,aAAa,QAAQ,aAAa;AAAA;AAAA,MAEhD,UAAU;AAAA,IACd,CAAG;AACD,UAAM,UAAU,aAAa,QAAQ,YAAY;AAAA,MAC/C,mBAAmB;AAAA,QACjB,SAAS;AAAA,QACT,OAAO;AAAA;MAET,aAAa;AAAA,QACX,SAAS;AAAA,QACT,OAAO;AAAA;MAET,WAAW;AAAA,QACT,SAAS;AAAA,QACT,OAAO;AAAA;MAET,SAAS;AAAA,MACT,MAAM;AAAA,QACJ,SAAS;AAAA,QACT,OAAO;AAAA;MAET,UAAU;AAAA,QACR,SAAS;AAAA,QACT,YAAY;AAAA;IAElB,CAAG;AACD,UAAM,UAAU,KAAK,QAAQ,EAAE,OAAO,OAAO,MAAM,UAAU;AAAA,EAC/D;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/shell-session-B_8HhSQY.js

@@ -0,0 +1,103 @@
+import { g as getDefaultExportFromCjs } from "./index-Cdd6oM-q.js";
+import { r as requireBash } from "./bash-ClZjbGxa.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 shellSession_1;
+var hasRequiredShellSession;
+function requireShellSession() {
+  if (hasRequiredShellSession) return shellSession_1;
+  hasRequiredShellSession = 1;
+  var refractorBash = requireBash();
+  shellSession_1 = shellSession2;
+  shellSession2.displayName = "shellSession";
+  shellSession2.aliases = [];
+  function shellSession2(Prism) {
+    Prism.register(refractorBash);
+    (function(Prism2) {
+      var strings = [
+        // normal string
+        /"(?:\\[\s\S]|\$\([^)]+\)|\$(?!\()|`[^`]+`|[^"\\`$])*"/.source,
+        /'[^']*'/.source,
+        /\$'(?:[^'\\]|\\[\s\S])*'/.source,
+        // here doc
+        // 2 capturing groups
+        /<<-?\s*(["']?)(\w+)\1\s[\s\S]*?[\r\n]\2/.source
+      ].join("|");
+      Prism2.languages["shell-session"] = {
+        command: {
+          pattern: RegExp(
+            // user info
+            /^/.source + "(?:" + // <user> ":" ( <path> )?
+            (/[^\s@:$#%*!/\\]+@[^\r\n@:$#%*!/\\]+(?::[^\0-\x1F$#%*?"<>:;|]+)?/.source + "|" + // <path>
+            // Since the path pattern is quite general, we will require it to start with a special character to
+            // prevent false positives.
+            /[/~.][^\0-\x1F$#%*?"<>@:;|]*/.source) + ")?" + // shell symbol
+            /[$#%](?=\s)/.source + // bash command
+            /(?:[^\\\r\n \t'"<$]|[ \t](?:(?!#)|#.*$)|\\(?:[^\r]|\r\n?)|\$(?!')|<(?!<)|<<str>>)+/.source.replace(
+              /<<str>>/g,
+              function() {
+                return strings;
+              }
+            ),
+            "m"
+          ),
+          greedy: true,
+          inside: {
+            info: {
+              // foo@bar:~/files$ exit
+              // foo@bar$ exit
+              // ~/files$ exit
+              pattern: /^[^#$%]+/,
+              alias: "punctuation",
+              inside: {
+                user: /^[^\s@:$#%*!/\\]+@[^\r\n@:$#%*!/\\]+/,
+                punctuation: /:/,
+                path: /[\s\S]+/
+              }
+            },
+            bash: {
+              pattern: /(^[$#%]\s*)\S[\s\S]*/,
+              lookbehind: true,
+              alias: "language-bash",
+              inside: Prism2.languages.bash
+            },
+            "shell-symbol": {
+              pattern: /^[$#%]/,
+              alias: "important"
+            }
+          }
+        },
+        output: /.(?:.*(?:[\r\n]|.$))*/
+      };
+      Prism2.languages["sh-session"] = Prism2.languages["shellsession"] = Prism2.languages["shell-session"];
+    })(Prism);
+  }
+  return shellSession_1;
+}
+var shellSessionExports = requireShellSession();
+const shellSession = /* @__PURE__ */ getDefaultExportFromCjs(shellSessionExports);
+const shellSession$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: shellSession
+}, [shellSessionExports]);
+export {
+  shellSession$1 as s
+};
+//# sourceMappingURL=shell-session-B_8HhSQY.js.map

package/dist/shell-session-B_8HhSQY.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"shell-session-B_8HhSQY.js","sources":["../node_modules/refractor/lang/shell-session.js"],"sourcesContent":["'use strict'\nvar refractorBash = require('./bash.js')\nmodule.exports = shellSession\nshellSession.displayName = 'shellSession'\nshellSession.aliases = []\nfunction shellSession(Prism) {\n  Prism.register(refractorBash)\n  ;(function (Prism) {\n    // CAREFUL!\n    // The following patterns are concatenated, so the group referenced by a back reference is non-obvious!\n    var strings = [\n      // normal string\n      /\"(?:\\\\[\\s\\S]|\\$\\([^)]+\\)|\\$(?!\\()|`[^`]+`|[^\"\\\\`$])*\"/.source,\n      /'[^']*'/.source,\n      /\\$'(?:[^'\\\\]|\\\\[\\s\\S])*'/.source, // here doc\n      // 2 capturing groups\n      /<<-?\\s*([\"']?)(\\w+)\\1\\s[\\s\\S]*?[\\r\\n]\\2/.source\n    ].join('|')\n    Prism.languages['shell-session'] = {\n      command: {\n        pattern: RegExp(\n          // user info\n          /^/.source +\n            '(?:' + // <user> \":\" ( <path> )?\n            (/[^\\s@:$#%*!/\\\\]+@[^\\r\\n@:$#%*!/\\\\]+(?::[^\\0-\\x1F$#%*?\"<>:;|]+)?/\n              .source +\n              '|' + // <path>\n              // Since the path pattern is quite general, we will require it to start with a special character to\n              // prevent false positives.\n              /[/~.][^\\0-\\x1F$#%*?\"<>@:;|]*/.source) +\n            ')?' + // shell symbol\n            /[$#%](?=\\s)/.source + // bash command\n            /(?:[^\\\\\\r\\n \\t'\"<$]|[ \\t](?:(?!#)|#.*$)|\\\\(?:[^\\r]|\\r\\n?)|\\$(?!')|<(?!<)|<<str>>)+/.source.replace(\n              /<<str>>/g,\n              function () {\n                return strings\n              }\n            ),\n          'm'\n        ),\n        greedy: true,\n        inside: {\n          info: {\n            // foo@bar:~/files$ exit\n            // foo@bar$ exit\n            // ~/files$ exit\n            pattern: /^[^#$%]+/,\n            alias: 'punctuation',\n            inside: {\n              user: /^[^\\s@:$#%*!/\\\\]+@[^\\r\\n@:$#%*!/\\\\]+/,\n              punctuation: /:/,\n              path: /[\\s\\S]+/\n            }\n          },\n          bash: {\n            pattern: /(^[$#%]\\s*)\\S[\\s\\S]*/,\n            lookbehind: true,\n            alias: 'language-bash',\n            inside: Prism.languages.bash\n          },\n          'shell-symbol': {\n            pattern: /^[$#%]/,\n            alias: 'important'\n          }\n        }\n      },\n      output: /.(?:.*(?:[\\r\\n]|.$))*/\n    }\n    Prism.languages['sh-session'] = Prism.languages['shellsession'] =\n      Prism.languages['shell-session']\n  })(Prism)\n}\n"],"names":["require$$0","shellSession","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AACA,MAAI,gBAAgBA,YAAA;AACpB,mBAAiBC;AACjB,EAAAA,cAAa,cAAc;AAC3B,EAAAA,cAAa,UAAU,CAAA;AACvB,WAASA,cAAa,OAAO;AAC3B,UAAM,SAAS,aAAa;AAC3B,KAAC,SAAUC,QAAO;AAGjB,UAAI,UAAU;AAAA;AAAA,QAEZ,wDAAwD;AAAA,QACxD,UAAU;AAAA,QACV,2BAA2B;AAAA;AAAA;AAAA,QAE3B,0CAA0C;AAAA,MAChD,EAAM,KAAK,GAAG;AACV,MAAAA,OAAM,UAAU,eAAe,IAAI;AAAA,QACjC,SAAS;AAAA,UACP,SAAS;AAAA;AAAA,YAEP,IAAI,SACF;AAAA,aACC,kEACE,SACD;AAAA;AAAA;AAAA,YAGA,+BAA+B,UACjC;AAAA,YACA,cAAc;AAAA,YACd,qFAAqF,OAAO;AAAA,cAC1F;AAAA,cACA,WAAY;AACV,uBAAO;AAAA,cACvB;AAAA;YAEU;AAAA;UAEF,QAAQ;AAAA,UACR,QAAQ;AAAA,YACN,MAAM;AAAA;AAAA;AAAA;AAAA,cAIJ,SAAS;AAAA,cACT,OAAO;AAAA,cACP,QAAQ;AAAA,gBACN,MAAM;AAAA,gBACN,aAAa;AAAA,gBACb,MAAM;AAAA;;YAGV,MAAM;AAAA,cACJ,SAAS;AAAA,cACT,YAAY;AAAA,cACZ,OAAO;AAAA,cACP,QAAQA,OAAM,UAAU;AAAA;YAE1B,gBAAgB;AAAA,cACd,SAAS;AAAA,cACT,OAAO;AAAA;;;QAIb,QAAQ;AAAA;AAEV,MAAAA,OAAM,UAAU,YAAY,IAAIA,OAAM,UAAU,cAAc,IAC5DA,OAAM,UAAU,eAAe;AAAA,IACrC,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/smali-3ybSF7DU.js

@@ -0,0 +1,121 @@
+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 smali_1;
+var hasRequiredSmali;
+function requireSmali() {
+  if (hasRequiredSmali) return smali_1;
+  hasRequiredSmali = 1;
+  smali_1 = smali2;
+  smali2.displayName = "smali";
+  smali2.aliases = [];
+  function smali2(Prism) {
+    Prism.languages.smali = {
+      comment: /#.*/,
+      string: {
+        pattern: /"(?:[^\r\n\\"]|\\.)*"|'(?:[^\r\n\\']|\\(?:.|u[\da-fA-F]{4}))'/,
+        greedy: true
+      },
+      "class-name": {
+        pattern: /(^|[^L])L(?:(?:\w+|`[^`\r\n]*`)\/)*(?:[\w$]+|`[^`\r\n]*`)(?=\s*;)/,
+        lookbehind: true,
+        inside: {
+          "class-name": {
+            pattern: /(^L|\/)(?:[\w$]+|`[^`\r\n]*`)$/,
+            lookbehind: true
+          },
+          namespace: {
+            pattern: /^(L)(?:(?:\w+|`[^`\r\n]*`)\/)+/,
+            lookbehind: true,
+            inside: {
+              punctuation: /\//
+            }
+          },
+          builtin: /^L/
+        }
+      },
+      builtin: [
+        {
+          // Reference: https://github.com/JesusFreke/smali/wiki/TypesMethodsAndFields#types
+          pattern: /([();\[])[BCDFIJSVZ]+/,
+          lookbehind: true
+        },
+        {
+          // e.g. .field mWifiOnUid:I
+          pattern: /([\w$>]:)[BCDFIJSVZ]/,
+          lookbehind: true
+        }
+      ],
+      keyword: [
+        {
+          pattern: /(\.end\s+)[\w-]+/,
+          lookbehind: true
+        },
+        {
+          pattern: /(^|[^\w.-])\.(?!\d)[\w-]+/,
+          lookbehind: true
+        },
+        {
+          pattern: /(^|[^\w.-])(?:abstract|annotation|bridge|constructor|enum|final|interface|private|protected|public|runtime|static|synthetic|system|transient)(?![\w.-])/,
+          lookbehind: true
+        }
+      ],
+      function: {
+        pattern: /(^|[^\w.-])(?:\w+|<[\w$-]+>)(?=\()/,
+        lookbehind: true
+      },
+      field: {
+        pattern: /[\w$]+(?=:)/,
+        alias: "variable"
+      },
+      register: {
+        pattern: /(^|[^\w.-])[vp]\d(?![\w.-])/,
+        lookbehind: true,
+        alias: "variable"
+      },
+      boolean: {
+        pattern: /(^|[^\w.-])(?:false|true)(?![\w.-])/,
+        lookbehind: true
+      },
+      number: {
+        pattern: /(^|[^/\w.-])-?(?:NAN|INFINITY|0x(?:[\dA-F]+(?:\.[\dA-F]*)?|\.[\dA-F]+)(?:p[+-]?[\dA-F]+)?|(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?)[dflst]?(?![\w.-])/i,
+        lookbehind: true
+      },
+      label: {
+        pattern: /(:)\w+/,
+        lookbehind: true,
+        alias: "property"
+      },
+      operator: /->|\.\.|[\[=]/,
+      punctuation: /[{}(),;:]/
+    };
+  }
+  return smali_1;
+}
+var smaliExports = requireSmali();
+const smali = /* @__PURE__ */ getDefaultExportFromCjs(smaliExports);
+const smali$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: smali
+}, [smaliExports]);
+export {
+  smali$1 as s
+};
+//# sourceMappingURL=smali-3ybSF7DU.js.map

package/dist/smali-3ybSF7DU.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"smali-3ybSF7DU.js","sources":["../node_modules/refractor/lang/smali.js"],"sourcesContent":["'use strict'\n\nmodule.exports = smali\nsmali.displayName = 'smali'\nsmali.aliases = []\nfunction smali(Prism) {\n  // Test files for the parser itself:\n  // https://github.com/JesusFreke/smali/tree/master/smali/src/test/resources/LexerTest\n  Prism.languages.smali = {\n    comment: /#.*/,\n    string: {\n      pattern: /\"(?:[^\\r\\n\\\\\"]|\\\\.)*\"|'(?:[^\\r\\n\\\\']|\\\\(?:.|u[\\da-fA-F]{4}))'/,\n      greedy: true\n    },\n    'class-name': {\n      pattern:\n        /(^|[^L])L(?:(?:\\w+|`[^`\\r\\n]*`)\\/)*(?:[\\w$]+|`[^`\\r\\n]*`)(?=\\s*;)/,\n      lookbehind: true,\n      inside: {\n        'class-name': {\n          pattern: /(^L|\\/)(?:[\\w$]+|`[^`\\r\\n]*`)$/,\n          lookbehind: true\n        },\n        namespace: {\n          pattern: /^(L)(?:(?:\\w+|`[^`\\r\\n]*`)\\/)+/,\n          lookbehind: true,\n          inside: {\n            punctuation: /\\//\n          }\n        },\n        builtin: /^L/\n      }\n    },\n    builtin: [\n      {\n        // Reference: https://github.com/JesusFreke/smali/wiki/TypesMethodsAndFields#types\n        pattern: /([();\\[])[BCDFIJSVZ]+/,\n        lookbehind: true\n      },\n      {\n        // e.g. .field mWifiOnUid:I\n        pattern: /([\\w$>]:)[BCDFIJSVZ]/,\n        lookbehind: true\n      }\n    ],\n    keyword: [\n      {\n        pattern: /(\\.end\\s+)[\\w-]+/,\n        lookbehind: true\n      },\n      {\n        pattern: /(^|[^\\w.-])\\.(?!\\d)[\\w-]+/,\n        lookbehind: true\n      },\n      {\n        pattern:\n          /(^|[^\\w.-])(?:abstract|annotation|bridge|constructor|enum|final|interface|private|protected|public|runtime|static|synthetic|system|transient)(?![\\w.-])/,\n        lookbehind: true\n      }\n    ],\n    function: {\n      pattern: /(^|[^\\w.-])(?:\\w+|<[\\w$-]+>)(?=\\()/,\n      lookbehind: true\n    },\n    field: {\n      pattern: /[\\w$]+(?=:)/,\n      alias: 'variable'\n    },\n    register: {\n      pattern: /(^|[^\\w.-])[vp]\\d(?![\\w.-])/,\n      lookbehind: true,\n      alias: 'variable'\n    },\n    boolean: {\n      pattern: /(^|[^\\w.-])(?:false|true)(?![\\w.-])/,\n      lookbehind: true\n    },\n    number: {\n      pattern:\n        /(^|[^/\\w.-])-?(?:NAN|INFINITY|0x(?:[\\dA-F]+(?:\\.[\\dA-F]*)?|\\.[\\dA-F]+)(?:p[+-]?[\\dA-F]+)?|(?:\\d+(?:\\.\\d*)?|\\.\\d+)(?:e[+-]?\\d+)?)[dflst]?(?![\\w.-])/i,\n      lookbehind: true\n    },\n    label: {\n      pattern: /(:)\\w+/,\n      lookbehind: true,\n      alias: 'property'\n    },\n    operator: /->|\\.\\.|[\\[=]/,\n    punctuation: /[{}(),;:]/\n  }\n}\n"],"names":["smali"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,YAAiBA;AACjB,EAAAA,OAAM,cAAc;AACpB,EAAAA,OAAM,UAAU,CAAA;AAChB,WAASA,OAAM,OAAO;AAGpB,UAAM,UAAU,QAAQ;AAAA,MACtB,SAAS;AAAA,MACT,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,cAAc;AAAA,QACZ,SACE;AAAA,QACF,YAAY;AAAA,QACZ,QAAQ;AAAA,UACN,cAAc;AAAA,YACZ,SAAS;AAAA,YACT,YAAY;AAAA;UAEd,WAAW;AAAA,YACT,SAAS;AAAA,YACT,YAAY;AAAA,YACZ,QAAQ;AAAA,cACN,aAAa;AAAA;;UAGjB,SAAS;AAAA;;MAGb,SAAS;AAAA,QACP;AAAA;AAAA,UAEE,SAAS;AAAA,UACT,YAAY;AAAA;QAEd;AAAA;AAAA,UAEE,SAAS;AAAA,UACT,YAAY;AAAA;;MAGhB,SAAS;AAAA,QACP;AAAA,UACE,SAAS;AAAA,UACT,YAAY;AAAA;QAEd;AAAA,UACE,SAAS;AAAA,UACT,YAAY;AAAA;QAEd;AAAA,UACE,SACE;AAAA,UACF,YAAY;AAAA;;MAGhB,UAAU;AAAA,QACR,SAAS;AAAA,QACT,YAAY;AAAA;MAEd,OAAO;AAAA,QACL,SAAS;AAAA,QACT,OAAO;AAAA;MAET,UAAU;AAAA,QACR,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,OAAO;AAAA;MAET,SAAS;AAAA,QACP,SAAS;AAAA,QACT,YAAY;AAAA;MAEd,QAAQ;AAAA,QACN,SACE;AAAA,QACF,YAAY;AAAA;MAEd,OAAO;AAAA,QACL,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,OAAO;AAAA;MAET,UAAU;AAAA,MACV,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/smalltalk-7LMs95g7.js

@@ -0,0 +1,80 @@
+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 smalltalk_1;
+var hasRequiredSmalltalk;
+function requireSmalltalk() {
+  if (hasRequiredSmalltalk) return smalltalk_1;
+  hasRequiredSmalltalk = 1;
+  smalltalk_1 = smalltalk2;
+  smalltalk2.displayName = "smalltalk";
+  smalltalk2.aliases = [];
+  function smalltalk2(Prism) {
+    Prism.languages.smalltalk = {
+      comment: {
+        pattern: /"(?:""|[^"])*"/,
+        greedy: true
+      },
+      char: {
+        pattern: /\$./,
+        greedy: true
+      },
+      string: {
+        pattern: /'(?:''|[^'])*'/,
+        greedy: true
+      },
+      symbol: /#[\da-z]+|#(?:-|([+\/\\*~<>=@%|&?!])\1?)|#(?=\()/i,
+      "block-arguments": {
+        pattern: /(\[\s*):[^\[|]*\|/,
+        lookbehind: true,
+        inside: {
+          variable: /:[\da-z]+/i,
+          punctuation: /\|/
+        }
+      },
+      "temporary-variables": {
+        pattern: /\|[^|]+\|/,
+        inside: {
+          variable: /[\da-z]+/i,
+          punctuation: /\|/
+        }
+      },
+      keyword: /\b(?:new|nil|self|super)\b/,
+      boolean: /\b(?:false|true)\b/,
+      number: [
+        /\d+r-?[\dA-Z]+(?:\.[\dA-Z]+)?(?:e-?\d+)?/,
+        /\b\d+(?:\.\d+)?(?:e-?\d+)?/
+      ],
+      operator: /[<=]=?|:=|~[~=]|\/\/?|\\\\|>[>=]?|[!^+\-*&|,@]/,
+      punctuation: /[.;:?\[\](){}]/
+    };
+  }
+  return smalltalk_1;
+}
+var smalltalkExports = requireSmalltalk();
+const smalltalk = /* @__PURE__ */ getDefaultExportFromCjs(smalltalkExports);
+const smalltalk$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: smalltalk
+}, [smalltalkExports]);
+export {
+  smalltalk$1 as s
+};
+//# sourceMappingURL=smalltalk-7LMs95g7.js.map

package/dist/smalltalk-7LMs95g7.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"smalltalk-7LMs95g7.js","sources":["../node_modules/refractor/lang/smalltalk.js"],"sourcesContent":["'use strict'\n\nmodule.exports = smalltalk\nsmalltalk.displayName = 'smalltalk'\nsmalltalk.aliases = []\nfunction smalltalk(Prism) {\n  Prism.languages.smalltalk = {\n    comment: {\n      pattern: /\"(?:\"\"|[^\"])*\"/,\n      greedy: true\n    },\n    char: {\n      pattern: /\\$./,\n      greedy: true\n    },\n    string: {\n      pattern: /'(?:''|[^'])*'/,\n      greedy: true\n    },\n    symbol: /#[\\da-z]+|#(?:-|([+\\/\\\\*~<>=@%|&?!])\\1?)|#(?=\\()/i,\n    'block-arguments': {\n      pattern: /(\\[\\s*):[^\\[|]*\\|/,\n      lookbehind: true,\n      inside: {\n        variable: /:[\\da-z]+/i,\n        punctuation: /\\|/\n      }\n    },\n    'temporary-variables': {\n      pattern: /\\|[^|]+\\|/,\n      inside: {\n        variable: /[\\da-z]+/i,\n        punctuation: /\\|/\n      }\n    },\n    keyword: /\\b(?:new|nil|self|super)\\b/,\n    boolean: /\\b(?:false|true)\\b/,\n    number: [\n      /\\d+r-?[\\dA-Z]+(?:\\.[\\dA-Z]+)?(?:e-?\\d+)?/,\n      /\\b\\d+(?:\\.\\d+)?(?:e-?\\d+)?/\n    ],\n    operator: /[<=]=?|:=|~[~=]|\\/\\/?|\\\\\\\\|>[>=]?|[!^+\\-*&|,@]/,\n    punctuation: /[.;:?\\[\\](){}]/\n  }\n}\n"],"names":["smalltalk"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,gBAAiBA;AACjB,EAAAA,WAAU,cAAc;AACxB,EAAAA,WAAU,UAAU,CAAA;AACpB,WAASA,WAAU,OAAO;AACxB,UAAM,UAAU,YAAY;AAAA,MAC1B,SAAS;AAAA,QACP,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,MAAM;AAAA,QACJ,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,QAAQ;AAAA,MACR,mBAAmB;AAAA,QACjB,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,QAAQ;AAAA,UACN,UAAU;AAAA,UACV,aAAa;AAAA;;MAGjB,uBAAuB;AAAA,QACrB,SAAS;AAAA,QACT,QAAQ;AAAA,UACN,UAAU;AAAA,UACV,aAAa;AAAA;;MAGjB,SAAS;AAAA,MACT,SAAS;AAAA,MACT,QAAQ;AAAA,QACN;AAAA,QACA;AAAA;MAEF,UAAU;AAAA,MACV,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}