@oscloudlab/knowledge-card 0.0.1 → 0.0.3

package/dist/qsharp-rtfe_NYv.js

@@ -0,0 +1,144 @@
+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 qsharp_1;
+var hasRequiredQsharp;
+function requireQsharp() {
+  if (hasRequiredQsharp) return qsharp_1;
+  hasRequiredQsharp = 1;
+  qsharp_1 = qsharp2;
+  qsharp2.displayName = "qsharp";
+  qsharp2.aliases = ["qs"];
+  function qsharp2(Prism) {
+    (function(Prism2) {
+      function replace(pattern, replacements) {
+        return pattern.replace(/<<(\d+)>>/g, function(m, index) {
+          return "(?:" + replacements[+index] + ")";
+        });
+      }
+      function re(pattern, replacements, flags) {
+        return RegExp(replace(pattern, replacements), "");
+      }
+      function nested(pattern, depthLog2) {
+        for (var i = 0; i < depthLog2; i++) {
+          pattern = pattern.replace(/<<self>>/g, function() {
+            return "(?:" + pattern + ")";
+          });
+        }
+        return pattern.replace(/<<self>>/g, "[^\\s\\S]");
+      }
+      var keywordKinds = {
+        // keywords which represent a return or variable type
+        type: "Adj BigInt Bool Ctl Double false Int One Pauli PauliI PauliX PauliY PauliZ Qubit Range Result String true Unit Zero",
+        // all other keywords
+        other: "Adjoint adjoint apply as auto body borrow borrowing Controlled controlled distribute elif else fail fixup for function if in internal intrinsic invert is let mutable namespace new newtype open operation repeat return self set until use using while within"
+      };
+      function keywordsToPattern(words) {
+        return "\\b(?:" + words.trim().replace(/ /g, "|") + ")\\b";
+      }
+      var keywords = RegExp(
+        keywordsToPattern(keywordKinds.type + " " + keywordKinds.other)
+      );
+      var identifier = /\b[A-Za-z_]\w*\b/.source;
+      var qualifiedName = replace(/<<0>>(?:\s*\.\s*<<0>>)*/.source, [identifier]);
+      var typeInside = {
+        keyword: keywords,
+        punctuation: /[<>()?,.:[\]]/
+      };
+      var regularString = /"(?:\\.|[^\\"])*"/.source;
+      Prism2.languages.qsharp = Prism2.languages.extend("clike", {
+        comment: /\/\/.*/,
+        string: [
+          {
+            pattern: re(/(^|[^$\\])<<0>>/.source, [regularString]),
+            lookbehind: true,
+            greedy: true
+          }
+        ],
+        "class-name": [
+          {
+            // open Microsoft.Quantum.Canon;
+            // open Microsoft.Quantum.Canon as CN;
+            pattern: re(/(\b(?:as|open)\s+)<<0>>(?=\s*(?:;|as\b))/.source, [
+              qualifiedName
+            ]),
+            lookbehind: true,
+            inside: typeInside
+          },
+          {
+            // namespace Quantum.App1;
+            pattern: re(/(\bnamespace\s+)<<0>>(?=\s*\{)/.source, [qualifiedName]),
+            lookbehind: true,
+            inside: typeInside
+          }
+        ],
+        keyword: keywords,
+        number: /(?:\b0(?:x[\da-f]+|b[01]+|o[0-7]+)|(?:\B\.\d+|\b\d+(?:\.\d*)?)(?:e[-+]?\d+)?)l?\b/i,
+        operator: /\band=|\bor=|\band\b|\bnot\b|\bor\b|<[-=]|[-=]>|>>>=?|<<<=?|\^\^\^=?|\|\|\|=?|&&&=?|w\/=?|~~~|[*\/+\-^=!%]=?/,
+        punctuation: /::|[{}[\];(),.:]/
+      });
+      Prism2.languages.insertBefore("qsharp", "number", {
+        range: {
+          pattern: /\.\./,
+          alias: "operator"
+        }
+      });
+      var interpolationExpr = nested(
+        replace(/\{(?:[^"{}]|<<0>>|<<self>>)*\}/.source, [regularString]),
+        2
+      );
+      Prism2.languages.insertBefore("qsharp", "string", {
+        "interpolation-string": {
+          pattern: re(/\$"(?:\\.|<<0>>|[^\\"{])*"/.source, [interpolationExpr]),
+          greedy: true,
+          inside: {
+            interpolation: {
+              pattern: re(/((?:^|[^\\])(?:\\\\)*)<<0>>/.source, [
+                interpolationExpr
+              ]),
+              lookbehind: true,
+              inside: {
+                punctuation: /^\{|\}$/,
+                expression: {
+                  pattern: /[\s\S]+/,
+                  alias: "language-qsharp",
+                  inside: Prism2.languages.qsharp
+                }
+              }
+            },
+            string: /[\s\S]+/
+          }
+        }
+      });
+    })(Prism);
+    Prism.languages.qs = Prism.languages.qsharp;
+  }
+  return qsharp_1;
+}
+var qsharpExports = requireQsharp();
+const qsharp = /* @__PURE__ */ getDefaultExportFromCjs(qsharpExports);
+const qsharp$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: qsharp
+}, [qsharpExports]);
+export {
+  qsharp$1 as q
+};
+//# sourceMappingURL=qsharp-rtfe_NYv.js.map

package/dist/qsharp-rtfe_NYv.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"qsharp-rtfe_NYv.js","sources":["../node_modules/refractor/lang/qsharp.js"],"sourcesContent":["'use strict'\n\nmodule.exports = qsharp\nqsharp.displayName = 'qsharp'\nqsharp.aliases = ['qs']\nfunction qsharp(Prism) {\n  ;(function (Prism) {\n    /**\n     * Replaces all placeholders \"<<n>>\" of given pattern with the n-th replacement (zero based).\n     *\n     * Note: This is a simple text based replacement. Be careful when using backreferences!\n     *\n     * @param {string} pattern the given pattern.\n     * @param {string[]} replacements a list of replacement which can be inserted into the given pattern.\n     * @returns {string} the pattern with all placeholders replaced with their corresponding replacements.\n     * @example replace(/a<<0>>a/.source, [/b+/.source]) === /a(?:b+)a/.source\n     */\n    function replace(pattern, replacements) {\n      return pattern.replace(/<<(\\d+)>>/g, function (m, index) {\n        return '(?:' + replacements[+index] + ')'\n      })\n    }\n    /**\n     * @param {string} pattern\n     * @param {string[]} replacements\n     * @param {string} [flags]\n     * @returns {RegExp}\n     */\n    function re(pattern, replacements, flags) {\n      return RegExp(replace(pattern, replacements), flags || '')\n    }\n    /**\n     * Creates a nested pattern where all occurrences of the string `<<self>>` are replaced with the pattern itself.\n     *\n     * @param {string} pattern\n     * @param {number} depthLog2\n     * @returns {string}\n     */\n    function nested(pattern, depthLog2) {\n      for (var i = 0; i < depthLog2; i++) {\n        pattern = pattern.replace(/<<self>>/g, function () {\n          return '(?:' + pattern + ')'\n        })\n      }\n      return pattern.replace(/<<self>>/g, '[^\\\\s\\\\S]')\n    } // https://docs.microsoft.com/en-us/azure/quantum/user-guide/language/typesystem/\n    // https://github.com/microsoft/qsharp-language/tree/main/Specifications/Language/5_Grammar\n    var keywordKinds = {\n      // keywords which represent a return or variable type\n      type: 'Adj BigInt Bool Ctl Double false Int One Pauli PauliI PauliX PauliY PauliZ Qubit Range Result String true Unit Zero',\n      // all other keywords\n      other:\n        'Adjoint adjoint apply as auto body borrow borrowing Controlled controlled distribute elif else fail fixup for function if in internal intrinsic invert is let mutable namespace new newtype open operation repeat return self set until use using while within'\n    } // keywords\n    function keywordsToPattern(words) {\n      return '\\\\b(?:' + words.trim().replace(/ /g, '|') + ')\\\\b'\n    }\n    var keywords = RegExp(\n      keywordsToPattern(keywordKinds.type + ' ' + keywordKinds.other)\n    ) // types\n    var identifier = /\\b[A-Za-z_]\\w*\\b/.source\n    var qualifiedName = replace(/<<0>>(?:\\s*\\.\\s*<<0>>)*/.source, [identifier])\n    var typeInside = {\n      keyword: keywords,\n      punctuation: /[<>()?,.:[\\]]/\n    } // strings\n    var regularString = /\"(?:\\\\.|[^\\\\\"])*\"/.source\n    Prism.languages.qsharp = Prism.languages.extend('clike', {\n      comment: /\\/\\/.*/,\n      string: [\n        {\n          pattern: re(/(^|[^$\\\\])<<0>>/.source, [regularString]),\n          lookbehind: true,\n          greedy: true\n        }\n      ],\n      'class-name': [\n        {\n          // open Microsoft.Quantum.Canon;\n          // open Microsoft.Quantum.Canon as CN;\n          pattern: re(/(\\b(?:as|open)\\s+)<<0>>(?=\\s*(?:;|as\\b))/.source, [\n            qualifiedName\n          ]),\n          lookbehind: true,\n          inside: typeInside\n        },\n        {\n          // namespace Quantum.App1;\n          pattern: re(/(\\bnamespace\\s+)<<0>>(?=\\s*\\{)/.source, [qualifiedName]),\n          lookbehind: true,\n          inside: typeInside\n        }\n      ],\n      keyword: keywords,\n      number:\n        /(?:\\b0(?:x[\\da-f]+|b[01]+|o[0-7]+)|(?:\\B\\.\\d+|\\b\\d+(?:\\.\\d*)?)(?:e[-+]?\\d+)?)l?\\b/i,\n      operator:\n        /\\band=|\\bor=|\\band\\b|\\bnot\\b|\\bor\\b|<[-=]|[-=]>|>>>=?|<<<=?|\\^\\^\\^=?|\\|\\|\\|=?|&&&=?|w\\/=?|~~~|[*\\/+\\-^=!%]=?/,\n      punctuation: /::|[{}[\\];(),.:]/\n    })\n    Prism.languages.insertBefore('qsharp', 'number', {\n      range: {\n        pattern: /\\.\\./,\n        alias: 'operator'\n      }\n    }) // single line\n    var interpolationExpr = nested(\n      replace(/\\{(?:[^\"{}]|<<0>>|<<self>>)*\\}/.source, [regularString]),\n      2\n    )\n    Prism.languages.insertBefore('qsharp', 'string', {\n      'interpolation-string': {\n        pattern: re(/\\$\"(?:\\\\.|<<0>>|[^\\\\\"{])*\"/.source, [interpolationExpr]),\n        greedy: true,\n        inside: {\n          interpolation: {\n            pattern: re(/((?:^|[^\\\\])(?:\\\\\\\\)*)<<0>>/.source, [\n              interpolationExpr\n            ]),\n            lookbehind: true,\n            inside: {\n              punctuation: /^\\{|\\}$/,\n              expression: {\n                pattern: /[\\s\\S]+/,\n                alias: 'language-qsharp',\n                inside: Prism.languages.qsharp\n              }\n            }\n          },\n          string: /[\\s\\S]+/\n        }\n      }\n    })\n  })(Prism)\n  Prism.languages.qs = Prism.languages.qsharp\n}\n"],"names":["qsharp","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,aAAiBA;AACjB,EAAAA,QAAO,cAAc;AACrB,EAAAA,QAAO,UAAU,CAAC,IAAI;AACtB,WAASA,QAAO,OAAO;AACpB,KAAC,SAAUC,QAAO;AAWjB,eAAS,QAAQ,SAAS,cAAc;AACtC,eAAO,QAAQ,QAAQ,cAAc,SAAU,GAAG,OAAO;AACvD,iBAAO,QAAQ,aAAa,CAAC,KAAK,IAAI;AAAA,QAC9C,CAAO;AAAA,MACP;AAOI,eAAS,GAAG,SAAS,cAAc,OAAO;AACxC,eAAO,OAAO,QAAQ,SAAS,YAAY,GAAY,EAAE;AAAA,MAC/D;AAQI,eAAS,OAAO,SAAS,WAAW;AAClC,iBAAS,IAAI,GAAG,IAAI,WAAW,KAAK;AAClC,oBAAU,QAAQ,QAAQ,aAAa,WAAY;AACjD,mBAAO,QAAQ,UAAU;AAAA,UACnC,CAAS;AAAA,QACT;AACM,eAAO,QAAQ,QAAQ,aAAa,WAAW;AAAA,MACrD;AAEI,UAAI,eAAe;AAAA;AAAA,QAEjB,MAAM;AAAA;AAAA,QAEN,OACE;AAAA;AAEJ,eAAS,kBAAkB,OAAO;AAChC,eAAO,WAAW,MAAM,KAAI,EAAG,QAAQ,MAAM,GAAG,IAAI;AAAA,MAC1D;AACI,UAAI,WAAW;AAAA,QACb,kBAAkB,aAAa,OAAO,MAAM,aAAa,KAAK;AAAA;AAEhE,UAAI,aAAa,mBAAmB;AACpC,UAAI,gBAAgB,QAAQ,0BAA0B,QAAQ,CAAC,UAAU,CAAC;AAC1E,UAAI,aAAa;AAAA,QACf,SAAS;AAAA,QACT,aAAa;AAAA;AAEf,UAAI,gBAAgB,oBAAoB;AACxC,MAAAA,OAAM,UAAU,SAASA,OAAM,UAAU,OAAO,SAAS;AAAA,QACvD,SAAS;AAAA,QACT,QAAQ;AAAA,UACN;AAAA,YACE,SAAS,GAAG,kBAAkB,QAAQ,CAAC,aAAa,CAAC;AAAA,YACrD,YAAY;AAAA,YACZ,QAAQ;AAAA;;QAGZ,cAAc;AAAA,UACZ;AAAA;AAAA;AAAA,YAGE,SAAS,GAAG,2CAA2C,QAAQ;AAAA,cAC7D;AAAA,YACZ,CAAW;AAAA,YACD,YAAY;AAAA,YACZ,QAAQ;AAAA;UAEV;AAAA;AAAA,YAEE,SAAS,GAAG,iCAAiC,QAAQ,CAAC,aAAa,CAAC;AAAA,YACpE,YAAY;AAAA,YACZ,QAAQ;AAAA;;QAGZ,SAAS;AAAA,QACT,QACE;AAAA,QACF,UACE;AAAA,QACF,aAAa;AAAA,MACnB,CAAK;AACD,MAAAA,OAAM,UAAU,aAAa,UAAU,UAAU;AAAA,QAC/C,OAAO;AAAA,UACL,SAAS;AAAA,UACT,OAAO;AAAA;MAEf,CAAK;AACD,UAAI,oBAAoB;AAAA,QACtB,QAAQ,iCAAiC,QAAQ,CAAC,aAAa,CAAC;AAAA,QAChE;AAAA;AAEF,MAAAA,OAAM,UAAU,aAAa,UAAU,UAAU;AAAA,QAC/C,wBAAwB;AAAA,UACtB,SAAS,GAAG,6BAA6B,QAAQ,CAAC,iBAAiB,CAAC;AAAA,UACpE,QAAQ;AAAA,UACR,QAAQ;AAAA,YACN,eAAe;AAAA,cACb,SAAS,GAAG,8BAA8B,QAAQ;AAAA,gBAChD;AAAA,cACd,CAAa;AAAA,cACD,YAAY;AAAA,cACZ,QAAQ;AAAA,gBACN,aAAa;AAAA,gBACb,YAAY;AAAA,kBACV,SAAS;AAAA,kBACT,OAAO;AAAA,kBACP,QAAQA,OAAM,UAAU;AAAA;;;YAI9B,QAAQ;AAAA;;MAGlB,CAAK;AAAA,IACL,GAAK,KAAK;AACR,UAAM,UAAU,KAAK,MAAM,UAAU;AAAA,EACvC;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/r-CqF54G5x.js

@@ -0,0 +1,64 @@
+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 r_1;
+var hasRequiredR;
+function requireR() {
+  if (hasRequiredR) return r_1;
+  hasRequiredR = 1;
+  r_1 = r2;
+  r2.displayName = "r";
+  r2.aliases = [];
+  function r2(Prism) {
+    Prism.languages.r = {
+      comment: /#.*/,
+      string: {
+        pattern: /(['"])(?:\\.|(?!\1)[^\\\r\n])*\1/,
+        greedy: true
+      },
+      "percent-operator": {
+        // Includes user-defined operators
+        // and %%, %*%, %/%, %in%, %o%, %x%
+        pattern: /%[^%\s]*%/,
+        alias: "operator"
+      },
+      boolean: /\b(?:FALSE|TRUE)\b/,
+      ellipsis: /\.\.(?:\.|\d+)/,
+      number: [
+        /\b(?:Inf|NaN)\b/,
+        /(?:\b0x[\dA-Fa-f]+(?:\.\d*)?|\b\d+(?:\.\d*)?|\B\.\d+)(?:[EePp][+-]?\d+)?[iL]?/
+      ],
+      keyword: /\b(?:NA|NA_character_|NA_complex_|NA_integer_|NA_real_|NULL|break|else|for|function|if|in|next|repeat|while)\b/,
+      operator: /->?>?|<(?:=|<?-)?|[>=!]=?|::?|&&?|\|\|?|[+*\/^$@~]/,
+      punctuation: /[(){}\[\],;]/
+    };
+  }
+  return r_1;
+}
+var rExports = requireR();
+const r = /* @__PURE__ */ getDefaultExportFromCjs(rExports);
+const r$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: r
+}, [rExports]);
+export {
+  r$1 as r
+};
+//# sourceMappingURL=r-CqF54G5x.js.map

package/dist/r-CqF54G5x.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"r-CqF54G5x.js","sources":["../node_modules/refractor/lang/r.js"],"sourcesContent":["'use strict'\n\nmodule.exports = r\nr.displayName = 'r'\nr.aliases = []\nfunction r(Prism) {\n  Prism.languages.r = {\n    comment: /#.*/,\n    string: {\n      pattern: /(['\"])(?:\\\\.|(?!\\1)[^\\\\\\r\\n])*\\1/,\n      greedy: true\n    },\n    'percent-operator': {\n      // Includes user-defined operators\n      // and %%, %*%, %/%, %in%, %o%, %x%\n      pattern: /%[^%\\s]*%/,\n      alias: 'operator'\n    },\n    boolean: /\\b(?:FALSE|TRUE)\\b/,\n    ellipsis: /\\.\\.(?:\\.|\\d+)/,\n    number: [\n      /\\b(?:Inf|NaN)\\b/,\n      /(?:\\b0x[\\dA-Fa-f]+(?:\\.\\d*)?|\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:[EePp][+-]?\\d+)?[iL]?/\n    ],\n    keyword:\n      /\\b(?:NA|NA_character_|NA_complex_|NA_integer_|NA_real_|NULL|break|else|for|function|if|in|next|repeat|while)\\b/,\n    operator: /->?>?|<(?:=|<?-)?|[>=!]=?|::?|&&?|\\|\\|?|[+*\\/^$@~]/,\n    punctuation: /[(){}\\[\\],;]/\n  }\n}\n"],"names":["r"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,QAAiBA;AACjB,EAAAA,GAAE,cAAc;AAChB,EAAAA,GAAE,UAAU,CAAA;AACZ,WAASA,GAAE,OAAO;AAChB,UAAM,UAAU,IAAI;AAAA,MAClB,SAAS;AAAA,MACT,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,oBAAoB;AAAA;AAAA;AAAA,QAGlB,SAAS;AAAA,QACT,OAAO;AAAA;MAET,SAAS;AAAA,MACT,UAAU;AAAA,MACV,QAAQ;AAAA,QACN;AAAA,QACA;AAAA;MAEF,SACE;AAAA,MACF,UAAU;AAAA,MACV,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/racket-CCoPKUn5.js

@@ -0,0 +1,61 @@
+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 racket_1;
+var hasRequiredRacket;
+function requireRacket() {
+  if (hasRequiredRacket) return racket_1;
+  hasRequiredRacket = 1;
+  var refractorScheme = requireScheme();
+  racket_1 = racket2;
+  racket2.displayName = "racket";
+  racket2.aliases = ["rkt"];
+  function racket2(Prism) {
+    Prism.register(refractorScheme);
+    Prism.languages.racket = Prism.languages.extend("scheme", {
+      "lambda-parameter": {
+        // the racket lambda syntax is a lot more complex, so we won't even attempt to capture it.
+        // this will just prevent false positives of the `function` pattern
+        pattern: /([(\[]lambda\s+[(\[])[^()\[\]'\s]+/,
+        lookbehind: true
+      }
+    });
+    Prism.languages.insertBefore("racket", "string", {
+      lang: {
+        pattern: /^#lang.+/m,
+        greedy: true,
+        alias: "keyword"
+      }
+    });
+    Prism.languages.rkt = Prism.languages.racket;
+  }
+  return racket_1;
+}
+var racketExports = requireRacket();
+const racket = /* @__PURE__ */ getDefaultExportFromCjs(racketExports);
+const racket$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: racket
+}, [racketExports]);
+export {
+  racket$1 as r
+};
+//# sourceMappingURL=racket-CCoPKUn5.js.map

package/dist/racket-CCoPKUn5.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"racket-CCoPKUn5.js","sources":["../node_modules/refractor/lang/racket.js"],"sourcesContent":["'use strict'\nvar refractorScheme = require('./scheme.js')\nmodule.exports = racket\nracket.displayName = 'racket'\nracket.aliases = ['rkt']\nfunction racket(Prism) {\n  Prism.register(refractorScheme)\n  Prism.languages.racket = Prism.languages.extend('scheme', {\n    'lambda-parameter': {\n      // the racket lambda syntax is a lot more complex, so we won't even attempt to capture it.\n      // this will just prevent false positives of the `function` pattern\n      pattern: /([(\\[]lambda\\s+[(\\[])[^()\\[\\]'\\s]+/,\n      lookbehind: true\n    }\n  })\n  Prism.languages.insertBefore('racket', 'string', {\n    lang: {\n      pattern: /^#lang.+/m,\n      greedy: true,\n      alias: 'keyword'\n    }\n  })\n  Prism.languages.rkt = Prism.languages.racket\n}\n"],"names":["require$$0","racket"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AACA,MAAI,kBAAkBA,cAAA;AACtB,aAAiBC;AACjB,EAAAA,QAAO,cAAc;AACrB,EAAAA,QAAO,UAAU,CAAC,KAAK;AACvB,WAASA,QAAO,OAAO;AACrB,UAAM,SAAS,eAAe;AAC9B,UAAM,UAAU,SAAS,MAAM,UAAU,OAAO,UAAU;AAAA,MACxD,oBAAoB;AAAA;AAAA;AAAA,QAGlB,SAAS;AAAA,QACT,YAAY;AAAA;IAElB,CAAG;AACD,UAAM,UAAU,aAAa,UAAU,UAAU;AAAA,MAC/C,MAAM;AAAA,QACJ,SAAS;AAAA,QACT,QAAQ;AAAA,QACR,OAAO;AAAA;IAEb,CAAG;AACD,UAAM,UAAU,MAAM,MAAM,UAAU;AAAA,EACxC;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/reason-CHBEgDgk.js

@@ -0,0 +1,65 @@
+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 reason_1;
+var hasRequiredReason;
+function requireReason() {
+  if (hasRequiredReason) return reason_1;
+  hasRequiredReason = 1;
+  reason_1 = reason2;
+  reason2.displayName = "reason";
+  reason2.aliases = [];
+  function reason2(Prism) {
+    Prism.languages.reason = Prism.languages.extend("clike", {
+      string: {
+        pattern: /"(?:\\(?:\r\n|[\s\S])|[^\\\r\n"])*"/,
+        greedy: true
+      },
+      // 'class-name' must be matched *after* 'constructor' defined below
+      "class-name": /\b[A-Z]\w*/,
+      keyword: /\b(?:and|as|assert|begin|class|constraint|do|done|downto|else|end|exception|external|for|fun|function|functor|if|in|include|inherit|initializer|lazy|let|method|module|mutable|new|nonrec|object|of|open|or|private|rec|sig|struct|switch|then|to|try|type|val|virtual|when|while|with)\b/,
+      operator: /\.{3}|:[:=]|\|>|->|=(?:==?|>)?|<=?|>=?|[|^?'#!~`]|[+\-*\/]\.?|\b(?:asr|land|lor|lsl|lsr|lxor|mod)\b/
+    });
+    Prism.languages.insertBefore("reason", "class-name", {
+      char: {
+        pattern: /'(?:\\x[\da-f]{2}|\\o[0-3][0-7][0-7]|\\\d{3}|\\.|[^'\\\r\n])'/,
+        greedy: true
+      },
+      // Negative look-ahead prevents from matching things like String.capitalize
+      constructor: /\b[A-Z]\w*\b(?!\s*\.)/,
+      label: {
+        pattern: /\b[a-z]\w*(?=::)/,
+        alias: "symbol"
+      }
+    });
+    delete Prism.languages.reason.function;
+  }
+  return reason_1;
+}
+var reasonExports = requireReason();
+const reason = /* @__PURE__ */ getDefaultExportFromCjs(reasonExports);
+const reason$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: reason
+}, [reasonExports]);
+export {
+  reason$1 as r
+};
+//# sourceMappingURL=reason-CHBEgDgk.js.map

package/dist/reason-CHBEgDgk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reason-CHBEgDgk.js","sources":["../node_modules/refractor/lang/reason.js"],"sourcesContent":["'use strict'\n\nmodule.exports = reason\nreason.displayName = 'reason'\nreason.aliases = []\nfunction reason(Prism) {\n  Prism.languages.reason = Prism.languages.extend('clike', {\n    string: {\n      pattern: /\"(?:\\\\(?:\\r\\n|[\\s\\S])|[^\\\\\\r\\n\"])*\"/,\n      greedy: true\n    },\n    // 'class-name' must be matched *after* 'constructor' defined below\n    'class-name': /\\b[A-Z]\\w*/,\n    keyword:\n      /\\b(?:and|as|assert|begin|class|constraint|do|done|downto|else|end|exception|external|for|fun|function|functor|if|in|include|inherit|initializer|lazy|let|method|module|mutable|new|nonrec|object|of|open|or|private|rec|sig|struct|switch|then|to|try|type|val|virtual|when|while|with)\\b/,\n    operator:\n      /\\.{3}|:[:=]|\\|>|->|=(?:==?|>)?|<=?|>=?|[|^?'#!~`]|[+\\-*\\/]\\.?|\\b(?:asr|land|lor|lsl|lsr|lxor|mod)\\b/\n  })\n  Prism.languages.insertBefore('reason', 'class-name', {\n    char: {\n      pattern: /'(?:\\\\x[\\da-f]{2}|\\\\o[0-3][0-7][0-7]|\\\\\\d{3}|\\\\.|[^'\\\\\\r\\n])'/,\n      greedy: true\n    },\n    // Negative look-ahead prevents from matching things like String.capitalize\n    constructor: /\\b[A-Z]\\w*\\b(?!\\s*\\.)/,\n    label: {\n      pattern: /\\b[a-z]\\w*(?=::)/,\n      alias: 'symbol'\n    }\n  }) // We can't match functions property, so let's not even try.\n  delete Prism.languages.reason.function\n}\n"],"names":["reason"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,aAAiBA;AACjB,EAAAA,QAAO,cAAc;AACrB,EAAAA,QAAO,UAAU,CAAA;AACjB,WAASA,QAAO,OAAO;AACrB,UAAM,UAAU,SAAS,MAAM,UAAU,OAAO,SAAS;AAAA,MACvD,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;;MAGV,cAAc;AAAA,MACd,SACE;AAAA,MACF,UACE;AAAA,IACN,CAAG;AACD,UAAM,UAAU,aAAa,UAAU,cAAc;AAAA,MACnD,MAAM;AAAA,QACJ,SAAS;AAAA,QACT,QAAQ;AAAA;;MAGV,aAAa;AAAA,MACb,OAAO;AAAA,QACL,SAAS;AAAA,QACT,OAAO;AAAA;IAEb,CAAG;AACD,WAAO,MAAM,UAAU,OAAO;AAAA,EAChC;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/regex-wHof4onn.js

@@ -0,0 +1,139 @@
+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 regex_1;
+var hasRequiredRegex;
+function requireRegex() {
+  if (hasRequiredRegex) return regex_1;
+  hasRequiredRegex = 1;
+  regex_1 = regex2;
+  regex2.displayName = "regex";
+  regex2.aliases = [];
+  function regex2(Prism) {
+    (function(Prism2) {
+      var specialEscape = {
+        pattern: /\\[\\(){}[\]^$+*?|.]/,
+        alias: "escape"
+      };
+      var escape = /\\(?:x[\da-fA-F]{2}|u[\da-fA-F]{4}|u\{[\da-fA-F]+\}|0[0-7]{0,2}|[123][0-7]{2}|c[a-zA-Z]|.)/;
+      var charSet = {
+        pattern: /\.|\\[wsd]|\\p\{[^{}]+\}/i,
+        alias: "class-name"
+      };
+      var charSetWithoutDot = {
+        pattern: /\\[wsd]|\\p\{[^{}]+\}/i,
+        alias: "class-name"
+      };
+      var rangeChar = "(?:[^\\\\-]|" + escape.source + ")";
+      var range = RegExp(rangeChar + "-" + rangeChar);
+      var groupName = {
+        pattern: /(<|')[^<>']+(?=[>']$)/,
+        lookbehind: true,
+        alias: "variable"
+      };
+      Prism2.languages.regex = {
+        "char-class": {
+          pattern: /((?:^|[^\\])(?:\\\\)*)\[(?:[^\\\]]|\\[\s\S])*\]/,
+          lookbehind: true,
+          inside: {
+            "char-class-negation": {
+              pattern: /(^\[)\^/,
+              lookbehind: true,
+              alias: "operator"
+            },
+            "char-class-punctuation": {
+              pattern: /^\[|\]$/,
+              alias: "punctuation"
+            },
+            range: {
+              pattern: range,
+              inside: {
+                escape,
+                "range-punctuation": {
+                  pattern: /-/,
+                  alias: "operator"
+                }
+              }
+            },
+            "special-escape": specialEscape,
+            "char-set": charSetWithoutDot,
+            escape
+          }
+        },
+        "special-escape": specialEscape,
+        "char-set": charSet,
+        backreference: [
+          {
+            // a backreference which is not an octal escape
+            pattern: /\\(?![123][0-7]{2})[1-9]/,
+            alias: "keyword"
+          },
+          {
+            pattern: /\\k<[^<>']+>/,
+            alias: "keyword",
+            inside: {
+              "group-name": groupName
+            }
+          }
+        ],
+        anchor: {
+          pattern: /[$^]|\\[ABbGZz]/,
+          alias: "function"
+        },
+        escape,
+        group: [
+          {
+            // https://docs.oracle.com/javase/10/docs/api/java/util/regex/Pattern.html
+            // https://docs.microsoft.com/en-us/dotnet/standard/base-types/regular-expression-language-quick-reference?view=netframework-4.7.2#grouping-constructs
+            // (), (?<name>), (?'name'), (?>), (?:), (?=), (?!), (?<=), (?<!), (?is-m), (?i-m:)
+            pattern: /\((?:\?(?:<[^<>']+>|'[^<>']+'|[>:]|<?[=!]|[idmnsuxU]+(?:-[idmnsuxU]+)?:?))?/,
+            alias: "punctuation",
+            inside: {
+              "group-name": groupName
+            }
+          },
+          {
+            pattern: /\)/,
+            alias: "punctuation"
+          }
+        ],
+        quantifier: {
+          pattern: /(?:[+*?]|\{\d+(?:,\d*)?\})[?+]?/,
+          alias: "number"
+        },
+        alternation: {
+          pattern: /\|/,
+          alias: "keyword"
+        }
+      };
+    })(Prism);
+  }
+  return regex_1;
+}
+var regexExports = requireRegex();
+const regex = /* @__PURE__ */ getDefaultExportFromCjs(regexExports);
+const regex$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: regex
+}, [regexExports]);
+export {
+  regex$1 as r
+};
+//# sourceMappingURL=regex-wHof4onn.js.map

package/dist/regex-wHof4onn.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"regex-wHof4onn.js","sources":["../node_modules/refractor/lang/regex.js"],"sourcesContent":["'use strict'\n\nmodule.exports = regex\nregex.displayName = 'regex'\nregex.aliases = []\nfunction regex(Prism) {\n  ;(function (Prism) {\n    var specialEscape = {\n      pattern: /\\\\[\\\\(){}[\\]^$+*?|.]/,\n      alias: 'escape'\n    }\n    var escape =\n      /\\\\(?:x[\\da-fA-F]{2}|u[\\da-fA-F]{4}|u\\{[\\da-fA-F]+\\}|0[0-7]{0,2}|[123][0-7]{2}|c[a-zA-Z]|.)/\n    var charSet = {\n      pattern: /\\.|\\\\[wsd]|\\\\p\\{[^{}]+\\}/i,\n      alias: 'class-name'\n    }\n    var charSetWithoutDot = {\n      pattern: /\\\\[wsd]|\\\\p\\{[^{}]+\\}/i,\n      alias: 'class-name'\n    }\n    var rangeChar = '(?:[^\\\\\\\\-]|' + escape.source + ')'\n    var range = RegExp(rangeChar + '-' + rangeChar) // the name of a capturing group\n    var groupName = {\n      pattern: /(<|')[^<>']+(?=[>']$)/,\n      lookbehind: true,\n      alias: 'variable'\n    }\n    Prism.languages.regex = {\n      'char-class': {\n        pattern: /((?:^|[^\\\\])(?:\\\\\\\\)*)\\[(?:[^\\\\\\]]|\\\\[\\s\\S])*\\]/,\n        lookbehind: true,\n        inside: {\n          'char-class-negation': {\n            pattern: /(^\\[)\\^/,\n            lookbehind: true,\n            alias: 'operator'\n          },\n          'char-class-punctuation': {\n            pattern: /^\\[|\\]$/,\n            alias: 'punctuation'\n          },\n          range: {\n            pattern: range,\n            inside: {\n              escape: escape,\n              'range-punctuation': {\n                pattern: /-/,\n                alias: 'operator'\n              }\n            }\n          },\n          'special-escape': specialEscape,\n          'char-set': charSetWithoutDot,\n          escape: escape\n        }\n      },\n      'special-escape': specialEscape,\n      'char-set': charSet,\n      backreference: [\n        {\n          // a backreference which is not an octal escape\n          pattern: /\\\\(?![123][0-7]{2})[1-9]/,\n          alias: 'keyword'\n        },\n        {\n          pattern: /\\\\k<[^<>']+>/,\n          alias: 'keyword',\n          inside: {\n            'group-name': groupName\n          }\n        }\n      ],\n      anchor: {\n        pattern: /[$^]|\\\\[ABbGZz]/,\n        alias: 'function'\n      },\n      escape: escape,\n      group: [\n        {\n          // https://docs.oracle.com/javase/10/docs/api/java/util/regex/Pattern.html\n          // https://docs.microsoft.com/en-us/dotnet/standard/base-types/regular-expression-language-quick-reference?view=netframework-4.7.2#grouping-constructs\n          // (), (?<name>), (?'name'), (?>), (?:), (?=), (?!), (?<=), (?<!), (?is-m), (?i-m:)\n          pattern:\n            /\\((?:\\?(?:<[^<>']+>|'[^<>']+'|[>:]|<?[=!]|[idmnsuxU]+(?:-[idmnsuxU]+)?:?))?/,\n          alias: 'punctuation',\n          inside: {\n            'group-name': groupName\n          }\n        },\n        {\n          pattern: /\\)/,\n          alias: 'punctuation'\n        }\n      ],\n      quantifier: {\n        pattern: /(?:[+*?]|\\{\\d+(?:,\\d*)?\\})[?+]?/,\n        alias: 'number'\n      },\n      alternation: {\n        pattern: /\\|/,\n        alias: 'keyword'\n      }\n    }\n  })(Prism)\n}\n"],"names":["regex","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,YAAiBA;AACjB,EAAAA,OAAM,cAAc;AACpB,EAAAA,OAAM,UAAU,CAAA;AAChB,WAASA,OAAM,OAAO;AACnB,KAAC,SAAUC,QAAO;AACjB,UAAI,gBAAgB;AAAA,QAClB,SAAS;AAAA,QACT,OAAO;AAAA;AAET,UAAI,SACF;AACF,UAAI,UAAU;AAAA,QACZ,SAAS;AAAA,QACT,OAAO;AAAA;AAET,UAAI,oBAAoB;AAAA,QACtB,SAAS;AAAA,QACT,OAAO;AAAA;AAET,UAAI,YAAY,iBAAiB,OAAO,SAAS;AACjD,UAAI,QAAQ,OAAO,YAAY,MAAM,SAAS;AAC9C,UAAI,YAAY;AAAA,QACd,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,OAAO;AAAA;AAET,MAAAA,OAAM,UAAU,QAAQ;AAAA,QACtB,cAAc;AAAA,UACZ,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,QAAQ;AAAA,YACN,uBAAuB;AAAA,cACrB,SAAS;AAAA,cACT,YAAY;AAAA,cACZ,OAAO;AAAA;YAET,0BAA0B;AAAA,cACxB,SAAS;AAAA,cACT,OAAO;AAAA;YAET,OAAO;AAAA,cACL,SAAS;AAAA,cACT,QAAQ;AAAA,gBACN;AAAA,gBACA,qBAAqB;AAAA,kBACnB,SAAS;AAAA,kBACT,OAAO;AAAA;;;YAIb,kBAAkB;AAAA,YAClB,YAAY;AAAA,YACZ;AAAA;;QAGJ,kBAAkB;AAAA,QAClB,YAAY;AAAA,QACZ,eAAe;AAAA,UACb;AAAA;AAAA,YAEE,SAAS;AAAA,YACT,OAAO;AAAA;UAET;AAAA,YACE,SAAS;AAAA,YACT,OAAO;AAAA,YACP,QAAQ;AAAA,cACN,cAAc;AAAA;;;QAIpB,QAAQ;AAAA,UACN,SAAS;AAAA,UACT,OAAO;AAAA;QAET;AAAA,QACA,OAAO;AAAA,UACL;AAAA;AAAA;AAAA;AAAA,YAIE,SACE;AAAA,YACF,OAAO;AAAA,YACP,QAAQ;AAAA,cACN,cAAc;AAAA;;UAGlB;AAAA,YACE,SAAS;AAAA,YACT,OAAO;AAAA;;QAGX,YAAY;AAAA,UACV,SAAS;AAAA,UACT,OAAO;AAAA;QAET,aAAa;AAAA,UACX,SAAS;AAAA,UACT,OAAO;AAAA;;IAGf,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/rego-ClQwoJuz.js

@@ -0,0 +1,67 @@
+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 rego_1;
+var hasRequiredRego;
+function requireRego() {
+  if (hasRequiredRego) return rego_1;
+  hasRequiredRego = 1;
+  rego_1 = rego2;
+  rego2.displayName = "rego";
+  rego2.aliases = [];
+  function rego2(Prism) {
+    Prism.languages.rego = {
+      comment: /#.*/,
+      property: {
+        pattern: /(^|[^\\.])(?:"(?:\\.|[^\\"\r\n])*"|`[^`]*`|\b[a-z_]\w*\b)(?=\s*:(?!=))/i,
+        lookbehind: true,
+        greedy: true
+      },
+      string: {
+        pattern: /(^|[^\\])"(?:\\.|[^\\"\r\n])*"|`[^`]*`/,
+        lookbehind: true,
+        greedy: true
+      },
+      keyword: /\b(?:as|default|else|import|not|null|package|set(?=\s*\()|some|with)\b/,
+      boolean: /\b(?:false|true)\b/,
+      function: {
+        pattern: /\b[a-z_]\w*\b(?:\s*\.\s*\b[a-z_]\w*\b)*(?=\s*\()/i,
+        inside: {
+          namespace: /\b\w+\b(?=\s*\.)/,
+          punctuation: /\./
+        }
+      },
+      number: /-?\b\d+(?:\.\d+)?(?:e[+-]?\d+)?\b/i,
+      operator: /[-+*/%|&]|[<>:=]=?|!=|\b_\b/,
+      punctuation: /[,;.\[\]{}()]/
+    };
+  }
+  return rego_1;
+}
+var regoExports = requireRego();
+const rego = /* @__PURE__ */ getDefaultExportFromCjs(regoExports);
+const rego$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: rego
+}, [regoExports]);
+export {
+  rego$1 as r
+};
+//# sourceMappingURL=rego-ClQwoJuz.js.map

package/dist/rego-ClQwoJuz.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rego-ClQwoJuz.js","sources":["../node_modules/refractor/lang/rego.js"],"sourcesContent":["'use strict'\n\nmodule.exports = rego\nrego.displayName = 'rego'\nrego.aliases = []\nfunction rego(Prism) {\n  // https://www.openpolicyagent.org/docs/latest/policy-reference/\n  Prism.languages.rego = {\n    comment: /#.*/,\n    property: {\n      pattern:\n        /(^|[^\\\\.])(?:\"(?:\\\\.|[^\\\\\"\\r\\n])*\"|`[^`]*`|\\b[a-z_]\\w*\\b)(?=\\s*:(?!=))/i,\n      lookbehind: true,\n      greedy: true\n    },\n    string: {\n      pattern: /(^|[^\\\\])\"(?:\\\\.|[^\\\\\"\\r\\n])*\"|`[^`]*`/,\n      lookbehind: true,\n      greedy: true\n    },\n    keyword:\n      /\\b(?:as|default|else|import|not|null|package|set(?=\\s*\\()|some|with)\\b/,\n    boolean: /\\b(?:false|true)\\b/,\n    function: {\n      pattern: /\\b[a-z_]\\w*\\b(?:\\s*\\.\\s*\\b[a-z_]\\w*\\b)*(?=\\s*\\()/i,\n      inside: {\n        namespace: /\\b\\w+\\b(?=\\s*\\.)/,\n        punctuation: /\\./\n      }\n    },\n    number: /-?\\b\\d+(?:\\.\\d+)?(?:e[+-]?\\d+)?\\b/i,\n    operator: /[-+*/%|&]|[<>:=]=?|!=|\\b_\\b/,\n    punctuation: /[,;.\\[\\]{}()]/\n  }\n}\n"],"names":["rego"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,WAAiBA;AACjB,EAAAA,MAAK,cAAc;AACnB,EAAAA,MAAK,UAAU,CAAA;AACf,WAASA,MAAK,OAAO;AAEnB,UAAM,UAAU,OAAO;AAAA,MACrB,SAAS;AAAA,MACT,UAAU;AAAA,QACR,SACE;AAAA,QACF,YAAY;AAAA,QACZ,QAAQ;AAAA;MAEV,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,QAAQ;AAAA;MAEV,SACE;AAAA,MACF,SAAS;AAAA,MACT,UAAU;AAAA,QACR,SAAS;AAAA,QACT,QAAQ;AAAA,UACN,WAAW;AAAA,UACX,aAAa;AAAA;;MAGjB,QAAQ;AAAA,MACR,UAAU;AAAA,MACV,aAAa;AAAA;EAEjB;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/renpy-CJmFfTdl.js

@@ -0,0 +1,61 @@
+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 renpy_1;
+var hasRequiredRenpy;
+function requireRenpy() {
+  if (hasRequiredRenpy) return renpy_1;
+  hasRequiredRenpy = 1;
+  renpy_1 = renpy2;
+  renpy2.displayName = "renpy";
+  renpy2.aliases = ["rpy"];
+  function renpy2(Prism) {
+    Prism.languages.renpy = {
+      comment: {
+        pattern: /(^|[^\\])#.+/,
+        lookbehind: true
+      },
+      string: {
+        pattern: /("""|''')[\s\S]+?\1|("|')(?:\\.|(?!\2)[^\\])*\2|(?:^#?(?:(?:[0-9a-fA-F]){3}|[0-9a-fA-F]{6})$)/m,
+        greedy: true
+      },
+      function: /\b[a-z_]\w*(?=\()/i,
+      property: /\b(?:Update|UpdateVersion|action|activate_sound|adv_nvl_transition|after_load_transition|align|alpha|alt|anchor|antialias|area|auto|background|bar_invert|bar_resizing|bar_vertical|black_color|bold|bottom_bar|bottom_gutter|bottom_margin|bottom_padding|box_reverse|box_wrap|can_update|caret|child|color|crop|default_afm_enable|default_afm_time|default_fullscreen|default_text_cps|developer|directory_name|drag_handle|drag_joined|drag_name|drag_raise|draggable|dragged|drop_shadow|drop_shadow_color|droppable|dropped|easein|easeout|edgescroll|end_game_transition|end_splash_transition|enter_replay_transition|enter_sound|enter_transition|enter_yesno_transition|executable_name|exit_replay_transition|exit_sound|exit_transition|exit_yesno_transition|fadein|fadeout|first_indent|first_spacing|fit_first|focus|focus_mask|font|foreground|game_main_transition|get_installed_packages|google_play_key|google_play_salt|ground|has_music|has_sound|has_voice|height|help|hinting|hover|hover_background|hover_color|hover_sound|hovered|hyperlink_functions|idle|idle_color|image_style|include_update|insensitive|insensitive_background|insensitive_color|inside|intra_transition|italic|justify|kerning|keyboard_focus|language|layer_clipping|layers|layout|left_bar|left_gutter|left_margin|left_padding|length|line_leading|line_overlap_split|line_spacing|linear|main_game_transition|main_menu_music|maximum|min_width|minimum|minwidth|modal|mouse|mousewheel|name|narrator_menu|newline_indent|nvl_adv_transition|offset|order_reverse|outlines|overlay_functions|pos|position|prefix|radius|range|rest_indent|right_bar|right_gutter|right_margin|right_padding|rotate|rotate_pad|ruby_style|sample_sound|save_directory|say_attribute_transition|screen_height|screen_width|scrollbars|selected_hover|selected_hover_color|selected_idle|selected_idle_color|selected_insensitive|show_side_image|show_two_window|side_spacing|side_xpos|side_ypos|size|size_group|slow_cps|slow_cps_multiplier|spacing|strikethrough|subpixel|text_align|text_style|text_xpos|text_y_fudge|text_ypos|thumb|thumb_offset|thumb_shadow|thumbnail_height|thumbnail_width|time|top_bar|top_gutter|top_margin|top_padding|translations|underline|unscrollable|update|value|version|version_name|version_tuple|vertical|width|window_hide_transition|window_icon|window_left_padding|window_show_transition|window_title|windows_icon|xadjustment|xalign|xanchor|xanchoraround|xaround|xcenter|xfill|xinitial|xmargin|xmaximum|xminimum|xoffset|xofsset|xpadding|xpos|xsize|xzoom|yadjustment|yalign|yanchor|yanchoraround|yaround|ycenter|yfill|yinitial|ymargin|ymaximum|yminimum|yoffset|ypadding|ypos|ysize|ysizexysize|yzoom|zoom|zorder)\b/,
+      tag: /\b(?:bar|block|button|buttoscreenn|drag|draggroup|fixed|frame|grid|[hv]box|hotbar|hotspot|image|imagebutton|imagemap|input|key|label|menu|mm_menu_frame|mousearea|nvl|parallel|screen|self|side|tag|text|textbutton|timer|vbar|viewport|window)\b|\$/,
+      keyword: /\b(?:None|add|adjustment|alignaround|allow|angle|animation|around|as|assert|behind|box_layout|break|build|cache|call|center|changed|child_size|choice|circles|class|clear|clicked|clipping|clockwise|config|contains|continue|corner1|corner2|counterclockwise|def|default|define|del|delay|disabled|disabled_text|dissolve|elif|else|event|except|exclude|exec|expression|fade|finally|for|from|function|global|gm_root|has|hide|id|if|import|in|init|is|jump|knot|lambda|left|less_rounded|mm_root|movie|music|null|on|onlayer|pass|pause|persistent|play|print|python|queue|raise|random|renpy|repeat|return|right|rounded_window|scene|scope|set|show|slow|slow_abortable|slow_done|sound|stop|store|style|style_group|substitute|suffix|theme|transform|transform_anchor|transpose|try|ui|unhovered|updater|use|voice|while|widget|widget_hover|widget_selected|widget_text|yield)\b/,
+      boolean: /\b(?:[Ff]alse|[Tt]rue)\b/,
+      number: /(?:\b(?:0[bo])?(?:(?:\d|0x[\da-f])[\da-f]*(?:\.\d*)?)|\B\.\d+)(?:e[+-]?\d+)?j?/i,
+      operator: /[-+%=]=?|!=|\*\*?=?|\/\/?=?|<[<=>]?|>[=>]?|[&|^~]|\b(?:and|at|not|or|with)\b/,
+      punctuation: /[{}[\];(),.:]/
+    };
+    Prism.languages.rpy = Prism.languages.renpy;
+  }
+  return renpy_1;
+}
+var renpyExports = requireRenpy();
+const renpy = /* @__PURE__ */ getDefaultExportFromCjs(renpyExports);
+const renpy$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: renpy
+}, [renpyExports]);
+export {
+  renpy$1 as r
+};
+//# sourceMappingURL=renpy-CJmFfTdl.js.map