@oscloudlab/knowledge-card 0.0.1 → 0.0.3

package/dist/pascal-CiRpum9a.js

@@ -0,0 +1,106 @@
+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 pascal_1;
+var hasRequiredPascal;
+function requirePascal() {
+  if (hasRequiredPascal) return pascal_1;
+  hasRequiredPascal = 1;
+  pascal_1 = pascal2;
+  pascal2.displayName = "pascal";
+  pascal2.aliases = ["objectpascal"];
+  function pascal2(Prism) {
+    Prism.languages.pascal = {
+      directive: {
+        pattern: /\{\$[\s\S]*?\}/,
+        greedy: true,
+        alias: ["marco", "property"]
+      },
+      comment: {
+        pattern: /\(\*[\s\S]*?\*\)|\{[\s\S]*?\}|\/\/.*/,
+        greedy: true
+      },
+      string: {
+        pattern: /(?:'(?:''|[^'\r\n])*'(?!')|#[&$%]?[a-f\d]+)+|\^[a-z]/i,
+        greedy: true
+      },
+      asm: {
+        pattern: /(\basm\b)[\s\S]+?(?=\bend\s*[;[])/i,
+        lookbehind: true,
+        greedy: true,
+        inside: null
+        // see below
+      },
+      keyword: [
+        {
+          // Turbo Pascal
+          pattern: /(^|[^&])\b(?:absolute|array|asm|begin|case|const|constructor|destructor|do|downto|else|end|file|for|function|goto|if|implementation|inherited|inline|interface|label|nil|object|of|operator|packed|procedure|program|record|reintroduce|repeat|self|set|string|then|to|type|unit|until|uses|var|while|with)\b/i,
+          lookbehind: true
+        },
+        {
+          // Free Pascal
+          pattern: /(^|[^&])\b(?:dispose|exit|false|new|true)\b/i,
+          lookbehind: true
+        },
+        {
+          // Object Pascal
+          pattern: /(^|[^&])\b(?:class|dispinterface|except|exports|finalization|finally|initialization|inline|library|on|out|packed|property|raise|resourcestring|threadvar|try)\b/i,
+          lookbehind: true
+        },
+        {
+          // Modifiers
+          pattern: /(^|[^&])\b(?:absolute|abstract|alias|assembler|bitpacked|break|cdecl|continue|cppdecl|cvar|default|deprecated|dynamic|enumerator|experimental|export|external|far|far16|forward|generic|helper|implements|index|interrupt|iochecks|local|message|name|near|nodefault|noreturn|nostackframe|oldfpccall|otherwise|overload|override|pascal|platform|private|protected|public|published|read|register|reintroduce|result|safecall|saveregisters|softfloat|specialize|static|stdcall|stored|strict|unaligned|unimplemented|varargs|virtual|write)\b/i,
+          lookbehind: true
+        }
+      ],
+      number: [
+        // Hexadecimal, octal and binary
+        /(?:[&%]\d+|\$[a-f\d]+)/i,
+        // Decimal
+        /\b\d+(?:\.\d+)?(?:e[+-]?\d+)?/i
+      ],
+      operator: [
+        /\.\.|\*\*|:=|<[<=>]?|>[>=]?|[+\-*\/]=?|[@^=]/,
+        {
+          pattern: /(^|[^&])\b(?:and|as|div|exclude|in|include|is|mod|not|or|shl|shr|xor)\b/,
+          lookbehind: true
+        }
+      ],
+      punctuation: /\(\.|\.\)|[()\[\]:;,.]/
+    };
+    Prism.languages.pascal.asm.inside = Prism.languages.extend("pascal", {
+      asm: void 0,
+      keyword: void 0,
+      operator: void 0
+    });
+    Prism.languages.objectpascal = Prism.languages.pascal;
+  }
+  return pascal_1;
+}
+var pascalExports = requirePascal();
+const pascal = /* @__PURE__ */ getDefaultExportFromCjs(pascalExports);
+const pascal$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: pascal
+}, [pascalExports]);
+export {
+  pascal$1 as p
+};
+//# sourceMappingURL=pascal-CiRpum9a.js.map

