@ynput/ayon-frontend-shared 0.3.5 → 0.3.7

package/dist/node_modules/refractor/lang/oz.cjs.js

@@ -0,0 +1,2 @@
+"use strict";e.displayName="oz";e.aliases=[];function e(t){t.languages.oz={comment:{pattern:/\/\*[\s\S]*?\*\/|%.*/,greedy:!0},string:{pattern:/"(?:[^"\\]|\\[\s\S])*"/,greedy:!0},atom:{pattern:/'(?:[^'\\]|\\[\s\S])*'/,greedy:!0,alias:"builtin"},keyword:/\$|\[\]|\b(?:_|at|attr|case|catch|choice|class|cond|declare|define|dis|else(?:case|if)?|end|export|fail|false|feat|finally|from|fun|functor|if|import|in|local|lock|meth|nil|not|of|or|prepare|proc|prop|raise|require|self|skip|then|thread|true|try|unit)\b/,function:[/\b[a-z][A-Za-z\d]*(?=\()/,{pattern:/(\{)[A-Z][A-Za-z\d]*\b/,lookbehind:!0}],number:/\b(?:0[bx][\da-f]+|\d+(?:\.\d*)?(?:e~?\d+)?)\b|&(?:[^\\]|\\(?:\d{3}|.))/i,variable:/`(?:[^`\\]|\\.)+`/,"attr-name":/\b\w+(?=[ \t]*:(?![:=]))/,operator:/:(?:=|::?)|<[-:=]?|=(?:=|<?:?)|>=?:?|\\=:?|!!?|[|#+\-*\/,~^@]|\b(?:andthen|div|mod|orelse)\b/,punctuation:/[\[\](){}.:;?]/}}module.exports=e;
+//# sourceMappingURL=oz.cjs.js.map

package/dist/node_modules/refractor/lang/oz.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"oz.cjs.js","sources":["../../../../../node_modules/refractor/lang/oz.js"],"sourcesContent":["// @ts-nocheck\n/**\n * @import {Syntax} from '../core.js'\n */\noz.displayName = 'oz'\noz.aliases = []\n\n/** @type {Syntax} */\nexport default function oz(Prism) {\n  Prism.languages.oz = {\n    comment: {\n      pattern: /\\/\\*[\\s\\S]*?\\*\\/|%.*/,\n      greedy: true\n    },\n    string: {\n      pattern: /\"(?:[^\"\\\\]|\\\\[\\s\\S])*\"/,\n      greedy: true\n    },\n    atom: {\n      pattern: /'(?:[^'\\\\]|\\\\[\\s\\S])*'/,\n      greedy: true,\n      alias: 'builtin'\n    },\n    keyword:\n      /\\$|\\[\\]|\\b(?:_|at|attr|case|catch|choice|class|cond|declare|define|dis|else(?:case|if)?|end|export|fail|false|feat|finally|from|fun|functor|if|import|in|local|lock|meth|nil|not|of|or|prepare|proc|prop|raise|require|self|skip|then|thread|true|try|unit)\\b/,\n    function: [\n      /\\b[a-z][A-Za-z\\d]*(?=\\()/,\n      {\n        pattern: /(\\{)[A-Z][A-Za-z\\d]*\\b/,\n        lookbehind: true\n      }\n    ],\n    number:\n      /\\b(?:0[bx][\\da-f]+|\\d+(?:\\.\\d*)?(?:e~?\\d+)?)\\b|&(?:[^\\\\]|\\\\(?:\\d{3}|.))/i,\n    variable: /`(?:[^`\\\\]|\\\\.)+`/,\n    'attr-name': /\\b\\w+(?=[ \\t]*:(?![:=]))/,\n    operator:\n      /:(?:=|::?)|<[-:=]?|=(?:=|<?:?)|>=?:?|\\\\=:?|!!?|[|#+\\-*\\/,~^@]|\\b(?:andthen|div|mod|orelse)\\b/,\n    punctuation: /[\\[\\](){}.:;?]/\n  }\n}\n"],"names":["oz","Prism"],"mappings":"aAIAA,EAAG,YAAc,KACjBA,EAAG,QAAU,CAAA,EAGE,SAASA,EAAGC,EAAO,CAChCA,EAAM,UAAU,GAAK,CACnB,QAAS,CACP,QAAS,uBACT,OAAQ,EACd,EACI,OAAQ,CACN,QAAS,yBACT,OAAQ,EACd,EACI,KAAM,CACJ,QAAS,yBACT,OAAQ,GACR,MAAO,SACb,EACI,QACE,gQACF,SAAU,CACR,2BACA,CACE,QAAS,yBACT,WAAY,EACpB,CACA,EACI,OACE,2EACF,SAAU,oBACV,YAAa,2BACb,SACE,+FACF,YAAa,gBACjB,CACA","x_google_ignoreList":[0]}

package/dist/node_modules/refractor/lang/oz.es.js

