@ynput/ayon-frontend-shared 0.3.5 → 0.3.6

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

@@ -0,0 +1,2 @@
+"use strict";const o=require("./clike.cjs.js");t.displayName="groovy";t.aliases=[];function t(n){n.register(o),(function(e){var a={pattern:/((?:^|[^\\$])(?:\\{2})*)\$(?:\w+|\{[^{}]*\})/,lookbehind:!0,inside:{"interpolation-punctuation":{pattern:/^\$\{?|\}$/,alias:"punctuation"},expression:{pattern:/[\s\S]+/,inside:null}}};e.languages.groovy=e.languages.extend("clike",{string:{pattern:/'''(?:[^\\]|\\[\s\S])*?'''|'(?:\\.|[^\\'\r\n])*'/,greedy:!0},keyword:/\b(?:abstract|as|assert|boolean|break|byte|case|catch|char|class|const|continue|def|default|do|double|else|enum|extends|final|finally|float|for|goto|if|implements|import|in|instanceof|int|interface|long|native|new|package|private|protected|public|return|short|static|strictfp|super|switch|synchronized|this|throw|throws|trait|transient|try|void|volatile|while)\b/,number:/\b(?:0b[01_]+|0x[\da-f_]+(?:\.[\da-f_p\-]+)?|[\d_]+(?:\.[\d_]+)?(?:e[+-]?\d+)?)[glidf]?\b/i,operator:{pattern:/(^|[^.])(?:~|==?~?|\?[.:]?|\*(?:[.=]|\*=?)?|\.[@&]|\.\.<|\.\.(?!\.)|-[-=>]?|\+[+=]?|!=?|<(?:<=?|=>?)?|>(?:>>?=?|=)?|&[&=]?|\|[|=]?|\/=?|\^=?|%=?)/,lookbehind:!0},punctuation:/\.+|[{}[\];(),:$]/}),e.languages.insertBefore("groovy","string",{shebang:{pattern:/#!.+/,alias:"comment",greedy:!0},"interpolation-string":{pattern:/"""(?:[^\\]|\\[\s\S])*?"""|(["/])(?:\\.|(?!\1)[^\\\r\n])*\1|\$\/(?:[^/$]|\$(?:[/$]|(?![/$]))|\/(?!\$))*\/\$/,greedy:!0,inside:{interpolation:a,string:/[\s\S]+/}}}),e.languages.insertBefore("groovy","punctuation",{"spock-block":/\b(?:and|cleanup|expect|given|setup|then|when|where):/}),e.languages.insertBefore("groovy","function",{annotation:{pattern:/(^|[^.])@\w+/,lookbehind:!0,alias:"punctuation"}}),a.inside.expression.inside=e.languages.groovy})(n)}module.exports=t;
+//# sourceMappingURL=groovy.cjs.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"groovy.cjs.js","sources":["../../../../../node_modules/refractor/lang/groovy.js"],"sourcesContent":["// @ts-nocheck\n/**\n * @import {Syntax} from '../core.js'\n */\nimport refractorClike from './clike.js'\ngroovy.displayName = 'groovy'\ngroovy.aliases = []\n\n/** @type {Syntax} */\nexport default function groovy(Prism) {\n  Prism.register(refractorClike)\n  ;(function (Prism) {\n    var interpolation = {\n      pattern: /((?:^|[^\\\\$])(?:\\\\{2})*)\\$(?:\\w+|\\{[^{}]*\\})/,\n      lookbehind: true,\n      inside: {\n        'interpolation-punctuation': {\n          pattern: /^\\$\\{?|\\}$/,\n          alias: 'punctuation'\n        },\n        expression: {\n          pattern: /[\\s\\S]+/,\n          inside: null // see below\n        }\n      }\n    }\n    Prism.languages.groovy = Prism.languages.extend('clike', {\n      string: {\n        // https://groovy-lang.org/syntax.html#_dollar_slashy_string\n        pattern: /'''(?:[^\\\\]|\\\\[\\s\\S])*?'''|'(?:\\\\.|[^\\\\'\\r\\n])*'/,\n        greedy: true\n      },\n      keyword:\n        /\\b(?:abstract|as|assert|boolean|break|byte|case|catch|char|class|const|continue|def|default|do|double|else|enum|extends|final|finally|float|for|goto|if|implements|import|in|instanceof|int|interface|long|native|new|package|private|protected|public|return|short|static|strictfp|super|switch|synchronized|this|throw|throws|trait|transient|try|void|volatile|while)\\b/,\n      number:\n        /\\b(?:0b[01_]+|0x[\\da-f_]+(?:\\.[\\da-f_p\\-]+)?|[\\d_]+(?:\\.[\\d_]+)?(?:e[+-]?\\d+)?)[glidf]?\\b/i,\n      operator: {\n        pattern:\n          /(^|[^.])(?:~|==?~?|\\?[.:]?|\\*(?:[.=]|\\*=?)?|\\.[@&]|\\.\\.<|\\.\\.(?!\\.)|-[-=>]?|\\+[+=]?|!=?|<(?:<=?|=>?)?|>(?:>>?=?|=)?|&[&=]?|\\|[|=]?|\\/=?|\\^=?|%=?)/,\n        lookbehind: true\n      },\n      punctuation: /\\.+|[{}[\\];(),:$]/\n    })\n    Prism.languages.insertBefore('groovy', 'string', {\n      shebang: {\n        pattern: /#!.+/,\n        alias: 'comment',\n        greedy: true\n      },\n      'interpolation-string': {\n        // TODO: Slash strings (e.g. /foo/) can contain line breaks but this will cause a lot of trouble with\n        // simple division (see JS regex), so find a fix maybe?\n        pattern:\n          /\"\"\"(?:[^\\\\]|\\\\[\\s\\S])*?\"\"\"|([\"/])(?:\\\\.|(?!\\1)[^\\\\\\r\\n])*\\1|\\$\\/(?:[^/$]|\\$(?:[/$]|(?![/$]))|\\/(?!\\$))*\\/\\$/,\n        greedy: true,\n        inside: {\n          interpolation: interpolation,\n          string: /[\\s\\S]+/\n        }\n      }\n    })\n    Prism.languages.insertBefore('groovy', 'punctuation', {\n      'spock-block': /\\b(?:and|cleanup|expect|given|setup|then|when|where):/\n    })\n    Prism.languages.insertBefore('groovy', 'function', {\n      annotation: {\n        pattern: /(^|[^.])@\\w+/,\n        lookbehind: true,\n        alias: 'punctuation'\n      }\n    })\n    interpolation.inside.expression.inside = Prism.languages.groovy\n  })(Prism)\n}\n"],"names":["groovy","Prism","refractorClike","interpolation"],"mappings":"+CAKAA,EAAO,YAAc,SACrBA,EAAO,QAAU,CAAA,EAGF,SAASA,EAAOC,EAAO,CACpCA,EAAM,SAASC,CAAc,GAC3B,SAAUD,EAAO,CACjB,IAAIE,EAAgB,CAClB,QAAS,+CACT,WAAY,GACZ,OAAQ,CACN,4BAA6B,CAC3B,QAAS,aACT,MAAO,aACjB,EACQ,WAAY,CACV,QAAS,UACT,OAAQ,IAClB,CACA,CACA,EACIF,EAAM,UAAU,OAASA,EAAM,UAAU,OAAO,QAAS,CACvD,OAAQ,CAEN,QAAS,mDACT,OAAQ,EAChB,EACM,QACE,6WACF,OACE,6FACF,SAAU,CACR,QACE,oJACF,WAAY,EACpB,EACM,YAAa,mBACnB,CAAK,EACDA,EAAM,UAAU,aAAa,SAAU,SAAU,CAC/C,QAAS,CACP,QAAS,OACT,MAAO,UACP,OAAQ,EAChB,EACM,uBAAwB,CAGtB,QACE,8GACF,OAAQ,GACR,OAAQ,CACN,cAAeE,EACf,OAAQ,SAClB,CACA,CACA,CAAK,EACDF,EAAM,UAAU,aAAa,SAAU,cAAe,CACpD,cAAe,uDACrB,CAAK,EACDA,EAAM,UAAU,aAAa,SAAU,WAAY,CACjD,WAAY,CACV,QAAS,eACT,WAAY,GACZ,MAAO,aACf,CACA,CAAK,EACDE,EAAc,OAAO,WAAW,OAASF,EAAM,UAAU,MAC3D,GAAGA,CAAK,CACV","x_google_ignoreList":[0]}

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

@@ -0,0 +1,64 @@
+import o from "./clike.es.js";
+a.displayName = "groovy";
+a.aliases = [];
+function a(t) {
+  t.register(o), (function(e) {
+    var n = {
+      pattern: /((?:^|[^\\$])(?:\\{2})*)\$(?:\w+|\{[^{}]*\})/,
+      lookbehind: !0,
+      inside: {
+        "interpolation-punctuation": {
+          pattern: /^\$\{?|\}$/,
+          alias: "punctuation"
+        },
+        expression: {
+          pattern: /[\s\S]+/,
+          inside: null
+          // see below
+        }
+      }
+    };
+    e.languages.groovy = e.languages.extend("clike", {
+      string: {
+        // https://groovy-lang.org/syntax.html#_dollar_slashy_string
+        pattern: /'''(?:[^\\]|\\[\s\S])*?'''|'(?:\\.|[^\\'\r\n])*'/,
+        greedy: !0
+      },
+      keyword: /\b(?:abstract|as|assert|boolean|break|byte|case|catch|char|class|const|continue|def|default|do|double|else|enum|extends|final|finally|float|for|goto|if|implements|import|in|instanceof|int|interface|long|native|new|package|private|protected|public|return|short|static|strictfp|super|switch|synchronized|this|throw|throws|trait|transient|try|void|volatile|while)\b/,
+      number: /\b(?:0b[01_]+|0x[\da-f_]+(?:\.[\da-f_p\-]+)?|[\d_]+(?:\.[\d_]+)?(?:e[+-]?\d+)?)[glidf]?\b/i,
+      operator: {
+        pattern: /(^|[^.])(?:~|==?~?|\?[.:]?|\*(?:[.=]|\*=?)?|\.[@&]|\.\.<|\.\.(?!\.)|-[-=>]?|\+[+=]?|!=?|<(?:<=?|=>?)?|>(?:>>?=?|=)?|&[&=]?|\|[|=]?|\/=?|\^=?|%=?)/,
+        lookbehind: !0
+      },
+      punctuation: /\.+|[{}[\];(),:$]/
+    }), e.languages.insertBefore("groovy", "string", {
+      shebang: {
+        pattern: /#!.+/,
+        alias: "comment",
+        greedy: !0
+      },
+      "interpolation-string": {
+        // TODO: Slash strings (e.g. /foo/) can contain line breaks but this will cause a lot of trouble with
+        // simple division (see JS regex), so find a fix maybe?
+        pattern: /"""(?:[^\\]|\\[\s\S])*?"""|(["/])(?:\\.|(?!\1)[^\\\r\n])*\1|\$\/(?:[^/$]|\$(?:[/$]|(?![/$]))|\/(?!\$))*\/\$/,
+        greedy: !0,
+        inside: {
+          interpolation: n,
+          string: /[\s\S]+/
+        }
+      }
+    }), e.languages.insertBefore("groovy", "punctuation", {
+      "spock-block": /\b(?:and|cleanup|expect|given|setup|then|when|where):/
+    }), e.languages.insertBefore("groovy", "function", {
+      annotation: {
+        pattern: /(^|[^.])@\w+/,
+        lookbehind: !0,
+        alias: "punctuation"
+      }
+    }), n.inside.expression.inside = e.languages.groovy;
+  })(t);
+}
+export {
+  a as default
+};
+//# sourceMappingURL=groovy.es.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"groovy.es.js","sources":["../../../../../node_modules/refractor/lang/groovy.js"],"sourcesContent":["// @ts-nocheck\n/**\n * @import {Syntax} from '../core.js'\n */\nimport refractorClike from './clike.js'\ngroovy.displayName = 'groovy'\ngroovy.aliases = []\n\n/** @type {Syntax} */\nexport default function groovy(Prism) {\n  Prism.register(refractorClike)\n  ;(function (Prism) {\n    var interpolation = {\n      pattern: /((?:^|[^\\\\$])(?:\\\\{2})*)\\$(?:\\w+|\\{[^{}]*\\})/,\n      lookbehind: true,\n      inside: {\n        'interpolation-punctuation': {\n          pattern: /^\\$\\{?|\\}$/,\n          alias: 'punctuation'\n        },\n        expression: {\n          pattern: /[\\s\\S]+/,\n          inside: null // see below\n        }\n      }\n    }\n    Prism.languages.groovy = Prism.languages.extend('clike', {\n      string: {\n        // https://groovy-lang.org/syntax.html#_dollar_slashy_string\n        pattern: /'''(?:[^\\\\]|\\\\[\\s\\S])*?'''|'(?:\\\\.|[^\\\\'\\r\\n])*'/,\n        greedy: true\n      },\n      keyword:\n        /\\b(?:abstract|as|assert|boolean|break|byte|case|catch|char|class|const|continue|def|default|do|double|else|enum|extends|final|finally|float|for|goto|if|implements|import|in|instanceof|int|interface|long|native|new|package|private|protected|public|return|short|static|strictfp|super|switch|synchronized|this|throw|throws|trait|transient|try|void|volatile|while)\\b/,\n      number:\n        /\\b(?:0b[01_]+|0x[\\da-f_]+(?:\\.[\\da-f_p\\-]+)?|[\\d_]+(?:\\.[\\d_]+)?(?:e[+-]?\\d+)?)[glidf]?\\b/i,\n      operator: {\n        pattern:\n          /(^|[^.])(?:~|==?~?|\\?[.:]?|\\*(?:[.=]|\\*=?)?|\\.[@&]|\\.\\.<|\\.\\.(?!\\.)|-[-=>]?|\\+[+=]?|!=?|<(?:<=?|=>?)?|>(?:>>?=?|=)?|&[&=]?|\\|[|=]?|\\/=?|\\^=?|%=?)/,\n        lookbehind: true\n      },\n      punctuation: /\\.+|[{}[\\];(),:$]/\n    })\n    Prism.languages.insertBefore('groovy', 'string', {\n      shebang: {\n        pattern: /#!.+/,\n        alias: 'comment',\n        greedy: true\n      },\n      'interpolation-string': {\n        // TODO: Slash strings (e.g. /foo/) can contain line breaks but this will cause a lot of trouble with\n        // simple division (see JS regex), so find a fix maybe?\n        pattern:\n          /\"\"\"(?:[^\\\\]|\\\\[\\s\\S])*?\"\"\"|([\"/])(?:\\\\.|(?!\\1)[^\\\\\\r\\n])*\\1|\\$\\/(?:[^/$]|\\$(?:[/$]|(?![/$]))|\\/(?!\\$))*\\/\\$/,\n        greedy: true,\n        inside: {\n          interpolation: interpolation,\n          string: /[\\s\\S]+/\n        }\n      }\n    })\n    Prism.languages.insertBefore('groovy', 'punctuation', {\n      'spock-block': /\\b(?:and|cleanup|expect|given|setup|then|when|where):/\n    })\n    Prism.languages.insertBefore('groovy', 'function', {\n      annotation: {\n        pattern: /(^|[^.])@\\w+/,\n        lookbehind: true,\n        alias: 'punctuation'\n      }\n    })\n    interpolation.inside.expression.inside = Prism.languages.groovy\n  })(Prism)\n}\n"],"names":["groovy","Prism","refractorClike","interpolation"],"mappings":";AAKAA,EAAO,cAAc;AACrBA,EAAO,UAAU,CAAA;AAGF,SAASA,EAAOC,GAAO;AACpC,EAAAA,EAAM,SAASC,CAAc,IAC3B,SAAUD,GAAO;AACjB,QAAIE,IAAgB;AAAA,MAClB,SAAS;AAAA,MACT,YAAY;AAAA,MACZ,QAAQ;AAAA,QACN,6BAA6B;AAAA,UAC3B,SAAS;AAAA,UACT,OAAO;AAAA,QACjB;AAAA,QACQ,YAAY;AAAA,UACV,SAAS;AAAA,UACT,QAAQ;AAAA;AAAA,QAClB;AAAA,MACA;AAAA,IACA;AACI,IAAAF,EAAM,UAAU,SAASA,EAAM,UAAU,OAAO,SAAS;AAAA,MACvD,QAAQ;AAAA;AAAA,QAEN,SAAS;AAAA,QACT,QAAQ;AAAA,MAChB;AAAA,MACM,SACE;AAAA,MACF,QACE;AAAA,MACF,UAAU;AAAA,QACR,SACE;AAAA,QACF,YAAY;AAAA,MACpB;AAAA,MACM,aAAa;AAAA,IACnB,CAAK,GACDA,EAAM,UAAU,aAAa,UAAU,UAAU;AAAA,MAC/C,SAAS;AAAA,QACP,SAAS;AAAA,QACT,OAAO;AAAA,QACP,QAAQ;AAAA,MAChB;AAAA,MACM,wBAAwB;AAAA;AAAA;AAAA,QAGtB,SACE;AAAA,QACF,QAAQ;AAAA,QACR,QAAQ;AAAA,UACN,eAAeE;AAAA,UACf,QAAQ;AAAA,QAClB;AAAA,MACA;AAAA,IACA,CAAK,GACDF,EAAM,UAAU,aAAa,UAAU,eAAe;AAAA,MACpD,eAAe;AAAA,IACrB,CAAK,GACDA,EAAM,UAAU,aAAa,UAAU,YAAY;AAAA,MACjD,YAAY;AAAA,QACV,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,OAAO;AAAA,MACf;AAAA,IACA,CAAK,GACDE,EAAc,OAAO,WAAW,SAASF,EAAM,UAAU;AAAA,EAC3D,GAAGA,CAAK;AACV;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,2 @@
+"use strict";const o=require("./ruby.cjs.js");a.displayName="haml";a.aliases=[];function a(r){r.register(o),(function(e){e.languages.haml={"multiline-comment":{pattern:/((?:^|\r?\n|\r)([\t ]*))(?:\/|-#).*(?:(?:\r?\n|\r)\2[\t ].+)*/,lookbehind:!0,alias:"comment"},"multiline-code":[{pattern:/((?:^|\r?\n|\r)([\t ]*)(?:[~-]|[&!]?=)).*,[\t ]*(?:(?:\r?\n|\r)\2[\t ].*,[\t ]*)*(?:(?:\r?\n|\r)\2[\t ].+)/,lookbehind:!0,inside:e.languages.ruby},{pattern:/((?:^|\r?\n|\r)([\t ]*)(?:[~-]|[&!]?=)).*\|[\t ]*(?:(?:\r?\n|\r)\2[\t ].*\|[\t ]*)*/,lookbehind:!0,inside:e.languages.ruby}],filter:{pattern:/((?:^|\r?\n|\r)([\t ]*)):[\w-]+(?:(?:\r?\n|\r)(?:\2[\t ].+|\s*?(?=\r?\n|\r)))+/,lookbehind:!0,inside:{"filter-name":{pattern:/^:[\w-]+/,alias:"symbol"}}},markup:{pattern:/((?:^|\r?\n|\r)[\t ]*)<.+/,lookbehind:!0,inside:e.languages.markup},doctype:{pattern:/((?:^|\r?\n|\r)[\t ]*)!!!(?: .+)?/,lookbehind:!0},tag:{pattern:/((?:^|\r?\n|\r)[\t ]*)[%.#][\w\-#.]*[\w\-](?:\([^)]+\)|\{(?:\{[^}]+\}|[^{}])+\}|\[[^\]]+\])*[\/<>]*/,lookbehind:!0,inside:{attributes:[{pattern:/(^|[^#])\{(?:\{[^}]+\}|[^{}])+\}/,lookbehind:!0,inside:e.languages.ruby},{pattern:/\([^)]+\)/,inside:{"attr-value":{pattern:/(=\s*)(?:"(?:\\.|[^\\"\r\n])*"|[^)\s]+)/,lookbehind:!0},"attr-name":/[\w:-]+(?=\s*!?=|\s*[,)])/,punctuation:/[=(),]/}},{pattern:/\[[^\]]+\]/,inside:e.languages.ruby}],punctuation:/[<>]/}},code:{pattern:/((?:^|\r?\n|\r)[\t ]*(?:[~-]|[&!]?=)).+/,lookbehind:!0,inside:e.languages.ruby},interpolation:{pattern:/#\{[^}]+\}/,inside:{delimiter:{pattern:/^#\{|\}$/,alias:"punctuation"},ruby:{pattern:/[\s\S]+/,inside:e.languages.ruby}}},punctuation:{pattern:/((?:^|\r?\n|\r)[\t ]*)[~=\-&!]+/,lookbehind:!0}};for(var u="((?:^|\\r?\\n|\\r)([\\t ]*)):{{filter_name}}(?:(?:\\r?\\n|\\r)(?:\\2[\\t ].+|\\s*?(?=\\r?\\n|\\r)))+",i=["css",{filter:"coffee",language:"coffeescript"},"erb","javascript","less","markdown","ruby","scss","textile"],l={},n=0,s=i.length;n<s;n++){var t=i[n];t=typeof t=="string"?{filter:t,language:t}:t,e.languages[t.language]&&(l["filter-"+t.filter]={pattern:RegExp(u.replace("{{filter_name}}",function(){return t.filter})),lookbehind:!0,inside:{"filter-name":{pattern:/^:[\w-]+/,alias:"symbol"},text:{pattern:/[\s\S]+/,alias:[t.language,"language-"+t.language],inside:e.languages[t.language]}}})}e.languages.insertBefore("haml","filter",l)})(r)}module.exports=a;
+//# sourceMappingURL=haml.cjs.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"haml.cjs.js","sources":["../../../../../node_modules/refractor/lang/haml.js"],"sourcesContent":["// @ts-nocheck\n/**\n * @import {Syntax} from '../core.js'\n */\nimport refractorRuby from './ruby.js'\nhaml.displayName = 'haml'\nhaml.aliases = []\n\n/** @type {Syntax} */\nexport default function haml(Prism) {\n  Prism.register(refractorRuby)\n  /* TODO\nHandle multiline code after tag\n%foo= some |\nmultiline |\ncode |\n*/\n\n  ;(function (Prism) {\n    Prism.languages.haml = {\n      // Multiline stuff should appear before the rest\n\n      'multiline-comment': {\n        pattern:\n          /((?:^|\\r?\\n|\\r)([\\t ]*))(?:\\/|-#).*(?:(?:\\r?\\n|\\r)\\2[\\t ].+)*/,\n        lookbehind: true,\n        alias: 'comment'\n      },\n      'multiline-code': [\n        {\n          pattern:\n            /((?:^|\\r?\\n|\\r)([\\t ]*)(?:[~-]|[&!]?=)).*,[\\t ]*(?:(?:\\r?\\n|\\r)\\2[\\t ].*,[\\t ]*)*(?:(?:\\r?\\n|\\r)\\2[\\t ].+)/,\n          lookbehind: true,\n          inside: Prism.languages.ruby\n        },\n        {\n          pattern:\n            /((?:^|\\r?\\n|\\r)([\\t ]*)(?:[~-]|[&!]?=)).*\\|[\\t ]*(?:(?:\\r?\\n|\\r)\\2[\\t ].*\\|[\\t ]*)*/,\n          lookbehind: true,\n          inside: Prism.languages.ruby\n        }\n      ],\n      // See at the end of the file for known filters\n      filter: {\n        pattern:\n          /((?:^|\\r?\\n|\\r)([\\t ]*)):[\\w-]+(?:(?:\\r?\\n|\\r)(?:\\2[\\t ].+|\\s*?(?=\\r?\\n|\\r)))+/,\n        lookbehind: true,\n        inside: {\n          'filter-name': {\n            pattern: /^:[\\w-]+/,\n            alias: 'symbol'\n          }\n        }\n      },\n      markup: {\n        pattern: /((?:^|\\r?\\n|\\r)[\\t ]*)<.+/,\n        lookbehind: true,\n        inside: Prism.languages.markup\n      },\n      doctype: {\n        pattern: /((?:^|\\r?\\n|\\r)[\\t ]*)!!!(?: .+)?/,\n        lookbehind: true\n      },\n      tag: {\n        // Allows for one nested group of braces\n        pattern:\n          /((?:^|\\r?\\n|\\r)[\\t ]*)[%.#][\\w\\-#.]*[\\w\\-](?:\\([^)]+\\)|\\{(?:\\{[^}]+\\}|[^{}])+\\}|\\[[^\\]]+\\])*[\\/<>]*/,\n        lookbehind: true,\n        inside: {\n          attributes: [\n            {\n              // Lookbehind tries to prevent interpolations from breaking it all\n              // Allows for one nested group of braces\n              pattern: /(^|[^#])\\{(?:\\{[^}]+\\}|[^{}])+\\}/,\n              lookbehind: true,\n              inside: Prism.languages.ruby\n            },\n            {\n              pattern: /\\([^)]+\\)/,\n              inside: {\n                'attr-value': {\n                  pattern: /(=\\s*)(?:\"(?:\\\\.|[^\\\\\"\\r\\n])*\"|[^)\\s]+)/,\n                  lookbehind: true\n                },\n                'attr-name': /[\\w:-]+(?=\\s*!?=|\\s*[,)])/,\n                punctuation: /[=(),]/\n              }\n            },\n            {\n              pattern: /\\[[^\\]]+\\]/,\n              inside: Prism.languages.ruby\n            }\n          ],\n          punctuation: /[<>]/\n        }\n      },\n      code: {\n        pattern: /((?:^|\\r?\\n|\\r)[\\t ]*(?:[~-]|[&!]?=)).+/,\n        lookbehind: true,\n        inside: Prism.languages.ruby\n      },\n      // Interpolations in plain text\n      interpolation: {\n        pattern: /#\\{[^}]+\\}/,\n        inside: {\n          delimiter: {\n            pattern: /^#\\{|\\}$/,\n            alias: 'punctuation'\n          },\n          ruby: {\n            pattern: /[\\s\\S]+/,\n            inside: Prism.languages.ruby\n          }\n        }\n      },\n      punctuation: {\n        pattern: /((?:^|\\r?\\n|\\r)[\\t ]*)[~=\\-&!]+/,\n        lookbehind: true\n      }\n    }\n    var filter_pattern =\n      '((?:^|\\\\r?\\\\n|\\\\r)([\\\\t ]*)):{{filter_name}}(?:(?:\\\\r?\\\\n|\\\\r)(?:\\\\2[\\\\t ].+|\\\\s*?(?=\\\\r?\\\\n|\\\\r)))+'\n\n    // Non exhaustive list of available filters and associated languages\n    var filters = [\n      'css',\n      {\n        filter: 'coffee',\n        language: 'coffeescript'\n      },\n      'erb',\n      'javascript',\n      'less',\n      'markdown',\n      'ruby',\n      'scss',\n      'textile'\n    ]\n    var all_filters = {}\n    for (var i = 0, l = filters.length; i < l; i++) {\n      var filter = filters[i]\n      filter =\n        typeof filter === 'string'\n          ? {\n              filter: filter,\n              language: filter\n            }\n          : filter\n      if (Prism.languages[filter.language]) {\n        all_filters['filter-' + filter.filter] = {\n          pattern: RegExp(\n            filter_pattern.replace('{{filter_name}}', function () {\n              return filter.filter\n            })\n          ),\n          lookbehind: true,\n          inside: {\n            'filter-name': {\n              pattern: /^:[\\w-]+/,\n              alias: 'symbol'\n            },\n            text: {\n              pattern: /[\\s\\S]+/,\n              alias: [filter.language, 'language-' + filter.language],\n              inside: Prism.languages[filter.language]\n            }\n          }\n        }\n      }\n    }\n    Prism.languages.insertBefore('haml', 'filter', all_filters)\n  })(Prism)\n}\n"],"names":["haml","Prism","refractorRuby","filter_pattern","filters","all_filters","i","l","filter"],"mappings":"8CAKAA,EAAK,YAAc,OACnBA,EAAK,QAAU,CAAA,EAGA,SAASA,EAAKC,EAAO,CAClCA,EAAM,SAASC,CAAa,GAQ1B,SAAUD,EAAO,CACjBA,EAAM,UAAU,KAAO,CAGrB,oBAAqB,CACnB,QACE,gEACF,WAAY,GACZ,MAAO,SACf,EACM,iBAAkB,CAChB,CACE,QACE,6GACF,WAAY,GACZ,OAAQA,EAAM,UAAU,IAClC,EACQ,CACE,QACE,sFACF,WAAY,GACZ,OAAQA,EAAM,UAAU,IAClC,CACA,EAEM,OAAQ,CACN,QACE,iFACF,WAAY,GACZ,OAAQ,CACN,cAAe,CACb,QAAS,WACT,MAAO,QACnB,CACA,CACA,EACM,OAAQ,CACN,QAAS,4BACT,WAAY,GACZ,OAAQA,EAAM,UAAU,MAChC,EACM,QAAS,CACP,QAAS,oCACT,WAAY,EACpB,EACM,IAAK,CAEH,QACE,sGACF,WAAY,GACZ,OAAQ,CACN,WAAY,CACV,CAGE,QAAS,mCACT,WAAY,GACZ,OAAQA,EAAM,UAAU,IACtC,EACY,CACE,QAAS,YACT,OAAQ,CACN,aAAc,CACZ,QAAS,0CACT,WAAY,EAC9B,EACgB,YAAa,4BACb,YAAa,QAC7B,CACA,EACY,CACE,QAAS,aACT,OAAQA,EAAM,UAAU,IACtC,CACA,EACU,YAAa,MACvB,CACA,EACM,KAAM,CACJ,QAAS,0CACT,WAAY,GACZ,OAAQA,EAAM,UAAU,IAChC,EAEM,cAAe,CACb,QAAS,aACT,OAAQ,CACN,UAAW,CACT,QAAS,WACT,MAAO,aACnB,EACU,KAAM,CACJ,QAAS,UACT,OAAQA,EAAM,UAAU,IACpC,CACA,CACA,EACM,YAAa,CACX,QAAS,kCACT,WAAY,EACpB,CACA,EAoBI,QAnBIE,EACF,uGAGEC,EAAU,CACZ,MACA,CACE,OAAQ,SACR,SAAU,cAClB,EACM,MACA,aACA,OACA,WACA,OACA,OACA,SACN,EACQC,EAAc,CAAA,EACTC,EAAI,EAAGC,EAAIH,EAAQ,OAAQE,EAAIC,EAAGD,IAAK,CAC9C,IAAIE,EAASJ,EAAQE,CAAC,EACtBE,EACE,OAAOA,GAAW,SACd,CACE,OAAQA,EACR,SAAUA,CACxB,EACYA,EACFP,EAAM,UAAUO,EAAO,QAAQ,IACjCH,EAAY,UAAYG,EAAO,MAAM,EAAI,CACvC,QAAS,OACPL,EAAe,QAAQ,kBAAmB,UAAY,CACpD,OAAOK,EAAO,MAChB,CAAC,CACb,EACU,WAAY,GACZ,OAAQ,CACN,cAAe,CACb,QAAS,WACT,MAAO,QACrB,EACY,KAAM,CACJ,QAAS,UACT,MAAO,CAACA,EAAO,SAAU,YAAcA,EAAO,QAAQ,EACtD,OAAQP,EAAM,UAAUO,EAAO,QAAQ,CACrD,CACA,CACA,EAEI,CACAP,EAAM,UAAU,aAAa,OAAQ,SAAUI,CAAW,CAC5D,GAAGJ,CAAK,CACV","x_google_ignoreList":[0]}

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

@@ -0,0 +1,145 @@
+import s from "./ruby.es.js";
+i.displayName = "haml";
+i.aliases = [];
+function i(a) {
+  a.register(s), (function(e) {
+    e.languages.haml = {
+      // Multiline stuff should appear before the rest
+      "multiline-comment": {
+        pattern: /((?:^|\r?\n|\r)([\t ]*))(?:\/|-#).*(?:(?:\r?\n|\r)\2[\t ].+)*/,
+        lookbehind: !0,
+        alias: "comment"
+      },
+      "multiline-code": [
+        {
+          pattern: /((?:^|\r?\n|\r)([\t ]*)(?:[~-]|[&!]?=)).*,[\t ]*(?:(?:\r?\n|\r)\2[\t ].*,[\t ]*)*(?:(?:\r?\n|\r)\2[\t ].+)/,
+          lookbehind: !0,
+          inside: e.languages.ruby
+        },
+        {
+          pattern: /((?:^|\r?\n|\r)([\t ]*)(?:[~-]|[&!]?=)).*\|[\t ]*(?:(?:\r?\n|\r)\2[\t ].*\|[\t ]*)*/,
+          lookbehind: !0,
+          inside: e.languages.ruby
+        }
+      ],
+      // See at the end of the file for known filters
+      filter: {
+        pattern: /((?:^|\r?\n|\r)([\t ]*)):[\w-]+(?:(?:\r?\n|\r)(?:\2[\t ].+|\s*?(?=\r?\n|\r)))+/,
+        lookbehind: !0,
+        inside: {
+          "filter-name": {
+            pattern: /^:[\w-]+/,
+            alias: "symbol"
+          }
+        }
+      },
+      markup: {
+        pattern: /((?:^|\r?\n|\r)[\t ]*)<.+/,
+        lookbehind: !0,
+        inside: e.languages.markup
+      },
+      doctype: {
+        pattern: /((?:^|\r?\n|\r)[\t ]*)!!!(?: .+)?/,
+        lookbehind: !0
+      },
+      tag: {
+        // Allows for one nested group of braces
+        pattern: /((?:^|\r?\n|\r)[\t ]*)[%.#][\w\-#.]*[\w\-](?:\([^)]+\)|\{(?:\{[^}]+\}|[^{}])+\}|\[[^\]]+\])*[\/<>]*/,
+        lookbehind: !0,
+        inside: {
+          attributes: [
+            {
+              // Lookbehind tries to prevent interpolations from breaking it all
+              // Allows for one nested group of braces
+              pattern: /(^|[^#])\{(?:\{[^}]+\}|[^{}])+\}/,
+              lookbehind: !0,
+              inside: e.languages.ruby
+            },
+            {
+              pattern: /\([^)]+\)/,
+              inside: {
+                "attr-value": {
+                  pattern: /(=\s*)(?:"(?:\\.|[^\\"\r\n])*"|[^)\s]+)/,
+                  lookbehind: !0
+                },
+                "attr-name": /[\w:-]+(?=\s*!?=|\s*[,)])/,
+                punctuation: /[=(),]/
+              }
+            },
+            {
+              pattern: /\[[^\]]+\]/,
+              inside: e.languages.ruby
+            }
+          ],
+          punctuation: /[<>]/
+        }
+      },
+      code: {
+        pattern: /((?:^|\r?\n|\r)[\t ]*(?:[~-]|[&!]?=)).+/,
+        lookbehind: !0,
+        inside: e.languages.ruby
+      },
+      // Interpolations in plain text
+      interpolation: {
+        pattern: /#\{[^}]+\}/,
+        inside: {
+          delimiter: {
+            pattern: /^#\{|\}$/,
+            alias: "punctuation"
+          },
+          ruby: {
+            pattern: /[\s\S]+/,
+            inside: e.languages.ruby
+          }
+        }
+      },
+      punctuation: {
+        pattern: /((?:^|\r?\n|\r)[\t ]*)[~=\-&!]+/,
+        lookbehind: !0
+      }
+    };
+    for (var u = "((?:^|\\r?\\n|\\r)([\\t ]*)):{{filter_name}}(?:(?:\\r?\\n|\\r)(?:\\2[\\t ].+|\\s*?(?=\\r?\\n|\\r)))+", r = [
+      "css",
+      {
+        filter: "coffee",
+        language: "coffeescript"
+      },
+      "erb",
+      "javascript",
+      "less",
+      "markdown",
+      "ruby",
+      "scss",
+      "textile"
+    ], l = {}, n = 0, o = r.length; n < o; n++) {
+      var t = r[n];
+      t = typeof t == "string" ? {
+        filter: t,
+        language: t
+      } : t, e.languages[t.language] && (l["filter-" + t.filter] = {
+        pattern: RegExp(
+          u.replace("{{filter_name}}", function() {
+            return t.filter;
+          })
+        ),
+        lookbehind: !0,
+        inside: {
+          "filter-name": {
+            pattern: /^:[\w-]+/,
+            alias: "symbol"
+          },
+          text: {
+            pattern: /[\s\S]+/,
+            alias: [t.language, "language-" + t.language],
+            inside: e.languages[t.language]
+          }
+        }
+      });
+    }
+    e.languages.insertBefore("haml", "filter", l);
+  })(a);
+}
+export {
+  i as default
+};
+//# sourceMappingURL=haml.es.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"haml.es.js","sources":["../../../../../node_modules/refractor/lang/haml.js"],"sourcesContent":["// @ts-nocheck\n/**\n * @import {Syntax} from '../core.js'\n */\nimport refractorRuby from './ruby.js'\nhaml.displayName = 'haml'\nhaml.aliases = []\n\n/** @type {Syntax} */\nexport default function haml(Prism) {\n  Prism.register(refractorRuby)\n  /* TODO\nHandle multiline code after tag\n%foo= some |\nmultiline |\ncode |\n*/\n\n  ;(function (Prism) {\n    Prism.languages.haml = {\n      // Multiline stuff should appear before the rest\n\n      'multiline-comment': {\n        pattern:\n          /((?:^|\\r?\\n|\\r)([\\t ]*))(?:\\/|-#).*(?:(?:\\r?\\n|\\r)\\2[\\t ].+)*/,\n        lookbehind: true,\n        alias: 'comment'\n      },\n      'multiline-code': [\n        {\n          pattern:\n            /((?:^|\\r?\\n|\\r)([\\t ]*)(?:[~-]|[&!]?=)).*,[\\t ]*(?:(?:\\r?\\n|\\r)\\2[\\t ].*,[\\t ]*)*(?:(?:\\r?\\n|\\r)\\2[\\t ].+)/,\n          lookbehind: true,\n          inside: Prism.languages.ruby\n        },\n        {\n          pattern:\n            /((?:^|\\r?\\n|\\r)([\\t ]*)(?:[~-]|[&!]?=)).*\\|[\\t ]*(?:(?:\\r?\\n|\\r)\\2[\\t ].*\\|[\\t ]*)*/,\n          lookbehind: true,\n          inside: Prism.languages.ruby\n        }\n      ],\n      // See at the end of the file for known filters\n      filter: {\n        pattern:\n          /((?:^|\\r?\\n|\\r)([\\t ]*)):[\\w-]+(?:(?:\\r?\\n|\\r)(?:\\2[\\t ].+|\\s*?(?=\\r?\\n|\\r)))+/,\n        lookbehind: true,\n        inside: {\n          'filter-name': {\n            pattern: /^:[\\w-]+/,\n            alias: 'symbol'\n          }\n        }\n      },\n      markup: {\n        pattern: /((?:^|\\r?\\n|\\r)[\\t ]*)<.+/,\n        lookbehind: true,\n        inside: Prism.languages.markup\n      },\n      doctype: {\n        pattern: /((?:^|\\r?\\n|\\r)[\\t ]*)!!!(?: .+)?/,\n        lookbehind: true\n      },\n      tag: {\n        // Allows for one nested group of braces\n        pattern:\n          /((?:^|\\r?\\n|\\r)[\\t ]*)[%.#][\\w\\-#.]*[\\w\\-](?:\\([^)]+\\)|\\{(?:\\{[^}]+\\}|[^{}])+\\}|\\[[^\\]]+\\])*[\\/<>]*/,\n        lookbehind: true,\n        inside: {\n          attributes: [\n            {\n              // Lookbehind tries to prevent interpolations from breaking it all\n              // Allows for one nested group of braces\n              pattern: /(^|[^#])\\{(?:\\{[^}]+\\}|[^{}])+\\}/,\n              lookbehind: true,\n              inside: Prism.languages.ruby\n            },\n            {\n              pattern: /\\([^)]+\\)/,\n              inside: {\n                'attr-value': {\n                  pattern: /(=\\s*)(?:\"(?:\\\\.|[^\\\\\"\\r\\n])*\"|[^)\\s]+)/,\n                  lookbehind: true\n                },\n                'attr-name': /[\\w:-]+(?=\\s*!?=|\\s*[,)])/,\n                punctuation: /[=(),]/\n              }\n            },\n            {\n              pattern: /\\[[^\\]]+\\]/,\n              inside: Prism.languages.ruby\n            }\n          ],\n          punctuation: /[<>]/\n        }\n      },\n      code: {\n        pattern: /((?:^|\\r?\\n|\\r)[\\t ]*(?:[~-]|[&!]?=)).+/,\n        lookbehind: true,\n        inside: Prism.languages.ruby\n      },\n      // Interpolations in plain text\n      interpolation: {\n        pattern: /#\\{[^}]+\\}/,\n        inside: {\n          delimiter: {\n            pattern: /^#\\{|\\}$/,\n            alias: 'punctuation'\n          },\n          ruby: {\n            pattern: /[\\s\\S]+/,\n            inside: Prism.languages.ruby\n          }\n        }\n      },\n      punctuation: {\n        pattern: /((?:^|\\r?\\n|\\r)[\\t ]*)[~=\\-&!]+/,\n        lookbehind: true\n      }\n    }\n    var filter_pattern =\n      '((?:^|\\\\r?\\\\n|\\\\r)([\\\\t ]*)):{{filter_name}}(?:(?:\\\\r?\\\\n|\\\\r)(?:\\\\2[\\\\t ].+|\\\\s*?(?=\\\\r?\\\\n|\\\\r)))+'\n\n    // Non exhaustive list of available filters and associated languages\n    var filters = [\n      'css',\n      {\n        filter: 'coffee',\n        language: 'coffeescript'\n      },\n      'erb',\n      'javascript',\n      'less',\n      'markdown',\n      'ruby',\n      'scss',\n      'textile'\n    ]\n    var all_filters = {}\n    for (var i = 0, l = filters.length; i < l; i++) {\n      var filter = filters[i]\n      filter =\n        typeof filter === 'string'\n          ? {\n              filter: filter,\n              language: filter\n            }\n          : filter\n      if (Prism.languages[filter.language]) {\n        all_filters['filter-' + filter.filter] = {\n          pattern: RegExp(\n            filter_pattern.replace('{{filter_name}}', function () {\n              return filter.filter\n            })\n          ),\n          lookbehind: true,\n          inside: {\n            'filter-name': {\n              pattern: /^:[\\w-]+/,\n              alias: 'symbol'\n            },\n            text: {\n              pattern: /[\\s\\S]+/,\n              alias: [filter.language, 'language-' + filter.language],\n              inside: Prism.languages[filter.language]\n            }\n          }\n        }\n      }\n    }\n    Prism.languages.insertBefore('haml', 'filter', all_filters)\n  })(Prism)\n}\n"],"names":["haml","Prism","refractorRuby","filter_pattern","filters","all_filters","i","l","filter"],"mappings":";AAKAA,EAAK,cAAc;AACnBA,EAAK,UAAU,CAAA;AAGA,SAASA,EAAKC,GAAO;AAClC,EAAAA,EAAM,SAASC,CAAa,IAQ1B,SAAUD,GAAO;AACjB,IAAAA,EAAM,UAAU,OAAO;AAAA;AAAA,MAGrB,qBAAqB;AAAA,QACnB,SACE;AAAA,QACF,YAAY;AAAA,QACZ,OAAO;AAAA,MACf;AAAA,MACM,kBAAkB;AAAA,QAChB;AAAA,UACE,SACE;AAAA,UACF,YAAY;AAAA,UACZ,QAAQA,EAAM,UAAU;AAAA,QAClC;AAAA,QACQ;AAAA,UACE,SACE;AAAA,UACF,YAAY;AAAA,UACZ,QAAQA,EAAM,UAAU;AAAA,QAClC;AAAA,MACA;AAAA;AAAA,MAEM,QAAQ;AAAA,QACN,SACE;AAAA,QACF,YAAY;AAAA,QACZ,QAAQ;AAAA,UACN,eAAe;AAAA,YACb,SAAS;AAAA,YACT,OAAO;AAAA,UACnB;AAAA,QACA;AAAA,MACA;AAAA,MACM,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,QAAQA,EAAM,UAAU;AAAA,MAChC;AAAA,MACM,SAAS;AAAA,QACP,SAAS;AAAA,QACT,YAAY;AAAA,MACpB;AAAA,MACM,KAAK;AAAA;AAAA,QAEH,SACE;AAAA,QACF,YAAY;AAAA,QACZ,QAAQ;AAAA,UACN,YAAY;AAAA,YACV;AAAA;AAAA;AAAA,cAGE,SAAS;AAAA,cACT,YAAY;AAAA,cACZ,QAAQA,EAAM,UAAU;AAAA,YACtC;AAAA,YACY;AAAA,cACE,SAAS;AAAA,cACT,QAAQ;AAAA,gBACN,cAAc;AAAA,kBACZ,SAAS;AAAA,kBACT,YAAY;AAAA,gBAC9B;AAAA,gBACgB,aAAa;AAAA,gBACb,aAAa;AAAA,cAC7B;AAAA,YACA;AAAA,YACY;AAAA,cACE,SAAS;AAAA,cACT,QAAQA,EAAM,UAAU;AAAA,YACtC;AAAA,UACA;AAAA,UACU,aAAa;AAAA,QACvB;AAAA,MACA;AAAA,MACM,MAAM;AAAA,QACJ,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,QAAQA,EAAM,UAAU;AAAA,MAChC;AAAA;AAAA,MAEM,eAAe;AAAA,QACb,SAAS;AAAA,QACT,QAAQ;AAAA,UACN,WAAW;AAAA,YACT,SAAS;AAAA,YACT,OAAO;AAAA,UACnB;AAAA,UACU,MAAM;AAAA,YACJ,SAAS;AAAA,YACT,QAAQA,EAAM,UAAU;AAAA,UACpC;AAAA,QACA;AAAA,MACA;AAAA,MACM,aAAa;AAAA,QACX,SAAS;AAAA,QACT,YAAY;AAAA,MACpB;AAAA,IACA;AAoBI,aAnBIE,IACF,wGAGEC,IAAU;AAAA,MACZ;AAAA,MACA;AAAA,QACE,QAAQ;AAAA,QACR,UAAU;AAAA,MAClB;AAAA,MACM;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACN,GACQC,IAAc,CAAA,GACTC,IAAI,GAAGC,IAAIH,EAAQ,QAAQE,IAAIC,GAAGD,KAAK;AAC9C,UAAIE,IAASJ,EAAQE,CAAC;AACtB,MAAAE,IACE,OAAOA,KAAW,WACd;AAAA,QACE,QAAQA;AAAA,QACR,UAAUA;AAAA,MACxB,IACYA,GACFP,EAAM,UAAUO,EAAO,QAAQ,MACjCH,EAAY,YAAYG,EAAO,MAAM,IAAI;AAAA,QACvC,SAAS;AAAA,UACPL,EAAe,QAAQ,mBAAmB,WAAY;AACpD,mBAAOK,EAAO;AAAA,UAChB,CAAC;AAAA,QACb;AAAA,QACU,YAAY;AAAA,QACZ,QAAQ;AAAA,UACN,eAAe;AAAA,YACb,SAAS;AAAA,YACT,OAAO;AAAA,UACrB;AAAA,UACY,MAAM;AAAA,YACJ,SAAS;AAAA,YACT,OAAO,CAACA,EAAO,UAAU,cAAcA,EAAO,QAAQ;AAAA,YACtD,QAAQP,EAAM,UAAUO,EAAO,QAAQ;AAAA,UACrD;AAAA,QACA;AAAA,MACA;AAAA,IAEI;AACA,IAAAP,EAAM,UAAU,aAAa,QAAQ,UAAUI,CAAW;AAAA,EAC5D,GAAGJ,CAAK;AACV;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,2 @@
+"use strict";const l=require("./markup-templating.cjs.js");n.displayName="handlebars";n.aliases=["hbs","mustache"];function n(t){t.register(l),(function(a){a.languages.handlebars={comment:/\{\{![\s\S]*?\}\}/,delimiter:{pattern:/^\{\{\{?|\}\}\}?$/,alias:"punctuation"},string:/(["'])(?:\\.|(?!\1)[^\\\r\n])*\1/,number:/\b0x[\dA-Fa-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee][+-]?\d+)?/,boolean:/\b(?:false|true)\b/,block:{pattern:/^(\s*(?:~\s*)?)[#\/]\S+?(?=\s*(?:~\s*)?$|\s)/,lookbehind:!0,alias:"keyword"},brackets:{pattern:/\[[^\]]+\]/,inside:{punctuation:/\[|\]/,variable:/[\s\S]+/}},punctuation:/[!"#%&':()*+,.\/;<=>@\[\\\]^`{|}~]/,variable:/[^!"#%&'()*+,\/;<=>@\[\\\]^`{|}~\s]+/},a.hooks.add("before-tokenize",function(e){var s=/\{\{\{[\s\S]+?\}\}\}|\{\{[\s\S]+?\}\}/g;a.languages["markup-templating"].buildPlaceholders(e,"handlebars",s)}),a.hooks.add("after-tokenize",function(e){a.languages["markup-templating"].tokenizePlaceholders(e,"handlebars")}),a.languages.hbs=a.languages.handlebars,a.languages.mustache=a.languages.handlebars})(t)}module.exports=n;
+//# sourceMappingURL=handlebars.cjs.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handlebars.cjs.js","sources":["../../../../../node_modules/refractor/lang/handlebars.js"],"sourcesContent":["// @ts-nocheck\n/**\n * @import {Syntax} from '../core.js'\n */\nimport refractorMarkupTemplating from './markup-templating.js'\nhandlebars.displayName = 'handlebars'\nhandlebars.aliases = ['hbs', 'mustache']\n\n/** @type {Syntax} */\nexport default function handlebars(Prism) {\n  Prism.register(refractorMarkupTemplating)\n  ;(function (Prism) {\n    Prism.languages.handlebars = {\n      comment: /\\{\\{![\\s\\S]*?\\}\\}/,\n      delimiter: {\n        pattern: /^\\{\\{\\{?|\\}\\}\\}?$/,\n        alias: 'punctuation'\n      },\n      string: /([\"'])(?:\\\\.|(?!\\1)[^\\\\\\r\\n])*\\1/,\n      number: /\\b0x[\\dA-Fa-f]+\\b|(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:[Ee][+-]?\\d+)?/,\n      boolean: /\\b(?:false|true)\\b/,\n      block: {\n        pattern: /^(\\s*(?:~\\s*)?)[#\\/]\\S+?(?=\\s*(?:~\\s*)?$|\\s)/,\n        lookbehind: true,\n        alias: 'keyword'\n      },\n      brackets: {\n        pattern: /\\[[^\\]]+\\]/,\n        inside: {\n          punctuation: /\\[|\\]/,\n          variable: /[\\s\\S]+/\n        }\n      },\n      punctuation: /[!\"#%&':()*+,.\\/;<=>@\\[\\\\\\]^`{|}~]/,\n      variable: /[^!\"#%&'()*+,\\/;<=>@\\[\\\\\\]^`{|}~\\s]+/\n    }\n    Prism.hooks.add('before-tokenize', function (env) {\n      var handlebarsPattern = /\\{\\{\\{[\\s\\S]+?\\}\\}\\}|\\{\\{[\\s\\S]+?\\}\\}/g\n      Prism.languages['markup-templating'].buildPlaceholders(\n        env,\n        'handlebars',\n        handlebarsPattern\n      )\n    })\n    Prism.hooks.add('after-tokenize', function (env) {\n      Prism.languages['markup-templating'].tokenizePlaceholders(\n        env,\n        'handlebars'\n      )\n    })\n    Prism.languages.hbs = Prism.languages.handlebars\n    Prism.languages.mustache = Prism.languages.handlebars\n  })(Prism)\n}\n"],"names":["handlebars","Prism","refractorMarkupTemplating","env","handlebarsPattern"],"mappings":"2DAKAA,EAAW,YAAc,aACzBA,EAAW,QAAU,CAAC,MAAO,UAAU,EAGxB,SAASA,EAAWC,EAAO,CACxCA,EAAM,SAASC,CAAyB,GACtC,SAAUD,EAAO,CACjBA,EAAM,UAAU,WAAa,CAC3B,QAAS,oBACT,UAAW,CACT,QAAS,oBACT,MAAO,aACf,EACM,OAAQ,mCACR,OAAQ,iEACR,QAAS,qBACT,MAAO,CACL,QAAS,+CACT,WAAY,GACZ,MAAO,SACf,EACM,SAAU,CACR,QAAS,aACT,OAAQ,CACN,YAAa,QACb,SAAU,SACpB,CACA,EACM,YAAa,qCACb,SAAU,sCAChB,EACIA,EAAM,MAAM,IAAI,kBAAmB,SAAUE,EAAK,CAChD,IAAIC,EAAoB,yCACxBH,EAAM,UAAU,mBAAmB,EAAE,kBACnCE,EACA,aACAC,CACR,CACI,CAAC,EACDH,EAAM,MAAM,IAAI,iBAAkB,SAAUE,EAAK,CAC/CF,EAAM,UAAU,mBAAmB,EAAE,qBACnCE,EACA,YACR,CACI,CAAC,EACDF,EAAM,UAAU,IAAMA,EAAM,UAAU,WACtCA,EAAM,UAAU,SAAWA,EAAM,UAAU,UAC7C,GAAGA,CAAK,CACV","x_google_ignoreList":[0]}

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

@@ -0,0 +1,47 @@
+import s from "./markup-templating.es.js";
+t.displayName = "handlebars";
+t.aliases = ["hbs", "mustache"];
+function t(n) {
+  n.register(s), (function(a) {
+    a.languages.handlebars = {
+      comment: /\{\{![\s\S]*?\}\}/,
+      delimiter: {
+        pattern: /^\{\{\{?|\}\}\}?$/,
+        alias: "punctuation"
+      },
+      string: /(["'])(?:\\.|(?!\1)[^\\\r\n])*\1/,
+      number: /\b0x[\dA-Fa-f]+\b|(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:[Ee][+-]?\d+)?/,
+      boolean: /\b(?:false|true)\b/,
+      block: {
+        pattern: /^(\s*(?:~\s*)?)[#\/]\S+?(?=\s*(?:~\s*)?$|\s)/,
+        lookbehind: !0,
+        alias: "keyword"
+      },
+      brackets: {
+        pattern: /\[[^\]]+\]/,
+        inside: {
+          punctuation: /\[|\]/,
+          variable: /[\s\S]+/
+        }
+      },
+      punctuation: /[!"#%&':()*+,.\/;<=>@\[\\\]^`{|}~]/,
+      variable: /[^!"#%&'()*+,\/;<=>@\[\\\]^`{|}~\s]+/
+    }, a.hooks.add("before-tokenize", function(e) {
+      var l = /\{\{\{[\s\S]+?\}\}\}|\{\{[\s\S]+?\}\}/g;
+      a.languages["markup-templating"].buildPlaceholders(
+        e,
+        "handlebars",
+        l
+      );
+    }), a.hooks.add("after-tokenize", function(e) {
+      a.languages["markup-templating"].tokenizePlaceholders(
+        e,
+        "handlebars"
+      );
+    }), a.languages.hbs = a.languages.handlebars, a.languages.mustache = a.languages.handlebars;
+  })(n);
+}
+export {
+  t as default
+};
+//# sourceMappingURL=handlebars.es.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"handlebars.es.js","sources":["../../../../../node_modules/refractor/lang/handlebars.js"],"sourcesContent":["// @ts-nocheck\n/**\n * @import {Syntax} from '../core.js'\n */\nimport refractorMarkupTemplating from './markup-templating.js'\nhandlebars.displayName = 'handlebars'\nhandlebars.aliases = ['hbs', 'mustache']\n\n/** @type {Syntax} */\nexport default function handlebars(Prism) {\n  Prism.register(refractorMarkupTemplating)\n  ;(function (Prism) {\n    Prism.languages.handlebars = {\n      comment: /\\{\\{![\\s\\S]*?\\}\\}/,\n      delimiter: {\n        pattern: /^\\{\\{\\{?|\\}\\}\\}?$/,\n        alias: 'punctuation'\n      },\n      string: /([\"'])(?:\\\\.|(?!\\1)[^\\\\\\r\\n])*\\1/,\n      number: /\\b0x[\\dA-Fa-f]+\\b|(?:\\b\\d+(?:\\.\\d*)?|\\B\\.\\d+)(?:[Ee][+-]?\\d+)?/,\n      boolean: /\\b(?:false|true)\\b/,\n      block: {\n        pattern: /^(\\s*(?:~\\s*)?)[#\\/]\\S+?(?=\\s*(?:~\\s*)?$|\\s)/,\n        lookbehind: true,\n        alias: 'keyword'\n      },\n      brackets: {\n        pattern: /\\[[^\\]]+\\]/,\n        inside: {\n          punctuation: /\\[|\\]/,\n          variable: /[\\s\\S]+/\n        }\n      },\n      punctuation: /[!\"#%&':()*+,.\\/;<=>@\\[\\\\\\]^`{|}~]/,\n      variable: /[^!\"#%&'()*+,\\/;<=>@\\[\\\\\\]^`{|}~\\s]+/\n    }\n    Prism.hooks.add('before-tokenize', function (env) {\n      var handlebarsPattern = /\\{\\{\\{[\\s\\S]+?\\}\\}\\}|\\{\\{[\\s\\S]+?\\}\\}/g\n      Prism.languages['markup-templating'].buildPlaceholders(\n        env,\n        'handlebars',\n        handlebarsPattern\n      )\n    })\n    Prism.hooks.add('after-tokenize', function (env) {\n      Prism.languages['markup-templating'].tokenizePlaceholders(\n        env,\n        'handlebars'\n      )\n    })\n    Prism.languages.hbs = Prism.languages.handlebars\n    Prism.languages.mustache = Prism.languages.handlebars\n  })(Prism)\n}\n"],"names":["handlebars","Prism","refractorMarkupTemplating","env","handlebarsPattern"],"mappings":";AAKAA,EAAW,cAAc;AACzBA,EAAW,UAAU,CAAC,OAAO,UAAU;AAGxB,SAASA,EAAWC,GAAO;AACxC,EAAAA,EAAM,SAASC,CAAyB,IACtC,SAAUD,GAAO;AACjB,IAAAA,EAAM,UAAU,aAAa;AAAA,MAC3B,SAAS;AAAA,MACT,WAAW;AAAA,QACT,SAAS;AAAA,QACT,OAAO;AAAA,MACf;AAAA,MACM,QAAQ;AAAA,MACR,QAAQ;AAAA,MACR,SAAS;AAAA,MACT,OAAO;AAAA,QACL,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,OAAO;AAAA,MACf;AAAA,MACM,UAAU;AAAA,QACR,SAAS;AAAA,QACT,QAAQ;AAAA,UACN,aAAa;AAAA,UACb,UAAU;AAAA,QACpB;AAAA,MACA;AAAA,MACM,aAAa;AAAA,MACb,UAAU;AAAA,IAChB,GACIA,EAAM,MAAM,IAAI,mBAAmB,SAAUE,GAAK;AAChD,UAAIC,IAAoB;AACxB,MAAAH,EAAM,UAAU,mBAAmB,EAAE;AAAA,QACnCE;AAAA,QACA;AAAA,QACAC;AAAA,MACR;AAAA,IACI,CAAC,GACDH,EAAM,MAAM,IAAI,kBAAkB,SAAUE,GAAK;AAC/C,MAAAF,EAAM,UAAU,mBAAmB,EAAE;AAAA,QACnCE;AAAA,QACA;AAAA,MACR;AAAA,IACI,CAAC,GACDF,EAAM,UAAU,MAAMA,EAAM,UAAU,YACtCA,EAAM,UAAU,WAAWA,EAAM,UAAU;AAAA,EAC7C,GAAGA,CAAK;AACV;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,2 @@
+"use strict";t.displayName="haskell";t.aliases=["hs"];function t(e){e.languages.haskell={comment:{pattern:/(^|[^-!#$%*+=?&@|~.:<>^\\\/])(?:--(?:(?=.)[^-!#$%*+=?&@|~.:<>^\\\/].*|$)|\{-[\s\S]*?-\})/m,lookbehind:!0},char:{pattern:/'(?:[^\\']|\\(?:[abfnrtv\\"'&]|\^[A-Z@[\]^_]|ACK|BEL|BS|CAN|CR|DC1|DC2|DC3|DC4|DEL|DLE|EM|ENQ|EOT|ESC|ETB|ETX|FF|FS|GS|HT|LF|NAK|NUL|RS|SI|SO|SOH|SP|STX|SUB|SYN|US|VT|\d+|o[0-7]+|x[0-9a-fA-F]+))'/,alias:"string"},string:{pattern:/"(?:[^\\"]|\\(?:\S|\s+\\))*"/,greedy:!0},keyword:/\b(?:case|class|data|deriving|do|else|if|in|infixl|infixr|instance|let|module|newtype|of|primitive|then|type|where)\b/,"import-statement":{pattern:/(^[\t ]*)import\s+(?:qualified\s+)?(?:[A-Z][\w']*)(?:\.[A-Z][\w']*)*(?:\s+as\s+(?:[A-Z][\w']*)(?:\.[A-Z][\w']*)*)?(?:\s+hiding\b)?/m,lookbehind:!0,inside:{keyword:/\b(?:as|hiding|import|qualified)\b/,punctuation:/\./}},builtin:/\b(?:abs|acos|acosh|all|and|any|appendFile|approxRational|asTypeOf|asin|asinh|atan|atan2|atanh|basicIORun|break|catch|ceiling|chr|compare|concat|concatMap|const|cos|cosh|curry|cycle|decodeFloat|denominator|digitToInt|div|divMod|drop|dropWhile|either|elem|encodeFloat|enumFrom|enumFromThen|enumFromThenTo|enumFromTo|error|even|exp|exponent|fail|filter|flip|floatDigits|floatRadix|floatRange|floor|fmap|foldl|foldl1|foldr|foldr1|fromDouble|fromEnum|fromInt|fromInteger|fromIntegral|fromRational|fst|gcd|getChar|getContents|getLine|group|head|id|inRange|index|init|intToDigit|interact|ioError|isAlpha|isAlphaNum|isAscii|isControl|isDenormalized|isDigit|isHexDigit|isIEEE|isInfinite|isLower|isNaN|isNegativeZero|isOctDigit|isPrint|isSpace|isUpper|iterate|last|lcm|length|lex|lexDigits|lexLitChar|lines|log|logBase|lookup|map|mapM|mapM_|max|maxBound|maximum|maybe|min|minBound|minimum|mod|negate|not|notElem|null|numerator|odd|or|ord|otherwise|pack|pi|pred|primExitWith|print|product|properFraction|putChar|putStr|putStrLn|quot|quotRem|range|rangeSize|read|readDec|readFile|readFloat|readHex|readIO|readInt|readList|readLitChar|readLn|readOct|readParen|readSigned|reads|readsPrec|realToFrac|recip|rem|repeat|replicate|return|reverse|round|scaleFloat|scanl|scanl1|scanr|scanr1|seq|sequence|sequence_|show|showChar|showInt|showList|showLitChar|showParen|showSigned|showString|shows|showsPrec|significand|signum|sin|sinh|snd|sort|span|splitAt|sqrt|subtract|succ|sum|tail|take|takeWhile|tan|tanh|threadToIOResult|toEnum|toInt|toInteger|toLower|toRational|toUpper|truncate|uncurry|undefined|unlines|until|unwords|unzip|unzip3|userError|words|writeFile|zip|zip3|zipWith|zipWith3)\b/,number:/\b(?:\d+(?:\.\d+)?(?:e[+-]?\d+)?|0o[0-7]+|0x[0-9a-f]+)\b/i,operator:[{pattern:/`(?:[A-Z][\w']*\.)*[_a-z][\w']*`/,greedy:!0},{pattern:/(\s)\.(?=\s)/,lookbehind:!0},/[-!#$%*+=?&@|~:<>^\\\/][-!#$%*+=?&@|~.:<>^\\\/]*|\.[-!#$%*+=?&@|~.:<>^\\\/]+/],hvariable:{pattern:/\b(?:[A-Z][\w']*\.)*[_a-z][\w']*/,inside:{punctuation:/\./}},constant:{pattern:/\b(?:[A-Z][\w']*\.)*[A-Z][\w']*/,inside:{punctuation:/\./}},punctuation:/[{}[\];(),.:]/},e.languages.hs=e.languages.haskell}module.exports=t;
+//# sourceMappingURL=haskell.cjs.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"haskell.cjs.js","sources":["../../../../../node_modules/refractor/lang/haskell.js"],"sourcesContent":["// @ts-nocheck\n/**\n * @import {Syntax} from '../core.js'\n */\nhaskell.displayName = 'haskell'\nhaskell.aliases = ['hs']\n\n/** @type {Syntax} */\nexport default function haskell(Prism) {\n  Prism.languages.haskell = {\n    comment: {\n      pattern:\n        /(^|[^-!#$%*+=?&@|~.:<>^\\\\\\/])(?:--(?:(?=.)[^-!#$%*+=?&@|~.:<>^\\\\\\/].*|$)|\\{-[\\s\\S]*?-\\})/m,\n      lookbehind: true\n    },\n    char: {\n      pattern:\n        /'(?:[^\\\\']|\\\\(?:[abfnrtv\\\\\"'&]|\\^[A-Z@[\\]^_]|ACK|BEL|BS|CAN|CR|DC1|DC2|DC3|DC4|DEL|DLE|EM|ENQ|EOT|ESC|ETB|ETX|FF|FS|GS|HT|LF|NAK|NUL|RS|SI|SO|SOH|SP|STX|SUB|SYN|US|VT|\\d+|o[0-7]+|x[0-9a-fA-F]+))'/,\n      alias: 'string'\n    },\n    string: {\n      pattern: /\"(?:[^\\\\\"]|\\\\(?:\\S|\\s+\\\\))*\"/,\n      greedy: true\n    },\n    keyword:\n      /\\b(?:case|class|data|deriving|do|else|if|in|infixl|infixr|instance|let|module|newtype|of|primitive|then|type|where)\\b/,\n    'import-statement': {\n      // The imported or hidden names are not included in this import\n      // statement. This is because we want to highlight those exactly like\n      // we do for the names in the program.\n      pattern:\n        /(^[\\t ]*)import\\s+(?:qualified\\s+)?(?:[A-Z][\\w']*)(?:\\.[A-Z][\\w']*)*(?:\\s+as\\s+(?:[A-Z][\\w']*)(?:\\.[A-Z][\\w']*)*)?(?:\\s+hiding\\b)?/m,\n      lookbehind: true,\n      inside: {\n        keyword: /\\b(?:as|hiding|import|qualified)\\b/,\n        punctuation: /\\./\n      }\n    },\n    // These are builtin variables only. Constructors are highlighted later as a constant.\n    builtin:\n      /\\b(?:abs|acos|acosh|all|and|any|appendFile|approxRational|asTypeOf|asin|asinh|atan|atan2|atanh|basicIORun|break|catch|ceiling|chr|compare|concat|concatMap|const|cos|cosh|curry|cycle|decodeFloat|denominator|digitToInt|div|divMod|drop|dropWhile|either|elem|encodeFloat|enumFrom|enumFromThen|enumFromThenTo|enumFromTo|error|even|exp|exponent|fail|filter|flip|floatDigits|floatRadix|floatRange|floor|fmap|foldl|foldl1|foldr|foldr1|fromDouble|fromEnum|fromInt|fromInteger|fromIntegral|fromRational|fst|gcd|getChar|getContents|getLine|group|head|id|inRange|index|init|intToDigit|interact|ioError|isAlpha|isAlphaNum|isAscii|isControl|isDenormalized|isDigit|isHexDigit|isIEEE|isInfinite|isLower|isNaN|isNegativeZero|isOctDigit|isPrint|isSpace|isUpper|iterate|last|lcm|length|lex|lexDigits|lexLitChar|lines|log|logBase|lookup|map|mapM|mapM_|max|maxBound|maximum|maybe|min|minBound|minimum|mod|negate|not|notElem|null|numerator|odd|or|ord|otherwise|pack|pi|pred|primExitWith|print|product|properFraction|putChar|putStr|putStrLn|quot|quotRem|range|rangeSize|read|readDec|readFile|readFloat|readHex|readIO|readInt|readList|readLitChar|readLn|readOct|readParen|readSigned|reads|readsPrec|realToFrac|recip|rem|repeat|replicate|return|reverse|round|scaleFloat|scanl|scanl1|scanr|scanr1|seq|sequence|sequence_|show|showChar|showInt|showList|showLitChar|showParen|showSigned|showString|shows|showsPrec|significand|signum|sin|sinh|snd|sort|span|splitAt|sqrt|subtract|succ|sum|tail|take|takeWhile|tan|tanh|threadToIOResult|toEnum|toInt|toInteger|toLower|toRational|toUpper|truncate|uncurry|undefined|unlines|until|unwords|unzip|unzip3|userError|words|writeFile|zip|zip3|zipWith|zipWith3)\\b/,\n    // decimal integers and floating point numbers | octal integers | hexadecimal integers\n    number: /\\b(?:\\d+(?:\\.\\d+)?(?:e[+-]?\\d+)?|0o[0-7]+|0x[0-9a-f]+)\\b/i,\n    operator: [\n      {\n        // infix operator\n        pattern: /`(?:[A-Z][\\w']*\\.)*[_a-z][\\w']*`/,\n        greedy: true\n      },\n      {\n        // function composition\n        pattern: /(\\s)\\.(?=\\s)/,\n        lookbehind: true\n      },\n      // Most of this is needed because of the meaning of a single '.'.\n      // If it stands alone freely, it is the function composition.\n      // It may also be a separator between a module name and an identifier => no\n      // operator. If it comes together with other special characters it is an\n      // operator too.\n      //\n      // This regex means: /[-!#$%*+=?&@|~.:<>^\\\\\\/]+/ without /\\./.\n      /[-!#$%*+=?&@|~:<>^\\\\\\/][-!#$%*+=?&@|~.:<>^\\\\\\/]*|\\.[-!#$%*+=?&@|~.:<>^\\\\\\/]+/\n    ],\n    // In Haskell, nearly everything is a variable, do not highlight these.\n    hvariable: {\n      pattern: /\\b(?:[A-Z][\\w']*\\.)*[_a-z][\\w']*/,\n      inside: {\n        punctuation: /\\./\n      }\n    },\n    constant: {\n      pattern: /\\b(?:[A-Z][\\w']*\\.)*[A-Z][\\w']*/,\n      inside: {\n        punctuation: /\\./\n      }\n    },\n    punctuation: /[{}[\\];(),.:]/\n  }\n  Prism.languages.hs = Prism.languages.haskell\n}\n"],"names":["haskell","Prism"],"mappings":"aAIAA,EAAQ,YAAc,UACtBA,EAAQ,QAAU,CAAC,IAAI,EAGR,SAASA,EAAQC,EAAO,CACrCA,EAAM,UAAU,QAAU,CACxB,QAAS,CACP,QACE,4FACF,WAAY,EAClB,EACI,KAAM,CACJ,QACE,sMACF,MAAO,QACb,EACI,OAAQ,CACN,QAAS,+BACT,OAAQ,EACd,EACI,QACE,wHACF,mBAAoB,CAIlB,QACE,sIACF,WAAY,GACZ,OAAQ,CACN,QAAS,qCACT,YAAa,IACrB,CACA,EAEI,QACE,yoDAEF,OAAQ,4DACR,SAAU,CACR,CAEE,QAAS,mCACT,OAAQ,EAChB,EACM,CAEE,QAAS,eACT,WAAY,EACpB,EAQM,8EACN,EAEI,UAAW,CACT,QAAS,mCACT,OAAQ,CACN,YAAa,IACrB,CACA,EACI,SAAU,CACR,QAAS,kCACT,OAAQ,CACN,YAAa,IACrB,CACA,EACI,YAAa,eACjB,EACEA,EAAM,UAAU,GAAKA,EAAM,UAAU,OACvC","x_google_ignoreList":[0]}

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

@@ -0,0 +1,72 @@
+t.displayName = "haskell";
+t.aliases = ["hs"];
+function t(e) {
+  e.languages.haskell = {
+    comment: {
+      pattern: /(^|[^-!#$%*+=?&@|~.:<>^\\\/])(?:--(?:(?=.)[^-!#$%*+=?&@|~.:<>^\\\/].*|$)|\{-[\s\S]*?-\})/m,
+      lookbehind: !0
+    },
+    char: {
+      pattern: /'(?:[^\\']|\\(?:[abfnrtv\\"'&]|\^[A-Z@[\]^_]|ACK|BEL|BS|CAN|CR|DC1|DC2|DC3|DC4|DEL|DLE|EM|ENQ|EOT|ESC|ETB|ETX|FF|FS|GS|HT|LF|NAK|NUL|RS|SI|SO|SOH|SP|STX|SUB|SYN|US|VT|\d+|o[0-7]+|x[0-9a-fA-F]+))'/,
+      alias: "string"
+    },
+    string: {
+      pattern: /"(?:[^\\"]|\\(?:\S|\s+\\))*"/,
+      greedy: !0
+    },
+    keyword: /\b(?:case|class|data|deriving|do|else|if|in|infixl|infixr|instance|let|module|newtype|of|primitive|then|type|where)\b/,
+    "import-statement": {
+      // The imported or hidden names are not included in this import
+      // statement. This is because we want to highlight those exactly like
+      // we do for the names in the program.
+      pattern: /(^[\t ]*)import\s+(?:qualified\s+)?(?:[A-Z][\w']*)(?:\.[A-Z][\w']*)*(?:\s+as\s+(?:[A-Z][\w']*)(?:\.[A-Z][\w']*)*)?(?:\s+hiding\b)?/m,
+      lookbehind: !0,
+      inside: {
+        keyword: /\b(?:as|hiding|import|qualified)\b/,
+        punctuation: /\./
+      }
+    },
+    // These are builtin variables only. Constructors are highlighted later as a constant.
+    builtin: /\b(?:abs|acos|acosh|all|and|any|appendFile|approxRational|asTypeOf|asin|asinh|atan|atan2|atanh|basicIORun|break|catch|ceiling|chr|compare|concat|concatMap|const|cos|cosh|curry|cycle|decodeFloat|denominator|digitToInt|div|divMod|drop|dropWhile|either|elem|encodeFloat|enumFrom|enumFromThen|enumFromThenTo|enumFromTo|error|even|exp|exponent|fail|filter|flip|floatDigits|floatRadix|floatRange|floor|fmap|foldl|foldl1|foldr|foldr1|fromDouble|fromEnum|fromInt|fromInteger|fromIntegral|fromRational|fst|gcd|getChar|getContents|getLine|group|head|id|inRange|index|init|intToDigit|interact|ioError|isAlpha|isAlphaNum|isAscii|isControl|isDenormalized|isDigit|isHexDigit|isIEEE|isInfinite|isLower|isNaN|isNegativeZero|isOctDigit|isPrint|isSpace|isUpper|iterate|last|lcm|length|lex|lexDigits|lexLitChar|lines|log|logBase|lookup|map|mapM|mapM_|max|maxBound|maximum|maybe|min|minBound|minimum|mod|negate|not|notElem|null|numerator|odd|or|ord|otherwise|pack|pi|pred|primExitWith|print|product|properFraction|putChar|putStr|putStrLn|quot|quotRem|range|rangeSize|read|readDec|readFile|readFloat|readHex|readIO|readInt|readList|readLitChar|readLn|readOct|readParen|readSigned|reads|readsPrec|realToFrac|recip|rem|repeat|replicate|return|reverse|round|scaleFloat|scanl|scanl1|scanr|scanr1|seq|sequence|sequence_|show|showChar|showInt|showList|showLitChar|showParen|showSigned|showString|shows|showsPrec|significand|signum|sin|sinh|snd|sort|span|splitAt|sqrt|subtract|succ|sum|tail|take|takeWhile|tan|tanh|threadToIOResult|toEnum|toInt|toInteger|toLower|toRational|toUpper|truncate|uncurry|undefined|unlines|until|unwords|unzip|unzip3|userError|words|writeFile|zip|zip3|zipWith|zipWith3)\b/,
+    // decimal integers and floating point numbers | octal integers | hexadecimal integers
+    number: /\b(?:\d+(?:\.\d+)?(?:e[+-]?\d+)?|0o[0-7]+|0x[0-9a-f]+)\b/i,
+    operator: [
+      {
+        // infix operator
+        pattern: /`(?:[A-Z][\w']*\.)*[_a-z][\w']*`/,
+        greedy: !0
+      },
+      {
+        // function composition
+        pattern: /(\s)\.(?=\s)/,
+        lookbehind: !0
+      },
+      // Most of this is needed because of the meaning of a single '.'.
+      // If it stands alone freely, it is the function composition.
+      // It may also be a separator between a module name and an identifier => no
+      // operator. If it comes together with other special characters it is an
+      // operator too.
+      //
+      // This regex means: /[-!#$%*+=?&@|~.:<>^\\\/]+/ without /\./.
+      /[-!#$%*+=?&@|~:<>^\\\/][-!#$%*+=?&@|~.:<>^\\\/]*|\.[-!#$%*+=?&@|~.:<>^\\\/]+/
+    ],
+    // In Haskell, nearly everything is a variable, do not highlight these.
+    hvariable: {
+      pattern: /\b(?:[A-Z][\w']*\.)*[_a-z][\w']*/,
+      inside: {
+        punctuation: /\./
+      }
+    },
+    constant: {
+      pattern: /\b(?:[A-Z][\w']*\.)*[A-Z][\w']*/,
+      inside: {
+        punctuation: /\./
+      }
+    },
+    punctuation: /[{}[\];(),.:]/
+  }, e.languages.hs = e.languages.haskell;
+}
+export {
+  t as default
+};
+//# sourceMappingURL=haskell.es.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"haskell.es.js","sources":["../../../../../node_modules/refractor/lang/haskell.js"],"sourcesContent":["// @ts-nocheck\n/**\n * @import {Syntax} from '../core.js'\n */\nhaskell.displayName = 'haskell'\nhaskell.aliases = ['hs']\n\n/** @type {Syntax} */\nexport default function haskell(Prism) {\n  Prism.languages.haskell = {\n    comment: {\n      pattern:\n        /(^|[^-!#$%*+=?&@|~.:<>^\\\\\\/])(?:--(?:(?=.)[^-!#$%*+=?&@|~.:<>^\\\\\\/].*|$)|\\{-[\\s\\S]*?-\\})/m,\n      lookbehind: true\n    },\n    char: {\n      pattern:\n        /'(?:[^\\\\']|\\\\(?:[abfnrtv\\\\\"'&]|\\^[A-Z@[\\]^_]|ACK|BEL|BS|CAN|CR|DC1|DC2|DC3|DC4|DEL|DLE|EM|ENQ|EOT|ESC|ETB|ETX|FF|FS|GS|HT|LF|NAK|NUL|RS|SI|SO|SOH|SP|STX|SUB|SYN|US|VT|\\d+|o[0-7]+|x[0-9a-fA-F]+))'/,\n      alias: 'string'\n    },\n    string: {\n      pattern: /\"(?:[^\\\\\"]|\\\\(?:\\S|\\s+\\\\))*\"/,\n      greedy: true\n    },\n    keyword:\n      /\\b(?:case|class|data|deriving|do|else|if|in|infixl|infixr|instance|let|module|newtype|of|primitive|then|type|where)\\b/,\n    'import-statement': {\n      // The imported or hidden names are not included in this import\n      // statement. This is because we want to highlight those exactly like\n      // we do for the names in the program.\n      pattern:\n        /(^[\\t ]*)import\\s+(?:qualified\\s+)?(?:[A-Z][\\w']*)(?:\\.[A-Z][\\w']*)*(?:\\s+as\\s+(?:[A-Z][\\w']*)(?:\\.[A-Z][\\w']*)*)?(?:\\s+hiding\\b)?/m,\n      lookbehind: true,\n      inside: {\n        keyword: /\\b(?:as|hiding|import|qualified)\\b/,\n        punctuation: /\\./\n      }\n    },\n    // These are builtin variables only. Constructors are highlighted later as a constant.\n    builtin:\n      /\\b(?:abs|acos|acosh|all|and|any|appendFile|approxRational|asTypeOf|asin|asinh|atan|atan2|atanh|basicIORun|break|catch|ceiling|chr|compare|concat|concatMap|const|cos|cosh|curry|cycle|decodeFloat|denominator|digitToInt|div|divMod|drop|dropWhile|either|elem|encodeFloat|enumFrom|enumFromThen|enumFromThenTo|enumFromTo|error|even|exp|exponent|fail|filter|flip|floatDigits|floatRadix|floatRange|floor|fmap|foldl|foldl1|foldr|foldr1|fromDouble|fromEnum|fromInt|fromInteger|fromIntegral|fromRational|fst|gcd|getChar|getContents|getLine|group|head|id|inRange|index|init|intToDigit|interact|ioError|isAlpha|isAlphaNum|isAscii|isControl|isDenormalized|isDigit|isHexDigit|isIEEE|isInfinite|isLower|isNaN|isNegativeZero|isOctDigit|isPrint|isSpace|isUpper|iterate|last|lcm|length|lex|lexDigits|lexLitChar|lines|log|logBase|lookup|map|mapM|mapM_|max|maxBound|maximum|maybe|min|minBound|minimum|mod|negate|not|notElem|null|numerator|odd|or|ord|otherwise|pack|pi|pred|primExitWith|print|product|properFraction|putChar|putStr|putStrLn|quot|quotRem|range|rangeSize|read|readDec|readFile|readFloat|readHex|readIO|readInt|readList|readLitChar|readLn|readOct|readParen|readSigned|reads|readsPrec|realToFrac|recip|rem|repeat|replicate|return|reverse|round|scaleFloat|scanl|scanl1|scanr|scanr1|seq|sequence|sequence_|show|showChar|showInt|showList|showLitChar|showParen|showSigned|showString|shows|showsPrec|significand|signum|sin|sinh|snd|sort|span|splitAt|sqrt|subtract|succ|sum|tail|take|takeWhile|tan|tanh|threadToIOResult|toEnum|toInt|toInteger|toLower|toRational|toUpper|truncate|uncurry|undefined|unlines|until|unwords|unzip|unzip3|userError|words|writeFile|zip|zip3|zipWith|zipWith3)\\b/,\n    // decimal integers and floating point numbers | octal integers | hexadecimal integers\n    number: /\\b(?:\\d+(?:\\.\\d+)?(?:e[+-]?\\d+)?|0o[0-7]+|0x[0-9a-f]+)\\b/i,\n    operator: [\n      {\n        // infix operator\n        pattern: /`(?:[A-Z][\\w']*\\.)*[_a-z][\\w']*`/,\n        greedy: true\n      },\n      {\n        // function composition\n        pattern: /(\\s)\\.(?=\\s)/,\n        lookbehind: true\n      },\n      // Most of this is needed because of the meaning of a single '.'.\n      // If it stands alone freely, it is the function composition.\n      // It may also be a separator between a module name and an identifier => no\n      // operator. If it comes together with other special characters it is an\n      // operator too.\n      //\n      // This regex means: /[-!#$%*+=?&@|~.:<>^\\\\\\/]+/ without /\\./.\n      /[-!#$%*+=?&@|~:<>^\\\\\\/][-!#$%*+=?&@|~.:<>^\\\\\\/]*|\\.[-!#$%*+=?&@|~.:<>^\\\\\\/]+/\n    ],\n    // In Haskell, nearly everything is a variable, do not highlight these.\n    hvariable: {\n      pattern: /\\b(?:[A-Z][\\w']*\\.)*[_a-z][\\w']*/,\n      inside: {\n        punctuation: /\\./\n      }\n    },\n    constant: {\n      pattern: /\\b(?:[A-Z][\\w']*\\.)*[A-Z][\\w']*/,\n      inside: {\n        punctuation: /\\./\n      }\n    },\n    punctuation: /[{}[\\];(),.:]/\n  }\n  Prism.languages.hs = Prism.languages.haskell\n}\n"],"names":["haskell","Prism"],"mappings":"AAIAA,EAAQ,cAAc;AACtBA,EAAQ,UAAU,CAAC,IAAI;AAGR,SAASA,EAAQC,GAAO;AACrC,EAAAA,EAAM,UAAU,UAAU;AAAA,IACxB,SAAS;AAAA,MACP,SACE;AAAA,MACF,YAAY;AAAA,IAClB;AAAA,IACI,MAAM;AAAA,MACJ,SACE;AAAA,MACF,OAAO;AAAA,IACb;AAAA,IACI,QAAQ;AAAA,MACN,SAAS;AAAA,MACT,QAAQ;AAAA,IACd;AAAA,IACI,SACE;AAAA,IACF,oBAAoB;AAAA;AAAA;AAAA;AAAA,MAIlB,SACE;AAAA,MACF,YAAY;AAAA,MACZ,QAAQ;AAAA,QACN,SAAS;AAAA,QACT,aAAa;AAAA,MACrB;AAAA,IACA;AAAA;AAAA,IAEI,SACE;AAAA;AAAA,IAEF,QAAQ;AAAA,IACR,UAAU;AAAA,MACR;AAAA;AAAA,QAEE,SAAS;AAAA,QACT,QAAQ;AAAA,MAChB;AAAA,MACM;AAAA;AAAA,QAEE,SAAS;AAAA,QACT,YAAY;AAAA,MACpB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,MAQM;AAAA,IACN;AAAA;AAAA,IAEI,WAAW;AAAA,MACT,SAAS;AAAA,MACT,QAAQ;AAAA,QACN,aAAa;AAAA,MACrB;AAAA,IACA;AAAA,IACI,UAAU;AAAA,MACR,SAAS;AAAA,MACT,QAAQ;AAAA,QACN,aAAa;AAAA,MACrB;AAAA,IACA;AAAA,IACI,aAAa;AAAA,EACjB,GACEA,EAAM,UAAU,KAAKA,EAAM,UAAU;AACvC;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,2 @@
+"use strict";const a=require("./clike.cjs.js");t.displayName="haxe";t.aliases=[];function t(e){e.register(a),e.languages.haxe=e.languages.extend("clike",{string:{pattern:/"(?:[^"\\]|\\[\s\S])*"/,greedy:!0},"class-name":[{pattern:/(\b(?:abstract|class|enum|extends|implements|interface|new|typedef)\s+)[A-Z_]\w*/,lookbehind:!0},/\b[A-Z]\w*/],keyword:/\bthis\b|\b(?:abstract|as|break|case|cast|catch|class|continue|default|do|dynamic|else|enum|extends|extern|final|for|from|function|if|implements|import|in|inline|interface|macro|new|null|operator|overload|override|package|private|public|return|static|super|switch|throw|to|try|typedef|untyped|using|var|while)(?!\.)\b/,function:{pattern:/\b[a-z_]\w*(?=\s*(?:<[^<>]*>\s*)?\()/i,greedy:!0},operator:/\.{3}|\+\+|--|&&|\|\||->|=>|(?:<<?|>{1,3}|[-+*/%!=&|^])=?|[?:~]/}),e.languages.insertBefore("haxe","string",{"string-interpolation":{pattern:/'(?:[^'\\]|\\[\s\S])*'/,greedy:!0,inside:{interpolation:{pattern:/(^|[^\\])\$(?:\w+|\{[^{}]+\})/,lookbehind:!0,inside:{"interpolation-punctuation":{pattern:/^\$\{?|\}$/,alias:"punctuation"},expression:{pattern:/[\s\S]+/,inside:e.languages.haxe}}},string:/[\s\S]+/}}}),e.languages.insertBefore("haxe","class-name",{regex:{pattern:/~\/(?:[^\/\\\r\n]|\\.)+\/[a-z]*/,greedy:!0,inside:{"regex-flags":/\b[a-z]+$/,"regex-source":{pattern:/^(~\/)[\s\S]+(?=\/$)/,lookbehind:!0,alias:"language-regex",inside:e.languages.regex},"regex-delimiter":/^~\/|\/$/}}}),e.languages.insertBefore("haxe","keyword",{preprocessor:{pattern:/#(?:else|elseif|end|if)\b.*/,alias:"property"},metadata:{pattern:/@:?[\w.]+/,alias:"symbol"},reification:{pattern:/\$(?:\w+|(?=\{))/,alias:"important"}})}module.exports=t;
+//# sourceMappingURL=haxe.cjs.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"haxe.cjs.js","sources":["../../../../../node_modules/refractor/lang/haxe.js"],"sourcesContent":["// @ts-nocheck\n/**\n * @import {Syntax} from '../core.js'\n */\nimport refractorClike from './clike.js'\nhaxe.displayName = 'haxe'\nhaxe.aliases = []\n\n/** @type {Syntax} */\nexport default function haxe(Prism) {\n  Prism.register(refractorClike)\n  Prism.languages.haxe = Prism.languages.extend('clike', {\n    string: {\n      // Strings can be multi-line\n      pattern: /\"(?:[^\"\\\\]|\\\\[\\s\\S])*\"/,\n      greedy: true\n    },\n    'class-name': [\n      {\n        pattern:\n          /(\\b(?:abstract|class|enum|extends|implements|interface|new|typedef)\\s+)[A-Z_]\\w*/,\n        lookbehind: true\n      },\n      // based on naming convention\n      /\\b[A-Z]\\w*/\n    ],\n    // The final look-ahead prevents highlighting of keywords if expressions such as \"haxe.macro.Expr\"\n    keyword:\n      /\\bthis\\b|\\b(?:abstract|as|break|case|cast|catch|class|continue|default|do|dynamic|else|enum|extends|extern|final|for|from|function|if|implements|import|in|inline|interface|macro|new|null|operator|overload|override|package|private|public|return|static|super|switch|throw|to|try|typedef|untyped|using|var|while)(?!\\.)\\b/,\n    function: {\n      pattern: /\\b[a-z_]\\w*(?=\\s*(?:<[^<>]*>\\s*)?\\()/i,\n      greedy: true\n    },\n    operator: /\\.{3}|\\+\\+|--|&&|\\|\\||->|=>|(?:<<?|>{1,3}|[-+*/%!=&|^])=?|[?:~]/\n  })\n  Prism.languages.insertBefore('haxe', 'string', {\n    'string-interpolation': {\n      pattern: /'(?:[^'\\\\]|\\\\[\\s\\S])*'/,\n      greedy: true,\n      inside: {\n        interpolation: {\n          pattern: /(^|[^\\\\])\\$(?:\\w+|\\{[^{}]+\\})/,\n          lookbehind: true,\n          inside: {\n            'interpolation-punctuation': {\n              pattern: /^\\$\\{?|\\}$/,\n              alias: 'punctuation'\n            },\n            expression: {\n              pattern: /[\\s\\S]+/,\n              inside: Prism.languages.haxe\n            }\n          }\n        },\n        string: /[\\s\\S]+/\n      }\n    }\n  })\n  Prism.languages.insertBefore('haxe', 'class-name', {\n    regex: {\n      pattern: /~\\/(?:[^\\/\\\\\\r\\n]|\\\\.)+\\/[a-z]*/,\n      greedy: true,\n      inside: {\n        'regex-flags': /\\b[a-z]+$/,\n        'regex-source': {\n          pattern: /^(~\\/)[\\s\\S]+(?=\\/$)/,\n          lookbehind: true,\n          alias: 'language-regex',\n          inside: Prism.languages.regex\n        },\n        'regex-delimiter': /^~\\/|\\/$/\n      }\n    }\n  })\n  Prism.languages.insertBefore('haxe', 'keyword', {\n    preprocessor: {\n      pattern: /#(?:else|elseif|end|if)\\b.*/,\n      alias: 'property'\n    },\n    metadata: {\n      pattern: /@:?[\\w.]+/,\n      alias: 'symbol'\n    },\n    reification: {\n      pattern: /\\$(?:\\w+|(?=\\{))/,\n      alias: 'important'\n    }\n  })\n}\n"],"names":["haxe","Prism","refractorClike"],"mappings":"+CAKAA,EAAK,YAAc,OACnBA,EAAK,QAAU,CAAA,EAGA,SAASA,EAAKC,EAAO,CAClCA,EAAM,SAASC,CAAc,EAC7BD,EAAM,UAAU,KAAOA,EAAM,UAAU,OAAO,QAAS,CACrD,OAAQ,CAEN,QAAS,yBACT,OAAQ,EACd,EACI,aAAc,CACZ,CACE,QACE,mFACF,WAAY,EACpB,EAEM,YACN,EAEI,QACE,gUACF,SAAU,CACR,QAAS,wCACT,OAAQ,EACd,EACI,SAAU,iEACd,CAAG,EACDA,EAAM,UAAU,aAAa,OAAQ,SAAU,CAC7C,uBAAwB,CACtB,QAAS,yBACT,OAAQ,GACR,OAAQ,CACN,cAAe,CACb,QAAS,gCACT,WAAY,GACZ,OAAQ,CACN,4BAA6B,CAC3B,QAAS,aACT,MAAO,aACrB,EACY,WAAY,CACV,QAAS,UACT,OAAQA,EAAM,UAAU,IACtC,CACA,CACA,EACQ,OAAQ,SAChB,CACA,CACA,CAAG,EACDA,EAAM,UAAU,aAAa,OAAQ,aAAc,CACjD,MAAO,CACL,QAAS,kCACT,OAAQ,GACR,OAAQ,CACN,cAAe,YACf,eAAgB,CACd,QAAS,uBACT,WAAY,GACZ,MAAO,iBACP,OAAQA,EAAM,UAAU,KAClC,EACQ,kBAAmB,UAC3B,CACA,CACA,CAAG,EACDA,EAAM,UAAU,aAAa,OAAQ,UAAW,CAC9C,aAAc,CACZ,QAAS,8BACT,MAAO,UACb,EACI,SAAU,CACR,QAAS,YACT,MAAO,QACb,EACI,YAAa,CACX,QAAS,mBACT,MAAO,WACb,CACA,CAAG,CACH","x_google_ignoreList":[0]}

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

@@ -0,0 +1,81 @@
+import t from "./clike.es.js";
+a.displayName = "haxe";
+a.aliases = [];
+function a(e) {
+  e.register(t), e.languages.haxe = e.languages.extend("clike", {
+    string: {
+      // Strings can be multi-line
+      pattern: /"(?:[^"\\]|\\[\s\S])*"/,
+      greedy: !0
+    },
+    "class-name": [
+      {
+        pattern: /(\b(?:abstract|class|enum|extends|implements|interface|new|typedef)\s+)[A-Z_]\w*/,
+        lookbehind: !0
+      },
+      // based on naming convention
+      /\b[A-Z]\w*/
+    ],
+    // The final look-ahead prevents highlighting of keywords if expressions such as "haxe.macro.Expr"
+    keyword: /\bthis\b|\b(?:abstract|as|break|case|cast|catch|class|continue|default|do|dynamic|else|enum|extends|extern|final|for|from|function|if|implements|import|in|inline|interface|macro|new|null|operator|overload|override|package|private|public|return|static|super|switch|throw|to|try|typedef|untyped|using|var|while)(?!\.)\b/,
+    function: {
+      pattern: /\b[a-z_]\w*(?=\s*(?:<[^<>]*>\s*)?\()/i,
+      greedy: !0
+    },
+    operator: /\.{3}|\+\+|--|&&|\|\||->|=>|(?:<<?|>{1,3}|[-+*/%!=&|^])=?|[?:~]/
+  }), e.languages.insertBefore("haxe", "string", {
+    "string-interpolation": {
+      pattern: /'(?:[^'\\]|\\[\s\S])*'/,
+      greedy: !0,
+      inside: {
+        interpolation: {
+          pattern: /(^|[^\\])\$(?:\w+|\{[^{}]+\})/,
+          lookbehind: !0,
+          inside: {
+            "interpolation-punctuation": {
+              pattern: /^\$\{?|\}$/,
+              alias: "punctuation"
+            },
+            expression: {
+              pattern: /[\s\S]+/,
+              inside: e.languages.haxe
+            }
+          }
+        },
+        string: /[\s\S]+/
+      }
+    }
+  }), e.languages.insertBefore("haxe", "class-name", {
+    regex: {
+      pattern: /~\/(?:[^\/\\\r\n]|\\.)+\/[a-z]*/,
+      greedy: !0,
+      inside: {
+        "regex-flags": /\b[a-z]+$/,
+        "regex-source": {
+          pattern: /^(~\/)[\s\S]+(?=\/$)/,
+          lookbehind: !0,
+          alias: "language-regex",
+          inside: e.languages.regex
+        },
+        "regex-delimiter": /^~\/|\/$/
+      }
+    }
+  }), e.languages.insertBefore("haxe", "keyword", {
+    preprocessor: {
+      pattern: /#(?:else|elseif|end|if)\b.*/,
+      alias: "property"
+    },
+    metadata: {
+      pattern: /@:?[\w.]+/,
+      alias: "symbol"
+    },
+    reification: {
+      pattern: /\$(?:\w+|(?=\{))/,
+      alias: "important"
+    }
+  });
+}
+export {
+  a as default
+};
+//# sourceMappingURL=haxe.es.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"haxe.es.js","sources":["../../../../../node_modules/refractor/lang/haxe.js"],"sourcesContent":["// @ts-nocheck\n/**\n * @import {Syntax} from '../core.js'\n */\nimport refractorClike from './clike.js'\nhaxe.displayName = 'haxe'\nhaxe.aliases = []\n\n/** @type {Syntax} */\nexport default function haxe(Prism) {\n  Prism.register(refractorClike)\n  Prism.languages.haxe = Prism.languages.extend('clike', {\n    string: {\n      // Strings can be multi-line\n      pattern: /\"(?:[^\"\\\\]|\\\\[\\s\\S])*\"/,\n      greedy: true\n    },\n    'class-name': [\n      {\n        pattern:\n          /(\\b(?:abstract|class|enum|extends|implements|interface|new|typedef)\\s+)[A-Z_]\\w*/,\n        lookbehind: true\n      },\n      // based on naming convention\n      /\\b[A-Z]\\w*/\n    ],\n    // The final look-ahead prevents highlighting of keywords if expressions such as \"haxe.macro.Expr\"\n    keyword:\n      /\\bthis\\b|\\b(?:abstract|as|break|case|cast|catch|class|continue|default|do|dynamic|else|enum|extends|extern|final|for|from|function|if|implements|import|in|inline|interface|macro|new|null|operator|overload|override|package|private|public|return|static|super|switch|throw|to|try|typedef|untyped|using|var|while)(?!\\.)\\b/,\n    function: {\n      pattern: /\\b[a-z_]\\w*(?=\\s*(?:<[^<>]*>\\s*)?\\()/i,\n      greedy: true\n    },\n    operator: /\\.{3}|\\+\\+|--|&&|\\|\\||->|=>|(?:<<?|>{1,3}|[-+*/%!=&|^])=?|[?:~]/\n  })\n  Prism.languages.insertBefore('haxe', 'string', {\n    'string-interpolation': {\n      pattern: /'(?:[^'\\\\]|\\\\[\\s\\S])*'/,\n      greedy: true,\n      inside: {\n        interpolation: {\n          pattern: /(^|[^\\\\])\\$(?:\\w+|\\{[^{}]+\\})/,\n          lookbehind: true,\n          inside: {\n            'interpolation-punctuation': {\n              pattern: /^\\$\\{?|\\}$/,\n              alias: 'punctuation'\n            },\n            expression: {\n              pattern: /[\\s\\S]+/,\n              inside: Prism.languages.haxe\n            }\n          }\n        },\n        string: /[\\s\\S]+/\n      }\n    }\n  })\n  Prism.languages.insertBefore('haxe', 'class-name', {\n    regex: {\n      pattern: /~\\/(?:[^\\/\\\\\\r\\n]|\\\\.)+\\/[a-z]*/,\n      greedy: true,\n      inside: {\n        'regex-flags': /\\b[a-z]+$/,\n        'regex-source': {\n          pattern: /^(~\\/)[\\s\\S]+(?=\\/$)/,\n          lookbehind: true,\n          alias: 'language-regex',\n          inside: Prism.languages.regex\n        },\n        'regex-delimiter': /^~\\/|\\/$/\n      }\n    }\n  })\n  Prism.languages.insertBefore('haxe', 'keyword', {\n    preprocessor: {\n      pattern: /#(?:else|elseif|end|if)\\b.*/,\n      alias: 'property'\n    },\n    metadata: {\n      pattern: /@:?[\\w.]+/,\n      alias: 'symbol'\n    },\n    reification: {\n      pattern: /\\$(?:\\w+|(?=\\{))/,\n      alias: 'important'\n    }\n  })\n}\n"],"names":["haxe","Prism","refractorClike"],"mappings":";AAKAA,EAAK,cAAc;AACnBA,EAAK,UAAU,CAAA;AAGA,SAASA,EAAKC,GAAO;AAClC,EAAAA,EAAM,SAASC,CAAc,GAC7BD,EAAM,UAAU,OAAOA,EAAM,UAAU,OAAO,SAAS;AAAA,IACrD,QAAQ;AAAA;AAAA,MAEN,SAAS;AAAA,MACT,QAAQ;AAAA,IACd;AAAA,IACI,cAAc;AAAA,MACZ;AAAA,QACE,SACE;AAAA,QACF,YAAY;AAAA,MACpB;AAAA;AAAA,MAEM;AAAA,IACN;AAAA;AAAA,IAEI,SACE;AAAA,IACF,UAAU;AAAA,MACR,SAAS;AAAA,MACT,QAAQ;AAAA,IACd;AAAA,IACI,UAAU;AAAA,EACd,CAAG,GACDA,EAAM,UAAU,aAAa,QAAQ,UAAU;AAAA,IAC7C,wBAAwB;AAAA,MACtB,SAAS;AAAA,MACT,QAAQ;AAAA,MACR,QAAQ;AAAA,QACN,eAAe;AAAA,UACb,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,QAAQ;AAAA,YACN,6BAA6B;AAAA,cAC3B,SAAS;AAAA,cACT,OAAO;AAAA,YACrB;AAAA,YACY,YAAY;AAAA,cACV,SAAS;AAAA,cACT,QAAQA,EAAM,UAAU;AAAA,YACtC;AAAA,UACA;AAAA,QACA;AAAA,QACQ,QAAQ;AAAA,MAChB;AAAA,IACA;AAAA,EACA,CAAG,GACDA,EAAM,UAAU,aAAa,QAAQ,cAAc;AAAA,IACjD,OAAO;AAAA,MACL,SAAS;AAAA,MACT,QAAQ;AAAA,MACR,QAAQ;AAAA,QACN,eAAe;AAAA,QACf,gBAAgB;AAAA,UACd,SAAS;AAAA,UACT,YAAY;AAAA,UACZ,OAAO;AAAA,UACP,QAAQA,EAAM,UAAU;AAAA,QAClC;AAAA,QACQ,mBAAmB;AAAA,MAC3B;AAAA,IACA;AAAA,EACA,CAAG,GACDA,EAAM,UAAU,aAAa,QAAQ,WAAW;AAAA,IAC9C,cAAc;AAAA,MACZ,SAAS;AAAA,MACT,OAAO;AAAA,IACb;AAAA,IACI,UAAU;AAAA,MACR,SAAS;AAAA,MACT,OAAO;AAAA,IACb;AAAA,IACI,aAAa;AAAA,MACX,SAAS;AAAA,MACT,OAAO;AAAA,IACb;AAAA,EACA,CAAG;AACH;","x_google_ignoreList":[0]}

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

@@ -0,0 +1,2 @@
+"use strict";e.displayName="hcl";e.aliases=[];function e(t){t.languages.hcl={comment:/(?:\/\/|#).*|\/\*[\s\S]*?(?:\*\/|$)/,heredoc:{pattern:/<<-?(\w+\b)[\s\S]*?^[ \t]*\1/m,greedy:!0,alias:"string"},keyword:[{pattern:/(?:data|resource)\s+(?:"(?:\\[\s\S]|[^\\"])*")(?=\s+"[\w-]+"\s+\{)/i,inside:{type:{pattern:/(resource|data|\s+)(?:"(?:\\[\s\S]|[^\\"])*")/i,lookbehind:!0,alias:"variable"}}},{pattern:/(?:backend|module|output|provider|provisioner|variable)\s+(?:[\w-]+|"(?:\\[\s\S]|[^\\"])*")\s+(?=\{)/i,inside:{type:{pattern:/(backend|module|output|provider|provisioner|variable)\s+(?:[\w-]+|"(?:\\[\s\S]|[^\\"])*")\s+/i,lookbehind:!0,alias:"variable"}}},/[\w-]+(?=\s+\{)/],property:[/[-\w\.]+(?=\s*=(?!=))/,/"(?:\\[\s\S]|[^\\"])+"(?=\s*[:=])/],string:{pattern:/"(?:[^\\$"]|\\[\s\S]|\$(?:(?=")|\$+(?!\$)|[^"${])|\$\{(?:[^{}"]|"(?:[^\\"]|\\[\s\S])*")*\})*"/,greedy:!0,inside:{interpolation:{pattern:/(^|[^$])\$\{(?:[^{}"]|"(?:[^\\"]|\\[\s\S])*")*\}/,lookbehind:!0,inside:{type:{pattern:/(\b(?:count|data|local|module|path|self|terraform|var)\b\.)[\w\*]+/i,lookbehind:!0,alias:"variable"},keyword:/\b(?:count|data|local|module|path|self|terraform|var)\b/i,function:/\w+(?=\()/,string:{pattern:/"(?:\\[\s\S]|[^\\"])*"/,greedy:!0},number:/\b0x[\da-f]+\b|\b\d+(?:\.\d*)?(?:e[+-]?\d+)?/i,punctuation:/[!\$#%&'()*+,.\/;<=>@\[\\\]^`{|}~?:]/}}}},number:/\b0x[\da-f]+\b|\b\d+(?:\.\d*)?(?:e[+-]?\d+)?/i,boolean:/\b(?:false|true)\b/i,punctuation:/[=\[\]{}]/}}module.exports=e;
+//# sourceMappingURL=hcl.cjs.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hcl.cjs.js","sources":["../../../../../node_modules/refractor/lang/hcl.js"],"sourcesContent":["// @ts-nocheck\n/**\n * @import {Syntax} from '../core.js'\n */\nhcl.displayName = 'hcl'\nhcl.aliases = []\n\n/** @type {Syntax} */\nexport default function hcl(Prism) {\n  Prism.languages.hcl = {\n    comment: /(?:\\/\\/|#).*|\\/\\*[\\s\\S]*?(?:\\*\\/|$)/,\n    heredoc: {\n      pattern: /<<-?(\\w+\\b)[\\s\\S]*?^[ \\t]*\\1/m,\n      greedy: true,\n      alias: 'string'\n    },\n    keyword: [\n      {\n        pattern:\n          /(?:data|resource)\\s+(?:\"(?:\\\\[\\s\\S]|[^\\\\\"])*\")(?=\\s+\"[\\w-]+\"\\s+\\{)/i,\n        inside: {\n          type: {\n            pattern: /(resource|data|\\s+)(?:\"(?:\\\\[\\s\\S]|[^\\\\\"])*\")/i,\n            lookbehind: true,\n            alias: 'variable'\n          }\n        }\n      },\n      {\n        pattern:\n          /(?:backend|module|output|provider|provisioner|variable)\\s+(?:[\\w-]+|\"(?:\\\\[\\s\\S]|[^\\\\\"])*\")\\s+(?=\\{)/i,\n        inside: {\n          type: {\n            pattern:\n              /(backend|module|output|provider|provisioner|variable)\\s+(?:[\\w-]+|\"(?:\\\\[\\s\\S]|[^\\\\\"])*\")\\s+/i,\n            lookbehind: true,\n            alias: 'variable'\n          }\n        }\n      },\n      /[\\w-]+(?=\\s+\\{)/\n    ],\n    property: [/[-\\w\\.]+(?=\\s*=(?!=))/, /\"(?:\\\\[\\s\\S]|[^\\\\\"])+\"(?=\\s*[:=])/],\n    string: {\n      pattern:\n        /\"(?:[^\\\\$\"]|\\\\[\\s\\S]|\\$(?:(?=\")|\\$+(?!\\$)|[^\"${])|\\$\\{(?:[^{}\"]|\"(?:[^\\\\\"]|\\\\[\\s\\S])*\")*\\})*\"/,\n      greedy: true,\n      inside: {\n        interpolation: {\n          pattern: /(^|[^$])\\$\\{(?:[^{}\"]|\"(?:[^\\\\\"]|\\\\[\\s\\S])*\")*\\}/,\n          lookbehind: true,\n          inside: {\n            type: {\n              pattern:\n                /(\\b(?:count|data|local|module|path|self|terraform|var)\\b\\.)[\\w\\*]+/i,\n              lookbehind: true,\n              alias: 'variable'\n            },\n            keyword: /\\b(?:count|data|local|module|path|self|terraform|var)\\b/i,\n            function: /\\w+(?=\\()/,\n            string: {\n              pattern: /\"(?:\\\\[\\s\\S]|[^\\\\\"])*\"/,\n              greedy: true\n            },\n            number: /\\b0x[\\da-f]+\\b|\\b\\d+(?:\\.\\d*)?(?:e[+-]?\\d+)?/i,\n            punctuation: /[!\\$#%&'()*+,.\\/;<=>@\\[\\\\\\]^`{|}~?:]/\n          }\n        }\n      }\n    },\n    number: /\\b0x[\\da-f]+\\b|\\b\\d+(?:\\.\\d*)?(?:e[+-]?\\d+)?/i,\n    boolean: /\\b(?:false|true)\\b/i,\n    punctuation: /[=\\[\\]{}]/\n  }\n}\n"],"names":["hcl","Prism"],"mappings":"aAIAA,EAAI,YAAc,MAClBA,EAAI,QAAU,CAAA,EAGC,SAASA,EAAIC,EAAO,CACjCA,EAAM,UAAU,IAAM,CACpB,QAAS,sCACT,QAAS,CACP,QAAS,gCACT,OAAQ,GACR,MAAO,QACb,EACI,QAAS,CACP,CACE,QACE,sEACF,OAAQ,CACN,KAAM,CACJ,QAAS,iDACT,WAAY,GACZ,MAAO,UACnB,CACA,CACA,EACM,CACE,QACE,wGACF,OAAQ,CACN,KAAM,CACJ,QACE,gGACF,WAAY,GACZ,MAAO,UACnB,CACA,CACA,EACM,iBACN,EACI,SAAU,CAAC,wBAAyB,mCAAmC,EACvE,OAAQ,CACN,QACE,gGACF,OAAQ,GACR,OAAQ,CACN,cAAe,CACb,QAAS,mDACT,WAAY,GACZ,OAAQ,CACN,KAAM,CACJ,QACE,sEACF,WAAY,GACZ,MAAO,UACrB,EACY,QAAS,2DACT,SAAU,YACV,OAAQ,CACN,QAAS,yBACT,OAAQ,EACtB,EACY,OAAQ,gDACR,YAAa,sCACzB,CACA,CACA,CACA,EACI,OAAQ,gDACR,QAAS,sBACT,YAAa,WACjB,CACA","x_google_ignoreList":[0]}