package/dist/pascal-CiRpum9a.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pascal-CiRpum9a.js","sources":["../node_modules/refractor/lang/pascal.js"],"sourcesContent":["'use strict'\n\nmodule.exports = pascal\npascal.displayName = 'pascal'\npascal.aliases = ['objectpascal']\nfunction pascal(Prism) {\n  // Based on Free Pascal\n  /* TODO\nSupport inline asm ?\n*/\n  Prism.languages.pascal = {\n    directive: {\n      pattern: /\\{\\$[\\s\\S]*?\\}/,\n      greedy: true,\n      alias: ['marco', 'property']\n    },\n    comment: {\n      pattern: /\\(\\*[\\s\\S]*?\\*\\)|\\{[\\s\\S]*?\\}|\\/\\/.*/,\n      greedy: true\n    },\n    string: {\n      pattern: /(?:'(?:''|[^'\\r\\n])*'(?!')|#[&$%]?[a-f\\d]+)+|\\^[a-z]/i,\n      greedy: true\n    },\n    asm: {\n      pattern: /(\\basm\\b)[\\s\\S]+?(?=\\bend\\s*[;[])/i,\n      lookbehind: true,\n      greedy: true,\n      inside: null // see below\n    },\n    keyword: [\n      {\n        // Turbo Pascal\n        pattern:\n          /(^|[^&])\\b(?:absolute|array|asm|begin|case|const|constructor|destructor|do|downto|else|end|file|for|function|goto|if|implementation|inherited|inline|interface|label|nil|object|of|operator|packed|procedure|program|record|reintroduce|repeat|self|set|string|then|to|type|unit|until|uses|var|while|with)\\b/i,\n        lookbehind: true\n      },\n      {\n        // Free Pascal\n        pattern: /(^|[^&])\\b(?:dispose|exit|false|new|true)\\b/i,\n        lookbehind: true\n      },\n      {\n        // Object Pascal\n        pattern:\n          /(^|[^&])\\b(?:class|dispinterface|except|exports|finalization|finally|initialization|inline|library|on|out|packed|property|raise|resourcestring|threadvar|try)\\b/i,\n        lookbehind: true\n      },\n      {\n        // Modifiers\n        pattern:\n          /(^|[^&])\\b(?:absolute|abstract|alias|assembler|bitpacked|break|cdecl|continue|cppdecl|cvar|default|deprecated|dynamic|enumerator|experimental|export|external|far|far16|forward|generic|helper|implements|index|interrupt|iochecks|local|message|name|near|nodefault|noreturn|nostackframe|oldfpccall|otherwise|overload|override|pascal|platform|private|protected|public|published|read|register|reintroduce|result|safecall|saveregisters|softfloat|specialize|static|stdcall|stored|strict|unaligned|unimplemented|varargs|virtual|write)\\b/i,\n        lookbehind: true\n      }\n    ],\n    number: [\n      // Hexadecimal, octal and binary\n      /(?:[&%]\\d+|\\$[a-f\\d]+)/i, // Decimal\n      /\\b\\d+(?:\\.\\d+)?(?:e[+-]?\\d+)?/i\n    ],\n    operator: [\n      /\\.\\.|\\*\\*|:=|<[<=>]?|>[>=]?|[+\\-*\\/]=?|[@^=]/,\n      {\n        pattern:\n          /(^|[^&])\\b(?:and|as|div|exclude|in|include|is|mod|not|or|shl|shr|xor)\\b/,\n        lookbehind: true\n      }\n    ],\n    punctuation: /\\(\\.|\\.\\)|[()\\[\\]:;,.]/\n  }\n  Prism.languages.pascal.asm.inside = Prism.languages.extend('pascal', {\n    asm: undefined,\n    keyword: undefined,\n    operator: undefined\n  })\n  Prism.languages.objectpascal = Prism.languages.pascal\n}\n"],"names":["pascal"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,aAAiBA;AACjB,EAAAA,QAAO,cAAc;AACrB,EAAAA,QAAO,UAAU,CAAC,cAAc;AAChC,WAASA,QAAO,OAAO;AAKrB,UAAM,UAAU,SAAS;AAAA,MACvB,WAAW;AAAA,QACT,SAAS;AAAA,QACT,QAAQ;AAAA,QACR,OAAO,CAAC,SAAS,UAAU;AAAA;MAE7B,SAAS;AAAA,QACP,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,KAAK;AAAA,QACH,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,QAAQ;AAAA,QACR,QAAQ;AAAA;AAAA;MAEV,SAAS;AAAA,QACP;AAAA;AAAA,UAEE,SACE;AAAA,UACF,YAAY;AAAA;QAEd;AAAA;AAAA,UAEE,SAAS;AAAA,UACT,YAAY;AAAA;QAEd;AAAA;AAAA,UAEE,SACE;AAAA,UACF,YAAY;AAAA;QAEd;AAAA;AAAA,UAEE,SACE;AAAA,UACF,YAAY;AAAA;;MAGhB,QAAQ;AAAA;AAAA,QAEN;AAAA;AAAA,QACA;AAAA;MAEF,UAAU;AAAA,QACR;AAAA,QACA;AAAA,UACE,SACE;AAAA,UACF,YAAY;AAAA;;MAGhB,aAAa;AAAA;AAEf,UAAM,UAAU,OAAO,IAAI,SAAS,MAAM,UAAU,OAAO,UAAU;AAAA,MACnE,KAAK;AAAA,MACL,SAAS;AAAA,MACT,UAAU;AAAA,IACd,CAAG;AACD,UAAM,UAAU,eAAe,MAAM,UAAU;AAAA,EACjD;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/pascaligo-BFBF5rf7.js

@@ -0,0 +1,128 @@
+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 pascaligo_1;
+var hasRequiredPascaligo;
+function requirePascaligo() {
+  if (hasRequiredPascaligo) return pascaligo_1;
+  hasRequiredPascaligo = 1;
+  pascaligo_1 = pascaligo2;
+  pascaligo2.displayName = "pascaligo";
+  pascaligo2.aliases = [];
+  function pascaligo2(Prism) {
+    (function(Prism2) {
+      var braces = /\((?:[^()]|\((?:[^()]|\([^()]*\))*\))*\)/.source;
+      var type = /(?:\b\w+(?:<braces>)?|<braces>)/.source.replace(
+        /<braces>/g,
+        function() {
+          return braces;
+        }
+      );
+      var pascaligo3 = Prism2.languages.pascaligo = {
+        comment: /\(\*[\s\S]+?\*\)|\/\/.*/,
+        string: {
+          pattern: /(["'`])(?:\\[\s\S]|(?!\1)[^\\])*\1|\^[a-z]/i,
+          greedy: true
+        },
+        "class-name": [
+          {
+            pattern: RegExp(
+              /(\btype\s+\w+\s+is\s+)<type>/.source.replace(
+                /<type>/g,
+                function() {
+                  return type;
+                }
+              ),
+              "i"
+            ),
+            lookbehind: true,
+            inside: null
+            // see below
+          },
+          {
+            pattern: RegExp(
+              /<type>(?=\s+is\b)/.source.replace(/<type>/g, function() {
+                return type;
+              }),
+              "i"
+            ),
+            inside: null
+            // see below
+          },
+          {
+            pattern: RegExp(
+              /(:\s*)<type>/.source.replace(/<type>/g, function() {
+                return type;
+              })
+            ),
+            lookbehind: true,
+            inside: null
+            // see below
+          }
+        ],
+        keyword: {
+          pattern: /(^|[^&])\b(?:begin|block|case|const|else|end|fail|for|from|function|if|is|nil|of|remove|return|skip|then|type|var|while|with)\b/i,
+          lookbehind: true
+        },
+        boolean: {
+          pattern: /(^|[^&])\b(?:False|True)\b/i,
+          lookbehind: true
+        },
+        builtin: {
+          pattern: /(^|[^&])\b(?:bool|int|list|map|nat|record|string|unit)\b/i,
+          lookbehind: true
+        },
+        function: /\b\w+(?=\s*\()/,
+        number: [
+          // Hexadecimal, octal and binary
+          /%[01]+|&[0-7]+|\$[a-f\d]+/i,
+          // Decimal
+          /\b\d+(?:\.\d+)?(?:e[+-]?\d+)?(?:mtz|n)?/i
+        ],
+        operator: /->|=\/=|\.\.|\*\*|:=|<[<=>]?|>[>=]?|[+\-*\/]=?|[@^=|]|\b(?:and|mod|or)\b/,
+        punctuation: /\(\.|\.\)|[()\[\]:;,.{}]/
+      };
+      var classNameInside = [
+        "comment",
+        "keyword",
+        "builtin",
+        "operator",
+        "punctuation"
+      ].reduce(function(accum, key) {
+        accum[key] = pascaligo3[key];
+        return accum;
+      }, {});
+      pascaligo3["class-name"].forEach(function(p) {
+        p.inside = classNameInside;
+      });
+    })(Prism);
+  }
+  return pascaligo_1;
+}
+var pascaligoExports = requirePascaligo();
+const pascaligo = /* @__PURE__ */ getDefaultExportFromCjs(pascaligoExports);
+const pascaligo$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: pascaligo
+}, [pascaligoExports]);
+export {
+  pascaligo$1 as p
+};
+//# sourceMappingURL=pascaligo-BFBF5rf7.js.map

package/dist/pascaligo-BFBF5rf7.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pascaligo-BFBF5rf7.js","sources":["../node_modules/refractor/lang/pascaligo.js"],"sourcesContent":["'use strict'\n\nmodule.exports = pascaligo\npascaligo.displayName = 'pascaligo'\npascaligo.aliases = []\nfunction pascaligo(Prism) {\n  ;(function (Prism) {\n    // Pascaligo is a layer 2 smart contract language for the tezos blockchain\n    var braces = /\\((?:[^()]|\\((?:[^()]|\\([^()]*\\))*\\))*\\)/.source\n    var type = /(?:\\b\\w+(?:<braces>)?|<braces>)/.source.replace(\n      /<braces>/g,\n      function () {\n        return braces\n      }\n    )\n    var pascaligo = (Prism.languages.pascaligo = {\n      comment: /\\(\\*[\\s\\S]+?\\*\\)|\\/\\/.*/,\n      string: {\n        pattern: /([\"'`])(?:\\\\[\\s\\S]|(?!\\1)[^\\\\])*\\1|\\^[a-z]/i,\n        greedy: true\n      },\n      'class-name': [\n        {\n          pattern: RegExp(\n            /(\\btype\\s+\\w+\\s+is\\s+)<type>/.source.replace(\n              /<type>/g,\n              function () {\n                return type\n              }\n            ),\n            'i'\n          ),\n          lookbehind: true,\n          inside: null // see below\n        },\n        {\n          pattern: RegExp(\n            /<type>(?=\\s+is\\b)/.source.replace(/<type>/g, function () {\n              return type\n            }),\n            'i'\n          ),\n          inside: null // see below\n        },\n        {\n          pattern: RegExp(\n            /(:\\s*)<type>/.source.replace(/<type>/g, function () {\n              return type\n            })\n          ),\n          lookbehind: true,\n          inside: null // see below\n        }\n      ],\n      keyword: {\n        pattern:\n          /(^|[^&])\\b(?:begin|block|case|const|else|end|fail|for|from|function|if|is|nil|of|remove|return|skip|then|type|var|while|with)\\b/i,\n        lookbehind: true\n      },\n      boolean: {\n        pattern: /(^|[^&])\\b(?:False|True)\\b/i,\n        lookbehind: true\n      },\n      builtin: {\n        pattern: /(^|[^&])\\b(?:bool|int|list|map|nat|record|string|unit)\\b/i,\n        lookbehind: true\n      },\n      function: /\\b\\w+(?=\\s*\\()/,\n      number: [\n        // Hexadecimal, octal and binary\n        /%[01]+|&[0-7]+|\\$[a-f\\d]+/i, // Decimal\n        /\\b\\d+(?:\\.\\d+)?(?:e[+-]?\\d+)?(?:mtz|n)?/i\n      ],\n      operator:\n        /->|=\\/=|\\.\\.|\\*\\*|:=|<[<=>]?|>[>=]?|[+\\-*\\/]=?|[@^=|]|\\b(?:and|mod|or)\\b/,\n      punctuation: /\\(\\.|\\.\\)|[()\\[\\]:;,.{}]/\n    })\n    var classNameInside = [\n      'comment',\n      'keyword',\n      'builtin',\n      'operator',\n      'punctuation'\n    ].reduce(function (accum, key) {\n      accum[key] = pascaligo[key]\n      return accum\n    }, {})\n    pascaligo['class-name'].forEach(function (p) {\n      p.inside = classNameInside\n    })\n  })(Prism)\n}\n"],"names":["pascaligo","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,gBAAiBA;AACjB,EAAAA,WAAU,cAAc;AACxB,EAAAA,WAAU,UAAU,CAAA;AACpB,WAASA,WAAU,OAAO;AACvB,KAAC,SAAUC,QAAO;AAEjB,UAAI,SAAS,2CAA2C;AACxD,UAAI,OAAO,kCAAkC,OAAO;AAAA,QAClD;AAAA,QACA,WAAY;AACV,iBAAO;AAAA,QACf;AAAA;AAEI,UAAID,aAAaC,OAAM,UAAU,YAAY;AAAA,QAC3C,SAAS;AAAA,QACT,QAAQ;AAAA,UACN,SAAS;AAAA,UACT,QAAQ;AAAA;QAEV,cAAc;AAAA,UACZ;AAAA,YACE,SAAS;AAAA,cACP,+BAA+B,OAAO;AAAA,gBACpC;AAAA,gBACA,WAAY;AACV,yBAAO;AAAA,gBACvB;AAAA;cAEY;AAAA;YAEF,YAAY;AAAA,YACZ,QAAQ;AAAA;AAAA;UAEV;AAAA,YACE,SAAS;AAAA,cACP,oBAAoB,OAAO,QAAQ,WAAW,WAAY;AACxD,uBAAO;AAAA,cACrB,CAAa;AAAA,cACD;AAAA;YAEF,QAAQ;AAAA;AAAA;UAEV;AAAA,YACE,SAAS;AAAA,cACP,eAAe,OAAO,QAAQ,WAAW,WAAY;AACnD,uBAAO;AAAA,cACrB,CAAa;AAAA;YAEH,YAAY;AAAA,YACZ,QAAQ;AAAA;AAAA;;QAGZ,SAAS;AAAA,UACP,SACE;AAAA,UACF,YAAY;AAAA;QAEd,SAAS;AAAA,UACP,SAAS;AAAA,UACT,YAAY;AAAA;QAEd,SAAS;AAAA,UACP,SAAS;AAAA,UACT,YAAY;AAAA;QAEd,UAAU;AAAA,QACV,QAAQ;AAAA;AAAA,UAEN;AAAA;AAAA,UACA;AAAA;QAEF,UACE;AAAA,QACF,aAAa;AAAA,MACnB;AACI,UAAI,kBAAkB;AAAA,QACpB;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACN,EAAM,OAAO,SAAU,OAAO,KAAK;AAC7B,cAAM,GAAG,IAAID,WAAU,GAAG;AAC1B,eAAO;AAAA,MACb,GAAO,CAAA,CAAE;AACL,MAAAA,WAAU,YAAY,EAAE,QAAQ,SAAU,GAAG;AAC3C,UAAE,SAAS;AAAA,MACjB,CAAK;AAAA,IACL,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/pcaxis-B3ZWwa4E.js

@@ -0,0 +1,94 @@
+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 pcaxis_1;
+var hasRequiredPcaxis;
+function requirePcaxis() {
+  if (hasRequiredPcaxis) return pcaxis_1;
+  hasRequiredPcaxis = 1;
+  pcaxis_1 = pcaxis2;
+  pcaxis2.displayName = "pcaxis";
+  pcaxis2.aliases = ["px"];
+  function pcaxis2(Prism) {
+    Prism.languages.pcaxis = {
+      string: /"[^"]*"/,
+      keyword: {
+        pattern: /((?:^|;)\s*)[-A-Z\d]+(?:\s*\[[-\w]+\])?(?:\s*\("[^"]*"(?:,\s*"[^"]*")*\))?(?=\s*=)/,
+        lookbehind: true,
+        greedy: true,
+        inside: {
+          keyword: /^[-A-Z\d]+/,
+          language: {
+            pattern: /^(\s*)\[[-\w]+\]/,
+            lookbehind: true,
+            inside: {
+              punctuation: /^\[|\]$/,
+              property: /[-\w]+/
+            }
+          },
+          "sub-key": {
+            pattern: /^(\s*)\S[\s\S]*/,
+            lookbehind: true,
+            inside: {
+              parameter: {
+                pattern: /"[^"]*"/,
+                alias: "property"
+              },
+              punctuation: /^\(|\)$|,/
+            }
+          }
+        }
+      },
+      operator: /=/,
+      tlist: {
+        pattern: /TLIST\s*\(\s*\w+(?:(?:\s*,\s*"[^"]*")+|\s*,\s*"[^"]*"-"[^"]*")?\s*\)/,
+        greedy: true,
+        inside: {
+          function: /^TLIST/,
+          property: {
+            pattern: /^(\s*\(\s*)\w+/,
+            lookbehind: true
+          },
+          string: /"[^"]*"/,
+          punctuation: /[(),]/,
+          operator: /-/
+        }
+      },
+      punctuation: /[;,]/,
+      number: {
+        pattern: /(^|\s)\d+(?:\.\d+)?(?!\S)/,
+        lookbehind: true
+      },
+      boolean: /NO|YES/
+    };
+    Prism.languages.px = Prism.languages.pcaxis;
+  }
+  return pcaxis_1;
+}
+var pcaxisExports = requirePcaxis();
+const pcaxis = /* @__PURE__ */ getDefaultExportFromCjs(pcaxisExports);
+const pcaxis$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: pcaxis
+}, [pcaxisExports]);
+export {
+  pcaxis$1 as p
+};
+//# sourceMappingURL=pcaxis-B3ZWwa4E.js.map

package/dist/pcaxis-B3ZWwa4E.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pcaxis-B3ZWwa4E.js","sources":["../node_modules/refractor/lang/pcaxis.js"],"sourcesContent":["'use strict'\n\nmodule.exports = pcaxis\npcaxis.displayName = 'pcaxis'\npcaxis.aliases = ['px']\nfunction pcaxis(Prism) {\n  Prism.languages.pcaxis = {\n    string: /\"[^\"]*\"/,\n    keyword: {\n      pattern:\n        /((?:^|;)\\s*)[-A-Z\\d]+(?:\\s*\\[[-\\w]+\\])?(?:\\s*\\(\"[^\"]*\"(?:,\\s*\"[^\"]*\")*\\))?(?=\\s*=)/,\n      lookbehind: true,\n      greedy: true,\n      inside: {\n        keyword: /^[-A-Z\\d]+/,\n        language: {\n          pattern: /^(\\s*)\\[[-\\w]+\\]/,\n          lookbehind: true,\n          inside: {\n            punctuation: /^\\[|\\]$/,\n            property: /[-\\w]+/\n          }\n        },\n        'sub-key': {\n          pattern: /^(\\s*)\\S[\\s\\S]*/,\n          lookbehind: true,\n          inside: {\n            parameter: {\n              pattern: /\"[^\"]*\"/,\n              alias: 'property'\n            },\n            punctuation: /^\\(|\\)$|,/\n          }\n        }\n      }\n    },\n    operator: /=/,\n    tlist: {\n      pattern:\n        /TLIST\\s*\\(\\s*\\w+(?:(?:\\s*,\\s*\"[^\"]*\")+|\\s*,\\s*\"[^\"]*\"-\"[^\"]*\")?\\s*\\)/,\n      greedy: true,\n      inside: {\n        function: /^TLIST/,\n        property: {\n          pattern: /^(\\s*\\(\\s*)\\w+/,\n          lookbehind: true\n        },\n        string: /\"[^\"]*\"/,\n        punctuation: /[(),]/,\n        operator: /-/\n      }\n    },\n    punctuation: /[;,]/,\n    number: {\n      pattern: /(^|\\s)\\d+(?:\\.\\d+)?(?!\\S)/,\n      lookbehind: true\n    },\n    boolean: /NO|YES/\n  }\n  Prism.languages.px = Prism.languages.pcaxis\n}\n"],"names":["pcaxis"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,aAAiBA;AACjB,EAAAA,QAAO,cAAc;AACrB,EAAAA,QAAO,UAAU,CAAC,IAAI;AACtB,WAASA,QAAO,OAAO;AACrB,UAAM,UAAU,SAAS;AAAA,MACvB,QAAQ;AAAA,MACR,SAAS;AAAA,QACP,SACE;AAAA,QACF,YAAY;AAAA,QACZ,QAAQ;AAAA,QACR,QAAQ;AAAA,UACN,SAAS;AAAA,UACT,UAAU;AAAA,YACR,SAAS;AAAA,YACT,YAAY;AAAA,YACZ,QAAQ;AAAA,cACN,aAAa;AAAA,cACb,UAAU;AAAA;;UAGd,WAAW;AAAA,YACT,SAAS;AAAA,YACT,YAAY;AAAA,YACZ,QAAQ;AAAA,cACN,WAAW;AAAA,gBACT,SAAS;AAAA,gBACT,OAAO;AAAA;cAET,aAAa;AAAA;;;;MAKrB,UAAU;AAAA,MACV,OAAO;AAAA,QACL,SACE;AAAA,QACF,QAAQ;AAAA,QACR,QAAQ;AAAA,UACN,UAAU;AAAA,UACV,UAAU;AAAA,YACR,SAAS;AAAA,YACT,YAAY;AAAA;UAEd,QAAQ;AAAA,UACR,aAAa;AAAA,UACb,UAAU;AAAA;;MAGd,aAAa;AAAA,MACb,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,YAAY;AAAA;MAEd,SAAS;AAAA;AAEX,UAAM,UAAU,KAAK,MAAM,UAAU;AAAA,EACvC;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/peoplecode-CnXb4DxE.js

@@ -0,0 +1,84 @@
+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 peoplecode_1;
+var hasRequiredPeoplecode;
+function requirePeoplecode() {
+  if (hasRequiredPeoplecode) return peoplecode_1;
+  hasRequiredPeoplecode = 1;
+  peoplecode_1 = peoplecode2;
+  peoplecode2.displayName = "peoplecode";
+  peoplecode2.aliases = ["pcode"];
+  function peoplecode2(Prism) {
+    Prism.languages.peoplecode = {
+      comment: RegExp(
+        [
+          // C-style multiline comments
+          /\/\*[\s\S]*?\*\//.source,
+          // REM comments
+          /\bREM[^;]*;/.source,
+          // Nested <* *> comments
+          /<\*(?:[^<*]|\*(?!>)|<(?!\*)|<\*(?:(?!\*>)[\s\S])*\*>)*\*>/.source,
+          // /+ +/ comments
+          /\/\+[\s\S]*?\+\//.source
+        ].join("|")
+      ),
+      string: {
+        pattern: /'(?:''|[^'\r\n])*'(?!')|"(?:""|[^"\r\n])*"(?!")/,
+        greedy: true
+      },
+      variable: /%\w+/,
+      "function-definition": {
+        pattern: /((?:^|[^\w-])(?:function|method)\s+)\w+/i,
+        lookbehind: true,
+        alias: "function"
+      },
+      "class-name": {
+        pattern: /((?:^|[^-\w])(?:as|catch|class|component|create|extends|global|implements|instance|local|of|property|returns)\s+)\w+(?::\w+)*/i,
+        lookbehind: true,
+        inside: {
+          punctuation: /:/
+        }
+      },
+      keyword: /\b(?:abstract|alias|as|catch|class|component|constant|create|declare|else|end-(?:class|evaluate|for|function|get|if|method|set|try|while)|evaluate|extends|for|function|get|global|if|implements|import|instance|library|local|method|null|of|out|peopleCode|private|program|property|protected|readonly|ref|repeat|returns?|set|step|then|throw|to|try|until|value|when(?:-other)?|while)\b/i,
+      "operator-keyword": {
+        pattern: /\b(?:and|not|or)\b/i,
+        alias: "operator"
+      },
+      function: /[_a-z]\w*(?=\s*\()/i,
+      boolean: /\b(?:false|true)\b/i,
+      number: /\b\d+(?:\.\d+)?\b/,
+      operator: /<>|[<>]=?|!=|\*\*|[-+*/|=@]/,
+      punctuation: /[:.;,()[\]]/
+    };
+    Prism.languages.pcode = Prism.languages.peoplecode;
+  }
+  return peoplecode_1;
+}
+var peoplecodeExports = requirePeoplecode();
+const peoplecode = /* @__PURE__ */ getDefaultExportFromCjs(peoplecodeExports);
+const peoplecode$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: peoplecode
+}, [peoplecodeExports]);
+export {
+  peoplecode$1 as p
+};
+//# sourceMappingURL=peoplecode-CnXb4DxE.js.map