@@ -0,0 +1,36 @@
+e.displayName = "oz";
+e.aliases = [];
+function e(t) {
+  t.languages.oz = {
+    comment: {
+      pattern: /\/\*[\s\S]*?\*\/|%.*/,
+      greedy: !0
+    },
+    string: {
+      pattern: /"(?:[^"\\]|\\[\s\S])*"/,
+      greedy: !0
+    },
+    atom: {
+      pattern: /'(?:[^'\\]|\\[\s\S])*'/,
+      greedy: !0,
+      alias: "builtin"
+    },
+    keyword: /\$|\[\]|\b(?:_|at|attr|case|catch|choice|class|cond|declare|define|dis|else(?:case|if)?|end|export|fail|false|feat|finally|from|fun|functor|if|import|in|local|lock|meth|nil|not|of|or|prepare|proc|prop|raise|require|self|skip|then|thread|true|try|unit)\b/,
+    function: [
+      /\b[a-z][A-Za-z\d]*(?=\()/,
+      {
+        pattern: /(\{)[A-Z][A-Za-z\d]*\b/,
+        lookbehind: !0
+      }
+    ],
+    number: /\b(?:0[bx][\da-f]+|\d+(?:\.\d*)?(?:e~?\d+)?)\b|&(?:[^\\]|\\(?:\d{3}|.))/i,
+    variable: /`(?:[^`\\]|\\.)+`/,
+    "attr-name": /\b\w+(?=[ \t]*:(?![:=]))/,
+    operator: /:(?:=|::?)|<[-:=]?|=(?:=|<?:?)|>=?:?|\\=:?|!!?|[|#+\-*\/,~^@]|\b(?:andthen|div|mod|orelse)\b/,
+    punctuation: /[\[\](){}.:;?]/
+  };
+}
+export {
+  e as default
+};
+//# sourceMappingURL=oz.es.js.map

package/dist/node_modules/refractor/lang/oz.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"oz.es.js","sources":["../../../../../node_modules/refractor/lang/oz.js"],"sourcesContent":["// @ts-nocheck\n/**\n * @import {Syntax} from '../core.js'\n */\noz.displayName = 'oz'\noz.aliases = []\n\n/** @type {Syntax} */\nexport default function oz(Prism) {\n  Prism.languages.oz = {\n    comment: {\n      pattern: /\\/\\*[\\s\\S]*?\\*\\/|%.*/,\n      greedy: true\n    },\n    string: {\n      pattern: /\"(?:[^\"\\\\]|\\\\[\\s\\S])*\"/,\n      greedy: true\n    },\n    atom: {\n      pattern: /'(?:[^'\\\\]|\\\\[\\s\\S])*'/,\n      greedy: true,\n      alias: 'builtin'\n    },\n    keyword:\n      /\\$|\\[\\]|\\b(?:_|at|attr|case|catch|choice|class|cond|declare|define|dis|else(?:case|if)?|end|export|fail|false|feat|finally|from|fun|functor|if|import|in|local|lock|meth|nil|not|of|or|prepare|proc|prop|raise|require|self|skip|then|thread|true|try|unit)\\b/,\n    function: [\n      /\\b[a-z][A-Za-z\\d]*(?=\\()/,\n      {\n        pattern: /(\\{)[A-Z][A-Za-z\\d]*\\b/,\n        lookbehind: true\n      }\n    ],\n    number:\n      /\\b(?:0[bx][\\da-f]+|\\d+(?:\\.\\d*)?(?:e~?\\d+)?)\\b|&(?:[^\\\\]|\\\\(?:\\d{3}|.))/i,\n    variable: /`(?:[^`\\\\]|\\\\.)+`/,\n    'attr-name': /\\b\\w+(?=[ \\t]*:(?![:=]))/,\n    operator:\n      /:(?:=|::?)|<[-:=]?|=(?:=|<?:?)|>=?:?|\\\\=:?|!!?|[|#+\\-*\\/,~^@]|\\b(?:andthen|div|mod|orelse)\\b/,\n    punctuation: /[\\[\\](){}.:;?]/\n  }\n}\n"],"names":["oz","Prism"],"mappings":"AAIAA,EAAG,cAAc;AACjBA,EAAG,UAAU,CAAA;AAGE,SAASA,EAAGC,GAAO;AAChC,EAAAA,EAAM,UAAU,KAAK;AAAA,IACnB,SAAS;AAAA,MACP,SAAS;AAAA,MACT,QAAQ;AAAA,IACd;AAAA,IACI,QAAQ;AAAA,MACN,SAAS;AAAA,MACT,QAAQ;AAAA,IACd;AAAA,IACI,MAAM;AAAA,MACJ,SAAS;AAAA,MACT,QAAQ;AAAA,MACR,OAAO;AAAA,IACb;AAAA,IACI,SACE;AAAA,IACF,UAAU;AAAA,MACR;AAAA,MACA;AAAA,QACE,SAAS;AAAA,QACT,YAAY;AAAA,MACpB;AAAA,IACA;AAAA,IACI,QACE;AAAA,IACF,UAAU;AAAA,IACV,aAAa;AAAA,IACb,UACE;AAAA,IACF,aAAa;AAAA,EACjB;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/refractor/lang/parigp.cjs.js

@@ -0,0 +1,2 @@
+"use strict";e.displayName="parigp";e.aliases=[];function e(o){o.languages.parigp={comment:/\/\*[\s\S]*?\*\/|\\\\.*/,string:{pattern:/"(?:[^"\\\r\n]|\\.)*"/,greedy:!0},keyword:(function(){var r=["breakpoint","break","dbg_down","dbg_err","dbg_up","dbg_x","forcomposite","fordiv","forell","forpart","forprime","forstep","forsubgroup","forvec","for","iferr","if","local","my","next","return","until","while"];return r=r.map(function(t){return t.split("").join(" *")}).join("|"),RegExp("\\b(?:"+r+")\\b")})(),function:/\b\w(?:[\w ]*\w)?(?= *\()/,number:{pattern:/((?:\. *\. *)?)(?:\b\d(?: *\d)*(?: *(?!\. *\.)\.(?: *\d)*)?|\. *\d(?: *\d)*)(?: *e *(?:[+-] *)?\d(?: *\d)*)?/i,lookbehind:!0},operator:/\. *\.|[*\/!](?: *=)?|%(?: *=|(?: *#)?(?: *')*)?|\+(?: *[+=])?|-(?: *[-=>])?|<(?: *>|(?: *<)?(?: *=)?)?|>(?: *>)?(?: *=)?|=(?: *=){0,2}|\\(?: *\/)?(?: *=)?|&(?: *&)?|\| *\||['#~^]/,punctuation:/[\[\]{}().,:;|]/}}module.exports=e;
+//# sourceMappingURL=parigp.cjs.js.map

package/dist/node_modules/refractor/lang/parigp.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parigp.cjs.js","sources":["../../../../../node_modules/refractor/lang/parigp.js"],"sourcesContent":["// @ts-nocheck\n/**\n * @import {Syntax} from '../core.js'\n */\nparigp.displayName = 'parigp'\nparigp.aliases = []\n\n/** @type {Syntax} */\nexport default function parigp(Prism) {\n  Prism.languages.parigp = {\n    comment: /\\/\\*[\\s\\S]*?\\*\\/|\\\\\\\\.*/,\n    string: {\n      pattern: /\"(?:[^\"\\\\\\r\\n]|\\\\.)*\"/,\n      greedy: true\n    },\n    // PARI/GP does not care about white spaces at all\n    // so let's process the keywords to build an appropriate regexp\n    // (e.g. \"b *r *e *a *k\", etc.)\n    keyword: (function () {\n      var keywords = [\n        'breakpoint',\n        'break',\n        'dbg_down',\n        'dbg_err',\n        'dbg_up',\n        'dbg_x',\n        'forcomposite',\n        'fordiv',\n        'forell',\n        'forpart',\n        'forprime',\n        'forstep',\n        'forsubgroup',\n        'forvec',\n        'for',\n        'iferr',\n        'if',\n        'local',\n        'my',\n        'next',\n        'return',\n        'until',\n        'while'\n      ]\n      keywords = keywords\n        .map(function (keyword) {\n          return keyword.split('').join(' *')\n        })\n        .join('|')\n      return RegExp('\\\\b(?:' + keywords + ')\\\\b')\n    })(),\n    function: /\\b\\w(?:[\\w ]*\\w)?(?= *\\()/,\n    number: {\n      // The lookbehind and the negative lookahead prevent from breaking the .. operator\n      pattern:\n        /((?:\\. *\\. *)?)(?:\\b\\d(?: *\\d)*(?: *(?!\\. *\\.)\\.(?: *\\d)*)?|\\. *\\d(?: *\\d)*)(?: *e *(?:[+-] *)?\\d(?: *\\d)*)?/i,\n      lookbehind: true\n    },\n    operator:\n      /\\. *\\.|[*\\/!](?: *=)?|%(?: *=|(?: *#)?(?: *')*)?|\\+(?: *[+=])?|-(?: *[-=>])?|<(?: *>|(?: *<)?(?: *=)?)?|>(?: *>)?(?: *=)?|=(?: *=){0,2}|\\\\(?: *\\/)?(?: *=)?|&(?: *&)?|\\| *\\||['#~^]/,\n    punctuation: /[\\[\\]{}().,:;|]/\n  }\n}\n"],"names":["parigp","Prism","keywords","keyword"],"mappings":"aAIAA,EAAO,YAAc,SACrBA,EAAO,QAAU,CAAA,EAGF,SAASA,EAAOC,EAAO,CACpCA,EAAM,UAAU,OAAS,CACvB,QAAS,0BACT,OAAQ,CACN,QAAS,wBACT,OAAQ,EACd,EAII,SAAU,UAAY,CACpB,IAAIC,EAAW,CACb,aACA,QACA,WACA,UACA,SACA,QACA,eACA,SACA,SACA,UACA,WACA,UACA,cACA,SACA,MACA,QACA,KACA,QACA,KACA,OACA,SACA,QACA,OACR,EACM,OAAAA,EAAWA,EACR,IAAI,SAAUC,EAAS,CACtB,OAAOA,EAAQ,MAAM,EAAE,EAAE,KAAK,IAAI,CACpC,CAAC,EACA,KAAK,GAAG,EACJ,OAAO,SAAWD,EAAW,MAAM,CAC5C,GAAC,EACD,SAAU,4BACV,OAAQ,CAEN,QACE,gHACF,WAAY,EAClB,EACI,SACE,sLACF,YAAa,iBACjB,CACA","x_google_ignoreList":[0]}

package/dist/node_modules/refractor/lang/parigp.es.js

@@ -0,0 +1,56 @@
+e.displayName = "parigp";
+e.aliases = [];
+function e(o) {
+  o.languages.parigp = {
+    comment: /\/\*[\s\S]*?\*\/|\\\\.*/,
+    string: {
+      pattern: /"(?:[^"\\\r\n]|\\.)*"/,
+      greedy: !0
+    },
+    // PARI/GP does not care about white spaces at all
+    // so let's process the keywords to build an appropriate regexp
+    // (e.g. "b *r *e *a *k", etc.)
+    keyword: (function() {
+      var r = [
+        "breakpoint",
+        "break",
+        "dbg_down",
+        "dbg_err",
+        "dbg_up",
+        "dbg_x",
+        "forcomposite",
+        "fordiv",
+        "forell",
+        "forpart",
+        "forprime",
+        "forstep",
+        "forsubgroup",
+        "forvec",
+        "for",
+        "iferr",
+        "if",
+        "local",
+        "my",
+        "next",
+        "return",
+        "until",
+        "while"
+      ];
+      return r = r.map(function(n) {
+        return n.split("").join(" *");
+      }).join("|"), RegExp("\\b(?:" + r + ")\\b");
+    })(),
+    function: /\b\w(?:[\w ]*\w)?(?= *\()/,
+    number: {
+      // The lookbehind and the negative lookahead prevent from breaking the .. operator
+      pattern: /((?:\. *\. *)?)(?:\b\d(?: *\d)*(?: *(?!\. *\.)\.(?: *\d)*)?|\. *\d(?: *\d)*)(?: *e *(?:[+-] *)?\d(?: *\d)*)?/i,
+      lookbehind: !0
+    },
+    operator: /\. *\.|[*\/!](?: *=)?|%(?: *=|(?: *#)?(?: *')*)?|\+(?: *[+=])?|-(?: *[-=>])?|<(?: *>|(?: *<)?(?: *=)?)?|>(?: *>)?(?: *=)?|=(?: *=){0,2}|\\(?: *\/)?(?: *=)?|&(?: *&)?|\| *\||['#~^]/,
+    punctuation: /[\[\]{}().,:;|]/
+  };
+}
+export {
+  e as default
+};
+//# sourceMappingURL=parigp.es.js.map

package/dist/node_modules/refractor/lang/parigp.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parigp.es.js","sources":["../../../../../node_modules/refractor/lang/parigp.js"],"sourcesContent":["// @ts-nocheck\n/**\n * @import {Syntax} from '../core.js'\n */\nparigp.displayName = 'parigp'\nparigp.aliases = []\n\n/** @type {Syntax} */\nexport default function parigp(Prism) {\n  Prism.languages.parigp = {\n    comment: /\\/\\*[\\s\\S]*?\\*\\/|\\\\\\\\.*/,\n    string: {\n      pattern: /\"(?:[^\"\\\\\\r\\n]|\\\\.)*\"/,\n      greedy: true\n    },\n    // PARI/GP does not care about white spaces at all\n    // so let's process the keywords to build an appropriate regexp\n    // (e.g. \"b *r *e *a *k\", etc.)\n    keyword: (function () {\n      var keywords = [\n        'breakpoint',\n        'break',\n        'dbg_down',\n        'dbg_err',\n        'dbg_up',\n        'dbg_x',\n        'forcomposite',\n        'fordiv',\n        'forell',\n        'forpart',\n        'forprime',\n        'forstep',\n        'forsubgroup',\n        'forvec',\n        'for',\n        'iferr',\n        'if',\n        'local',\n        'my',\n        'next',\n        'return',\n        'until',\n        'while'\n      ]\n      keywords = keywords\n        .map(function (keyword) {\n          return keyword.split('').join(' *')\n        })\n        .join('|')\n      return RegExp('\\\\b(?:' + keywords + ')\\\\b')\n    })(),\n    function: /\\b\\w(?:[\\w ]*\\w)?(?= *\\()/,\n    number: {\n      // The lookbehind and the negative lookahead prevent from breaking the .. operator\n      pattern:\n        /((?:\\. *\\. *)?)(?:\\b\\d(?: *\\d)*(?: *(?!\\. *\\.)\\.(?: *\\d)*)?|\\. *\\d(?: *\\d)*)(?: *e *(?:[+-] *)?\\d(?: *\\d)*)?/i,\n      lookbehind: true\n    },\n    operator:\n      /\\. *\\.|[*\\/!](?: *=)?|%(?: *=|(?: *#)?(?: *')*)?|\\+(?: *[+=])?|-(?: *[-=>])?|<(?: *>|(?: *<)?(?: *=)?)?|>(?: *>)?(?: *=)?|=(?: *=){0,2}|\\\\(?: *\\/)?(?: *=)?|&(?: *&)?|\\| *\\||['#~^]/,\n    punctuation: /[\\[\\]{}().,:;|]/\n  }\n}\n"],"names":["parigp","Prism","keywords","keyword"],"mappings":"AAIAA,EAAO,cAAc;AACrBA,EAAO,UAAU,CAAA;AAGF,SAASA,EAAOC,GAAO;AACpC,EAAAA,EAAM,UAAU,SAAS;AAAA,IACvB,SAAS;AAAA,IACT,QAAQ;AAAA,MACN,SAAS;AAAA,MACT,QAAQ;AAAA,IACd;AAAA;AAAA;AAAA;AAAA,IAII,UAAU,WAAY;AACpB,UAAIC,IAAW;AAAA,QACb;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,QACA;AAAA,MACR;AACM,aAAAA,IAAWA,EACR,IAAI,SAAUC,GAAS;AACtB,eAAOA,EAAQ,MAAM,EAAE,EAAE,KAAK,IAAI;AAAA,MACpC,CAAC,EACA,KAAK,GAAG,GACJ,OAAO,WAAWD,IAAW,MAAM;AAAA,IAC5C,GAAC;AAAA,IACD,UAAU;AAAA,IACV,QAAQ;AAAA;AAAA,MAEN,SACE;AAAA,MACF,YAAY;AAAA,IAClB;AAAA,IACI,UACE;AAAA,IACF,aAAa;AAAA,EACjB;AACA;","x_google_ignoreList":[0]}

package/dist/node_modules/refractor/lang/parser.cjs.js

@@ -0,0 +1,2 @@
+"use strict";const r=require("./markup.cjs.js");t.displayName="parser";t.aliases=[];function t(a){a.register(r),(function(n){var e=n.languages.parser=n.languages.extend("markup",{keyword:{pattern:/(^|[^^])(?:\^(?:case|eval|for|if|switch|throw)\b|@(?:BASE|CLASS|GET(?:_DEFAULT)?|OPTIONS|SET_DEFAULT|USE)\b)/,lookbehind:!0},variable:{pattern:/(^|[^^])\B\$(?:\w+|(?=[.{]))(?:(?:\.|::?)\w+)*(?:\.|::?)?/,lookbehind:!0,inside:{punctuation:/\.|:+/}},function:{pattern:/(^|[^^])\B[@^]\w+(?:(?:\.|::?)\w+)*(?:\.|::?)?/,lookbehind:!0,inside:{keyword:{pattern:/(^@)(?:GET_|SET_)/,lookbehind:!0},punctuation:/\.|:+/}},escape:{pattern:/\^(?:[$^;@()\[\]{}"':]|#[a-f\d]*)/i,alias:"builtin"},punctuation:/[\[\](){};]/});e=n.languages.insertBefore("parser","keyword",{"parser-comment":{pattern:/(\s)#.*/,lookbehind:!0,alias:"comment"},expression:{pattern:/(^|[^^])\((?:[^()]|\((?:[^()]|\((?:[^()])*\))*\))*\)/,greedy:!0,lookbehind:!0,inside:{string:{pattern:/(^|[^^])(["'])(?:(?!\2)[^^]|\^[\s\S])*\2/,lookbehind:!0},keyword:e.keyword,variable:e.variable,function:e.function,boolean:/\b(?:false|true)\b/,number:/\b(?:0x[a-f\d]+|\d+(?:\.\d*)?(?:e[+-]?\d+)?)\b/i,escape:e.escape,operator:/[~+*\/\\%]|!(?:\|\|?|=)?|&&?|\|\|?|==|<[<=]?|>[>=]?|-[fd]?|\b(?:def|eq|ge|gt|in|is|le|lt|ne)\b/,punctuation:e.punctuation}}}),n.languages.insertBefore("inside","punctuation",{expression:e.expression,keyword:e.keyword,variable:e.variable,function:e.function,escape:e.escape,"parser-punctuation":{pattern:e.punctuation,alias:"punctuation"}},e.tag.inside["attr-value"])})(a)}module.exports=t;
+//# sourceMappingURL=parser.cjs.js.map

package/dist/node_modules/refractor/lang/parser.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.cjs.js","sources":["../../../../../node_modules/refractor/lang/parser.js"],"sourcesContent":["// @ts-nocheck\n/**\n * @import {Syntax} from '../core.js'\n */\nimport refractorMarkup from './markup.js'\nparser.displayName = 'parser'\nparser.aliases = []\n\n/** @type {Syntax} */\nexport default function parser(Prism) {\n  Prism.register(refractorMarkup)\n  ;(function (Prism) {\n    var parser = (Prism.languages.parser = Prism.languages.extend('markup', {\n      keyword: {\n        pattern:\n          /(^|[^^])(?:\\^(?:case|eval|for|if|switch|throw)\\b|@(?:BASE|CLASS|GET(?:_DEFAULT)?|OPTIONS|SET_DEFAULT|USE)\\b)/,\n        lookbehind: true\n      },\n      variable: {\n        pattern: /(^|[^^])\\B\\$(?:\\w+|(?=[.{]))(?:(?:\\.|::?)\\w+)*(?:\\.|::?)?/,\n        lookbehind: true,\n        inside: {\n          punctuation: /\\.|:+/\n        }\n      },\n      function: {\n        pattern: /(^|[^^])\\B[@^]\\w+(?:(?:\\.|::?)\\w+)*(?:\\.|::?)?/,\n        lookbehind: true,\n        inside: {\n          keyword: {\n            pattern: /(^@)(?:GET_|SET_)/,\n            lookbehind: true\n          },\n          punctuation: /\\.|:+/\n        }\n      },\n      escape: {\n        pattern: /\\^(?:[$^;@()\\[\\]{}\"':]|#[a-f\\d]*)/i,\n        alias: 'builtin'\n      },\n      punctuation: /[\\[\\](){};]/\n    }))\n    parser = Prism.languages.insertBefore('parser', 'keyword', {\n      'parser-comment': {\n        pattern: /(\\s)#.*/,\n        lookbehind: true,\n        alias: 'comment'\n      },\n      expression: {\n        // Allow for 3 levels of depth\n        pattern: /(^|[^^])\\((?:[^()]|\\((?:[^()]|\\((?:[^()])*\\))*\\))*\\)/,\n        greedy: true,\n        lookbehind: true,\n        inside: {\n          string: {\n            pattern: /(^|[^^])([\"'])(?:(?!\\2)[^^]|\\^[\\s\\S])*\\2/,\n            lookbehind: true\n          },\n          keyword: parser.keyword,\n          variable: parser.variable,\n          function: parser.function,\n          boolean: /\\b(?:false|true)\\b/,\n          number: /\\b(?:0x[a-f\\d]+|\\d+(?:\\.\\d*)?(?:e[+-]?\\d+)?)\\b/i,\n          escape: parser.escape,\n          operator:\n            /[~+*\\/\\\\%]|!(?:\\|\\|?|=)?|&&?|\\|\\|?|==|<[<=]?|>[>=]?|-[fd]?|\\b(?:def|eq|ge|gt|in|is|le|lt|ne)\\b/,\n          punctuation: parser.punctuation\n        }\n      }\n    })\n    Prism.languages.insertBefore(\n      'inside',\n      'punctuation',\n      {\n        expression: parser.expression,\n        keyword: parser.keyword,\n        variable: parser.variable,\n        function: parser.function,\n        escape: parser.escape,\n        'parser-punctuation': {\n          pattern: parser.punctuation,\n          alias: 'punctuation'\n        }\n      },\n      parser['tag'].inside['attr-value']\n    )\n  })(Prism)\n}\n"],"names":["parser","Prism","refractorMarkup"],"mappings":"gDAKAA,EAAO,YAAc,SACrBA,EAAO,QAAU,CAAA,EAGF,SAASA,EAAOC,EAAO,CACpCA,EAAM,SAASC,CAAe,GAC5B,SAAUD,EAAO,CACjB,IAAID,EAAUC,EAAM,UAAU,OAASA,EAAM,UAAU,OAAO,SAAU,CACtE,QAAS,CACP,QACE,+GACF,WAAY,EACpB,EACM,SAAU,CACR,QAAS,4DACT,WAAY,GACZ,OAAQ,CACN,YAAa,OACvB,CACA,EACM,SAAU,CACR,QAAS,iDACT,WAAY,GACZ,OAAQ,CACN,QAAS,CACP,QAAS,oBACT,WAAY,EACxB,EACU,YAAa,OACvB,CACA,EACM,OAAQ,CACN,QAAS,qCACT,MAAO,SACf,EACM,YAAa,aACnB,CAAK,EACDD,EAASC,EAAM,UAAU,aAAa,SAAU,UAAW,CACzD,iBAAkB,CAChB,QAAS,UACT,WAAY,GACZ,MAAO,SACf,EACM,WAAY,CAEV,QAAS,uDACT,OAAQ,GACR,WAAY,GACZ,OAAQ,CACN,OAAQ,CACN,QAAS,2CACT,WAAY,EACxB,EACU,QAASD,EAAO,QAChB,SAAUA,EAAO,SACjB,SAAUA,EAAO,SACjB,QAAS,qBACT,OAAQ,kDACR,OAAQA,EAAO,OACf,SACE,iGACF,YAAaA,EAAO,WAC9B,CACA,CACA,CAAK,EACDC,EAAM,UAAU,aACd,SACA,cACA,CACE,WAAYD,EAAO,WACnB,QAASA,EAAO,QAChB,SAAUA,EAAO,SACjB,SAAUA,EAAO,SACjB,OAAQA,EAAO,OACf,qBAAsB,CACpB,QAASA,EAAO,YAChB,MAAO,aACjB,CACA,EACMA,EAAO,IAAO,OAAO,YAAY,CACvC,CACE,GAAGC,CAAK,CACV","x_google_ignoreList":[0]}

package/dist/node_modules/refractor/lang/parser.es.js

@@ -0,0 +1,82 @@
+import r from "./markup.es.js";
+t.displayName = "parser";
+t.aliases = [];
+function t(n) {
+  n.register(r), (function(a) {
+    var e = a.languages.parser = a.languages.extend("markup", {
+      keyword: {
+        pattern: /(^|[^^])(?:\^(?:case|eval|for|if|switch|throw)\b|@(?:BASE|CLASS|GET(?:_DEFAULT)?|OPTIONS|SET_DEFAULT|USE)\b)/,
+        lookbehind: !0
+      },
+      variable: {
+        pattern: /(^|[^^])\B\$(?:\w+|(?=[.{]))(?:(?:\.|::?)\w+)*(?:\.|::?)?/,
+        lookbehind: !0,
+        inside: {
+          punctuation: /\.|:+/
+        }
+      },
+      function: {
+        pattern: /(^|[^^])\B[@^]\w+(?:(?:\.|::?)\w+)*(?:\.|::?)?/,
+        lookbehind: !0,
+        inside: {
+          keyword: {
+            pattern: /(^@)(?:GET_|SET_)/,
+            lookbehind: !0
+          },
+          punctuation: /\.|:+/
+        }
+      },
+      escape: {
+        pattern: /\^(?:[$^;@()\[\]{}"':]|#[a-f\d]*)/i,
+        alias: "builtin"
+      },
+      punctuation: /[\[\](){};]/
+    });
+    e = a.languages.insertBefore("parser", "keyword", {
+      "parser-comment": {
+        pattern: /(\s)#.*/,
+        lookbehind: !0,
+        alias: "comment"
+      },
+      expression: {
+        // Allow for 3 levels of depth
+        pattern: /(^|[^^])\((?:[^()]|\((?:[^()]|\((?:[^()])*\))*\))*\)/,
+        greedy: !0,
+        lookbehind: !0,
+        inside: {
+          string: {
+            pattern: /(^|[^^])(["'])(?:(?!\2)[^^]|\^[\s\S])*\2/,
+            lookbehind: !0
+          },
+          keyword: e.keyword,
+          variable: e.variable,
+          function: e.function,
+          boolean: /\b(?:false|true)\b/,
+          number: /\b(?:0x[a-f\d]+|\d+(?:\.\d*)?(?:e[+-]?\d+)?)\b/i,
+          escape: e.escape,
+          operator: /[~+*\/\\%]|!(?:\|\|?|=)?|&&?|\|\|?|==|<[<=]?|>[>=]?|-[fd]?|\b(?:def|eq|ge|gt|in|is|le|lt|ne)\b/,
+          punctuation: e.punctuation
+        }
+      }
+    }), a.languages.insertBefore(
+      "inside",
+      "punctuation",
+      {
+        expression: e.expression,
+        keyword: e.keyword,
+        variable: e.variable,
+        function: e.function,
+        escape: e.escape,
+        "parser-punctuation": {
+          pattern: e.punctuation,
+          alias: "punctuation"
+        }
+      },
+      e.tag.inside["attr-value"]
+    );
+  })(n);
+}
+export {
+  t as default
+};
+//# sourceMappingURL=parser.es.js.map

package/dist/node_modules/refractor/lang/parser.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parser.es.js","sources":["../../../../../node_modules/refractor/lang/parser.js"],"sourcesContent":["// @ts-nocheck\n/**\n * @import {Syntax} from '../core.js'\n */\nimport refractorMarkup from './markup.js'\nparser.displayName = 'parser'\nparser.aliases = []\n\n/** @type {Syntax} */\nexport default function parser(Prism) {\n  Prism.register(refractorMarkup)\n  ;(function (Prism) {\n    var parser = (Prism.languages.parser = Prism.languages.extend('markup', {\n      keyword: {\n        pattern:\n          /(^|[^^])(?:\\^(?:case|eval|for|if|switch|throw)\\b|@(?:BASE|CLASS|GET(?:_DEFAULT)?|OPTIONS|SET_DEFAULT|USE)\\b)/,\n        lookbehind: true\n      },\n      variable: {\n        pattern: /(^|[^^])\\B\\$(?:\\w+|(?=[.{]))(?:(?:\\.|::?)\\w+)*(?:\\.|::?)?/,\n        lookbehind: true,\n        inside: {\n          punctuation: /\\.|:+/\n        }\n      },\n      function: {\n        pattern: /(^|[^^])\\B[@^]\\w+(?:(?:\\.|::?)\\w+)*(?:\\.|::?)?/,\n        lookbehind: true,\n        inside: {\n          keyword: {\n            pattern: /(^@)(?:GET_|SET_)/,\n            lookbehind: true\n          },\n          punctuation: /\\.|:+/\n        }\n      },\n      escape: {\n        pattern: /\\^(?:[$^;@()\\[\\]{}\"':]|#[a-f\\d]*)/i,\n        alias: 'builtin'\n      },\n      punctuation: /[\\[\\](){};]/\n    }))\n    parser = Prism.languages.insertBefore('parser', 'keyword', {\n      'parser-comment': {\n        pattern: /(\\s)#.*/,\n        lookbehind: true,\n        alias: 'comment'\n      },\n      expression: {\n        // Allow for 3 levels of depth\n        pattern: /(^|[^^])\\((?:[^()]|\\((?:[^()]|\\((?:[^()])*\\))*\\))*\\)/,\n        greedy: true,\n        lookbehind: true,\n        inside: {\n          string: {\n            pattern: /(^|[^^])([\"'])(?:(?!\\2)[^^]|\\^[\\s\\S])*\\2/,\n            lookbehind: true\n          },\n          keyword: parser.keyword,\n          variable: parser.variable,\n          function: parser.function,\n          boolean: /\\b(?:false|true)\\b/,\n          number: /\\b(?:0x[a-f\\d]+|\\d+(?:\\.\\d*)?(?:e[+-]?\\d+)?)\\b/i,\n          escape: parser.escape,\n          operator:\n            /[~+*\\/\\\\%]|!(?:\\|\\|?|=)?|&&?|\\|\\|?|==|<[<=]?|>[>=]?|-[fd]?|\\b(?:def|eq|ge|gt|in|is|le|lt|ne)\\b/,\n          punctuation: parser.punctuation\n        }\n      }\n    })\n    Prism.languages.insertBefore(\n      'inside',\n      'punctuation',\n      {\n        expression: parser.expression,\n        keyword: parser.keyword,\n        variable: parser.variable,\n        function: parser.function,\n        escape: parser.escape,\n        'parser-punctuation': {\n          pattern: parser.punctuation,\n          alias: 'punctuation'\n        }\n      },\n      parser['tag'].inside['attr-value']\n    )\n  })(Prism)\n}\n"],"names":["parser","Prism","refractorMarkup"],"mappings":";AAKAA,EAAO,cAAc;AACrBA,EAAO,UAAU,CAAA;AAGF,SAASA,EAAOC,GAAO;AACpC,EAAAA,EAAM,SAASC,CAAe,IAC5B,SAAUD,GAAO;AACjB,QAAID,IAAUC,EAAM,UAAU,SAASA,EAAM,UAAU,OAAO,UAAU;AAAA,MACtE,SAAS;AAAA,QACP,SACE;AAAA,QACF,YAAY;AAAA,MACpB;AAAA,MACM,UAAU;AAAA,QACR,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,QAAQ;AAAA,UACN,aAAa;AAAA,QACvB;AAAA,MACA;AAAA,MACM,UAAU;AAAA,QACR,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,QAAQ;AAAA,UACN,SAAS;AAAA,YACP,SAAS;AAAA,YACT,YAAY;AAAA,UACxB;AAAA,UACU,aAAa;AAAA,QACvB;AAAA,MACA;AAAA,MACM,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,OAAO;AAAA,MACf;AAAA,MACM,aAAa;AAAA,IACnB,CAAK;AACD,IAAAD,IAASC,EAAM,UAAU,aAAa,UAAU,WAAW;AAAA,MACzD,kBAAkB;AAAA,QAChB,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,OAAO;AAAA,MACf;AAAA,MACM,YAAY;AAAA;AAAA,QAEV,SAAS;AAAA,QACT,QAAQ;AAAA,QACR,YAAY;AAAA,QACZ,QAAQ;AAAA,UACN,QAAQ;AAAA,YACN,SAAS;AAAA,YACT,YAAY;AAAA,UACxB;AAAA,UACU,SAASD,EAAO;AAAA,UAChB,UAAUA,EAAO;AAAA,UACjB,UAAUA,EAAO;AAAA,UACjB,SAAS;AAAA,UACT,QAAQ;AAAA,UACR,QAAQA,EAAO;AAAA,UACf,UACE;AAAA,UACF,aAAaA,EAAO;AAAA,QAC9B;AAAA,MACA;AAAA,IACA,CAAK,GACDC,EAAM,UAAU;AAAA,MACd;AAAA,MACA;AAAA,MACA;AAAA,QACE,YAAYD,EAAO;AAAA,QACnB,SAASA,EAAO;AAAA,QAChB,UAAUA,EAAO;AAAA,QACjB,UAAUA,EAAO;AAAA,QACjB,QAAQA,EAAO;AAAA,QACf,sBAAsB;AAAA,UACpB,SAASA,EAAO;AAAA,UAChB,OAAO;AAAA,QACjB;AAAA,MACA;AAAA,MACMA,EAAO,IAAO,OAAO,YAAY;AAAA,IACvC;AAAA,EACE,GAAGC,CAAK;AACV;","x_google_ignoreList":[0]}

package/dist/node_modules/refractor/lang/pascal.cjs.js

@@ -0,0 +1,2 @@
+"use strict";a.displayName="pascal";a.aliases=["objectpascal"];function a(e){e.languages.pascal={directive:{pattern:/\{\$[\s\S]*?\}/,greedy:!0,alias:["marco","property"]},comment:{pattern:/\(\*[\s\S]*?\*\)|\{[\s\S]*?\}|\/\/.*/,greedy:!0},string:{pattern:/(?:'(?:''|[^'\r\n])*'(?!')|#[&$%]?[a-f\d]+)+|\^[a-z]/i,greedy:!0},asm:{pattern:/(\basm\b)[\s\S]+?(?=\bend\s*[;[])/i,lookbehind:!0,greedy:!0,inside:null},keyword:[{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:!0},{pattern:/(^|[^&])\b(?:dispose|exit|false|new|true)\b/i,lookbehind:!0},{pattern:/(^|[^&])\b(?:class|dispinterface|except|exports|finalization|finally|initialization|inline|library|on|out|packed|property|raise|resourcestring|threadvar|try)\b/i,lookbehind:!0},{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:!0}],number:[/(?:[&%]\d+|\$[a-f\d]+)/i,/\b\d+(?:\.\d+)?(?:e[+-]?\d+)?/i],operator:[/\.\.|\*\*|:=|<[<=>]?|>[>=]?|[+\-*\/]=?|[@^=]/,{pattern:/(^|[^&])\b(?:and|as|div|exclude|in|include|is|mod|not|or|shl|shr|xor)\b/,lookbehind:!0}],punctuation:/\(\.|\.\)|[()\[\]:;,.]/},e.languages.pascal.asm.inside=e.languages.extend("pascal",{asm:void 0,keyword:void 0,operator:void 0}),e.languages.objectpascal=e.languages.pascal}module.exports=a;
+//# sourceMappingURL=pascal.cjs.js.map

package/dist/node_modules/refractor/lang/pascal.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pascal.cjs.js","sources":["../../../../../node_modules/refractor/lang/pascal.js"],"sourcesContent":["// @ts-nocheck\n/**\n * @import {Syntax} from '../core.js'\n */\npascal.displayName = 'pascal'\npascal.aliases = ['objectpascal']\n\n/** @type {Syntax} */\nexport default function pascal(Prism) {\n  // Based on Free Pascal\n\n  /* TODO\nSupport inline asm ?\n*/\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,\n      // 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","Prism"],"mappings":"aAIAA,EAAO,YAAc,SACrBA,EAAO,QAAU,CAAC,cAAc,EAGjB,SAASA,EAAOC,EAAO,CAOpCA,EAAM,UAAU,OAAS,CACvB,UAAW,CACT,QAAS,iBACT,OAAQ,GACR,MAAO,CAAC,QAAS,UAAU,CACjC,EACI,QAAS,CACP,QAAS,uCACT,OAAQ,EACd,EACI,OAAQ,CACN,QAAS,wDACT,OAAQ,EACd,EACI,IAAK,CACH,QAAS,qCACT,WAAY,GACZ,OAAQ,GACR,OAAQ,IACd,EACI,QAAS,CACP,CAEE,QACE,iTACF,WAAY,EACpB,EACM,CAEE,QAAS,+CACT,WAAY,EACpB,EACM,CAEE,QACE,mKACF,WAAY,EACpB,EACM,CAEE,QACE,mhBACF,WAAY,EACpB,CACA,EACI,OAAQ,CAEN,0BAEA,gCACN,EACI,SAAU,CACR,+CACA,CACE,QACE,0EACF,WAAY,EACpB,CACA,EACI,YAAa,wBACjB,EACEA,EAAM,UAAU,OAAO,IAAI,OAASA,EAAM,UAAU,OAAO,SAAU,CACnE,IAAK,OACL,QAAS,OACT,SAAU,MACd,CAAG,EACDA,EAAM,UAAU,aAAeA,EAAM,UAAU,MACjD","x_google_ignoreList":[0]}

package/dist/node_modules/refractor/lang/pascal.es.js

@@ -0,0 +1,70 @@
+a.displayName = "pascal";
+a.aliases = ["objectpascal"];
+function a(e) {
+  e.languages.pascal = {
+    directive: {
+      pattern: /\{\$[\s\S]*?\}/,
+      greedy: !0,
+      alias: ["marco", "property"]
+    },
+    comment: {
+      pattern: /\(\*[\s\S]*?\*\)|\{[\s\S]*?\}|\/\/.*/,
+      greedy: !0
+    },
+    string: {
+      pattern: /(?:'(?:''|[^'\r\n])*'(?!')|#[&$%]?[a-f\d]+)+|\^[a-z]/i,
+      greedy: !0
+    },
+    asm: {
+      pattern: /(\basm\b)[\s\S]+?(?=\bend\s*[;[])/i,
+      lookbehind: !0,
+      greedy: !0,
+      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: !0
+      },
+      {
+        // Free Pascal
+        pattern: /(^|[^&])\b(?:dispose|exit|false|new|true)\b/i,
+        lookbehind: !0
+      },
+      {
+        // Object Pascal
+        pattern: /(^|[^&])\b(?:class|dispinterface|except|exports|finalization|finally|initialization|inline|library|on|out|packed|property|raise|resourcestring|threadvar|try)\b/i,
+        lookbehind: !0
+      },
+      {
+        // 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: !0
+      }
+    ],
+    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: !0
+      }
+    ],
+    punctuation: /\(\.|\.\)|[()\[\]:;,.]/
+  }, e.languages.pascal.asm.inside = e.languages.extend("pascal", {
+    asm: void 0,
+    keyword: void 0,
+    operator: void 0
+  }), e.languages.objectpascal = e.languages.pascal;
+}
+export {
+  a as default
+};
+//# sourceMappingURL=pascal.es.js.map

package/dist/node_modules/refractor/lang/pascal.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pascal.es.js","sources":["../../../../../node_modules/refractor/lang/pascal.js"],"sourcesContent":["// @ts-nocheck\n/**\n * @import {Syntax} from '../core.js'\n */\npascal.displayName = 'pascal'\npascal.aliases = ['objectpascal']\n\n/** @type {Syntax} */\nexport default function pascal(Prism) {\n  // Based on Free Pascal\n\n  /* TODO\nSupport inline asm ?\n*/\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,\n      // 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","Prism"],"mappings":"AAIAA,EAAO,cAAc;AACrBA,EAAO,UAAU,CAAC,cAAc;AAGjB,SAASA,EAAOC,GAAO;AAOpC,EAAAA,EAAM,UAAU,SAAS;AAAA,IACvB,WAAW;AAAA,MACT,SAAS;AAAA,MACT,QAAQ;AAAA,MACR,OAAO,CAAC,SAAS,UAAU;AAAA,IACjC;AAAA,IACI,SAAS;AAAA,MACP,SAAS;AAAA,MACT,QAAQ;AAAA,IACd;AAAA,IACI,QAAQ;AAAA,MACN,SAAS;AAAA,MACT,QAAQ;AAAA,IACd;AAAA,IACI,KAAK;AAAA,MACH,SAAS;AAAA,MACT,YAAY;AAAA,MACZ,QAAQ;AAAA,MACR,QAAQ;AAAA;AAAA,IACd;AAAA,IACI,SAAS;AAAA,MACP;AAAA;AAAA,QAEE,SACE;AAAA,QACF,YAAY;AAAA,MACpB;AAAA,MACM;AAAA;AAAA,QAEE,SAAS;AAAA,QACT,YAAY;AAAA,MACpB;AAAA,MACM;AAAA;AAAA,QAEE,SACE;AAAA,QACF,YAAY;AAAA,MACpB;AAAA,MACM;AAAA;AAAA,QAEE,SACE;AAAA,QACF,YAAY;AAAA,MACpB;AAAA,IACA;AAAA,IACI,QAAQ;AAAA;AAAA,MAEN;AAAA;AAAA,MAEA;AAAA,IACN;AAAA,IACI,UAAU;AAAA,MACR;AAAA,MACA;AAAA,QACE,SACE;AAAA,QACF,YAAY;AAAA,MACpB;AAAA,IACA;AAAA,IACI,aAAa;AAAA,EACjB,GACEA,EAAM,UAAU,OAAO,IAAI,SAASA,EAAM,UAAU,OAAO,UAAU;AAAA,IACnE,KAAK;AAAA,IACL,SAAS;AAAA,IACT,UAAU;AAAA,EACd,CAAG,GACDA,EAAM,UAAU,eAAeA,EAAM,UAAU;AACjD;","x_google_ignoreList":[0]}

package/dist/node_modules/refractor/lang/pascaligo.cjs.js

@@ -0,0 +1,2 @@
+"use strict";t.displayName="pascaligo";t.aliases=[];function t(o){(function(a){var s=/\((?:[^()]|\((?:[^()]|\([^()]*\))*\))*\)/.source,n=/(?:\b\w+(?:<braces>)?|<braces>)/.source.replace(/<braces>/g,function(){return s}),r=a.languages.pascaligo={comment:/\(\*[\s\S]+?\*\)|\/\/.*/,string:{pattern:/(["'`])(?:\\[\s\S]|(?!\1)[^\\])*\1|\^[a-z]/i,greedy:!0},"class-name":[{pattern:RegExp(/(\btype\s+\w+\s+is\s+)<type>/.source.replace(/<type>/g,function(){return n}),"i"),lookbehind:!0,inside:null},{pattern:RegExp(/<type>(?=\s+is\b)/.source.replace(/<type>/g,function(){return n}),"i"),inside:null},{pattern:RegExp(/(:\s*)<type>/.source.replace(/<type>/g,function(){return n})),lookbehind:!0,inside:null}],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:!0},boolean:{pattern:/(^|[^&])\b(?:False|True)\b/i,lookbehind:!0},builtin:{pattern:/(^|[^&])\b(?:bool|int|list|map|nat|record|string|unit)\b/i,lookbehind:!0},function:/\b\w+(?=\s*\()/,number:[/%[01]+|&[0-7]+|\$[a-f\d]+/i,/\b\d+(?:\.\d+)?(?:e[+-]?\d+)?(?:mtz|n)?/i],operator:/->|=\/=|\.\.|\*\*|:=|<[<=>]?|>[>=]?|[+\-*\/]=?|[@^=|]|\b(?:and|mod|or)\b/,punctuation:/\(\.|\.\)|[()\[\]:;,.{}]/},u=["comment","keyword","builtin","operator","punctuation"].reduce(function(e,i){return e[i]=r[i],e},{});r["class-name"].forEach(function(e){e.inside=u})})(o)}module.exports=t;
+//# sourceMappingURL=pascaligo.cjs.js.map

package/dist/node_modules/refractor/lang/pascaligo.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pascaligo.cjs.js","sources":["../../../../../node_modules/refractor/lang/pascaligo.js"],"sourcesContent":["// @ts-nocheck\n/**\n * @import {Syntax} from '../core.js'\n */\npascaligo.displayName = 'pascaligo'\npascaligo.aliases = []\n\n/** @type {Syntax} */\nexport default function pascaligo(Prism) {\n  ;(function (Prism) {\n    // Pascaligo is a layer 2 smart contract language for the tezos blockchain\n\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,\n        // 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","braces","type","classNameInside","accum","key","p"],"mappings":"aAIAA,EAAU,YAAc,YACxBA,EAAU,QAAU,CAAA,EAGL,SAASA,EAAUC,EAAO,EACrC,SAAUA,EAAO,CAGjB,IAAIC,EAAS,2CAA2C,OACpDC,EAAO,kCAAkC,OAAO,QAClD,YACA,UAAY,CACV,OAAOD,CACT,CACN,EACQF,EAAaC,EAAM,UAAU,UAAY,CAC3C,QAAS,0BACT,OAAQ,CACN,QAAS,8CACT,OAAQ,EAChB,EACM,aAAc,CACZ,CACE,QAAS,OACP,+BAA+B,OAAO,QACpC,UACA,UAAY,CACV,OAAOE,CACT,CACd,EACY,GACZ,EACU,WAAY,GACZ,OAAQ,IAClB,EACQ,CACE,QAAS,OACP,oBAAoB,OAAO,QAAQ,UAAW,UAAY,CACxD,OAAOA,CACT,CAAC,EACD,GACZ,EACU,OAAQ,IAClB,EACQ,CACE,QAAS,OACP,eAAe,OAAO,QAAQ,UAAW,UAAY,CACnD,OAAOA,CACT,CAAC,CACb,EACU,WAAY,GACZ,OAAQ,IAClB,CACA,EACM,QAAS,CACP,QACE,mIACF,WAAY,EACpB,EACM,QAAS,CACP,QAAS,8BACT,WAAY,EACpB,EACM,QAAS,CACP,QAAS,4DACT,WAAY,EACpB,EACM,SAAU,iBACV,OAAQ,CAEN,6BAEA,0CACR,EACM,SACE,2EACF,YAAa,0BACnB,EACQC,EAAkB,CACpB,UACA,UACA,UACA,WACA,aACN,EAAM,OAAO,SAAUC,EAAOC,EAAK,CAC7B,OAAAD,EAAMC,CAAG,EAAIN,EAAUM,CAAG,EACnBD,CACT,EAAG,CAAA,CAAE,EACLL,EAAU,YAAY,EAAE,QAAQ,SAAUO,EAAG,CAC3CA,EAAE,OAASH,CACb,CAAC,CACH,GAAGH,CAAK,CACV","x_google_ignoreList":[0]}

package/dist/node_modules/refractor/lang/pascaligo.es.js

@@ -0,0 +1,90 @@
+i.displayName = "pascaligo";
+i.aliases = [];
+function i(a) {
+  (function(o) {
+    var s = /\((?:[^()]|\((?:[^()]|\([^()]*\))*\))*\)/.source, n = /(?:\b\w+(?:<braces>)?|<braces>)/.source.replace(
+      /<braces>/g,
+      function() {
+        return s;
+      }
+    ), t = o.languages.pascaligo = {
+      comment: /\(\*[\s\S]+?\*\)|\/\/.*/,
+      string: {
+        pattern: /(["'`])(?:\\[\s\S]|(?!\1)[^\\])*\1|\^[a-z]/i,
+        greedy: !0
+      },
+      "class-name": [
+        {
+          pattern: RegExp(
+            /(\btype\s+\w+\s+is\s+)<type>/.source.replace(
+              /<type>/g,
+              function() {
+                return n;
+              }
+            ),
+            "i"
+          ),
+          lookbehind: !0,
+          inside: null
+          // see below
+        },
+        {
+          pattern: RegExp(
+            /<type>(?=\s+is\b)/.source.replace(/<type>/g, function() {
+              return n;
+            }),
+            "i"
+          ),
+          inside: null
+          // see below
+        },
+        {
+          pattern: RegExp(
+            /(:\s*)<type>/.source.replace(/<type>/g, function() {
+              return n;
+            })
+          ),
+          lookbehind: !0,
+          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: !0
+      },
+      boolean: {
+        pattern: /(^|[^&])\b(?:False|True)\b/i,
+        lookbehind: !0
+      },
+      builtin: {
+        pattern: /(^|[^&])\b(?:bool|int|list|map|nat|record|string|unit)\b/i,
+        lookbehind: !0
+      },
+      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: /\(\.|\.\)|[()\[\]:;,.{}]/
+    }, u = [
+      "comment",
+      "keyword",
+      "builtin",
+      "operator",
+      "punctuation"
+    ].reduce(function(e, r) {
+      return e[r] = t[r], e;
+    }, {});
+    t["class-name"].forEach(function(e) {
+      e.inside = u;
+    });
+  })(a);
+}
+export {
+  i as default
+};
+//# sourceMappingURL=pascaligo.es.js.map

package/dist/node_modules/refractor/lang/pascaligo.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pascaligo.es.js","sources":["../../../../../node_modules/refractor/lang/pascaligo.js"],"sourcesContent":["// @ts-nocheck\n/**\n * @import {Syntax} from '../core.js'\n */\npascaligo.displayName = 'pascaligo'\npascaligo.aliases = []\n\n/** @type {Syntax} */\nexport default function pascaligo(Prism) {\n  ;(function (Prism) {\n    // Pascaligo is a layer 2 smart contract language for the tezos blockchain\n\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,\n        // 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","braces","type","classNameInside","accum","key","p"],"mappings":"AAIAA,EAAU,cAAc;AACxBA,EAAU,UAAU,CAAA;AAGL,SAASA,EAAUC,GAAO;AACtC,GAAC,SAAUA,GAAO;AAGjB,QAAIC,IAAS,2CAA2C,QACpDC,IAAO,kCAAkC,OAAO;AAAA,MAClD;AAAA,MACA,WAAY;AACV,eAAOD;AAAA,MACT;AAAA,IACN,GACQF,IAAaC,EAAM,UAAU,YAAY;AAAA,MAC3C,SAAS;AAAA,MACT,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,QAAQ;AAAA,MAChB;AAAA,MACM,cAAc;AAAA,QACZ;AAAA,UACE,SAAS;AAAA,YACP,+BAA+B,OAAO;AAAA,cACpC;AAAA,cACA,WAAY;AACV,uBAAOE;AAAA,cACT;AAAA,YACd;AAAA,YACY;AAAA,UACZ;AAAA,UACU,YAAY;AAAA,UACZ,QAAQ;AAAA;AAAA,QAClB;AAAA,QACQ;AAAA,UACE,SAAS;AAAA,YACP,oBAAoB,OAAO,QAAQ,WAAW,WAAY;AACxD,qBAAOA;AAAA,YACT,CAAC;AAAA,YACD;AAAA,UACZ;AAAA,UACU,QAAQ;AAAA;AAAA,QAClB;AAAA,QACQ;AAAA,UACE,SAAS;AAAA,YACP,eAAe,OAAO,QAAQ,WAAW,WAAY;AACnD,qBAAOA;AAAA,YACT,CAAC;AAAA,UACb;AAAA,UACU,YAAY;AAAA,UACZ,QAAQ;AAAA;AAAA,QAClB;AAAA,MACA;AAAA,MACM,SAAS;AAAA,QACP,SACE;AAAA,QACF,YAAY;AAAA,MACpB;AAAA,MACM,SAAS;AAAA,QACP,SAAS;AAAA,QACT,YAAY;AAAA,MACpB;AAAA,MACM,SAAS;AAAA,QACP,SAAS;AAAA,QACT,YAAY;AAAA,MACpB;AAAA,MACM,UAAU;AAAA,MACV,QAAQ;AAAA;AAAA,QAEN;AAAA;AAAA,QAEA;AAAA,MACR;AAAA,MACM,UACE;AAAA,MACF,aAAa;AAAA,IACnB,GACQC,IAAkB;AAAA,MACpB;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACN,EAAM,OAAO,SAAUC,GAAOC,GAAK;AAC7B,aAAAD,EAAMC,CAAG,IAAIN,EAAUM,CAAG,GACnBD;AAAA,IACT,GAAG,CAAA,CAAE;AACL,IAAAL,EAAU,YAAY,EAAE,QAAQ,SAAUO,GAAG;AAC3C,MAAAA,EAAE,SAASH;AAAA,IACb,CAAC;AAAA,EACH,GAAGH,CAAK;AACV;","x_google_ignoreList":[0]}

package/dist/node_modules/refractor/lang/pcaxis.cjs.js

@@ -0,0 +1,2 @@
+"use strict";t.displayName="pcaxis";t.aliases=["px"];function t(e){e.languages.pcaxis={string:/"[^"]*"/,keyword:{pattern:/((?:^|;)\s*)[-A-Z\d]+(?:\s*\[[-\w]+\])?(?:\s*\("[^"]*"(?:,\s*"[^"]*")*\))?(?=\s*=)/,lookbehind:!0,greedy:!0,inside:{keyword:/^[-A-Z\d]+/,language:{pattern:/^(\s*)\[[-\w]+\]/,lookbehind:!0,inside:{punctuation:/^\[|\]$/,property:/[-\w]+/}},"sub-key":{pattern:/^(\s*)\S[\s\S]*/,lookbehind:!0,inside:{parameter:{pattern:/"[^"]*"/,alias:"property"},punctuation:/^\(|\)$|,/}}}},operator:/=/,tlist:{pattern:/TLIST\s*\(\s*\w+(?:(?:\s*,\s*"[^"]*")+|\s*,\s*"[^"]*"-"[^"]*")?\s*\)/,greedy:!0,inside:{function:/^TLIST/,property:{pattern:/^(\s*\(\s*)\w+/,lookbehind:!0},string:/"[^"]*"/,punctuation:/[(),]/,operator:/-/}},punctuation:/[;,]/,number:{pattern:/(^|\s)\d+(?:\.\d+)?(?!\S)/,lookbehind:!0},boolean:/NO|YES/},e.languages.px=e.languages.pcaxis}module.exports=t;
+//# sourceMappingURL=pcaxis.cjs.js.map

package/dist/node_modules/refractor/lang/pcaxis.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pcaxis.cjs.js","sources":["../../../../../node_modules/refractor/lang/pcaxis.js"],"sourcesContent":["// @ts-nocheck\n/**\n * @import {Syntax} from '../core.js'\n */\npcaxis.displayName = 'pcaxis'\npcaxis.aliases = ['px']\n\n/** @type {Syntax} */\nexport default function 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","Prism"],"mappings":"aAIAA,EAAO,YAAc,SACrBA,EAAO,QAAU,CAAC,IAAI,EAGP,SAASA,EAAOC,EAAO,CACpCA,EAAM,UAAU,OAAS,CACvB,OAAQ,UACR,QAAS,CACP,QACE,qFACF,WAAY,GACZ,OAAQ,GACR,OAAQ,CACN,QAAS,aACT,SAAU,CACR,QAAS,mBACT,WAAY,GACZ,OAAQ,CACN,YAAa,UACb,SAAU,QACtB,CACA,EACQ,UAAW,CACT,QAAS,kBACT,WAAY,GACZ,OAAQ,CACN,UAAW,CACT,QAAS,UACT,MAAO,UACrB,EACY,YAAa,WACzB,CACA,CACA,CACA,EACI,SAAU,IACV,MAAO,CACL,QACE,uEACF,OAAQ,GACR,OAAQ,CACN,SAAU,SACV,SAAU,CACR,QAAS,iBACT,WAAY,EACtB,EACQ,OAAQ,UACR,YAAa,QACb,SAAU,GAClB,CACA,EACI,YAAa,OACb,OAAQ,CACN,QAAS,4BACT,WAAY,EAClB,EACI,QAAS,QACb,EACEA,EAAM,UAAU,GAAKA,EAAM,UAAU,MACvC","x_google_ignoreList":[0]}

package/dist/node_modules/refractor/lang/pcaxis.es.js

@@ -0,0 +1,59 @@
+t.displayName = "pcaxis";
+t.aliases = ["px"];
+function t(e) {
+  e.languages.pcaxis = {
+    string: /"[^"]*"/,
+    keyword: {
+      pattern: /((?:^|;)\s*)[-A-Z\d]+(?:\s*\[[-\w]+\])?(?:\s*\("[^"]*"(?:,\s*"[^"]*")*\))?(?=\s*=)/,
+      lookbehind: !0,
+      greedy: !0,
+      inside: {
+        keyword: /^[-A-Z\d]+/,
+        language: {
+          pattern: /^(\s*)\[[-\w]+\]/,
+          lookbehind: !0,
+          inside: {
+            punctuation: /^\[|\]$/,
+            property: /[-\w]+/
+          }
+        },
+        "sub-key": {
+          pattern: /^(\s*)\S[\s\S]*/,
+          lookbehind: !0,
+          inside: {
+            parameter: {
+              pattern: /"[^"]*"/,
+              alias: "property"
+            },
+            punctuation: /^\(|\)$|,/
+          }
+        }
+      }
+    },
+    operator: /=/,
+    tlist: {
+      pattern: /TLIST\s*\(\s*\w+(?:(?:\s*,\s*"[^"]*")+|\s*,\s*"[^"]*"-"[^"]*")?\s*\)/,
+      greedy: !0,
+      inside: {
+        function: /^TLIST/,
+        property: {
+          pattern: /^(\s*\(\s*)\w+/,
+          lookbehind: !0
+        },
+        string: /"[^"]*"/,
+        punctuation: /[(),]/,
+        operator: /-/
+      }
+    },
+    punctuation: /[;,]/,
+    number: {
+      pattern: /(^|\s)\d+(?:\.\d+)?(?!\S)/,
+      lookbehind: !0
+    },
+    boolean: /NO|YES/
+  }, e.languages.px = e.languages.pcaxis;
+}
+export {
+  t as default
+};
+//# sourceMappingURL=pcaxis.es.js.map

package/dist/node_modules/refractor/lang/pcaxis.es.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pcaxis.es.js","sources":["../../../../../node_modules/refractor/lang/pcaxis.js"],"sourcesContent":["// @ts-nocheck\n/**\n * @import {Syntax} from '../core.js'\n */\npcaxis.displayName = 'pcaxis'\npcaxis.aliases = ['px']\n\n/** @type {Syntax} */\nexport default function 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","Prism"],"mappings":"AAIAA,EAAO,cAAc;AACrBA,EAAO,UAAU,CAAC,IAAI;AAGP,SAASA,EAAOC,GAAO;AACpC,EAAAA,EAAM,UAAU,SAAS;AAAA,IACvB,QAAQ;AAAA,IACR,SAAS;AAAA,MACP,SACE;AAAA,MACF,YAAY;AAAA,MACZ,QAAQ;AAAA,MACR,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,UAAU;AAAA,UACR,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,QAAQ;AAAA,YACN,aAAa;AAAA,YACb,UAAU;AAAA,UACtB;AAAA,QACA;AAAA,QACQ,WAAW;AAAA,UACT,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,QAAQ;AAAA,YACN,WAAW;AAAA,cACT,SAAS;AAAA,cACT,OAAO;AAAA,YACrB;AAAA,YACY,aAAa;AAAA,UACzB;AAAA,QACA;AAAA,MACA;AAAA,IACA;AAAA,IACI,UAAU;AAAA,IACV,OAAO;AAAA,MACL,SACE;AAAA,MACF,QAAQ;AAAA,MACR,QAAQ;AAAA,QACN,UAAU;AAAA,QACV,UAAU;AAAA,UACR,SAAS;AAAA,UACT,YAAY;AAAA,QACtB;AAAA,QACQ,QAAQ;AAAA,QACR,aAAa;AAAA,QACb,UAAU;AAAA,MAClB;AAAA,IACA;AAAA,IACI,aAAa;AAAA,IACb,QAAQ;AAAA,MACN,SAAS;AAAA,MACT,YAAY;AAAA,IAClB;AAAA,IACI,SAAS;AAAA,EACb,GACEA,EAAM,UAAU,KAAKA,EAAM,UAAU;AACvC;","x_google_ignoreList":[0]}

package/dist/node_modules/refractor/lang/peoplecode.cjs.js

@@ -0,0 +1,2 @@
+"use strict";t.displayName="peoplecode";t.aliases=["pcode"];function t(e){e.languages.peoplecode={comment:RegExp([/\/\*[\s\S]*?\*\//.source,/\bREM[^;]*;/.source,/<\*(?:[^<*]|\*(?!>)|<(?!\*)|<\*(?:(?!\*>)[\s\S])*\*>)*\*>/.source,/\/\+[\s\S]*?\+\//.source].join("|")),string:{pattern:/'(?:''|[^'\r\n])*'(?!')|"(?:""|[^"\r\n])*"(?!")/,greedy:!0},variable:/%\w+/,"function-definition":{pattern:/((?:^|[^\w-])(?:function|method)\s+)\w+/i,lookbehind:!0,alias:"function"},"class-name":{pattern:/((?:^|[^-\w])(?:as|catch|class|component|create|extends|global|implements|instance|local|of|property|returns)\s+)\w+(?::\w+)*/i,lookbehind:!0,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:/[:.;,()[\]]/},e.languages.pcode=e.languages.peoplecode}module.exports=t;
+//# sourceMappingURL=peoplecode.cjs.js.map

package/dist/node_modules/refractor/lang/peoplecode.cjs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"peoplecode.cjs.js","sources":["../../../../../node_modules/refractor/lang/peoplecode.js"],"sourcesContent":["// @ts-nocheck\n/**\n * @import {Syntax} from '../core.js'\n */\npeoplecode.displayName = 'peoplecode'\npeoplecode.aliases = ['pcode']\n\n/** @type {Syntax} */\nexport default function peoplecode(Prism) {\n  Prism.languages.peoplecode = {\n    comment: RegExp(\n      [\n        // C-style multiline comments\n        /\\/\\*[\\s\\S]*?\\*\\//.source,\n        // REM comments\n        /\\bREM[^;]*;/.source,\n        // Nested <* *> comments\n        /<\\*(?:[^<*]|\\*(?!>)|<(?!\\*)|<\\*(?:(?!\\*>)[\\s\\S])*\\*>)*\\*>/.source,\n        // /+ +/ 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","Prism"],"mappings":"aAIAA,EAAW,YAAc,aACzBA,EAAW,QAAU,CAAC,OAAO,EAGd,SAASA,EAAWC,EAAO,CACxCA,EAAM,UAAU,WAAa,CAC3B,QAAS,OACP,CAEE,mBAAmB,OAEnB,cAAc,OAEd,4DAA4D,OAE5D,mBAAmB,MAC3B,EAAQ,KAAK,GAAG,CAChB,EACI,OAAQ,CACN,QAAS,kDACT,OAAQ,EACd,EACI,SAAU,OACV,sBAAuB,CACrB,QAAS,2CACT,WAAY,GACZ,MAAO,UACb,EACI,aAAc,CACZ,QACE,iIACF,WAAY,GACZ,OAAQ,CACN,YAAa,GACrB,CACA,EACI,QACE,gYACF,mBAAoB,CAClB,QAAS,sBACT,MAAO,UACb,EACI,SAAU,sBACV,QAAS,sBACT,OAAQ,oBACR,SAAU,8BACV,YAAa,aACjB,EACEA,EAAM,UAAU,MAAQA,EAAM,UAAU,UAC1C","x_google_ignoreList":[0]}

package/dist/node_modules/refractor/lang/peoplecode.es.js

@@ -0,0 +1,49 @@
+t.displayName = "peoplecode";
+t.aliases = ["pcode"];
+function t(e) {
+  e.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: !0
+    },
+    variable: /%\w+/,
+    "function-definition": {
+      pattern: /((?:^|[^\w-])(?:function|method)\s+)\w+/i,
+      lookbehind: !0,
+      alias: "function"
+    },
+    "class-name": {
+      pattern: /((?:^|[^-\w])(?:as|catch|class|component|create|extends|global|implements|instance|local|of|property|returns)\s+)\w+(?::\w+)*/i,
+      lookbehind: !0,
+      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: /[:.;,()[\]]/
+  }, e.languages.pcode = e.languages.peoplecode;
+}
+export {
+  t as default
+};
+//# sourceMappingURL=peoplecode.es.js.map