package/dist/peoplecode-CnXb4DxE.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"peoplecode-CnXb4DxE.js","sources":["../node_modules/refractor/lang/peoplecode.js"],"sourcesContent":["'use strict'\n\nmodule.exports = peoplecode\npeoplecode.displayName = 'peoplecode'\npeoplecode.aliases = ['pcode']\nfunction peoplecode(Prism) {\n  Prism.languages.peoplecode = {\n    comment: RegExp(\n      [\n        // C-style multiline comments\n        /\\/\\*[\\s\\S]*?\\*\\//.source, // REM comments\n        /\\bREM[^;]*;/.source, // Nested <* *> comments\n        /<\\*(?:[^<*]|\\*(?!>)|<(?!\\*)|<\\*(?:(?!\\*>)[\\s\\S])*\\*>)*\\*>/.source, // /+ +/ comments\n        /\\/\\+[\\s\\S]*?\\+\\//.source\n      ].join('|')\n    ),\n    string: {\n      pattern: /'(?:''|[^'\\r\\n])*'(?!')|\"(?:\"\"|[^\"\\r\\n])*\"(?!\")/,\n      greedy: true\n    },\n    variable: /%\\w+/,\n    'function-definition': {\n      pattern: /((?:^|[^\\w-])(?:function|method)\\s+)\\w+/i,\n      lookbehind: true,\n      alias: 'function'\n    },\n    'class-name': {\n      pattern:\n        /((?:^|[^-\\w])(?:as|catch|class|component|create|extends|global|implements|instance|local|of|property|returns)\\s+)\\w+(?::\\w+)*/i,\n      lookbehind: true,\n      inside: {\n        punctuation: /:/\n      }\n    },\n    keyword:\n      /\\b(?:abstract|alias|as|catch|class|component|constant|create|declare|else|end-(?:class|evaluate|for|function|get|if|method|set|try|while)|evaluate|extends|for|function|get|global|if|implements|import|instance|library|local|method|null|of|out|peopleCode|private|program|property|protected|readonly|ref|repeat|returns?|set|step|then|throw|to|try|until|value|when(?:-other)?|while)\\b/i,\n    'operator-keyword': {\n      pattern: /\\b(?:and|not|or)\\b/i,\n      alias: 'operator'\n    },\n    function: /[_a-z]\\w*(?=\\s*\\()/i,\n    boolean: /\\b(?:false|true)\\b/i,\n    number: /\\b\\d+(?:\\.\\d+)?\\b/,\n    operator: /<>|[<>]=?|!=|\\*\\*|[-+*/|=@]/,\n    punctuation: /[:.;,()[\\]]/\n  }\n  Prism.languages.pcode = Prism.languages.peoplecode\n}\n"],"names":["peoplecode"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,iBAAiBA;AACjB,EAAAA,YAAW,cAAc;AACzB,EAAAA,YAAW,UAAU,CAAC,OAAO;AAC7B,WAASA,YAAW,OAAO;AACzB,UAAM,UAAU,aAAa;AAAA,MAC3B,SAAS;AAAA,QACP;AAAA;AAAA,UAEE,mBAAmB;AAAA;AAAA,UACnB,cAAc;AAAA;AAAA,UACd,4DAA4D;AAAA;AAAA,UAC5D,mBAAmB;AAAA,QAC3B,EAAQ,KAAK,GAAG;AAAA;MAEZ,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA;MAEV,UAAU;AAAA,MACV,uBAAuB;AAAA,QACrB,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,OAAO;AAAA;MAET,cAAc;AAAA,QACZ,SACE;AAAA,QACF,YAAY;AAAA,QACZ,QAAQ;AAAA,UACN,aAAa;AAAA;;MAGjB,SACE;AAAA,MACF,oBAAoB;AAAA,QAClB,SAAS;AAAA,QACT,OAAO;AAAA;MAET,UAAU;AAAA,MACV,SAAS;AAAA,MACT,QAAQ;AAAA,MACR,UAAU;AAAA,MACV,aAAa;AAAA;AAEf,UAAM,UAAU,QAAQ,MAAM,UAAU;AAAA,EAC1C;;;;;;;;;","x_google_ignoreList":[0]}

package/dist/perl-B5ZO0bi4.js

@@ -0,0 +1,173 @@
+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 perl_1;
+var hasRequiredPerl;
+function requirePerl() {
+  if (hasRequiredPerl) return perl_1;
+  hasRequiredPerl = 1;
+  perl_1 = perl2;
+  perl2.displayName = "perl";
+  perl2.aliases = [];
+  function perl2(Prism) {
+    (function(Prism2) {
+      var brackets = /(?:\((?:[^()\\]|\\[\s\S])*\)|\{(?:[^{}\\]|\\[\s\S])*\}|\[(?:[^[\]\\]|\\[\s\S])*\]|<(?:[^<>\\]|\\[\s\S])*>)/.source;
+      Prism2.languages.perl = {
+        comment: [
+          {
+            // POD
+            pattern: /(^\s*)=\w[\s\S]*?=cut.*/m,
+            lookbehind: true,
+            greedy: true
+          },
+          {
+            pattern: /(^|[^\\$])#.*/,
+            lookbehind: true,
+            greedy: true
+          }
+        ],
+        // TODO Could be nice to handle Heredoc too.
+        string: [
+          {
+            pattern: RegExp(
+              /\b(?:q|qq|qw|qx)(?![a-zA-Z0-9])\s*/.source + "(?:" + [
+                // q/.../
+                /([^a-zA-Z0-9\s{(\[<])(?:(?!\1)[^\\]|\\[\s\S])*\1/.source,
+                // q a...a
+                // eslint-disable-next-line regexp/strict
+                /([a-zA-Z0-9])(?:(?!\2)[^\\]|\\[\s\S])*\2/.source,
+                // q(...)
+                // q{...}
+                // q[...]
+                // q<...>
+                brackets
+              ].join("|") + ")"
+            ),
+            greedy: true
+          },
+          // "...", `...`
+          {
+            pattern: /("|`)(?:(?!\1)[^\\]|\\[\s\S])*\1/,
+            greedy: true
+          },
+          // '...'
+          // FIXME Multi-line single-quoted strings are not supported as they would break variables containing '
+          {
+            pattern: /'(?:[^'\\\r\n]|\\.)*'/,
+            greedy: true
+          }
+        ],
+        regex: [
+          {
+            pattern: RegExp(
+              /\b(?:m|qr)(?![a-zA-Z0-9])\s*/.source + "(?:" + [
+                // m/.../
+                /([^a-zA-Z0-9\s{(\[<])(?:(?!\1)[^\\]|\\[\s\S])*\1/.source,
+                // m a...a
+                // eslint-disable-next-line regexp/strict
+                /([a-zA-Z0-9])(?:(?!\2)[^\\]|\\[\s\S])*\2/.source,
+                // m(...)
+                // m{...}
+                // m[...]
+                // m<...>
+                brackets
+              ].join("|") + ")" + /[msixpodualngc]*/.source
+            ),
+            greedy: true
+          },
+          // The lookbehinds prevent -s from breaking
+          {
+            pattern: RegExp(
+              /(^|[^-])\b(?:s|tr|y)(?![a-zA-Z0-9])\s*/.source + "(?:" + [
+                // s/.../.../
+                // eslint-disable-next-line regexp/strict
+                /([^a-zA-Z0-9\s{(\[<])(?:(?!\2)[^\\]|\\[\s\S])*\2(?:(?!\2)[^\\]|\\[\s\S])*\2/.source,
+                // s a...a...a
+                // eslint-disable-next-line regexp/strict
+                /([a-zA-Z0-9])(?:(?!\3)[^\\]|\\[\s\S])*\3(?:(?!\3)[^\\]|\\[\s\S])*\3/.source,
+                // s(...)(...)
+                // s{...}{...}
+                // s[...][...]
+                // s<...><...>
+                // s(...)[...]
+                brackets + /\s*/.source + brackets
+              ].join("|") + ")" + /[msixpodualngcer]*/.source
+            ),
+            lookbehind: true,
+            greedy: true
+          },
+          // /.../
+          // The look-ahead tries to prevent two divisions on
+          // the same line from being highlighted as regex.
+          // This does not support multi-line regex.
+          {
+            pattern: /\/(?:[^\/\\\r\n]|\\.)*\/[msixpodualngc]*(?=\s*(?:$|[\r\n,.;})&|\-+*~<>!?^]|(?:and|cmp|eq|ge|gt|le|lt|ne|not|or|x|xor)\b))/,
+            greedy: true
+          }
+        ],
+        // FIXME Not sure about the handling of ::, ', and #
+        variable: [
+          // ${^POSTMATCH}
+          /[&*$@%]\{\^[A-Z]+\}/,
+          // $^V
+          /[&*$@%]\^[A-Z_]/,
+          // ${...}
+          /[&*$@%]#?(?=\{)/,
+          // $foo
+          /[&*$@%]#?(?:(?:::)*'?(?!\d)[\w$]+(?![\w$]))+(?:::)*/,
+          // $1
+          /[&*$@%]\d+/,
+          // $_, @_, %!
+          // The negative lookahead prevents from breaking the %= operator
+          /(?!%=)[$@%][!"#$%&'()*+,\-.\/:;<=>?@[\\\]^_`{|}~]/
+        ],
+        filehandle: {
+          // <>, <FOO>, _
+          pattern: /<(?![<=])\S*?>|\b_\b/,
+          alias: "symbol"
+        },
+        "v-string": {
+          // v1.2, 1.2.3
+          pattern: /v\d+(?:\.\d+)*|\d+(?:\.\d+){2,}/,
+          alias: "string"
+        },
+        function: {
+          pattern: /(\bsub[ \t]+)\w+/,
+          lookbehind: true
+        },
+        keyword: /\b(?:any|break|continue|default|delete|die|do|else|elsif|eval|for|foreach|given|goto|if|last|local|my|next|our|package|print|redo|require|return|say|state|sub|switch|undef|unless|until|use|when|while)\b/,
+        number: /\b(?:0x[\dA-Fa-f](?:_?[\dA-Fa-f])*|0b[01](?:_?[01])*|(?:(?:\d(?:_?\d)*)?\.)?\d(?:_?\d)*(?:[Ee][+-]?\d+)?)\b/,
+        operator: /-[rwxoRWXOezsfdlpSbctugkTBMAC]\b|\+[+=]?|-[-=>]?|\*\*?=?|\/\/?=?|=[=~>]?|~[~=]?|\|\|?=?|&&?=?|<(?:=>?|<=?)?|>>?=?|![~=]?|[%^]=?|\.(?:=|\.\.?)?|[\\?]|\bx(?:=|\b)|\b(?:and|cmp|eq|ge|gt|le|lt|ne|not|or|xor)\b/,
+        punctuation: /[{}[\];(),:]/
+      };
+    })(Prism);
+  }
+  return perl_1;
+}
+var perlExports = requirePerl();
+const perl = /* @__PURE__ */ getDefaultExportFromCjs(perlExports);
+const perl$1 = /* @__PURE__ */ _mergeNamespaces({
+  __proto__: null,
+  default: perl
+}, [perlExports]);
+export {
+  perl$1 as p
+};
+//# sourceMappingURL=perl-B5ZO0bi4.js.map

package/dist/perl-B5ZO0bi4.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"perl-B5ZO0bi4.js","sources":["../node_modules/refractor/lang/perl.js"],"sourcesContent":["'use strict'\n\nmodule.exports = perl\nperl.displayName = 'perl'\nperl.aliases = []\nfunction perl(Prism) {\n  ;(function (Prism) {\n    var brackets =\n      /(?:\\((?:[^()\\\\]|\\\\[\\s\\S])*\\)|\\{(?:[^{}\\\\]|\\\\[\\s\\S])*\\}|\\[(?:[^[\\]\\\\]|\\\\[\\s\\S])*\\]|<(?:[^<>\\\\]|\\\\[\\s\\S])*>)/\n        .source\n    Prism.languages.perl = {\n      comment: [\n        {\n          // POD\n          pattern: /(^\\s*)=\\w[\\s\\S]*?=cut.*/m,\n          lookbehind: true,\n          greedy: true\n        },\n        {\n          pattern: /(^|[^\\\\$])#.*/,\n          lookbehind: true,\n          greedy: true\n        }\n      ],\n      // TODO Could be nice to handle Heredoc too.\n      string: [\n        {\n          pattern: RegExp(\n            /\\b(?:q|qq|qw|qx)(?![a-zA-Z0-9])\\s*/.source +\n              '(?:' +\n              [\n                // q/.../\n                /([^a-zA-Z0-9\\s{(\\[<])(?:(?!\\1)[^\\\\]|\\\\[\\s\\S])*\\1/.source, // q a...a\n                // eslint-disable-next-line regexp/strict\n                /([a-zA-Z0-9])(?:(?!\\2)[^\\\\]|\\\\[\\s\\S])*\\2/.source, // q(...)\n                // q{...}\n                // q[...]\n                // q<...>\n                brackets\n              ].join('|') +\n              ')'\n          ),\n          greedy: true\n        }, // \"...\", `...`\n        {\n          pattern: /(\"|`)(?:(?!\\1)[^\\\\]|\\\\[\\s\\S])*\\1/,\n          greedy: true\n        }, // '...'\n        // FIXME Multi-line single-quoted strings are not supported as they would break variables containing '\n        {\n          pattern: /'(?:[^'\\\\\\r\\n]|\\\\.)*'/,\n          greedy: true\n        }\n      ],\n      regex: [\n        {\n          pattern: RegExp(\n            /\\b(?:m|qr)(?![a-zA-Z0-9])\\s*/.source +\n              '(?:' +\n              [\n                // m/.../\n                /([^a-zA-Z0-9\\s{(\\[<])(?:(?!\\1)[^\\\\]|\\\\[\\s\\S])*\\1/.source, // m a...a\n                // eslint-disable-next-line regexp/strict\n                /([a-zA-Z0-9])(?:(?!\\2)[^\\\\]|\\\\[\\s\\S])*\\2/.source, // m(...)\n                // m{...}\n                // m[...]\n                // m<...>\n                brackets\n              ].join('|') +\n              ')' +\n              /[msixpodualngc]*/.source\n          ),\n          greedy: true\n        }, // The lookbehinds prevent -s from breaking\n        {\n          pattern: RegExp(\n            /(^|[^-])\\b(?:s|tr|y)(?![a-zA-Z0-9])\\s*/.source +\n              '(?:' +\n              [\n                // s/.../.../\n                // eslint-disable-next-line regexp/strict\n                /([^a-zA-Z0-9\\s{(\\[<])(?:(?!\\2)[^\\\\]|\\\\[\\s\\S])*\\2(?:(?!\\2)[^\\\\]|\\\\[\\s\\S])*\\2/\n                  .source, // s a...a...a\n                // eslint-disable-next-line regexp/strict\n                /([a-zA-Z0-9])(?:(?!\\3)[^\\\\]|\\\\[\\s\\S])*\\3(?:(?!\\3)[^\\\\]|\\\\[\\s\\S])*\\3/\n                  .source, // s(...)(...)\n                // s{...}{...}\n                // s[...][...]\n                // s<...><...>\n                // s(...)[...]\n                brackets + /\\s*/.source + brackets\n              ].join('|') +\n              ')' +\n              /[msixpodualngcer]*/.source\n          ),\n          lookbehind: true,\n          greedy: true\n        }, // /.../\n        // The look-ahead tries to prevent two divisions on\n        // the same line from being highlighted as regex.\n        // This does not support multi-line regex.\n        {\n          pattern:\n            /\\/(?:[^\\/\\\\\\r\\n]|\\\\.)*\\/[msixpodualngc]*(?=\\s*(?:$|[\\r\\n,.;})&|\\-+*~<>!?^]|(?:and|cmp|eq|ge|gt|le|lt|ne|not|or|x|xor)\\b))/,\n          greedy: true\n        }\n      ],\n      // FIXME Not sure about the handling of ::, ', and #\n      variable: [\n        // ${^POSTMATCH}\n        /[&*$@%]\\{\\^[A-Z]+\\}/, // $^V\n        /[&*$@%]\\^[A-Z_]/, // ${...}\n        /[&*$@%]#?(?=\\{)/, // $foo\n        /[&*$@%]#?(?:(?:::)*'?(?!\\d)[\\w$]+(?![\\w$]))+(?:::)*/, // $1\n        /[&*$@%]\\d+/, // $_, @_, %!\n        // The negative lookahead prevents from breaking the %= operator\n        /(?!%=)[$@%][!\"#$%&'()*+,\\-.\\/:;<=>?@[\\\\\\]^_`{|}~]/\n      ],\n      filehandle: {\n        // <>, <FOO>, _\n        pattern: /<(?![<=])\\S*?>|\\b_\\b/,\n        alias: 'symbol'\n      },\n      'v-string': {\n        // v1.2, 1.2.3\n        pattern: /v\\d+(?:\\.\\d+)*|\\d+(?:\\.\\d+){2,}/,\n        alias: 'string'\n      },\n      function: {\n        pattern: /(\\bsub[ \\t]+)\\w+/,\n        lookbehind: true\n      },\n      keyword:\n        /\\b(?:any|break|continue|default|delete|die|do|else|elsif|eval|for|foreach|given|goto|if|last|local|my|next|our|package|print|redo|require|return|say|state|sub|switch|undef|unless|until|use|when|while)\\b/,\n      number:\n        /\\b(?:0x[\\dA-Fa-f](?:_?[\\dA-Fa-f])*|0b[01](?:_?[01])*|(?:(?:\\d(?:_?\\d)*)?\\.)?\\d(?:_?\\d)*(?:[Ee][+-]?\\d+)?)\\b/,\n      operator:\n        /-[rwxoRWXOezsfdlpSbctugkTBMAC]\\b|\\+[+=]?|-[-=>]?|\\*\\*?=?|\\/\\/?=?|=[=~>]?|~[~=]?|\\|\\|?=?|&&?=?|<(?:=>?|<=?)?|>>?=?|![~=]?|[%^]=?|\\.(?:=|\\.\\.?)?|[\\\\?]|\\bx(?:=|\\b)|\\b(?:and|cmp|eq|ge|gt|le|lt|ne|not|or|xor)\\b/,\n      punctuation: /[{}[\\];(),:]/\n    }\n  })(Prism)\n}\n"],"names":["perl","Prism"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAEA,WAAiBA;AACjB,EAAAA,MAAK,cAAc;AACnB,EAAAA,MAAK,UAAU,CAAA;AACf,WAASA,MAAK,OAAO;AAClB,KAAC,SAAUC,QAAO;AACjB,UAAI,WACF,6GACG;AACL,MAAAA,OAAM,UAAU,OAAO;AAAA,QACrB,SAAS;AAAA,UACP;AAAA;AAAA,YAEE,SAAS;AAAA,YACT,YAAY;AAAA,YACZ,QAAQ;AAAA;UAEV;AAAA,YACE,SAAS;AAAA,YACT,YAAY;AAAA,YACZ,QAAQ;AAAA;;;QAIZ,QAAQ;AAAA,UACN;AAAA,YACE,SAAS;AAAA,cACP,qCAAqC,SACnC,QACA;AAAA;AAAA,gBAEE,mDAAmD;AAAA;AAAA;AAAA,gBAEnD,2CAA2C;AAAA;AAAA;AAAA;AAAA;AAAA,gBAI3C;AAAA,cAChB,EAAgB,KAAK,GAAG,IACV;AAAA;YAEJ,QAAQ;AAAA;;UAEV;AAAA,YACE,SAAS;AAAA,YACT,QAAQ;AAAA;;;UAGV;AAAA,YACE,SAAS;AAAA,YACT,QAAQ;AAAA;;QAGZ,OAAO;AAAA,UACL;AAAA,YACE,SAAS;AAAA,cACP,+BAA+B,SAC7B,QACA;AAAA;AAAA,gBAEE,mDAAmD;AAAA;AAAA;AAAA,gBAEnD,2CAA2C;AAAA;AAAA;AAAA;AAAA;AAAA,gBAI3C;AAAA,cAChB,EAAgB,KAAK,GAAG,IACV,MACA,mBAAmB;AAAA;YAEvB,QAAQ;AAAA;;UAEV;AAAA,YACE,SAAS;AAAA,cACP,yCAAyC,SACvC,QACA;AAAA;AAAA;AAAA,gBAGE,8EACG;AAAA;AAAA;AAAA,gBAEH,sEACG;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,gBAKH,WAAW,MAAM,SAAS;AAAA,cAC1C,EAAgB,KAAK,GAAG,IACV,MACA,qBAAqB;AAAA;YAEzB,YAAY;AAAA,YACZ,QAAQ;AAAA;;;;;UAKV;AAAA,YACE,SACE;AAAA,YACF,QAAQ;AAAA;;;QAIZ,UAAU;AAAA;AAAA,UAER;AAAA;AAAA,UACA;AAAA;AAAA,UACA;AAAA;AAAA,UACA;AAAA;AAAA,UACA;AAAA;AAAA;AAAA,UAEA;AAAA;QAEF,YAAY;AAAA;AAAA,UAEV,SAAS;AAAA,UACT,OAAO;AAAA;QAET,YAAY;AAAA;AAAA,UAEV,SAAS;AAAA,UACT,OAAO;AAAA;QAET,UAAU;AAAA,UACR,SAAS;AAAA,UACT,YAAY;AAAA;QAEd,SACE;AAAA,QACF,QACE;AAAA,QACF,UACE;AAAA,QACF,aAAa;AAAA;IAEnB,GAAK,KAAK;AAAA,EACV;;;;;;;;;","x_google_ignoreList":[0]}