修改editor样式
// ==UserScript==
// @name codeTheme
// @namespace Baozoulolw
// @version 0.1.7
// @author Baozoulolw
// @description 修改editor样式
// @license MIT
// @icon https://baozoulolw.oss-cn-chengdu.aliyuncs.com/codeSet/theme.svg
// @match *://*/*
// @grant GM_addStyle
// @grant unsafeWindow
// ==/UserScript==
(n=>{if(typeof GM_addStyle=="function"){GM_addStyle(n);return}const e=document.createElement("style");e.textContent=n,document.head.append(e)})(` #self_dialog{
font-size: 18px;
margin-right: 10px;
}
.head-right{
display: flex;
align-items: center;
}
.custom-tree-node[data-v-545643b4] {
flex: 1;
display: flex;
align-items: center;
justify-content: space-between;
font-size: 14px;
padding-right: 8px;
}
.el-input[data-v-93c5e0b4] .el-input__inner {
text-align: left;
} `);
(async function () {
'use strict';
var __defProp = Object.defineProperty;
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __publicField = (obj, key, value) => {
__defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
return value;
};
var _a, _b, _c, _d, _e2, _f, _g, _h, _i, _j, _k, _l, _m, _n2, _o, _p, _q, _r;
function waitForElementByClass(className, callback) {
const observer = new MutationObserver((mutations) => {
mutations.forEach((mutation) => {
Array.from(mutation.addedNodes).forEach((addedNode) => {
let classNames = addedNode.className;
if (!classNames || typeof classNames !== "string")
return;
if (classNames.includes(className)) {
callback(addedNode);
observer.disconnect();
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
}
var _unsafeWindow = /* @__PURE__ */ (() => typeof unsafeWindow != "undefined" ? unsafeWindow : void 0)();
const monacoEditorInnerLanguages = [
"css",
"vue",
"html",
"javascript",
"less",
"pug",
"scss",
"typescript",
"coffee"
];
const scopeNameMap = {
html: "text.html.basic",
vue: "text.html.basic",
pug: "text.pug",
css: "source.css",
less: "source.css.less",
scss: "source.css.scss",
sass: "source.sassdoc",
typescript: "source.ts",
javascript: "source.js",
javascriptreact: "source.js.jsx",
coffeescript: "source.coffee",
json: "source.json"
};
const tmGrammarJsonMap = {
"text.html.basic": "html.tmLanguage.json",
"text.pug": "pug.tmLanguage.json",
"source.css": "css.tmLanguage.json",
"source.css.less": "less.tmLanguage.json",
"source.less": "less.tmLanguage.json",
"source.css.scss": "scss.tmLanguage.json",
"source.sass": "scss.tmLanguage.json",
"source.sassdoc": "sassdoc.tmLanguage.json",
"source.stylus": "css.tmLanguage.json",
"source.ts": "TypeScript.tmLanguage.json",
"source.js": "JavaScript.tmLanguage.json",
"source.js.jsx": "JavaScriptReact.tmLanguage.json",
"source.coffee": "coffeescript.tmLanguage.json",
"source.js.regexp": {
format: "plist",
path: "Regular Expressions (JavaScript).tmLanguage"
},
"source.json": "JSON.tmLanguage.json"
};
const completionItemKinds = [
{ name: "Text", value: 1, description: "\u666E\u901A\u6587\u672C" },
{ name: "Method", value: 2, description: "\u65B9\u6CD5\u6216\u51FD\u6570" },
{ name: "Function", value: 3, description: "\u51FD\u6570\uFF08\u975E\u65B9\u6CD5\uFF09" },
{ name: "Constructor", value: 4, description: "\u6784\u9020\u51FD\u6570" },
{ name: "Field", value: 5, description: "\u7C7B\u7684\u5B57\u6BB5\u6216\u5C5E\u6027" },
{ name: "Variable", value: 6, description: "\u53D8\u91CF" },
{ name: "Class", value: 7, description: "\u7C7B" },
{ name: "Interface", value: 8, description: "\u63A5\u53E3" },
{ name: "Module", value: 9, description: "\u6A21\u5757" },
{ name: "Property", value: 10, description: "\u5BF9\u8C61\u7684\u5C5E\u6027" },
{ name: "Unit", value: 11, description: "\u5355\u4F4D\uFF0C\u5982\u50CF\u7D20\u3001\u79D2\u7B49" },
{ name: "Value", value: 12, description: "\u5E38\u91CF\u6216\u679A\u4E3E\u6210\u5458" },
{ name: "Enum", value: 13, description: "\u679A\u4E3E\u7C7B\u578B" },
{ name: "Keyword", value: 14, description: "\u5173\u952E\u5B57\uFF0C\u5982\u8BED\u8A00\u4FDD\u7559\u5B57" },
{ name: "Snippet", value: 15, description: "\u4EE3\u7801\u7247\u6BB5" },
{ name: "Color", value: 16, description: "\u989C\u8272" },
{ name: "File", value: 17, description: "\u6587\u4EF6" },
{ name: "Reference", value: 18, description: "\u5F15\u7528\uFF0C\u901A\u5E38\u6307\u5411\u53E6\u4E00\u4E2A\u8865\u5168\u9879" },
{ name: "Folder", value: 19, description: "\u6587\u4EF6\u5939" },
{ name: "EnumMember", value: 20, description: "\u679A\u4E3E\u7684\u6210\u5458" },
{ name: "Constant", value: 21, description: "\u5E38\u91CF" },
{ name: "Struct", value: 22, description: "\u7ED3\u6784\u4F53" },
{ name: "Event", value: 23, description: "\u4E8B\u4EF6" },
{ name: "Operator", value: 24, description: "\u8FD0\u7B97\u7B26" },
{ name: "TypeParameter", value: 25, description: "\u6CDB\u578B\u6216\u7C7B\u578B\u53C2\u6570" }
];
const insertTextRules = [
{ name: "None", value: 1, description: "\u6CA1\u6709\u7279\u6B8A\u89C4\u5219\uFF0C\u63D2\u5165\u6587\u672C\u5C06\u66FF\u6362\u6574\u4E2A\u8303\u56F4" },
{ name: "InsertAsSnippet", value: 2, description: "\u63D2\u5165\u6587\u672C\u5E94\u88AB\u89C6\u4E3A\u4EE3\u7801\u7247\u6BB5\uFF0C\u5141\u8BB8\u4F7F\u7528\u5360\u4F4D\u7B26" },
{ name: "KeepWhitespace", value: 4, description: "\u4FDD\u7559\u524D\u5BFC\u548C\u5C3E\u968F\u7A7A\u767D\u5B57\u7B26\uFF0C\u5373\u4F7F\u5B83\u4EEC\u5728\u63D2\u5165\u6587\u672C\u4E4B\u5916" },
{ name: "AdjustIndentation", value: 8, description: "\u8C03\u6574\u7F29\u8FDB\uFF0C\u4EE5\u5339\u914D\u63D2\u5165\u4F4D\u7F6E\u7684\u7F29\u8FDB\u7EA7\u522B" },
{ name: "ReplaceAllEnclosing", value: 16, description: "\u66FF\u6362\u6574\u4E2A\u8303\u56F4\uFF0C\u5305\u62EC\u5305\u56F4\u7684\u62EC\u53F7\u3001\u5F15\u53F7\u7B49" },
{ name: "InsertAfter", value: 32, description: "\u5728\u8303\u56F4\u4E4B\u540E\u63D2\u5165\u6587\u672C\uFF0C\u4FDD\u7559\u8303\u56F4\u5185\u7684\u6587\u672C" },
{ name: "InsertBefore", value: 64, description: "\u5728\u8303\u56F4\u4E4B\u524D\u63D2\u5165\u6587\u672C\uFF0C\u4FDD\u7559\u8303\u56F4\u5185\u7684\u6587\u672C" },
{ name: "InsertAfterComment", value: 128, description: "\u5728\u6CE8\u91CA\u7ED3\u675F\u6807\u8BB0\u540E\u63D2\u5165\u6587\u672C" }
];
const tips = [
{
id: "1",
label: "log",
insertText: "console.log(${1:})",
kind: 2,
documentation: "Logs a message to the console.",
detail: "Shortcut for console.log()",
insertTextRules: [2],
sortText: "001",
supportLanguage: "javascript"
},
{
id: "3",
label: "watchEffectOnce",
insertText: "const ${1:} = await zzUtil.watchEffectOnce(() => this.\\$page('${2:}'))",
kind: 1,
documentation: "watchEffectOnce",
detail: "watchEffectOnce",
insertTextRules: [2],
sortText: "001",
supportLanguage: "javascript"
},
{
id: "2",
label: "<xtypeRender",
insertText: 'xtypeRender v-bind="\\$attrs" v-model="value"></xtypeRender>',
kind: 1,
documentation: "xtypeRender",
detail: "xtypeRender",
insertTextRules: [2],
sortText: "001",
supportLanguage: "html"
}
];
var render$2 = function() {
var _vm = this;
var _h2 = _vm.$createElement;
var _c2 = _vm._self._c || _h2;
return _c2("div", [_c2("el-tree", {
attrs: {
"data": _vm.languages,
"props": _vm.defaultProps
},
scopedSlots: _vm._u([{
key: "default",
fn: function(_ref) {
var node = _ref.node;
_ref.data;
return _c2("span", {
staticClass: "custom-tree-node"
}, [_c2("span", [_vm._v(_vm._s(node.label))])]);
}
}])
}), _c2("el-dialog", {
attrs: {
"append-to-body": "",
"title": "\u65B0\u589E\u4EE3\u7801\u7247\u6BB5",
"visible": _vm.formShow,
"before-close": _vm.dialogClose
}
}, [_c2("el-form", {
ref: "form",
attrs: {
"rules": _vm.rules,
"label-width": "120px",
"model": _vm.editTips
}
}, [_c2("el-form-item", {
attrs: {
"label": "label"
}
}, [_c2("el-input", {
attrs: {
"autosize": {
minRows: 3
},
"type": "textarea"
},
model: {
value: _vm.editTips.label,
callback: function($$v) {
_vm.$set(_vm.editTips, "label", $$v);
},
expression: "editTips.label"
}
})], 1), _c2("el-form-item", {
attrs: {
"label": "insertText"
}
}, [_c2("el-input", {
attrs: {
"autosize": {
minRows: 4
},
"type": "textarea"
},
model: {
value: _vm.editTips.insertText,
callback: function($$v) {
_vm.$set(_vm.editTips, "insertText", $$v);
},
expression: "editTips.insertText"
}
})], 1), _c2("el-form-item", {
attrs: {
"label": "kind"
}
}, [_c2("el-select", {
staticClass: "tw-w-full",
model: {
value: _vm.editTips.kind,
callback: function($$v) {
_vm.$set(_vm.editTips, "kind", $$v);
},
expression: "editTips.kind"
}
}, _vm._l(_vm.completionItemKinds, function(item) {
return _c2("el-option", {
key: item.value,
attrs: {
"label": item.name,
"value": item.value
}
});
}), 1)], 1), _c2("el-form-item", {
attrs: {
"label": "documentation"
}
}, [_c2("el-input", {
model: {
value: _vm.editTips.documentation,
callback: function($$v) {
_vm.$set(_vm.editTips, "documentation", $$v);
},
expression: "editTips.documentation"
}
})], 1), _c2("el-form-item", {
attrs: {
"label": "detail"
}
}, [_c2("el-input", {
model: {
value: _vm.editTips.detail,
callback: function($$v) {
_vm.$set(_vm.editTips, "detail", $$v);
},
expression: "editTips.detail"
}
})], 1), _c2("el-form-item", {
attrs: {
"label": "insertTextRules"
}
}, [_c2("el-select", {
staticClass: "tw-w-full",
attrs: {
"multiple": ""
},
model: {
value: _vm.editTips.insertTextRules,
callback: function($$v) {
_vm.$set(_vm.editTips, "insertTextRules", $$v);
},
expression: "editTips.insertTextRules"
}
}, _vm._l(_vm.insertTextRules, function(item) {
return _c2("el-option", {
key: item.value,
attrs: {
"label": item.name,
"value": item.value
}
});
}), 1), _c2("div", _vm._l(_vm.showTags, function(item) {
return _c2("el-tag", {
key: item.value
}, [_vm._v(_vm._s(item.name))]);
}), 1)], 1), _c2("el-form-item", {
attrs: {
"label": "sortText"
}
}, [_c2("el-input", {
model: {
value: _vm.editTips.sortText,
callback: function($$v) {
_vm.$set(_vm.editTips, "sortText", $$v);
},
expression: "editTips.sortText"
}
})], 1)], 1), _c2("span", {
staticClass: "dialog-footer",
attrs: {
"slot": "footer"
},
slot: "footer"
}, [_c2("el-button", {
on: {
"click": _vm.cancel
}
}, [_vm._v("\u53D6 \u6D88")]), _c2("el-button", {
attrs: {
"type": "primary"
},
on: {
"click": _vm.confirm
}
}, [_vm._v("\u786E \u5B9A")])], 1)], 1)], 1);
};
var staticRenderFns$1 = [];
function normalizeComponent(scriptExports, render2, staticRenderFns2, functionalTemplate, injectStyles, scopeId, moduleIdentifier, shadowMode) {
var options = typeof scriptExports === "function" ? scriptExports.options : scriptExports;
if (render2) {
options.render = render2;
options.staticRenderFns = staticRenderFns2;
options._compiled = true;
}
if (functionalTemplate) {
options.functional = true;
}
if (scopeId) {
options._scopeId = "data-v-" + scopeId;
}
var hook;
if (moduleIdentifier) {
hook = function(context) {
context = context || this.$vnode && this.$vnode.ssrContext || this.parent && this.parent.$vnode && this.parent.$vnode.ssrContext;
if (!context && typeof __VUE_SSR_CONTEXT__ !== "undefined") {
context = __VUE_SSR_CONTEXT__;
}
if (injectStyles) {
injectStyles.call(this, context);
}
if (context && context._registeredComponents) {
context._registeredComponents.add(moduleIdentifier);
}
};
options._ssrRegister = hook;
} else if (injectStyles) {
hook = shadowMode ? function() {
injectStyles.call(
this,
(options.functional ? this.parent : this).$root.$options.shadowRoot
);
} : injectStyles;
}
if (hook) {
if (options.functional) {
options._injectStyles = hook;
var originalRender = options.render;
options.render = function renderWithStyleInjection(h, context) {
hook.call(context);
return originalRender(h, context);
};
} else {
var existing = options.beforeCreate;
options.beforeCreate = existing ? [].concat(existing, hook) : [hook];
}
}
return {
exports: scriptExports,
options
};
}
const _$3 = _unsafeWindow._;
const __vue2_script$1 = {
name: "",
data: () => ({
languages: [
{
name: "javascript",
children: []
},
{
name: "css",
children: []
},
{
name: "html",
children: []
},
{
name: "json",
children: []
}
],
activeNames: "",
colSpans: {},
formShow: false,
defaultProps: {
children: "children",
label: "name"
},
editTips: {},
completionItemKinds: [],
insertTextRules: [],
rules: {
label: [{ required: true, message: "\u8BF7\u8F93\u5165label", trigger: "blur" }],
insertText: [
{ required: true, message: "\u8BF7\u8F93\u5165insertText", trigger: "blur" }
],
kind: [{ required: true, message: "\u8BF7\u9009\u62E9kind", trigger: "change" }],
detail: [{ required: true, message: "\u8BF7\u8F93\u5165detail", trigger: "blur" }],
documentation: [
{ required: true, message: "\u8BF7\u8F93\u5165documentation", trigger: "blur" }
]
}
}),
computed: {
colKeys() {
return Object.keys(this.colSpans);
},
showTags() {
const { insertTextRules: rules = [] } = this.editTips;
return insertTextRules.filter((i) => rules.includes(i.value));
}
},
methods: {
handleChange() {
},
editSnippet() {
},
getLabel(node) {
console.log(node);
},
append(node, data) {
this.formShow = true;
},
edit(node, data) {
console.log(data);
this.editTips = data.data;
this.formShow = true;
},
dialogClose() {
this.editTips = {};
this.formShow = false;
},
cancel() {
this.dialogClose();
},
async confirm() {
const check = await this.$refs.form.validate();
if (!check)
return;
},
initData() {
let codeSnippets = _unsafeWindow.editorTips;
let obj = _$3.groupBy(codeSnippets, "supportLanguage");
this.languages.forEach((language) => {
var _a2;
let arr = (_a2 = obj[language.name]) != null ? _a2 : [];
language.children = arr.map((i) => ({
name: `${i.label}(${i.detail})`,
data: i
}));
});
}
},
async mounted() {
this.completionItemKinds = completionItemKinds;
this.insertTextRules = insertTextRules;
this.initData();
}
};
const __cssModules$1 = {};
var __component__$1 = /* @__PURE__ */ normalizeComponent(
__vue2_script$1,
render$2,
staticRenderFns$1,
false,
__vue2_injectStyles$1,
"545643b4",
null,
null
);
function __vue2_injectStyles$1(context) {
for (let o in __cssModules$1) {
this[o] = __cssModules$1[o];
}
}
var Tips = /* @__PURE__ */ function() {
return __component__$1.exports;
}();
const codeThemeList = [
{ name: "vs", value: "vs", out: true, group: "\u9ED8\u8BA4" },
{ name: "vs-dark", value: "vs-dark", out: true, group: "\u9ED8\u8BA4" },
{ name: "hc-black", value: "hc-black", out: true, group: "\u9ED8\u8BA4" },
{
"group": "Winter is Coming",
"name": "Winter Is Coming1",
"themeName": "WinterIsComing1",
"path": "WinterIsComing-dark-blue-color-no-italics-theme.json",
"loaded": false,
"cache": ""
},
{
"group": "Winter is Coming",
"name": "Winter is Coming5",
"themeName": "WinterisComing5",
"path": "WinterIsComing-light-color-no-italics-theme.json",
"loaded": false,
"cache": ""
},
{
"group": "Winter is Coming",
"name": "Winter is Coming6",
"themeName": "WinterisComing6",
"path": "WinterIsComing-light-color-theme.json",
"loaded": false,
"cache": ""
},
{
"group": "Winter is Coming",
"name": "Winter Is Coming3",
"themeName": "WinterIsComing3",
"path": "WinterIsComing-dark-color-no-italics-theme.json",
"loaded": false,
"cache": ""
},
{
"group": "Winter is Coming",
"name": "Winter Is Coming4",
"themeName": "WinterIsComing4",
"path": "WinterIsComing-dark-color-theme.json",
"loaded": false,
"cache": ""
},
{
"group": "Winter is Coming",
"name": "Winter Is Coming2",
"themeName": "WinterIsComing2",
"path": "WinterIsComing-dark-blue-color-theme.json",
"loaded": false,
"cache": ""
},
{
"group": "Catppuccin",
"name": "Catppuccin Macchiato",
"themeName": "CatppuccinMacchiato",
"path": "macchiato.json",
"loaded": false,
"cache": ""
},
{
"group": "Catppuccin",
"name": "Catppuccin Mocha",
"themeName": "CatppuccinMocha",
"path": "mocha.json",
"loaded": false,
"cache": ""
},
{
"group": "Catppuccin",
"name": "Catppuccin Frapp\xE9",
"themeName": "CatppuccinFrapp\xE9",
"path": "frappe.json",
"loaded": false,
"cache": ""
},
{
"group": "Catppuccin",
"name": "Catppuccin Latte",
"themeName": "CatppuccinLatte",
"path": "latte.json",
"loaded": false,
"cache": ""
},
{
"group": "Atom One Dark Theme",
"name": "OneDark",
"themeName": "OneDark",
"path": "OneDark.json",
"loaded": false,
"cache": ""
},
{
"group": "One Dark Pro",
"name": "One Dark Pro1",
"themeName": "OneDarkPro1",
"path": "OneDark-Pro-darker.json",
"loaded": false,
"cache": ""
},
{
"group": "One Dark Pro",
"name": "One Dark Pro2",
"themeName": "OneDarkPro2",
"path": "OneDark-Pro-flat.json",
"loaded": false,
"cache": ""
},
{
"group": "One Dark Pro",
"name": "One Dark Pro3",
"themeName": "OneDarkPro3",
"path": "OneDark-Pro-mix.json",
"loaded": false,
"cache": ""
},
{
"group": "One Dark Pro",
"name": "One Dark Pro4",
"themeName": "OneDarkPro4",
"path": "OneDark-Pro.json",
"loaded": false,
"cache": ""
},
{
"group": "GitHub's",
"name": "GitHub Dark High Contrast",
"themeName": "GitHubDarkHighContrast",
"path": "dark-high-contrast.json",
"loaded": false,
"cache": ""
},
{
"group": "GitHub's",
"name": "GitHub Dark Colorblind",
"themeName": "GitHubDarkColorblind",
"path": "dark-colorblind.json",
"loaded": false,
"cache": ""
},
{
"group": "GitHub's",
"name": "GitHub Light Colorblind",
"themeName": "GitHubLightColorblind",
"path": "light-colorblind.json",
"loaded": false,
"cache": ""
},
{
"group": "GitHub's",
"name": "GitHub Light",
"themeName": "GitHubLight",
"path": "light.json",
"loaded": false,
"cache": ""
},
{
"group": "GitHub's",
"name": "GitHub Light Default",
"themeName": "GitHubLightDefault",
"path": "light-default.json",
"loaded": false,
"cache": ""
},
{
"group": "GitHub's",
"name": "GitHub Light High Contrast",
"themeName": "GitHubLightHighContrast",
"path": "light-high-contrast.json",
"loaded": false,
"cache": ""
},
{
"group": "GitHub's",
"name": "GitHub Dark",
"themeName": "GitHubDark",
"path": "dark.json",
"loaded": false,
"cache": ""
},
{
"group": "GitHub's",
"name": "GitHub Dark Default",
"themeName": "GitHubDarkDefault",
"path": "dark-default.json",
"loaded": false,
"cache": ""
},
{
"group": "GitHub's",
"name": "GitHub Dark Dimmed",
"themeName": "GitHubDarkDimmed",
"path": "dark-dimmed.json",
"loaded": false,
"cache": ""
},
{
"group": "Monokai Pro",
"name": "Monokai Classic",
"themeName": "MonokaiClassic",
"path": "Monokai Classic.json",
"loaded": false,
"cache": ""
},
{
"group": "Monokai Pro",
"name": "Monokai Pro (Filter Ristretto)",
"themeName": "MonokaiProFilterRistretto",
"path": "Monokai Pro (Filter Ristretto).json",
"loaded": false,
"cache": ""
},
{
"group": "Monokai Pro",
"name": "Monokai Pro",
"themeName": "MonokaiPro",
"path": "Monokai Pro.json",
"loaded": false,
"cache": ""
},
{
"group": "Monokai Pro",
"name": "Monokai Pro (Filter Machine)",
"themeName": "MonokaiProFilterMachine",
"path": "Monokai Pro (Filter Machine).json",
"loaded": false,
"cache": ""
},
{
"group": "Monokai Pro",
"name": "Monokai Pro (Filter Octagon)",
"themeName": "MonokaiProFilterOctagon",
"path": "Monokai Pro (Filter Octagon).json",
"loaded": false,
"cache": ""
},
{
"group": "Monokai Pro",
"name": "Monokai Pro (Filter Spectrum)",
"themeName": "MonokaiProFilterSpectrum",
"path": "Monokai Pro (Filter Spectrum).json",
"loaded": false,
"cache": ""
},
{
"group": "Bluloco Dark",
"name": "Bluloco Dark Italic",
"themeName": "BlulocoDarkItalic",
"path": "bluloco-dark-italic-color-theme.json",
"loaded": false,
"cache": ""
},
{
"group": "Bluloco Dark",
"name": "Bluloco Dark",
"themeName": "BlulocoDark",
"path": "bluloco-dark-color-theme.json",
"loaded": false,
"cache": ""
}
];
const fontFamilys = [
{ label: "Fira Code", value: "Fira Code, Monoid, Consolas, monospace" },
{ label: "Menlo", value: "Menlo, Monaco, Courier New, monospace" }
];
var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
function getAugmentedNamespace(n) {
if (n.__esModule)
return n;
var a = Object.defineProperty({}, "__esModule", { value: true });
Object.keys(n).forEach(function(k) {
var d2 = Object.getOwnPropertyDescriptor(n, k);
Object.defineProperty(a, k, d2.get ? d2 : {
enumerable: true,
get: function() {
return n[k];
}
});
});
return a;
}
var main$1 = {};
var registry = {};
var grammar = {};
var utils = {};
Object.defineProperty(utils, "__esModule", { value: true });
function clone(something) {
return doClone(something);
}
utils.clone = clone;
function doClone(something) {
if (Array.isArray(something)) {
return cloneArray(something);
}
if (typeof something === "object") {
return cloneObj(something);
}
return something;
}
function cloneArray(arr) {
var r = [];
for (var i = 0, len = arr.length; i < len; i++) {
r[i] = doClone(arr[i]);
}
return r;
}
function cloneObj(obj) {
var r = {};
for (var key in obj) {
r[key] = doClone(obj[key]);
}
return r;
}
function mergeObjects(target) {
var sources = [];
for (var _i2 = 1; _i2 < arguments.length; _i2++) {
sources[_i2 - 1] = arguments[_i2];
}
sources.forEach(function(source) {
for (var key in source) {
target[key] = source[key];
}
});
return target;
}
utils.mergeObjects = mergeObjects;
var CAPTURING_REGEX_SOURCE = /\$(\d+)|\${(\d+):\/(downcase|upcase)}/;
var RegexSource = function() {
function RegexSource2() {
}
RegexSource2.hasCaptures = function(regexSource) {
return CAPTURING_REGEX_SOURCE.test(regexSource);
};
RegexSource2.replaceCaptures = function(regexSource, captureSource, captureIndices) {
return regexSource.replace(CAPTURING_REGEX_SOURCE, function(match, index, commandIndex, command) {
var capture = captureIndices[parseInt(index || commandIndex, 10)];
if (capture) {
var result = captureSource.substring(capture.start, capture.end);
while (result[0] === ".") {
result = result.substring(1);
}
switch (command) {
case "downcase":
return result.toLowerCase();
case "upcase":
return result.toUpperCase();
default:
return result;
}
} else {
return match;
}
});
};
return RegexSource2;
}();
utils.RegexSource = RegexSource;
var rule = {};
var __viteBrowserExternal = {};
var __viteBrowserExternal$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
__proto__: null,
"default": __viteBrowserExternal
}, Symbol.toStringTag, { value: "Module" }));
var require$$0 = /* @__PURE__ */ getAugmentedNamespace(__viteBrowserExternal$1);
var lib = {};
var onigasmH = {};
var onigasm = { exports: {} };
(function(module, exports) {
var Onigasm = function() {
typeof document !== "undefined" && document.currentScript ? document.currentScript.src : void 0;
return function(Onigasm2) {
Onigasm2 = Onigasm2 || {};
var Module = typeof Onigasm2 !== "undefined" ? Onigasm2 : {};
var moduleOverrides = {};
var key;
for (key in Module) {
if (Module.hasOwnProperty(key)) {
moduleOverrides[key] = Module[key];
}
}
var ENVIRONMENT_IS_WORKER = false;
var scriptDirectory = "";
function locateFile(path2) {
if (Module["locateFile"]) {
return Module["locateFile"](path2, scriptDirectory);
}
return scriptDirectory + path2;
}
var readBinary;
{
readBinary = function readBinary2(f2) {
var data;
if (typeof readbuffer === "function") {
return new Uint8Array(readbuffer(f2));
}
data = read(f2, "binary");
assert(typeof data === "object");
return data;
};
if (typeof scriptArgs != "undefined") {
scriptArgs;
}
if (typeof print !== "undefined") {
if (typeof console === "undefined")
console = {};
// console.log = print;
// console.warn = console.error = typeof printErr !== "undefined" ? printErr : print;
}
}
var out = Module["print"] || console.log.bind(console);
var err = Module["printErr"] || console.warn.bind(console);
for (key in moduleOverrides) {
if (moduleOverrides.hasOwnProperty(key)) {
Module[key] = moduleOverrides[key];
}
}
moduleOverrides = null;
if (Module["arguments"])
Module["arguments"];
if (Module["thisProgram"])
Module["thisProgram"];
if (Module["quit"])
Module["quit"];
var wasmBinary;
if (Module["wasmBinary"])
wasmBinary = Module["wasmBinary"];
if (Module["noExitRuntime"])
Module["noExitRuntime"];
if (typeof WebAssembly !== "object") {
err("no native wasm support detected");
}
var wasmMemory;
var wasmTable = new WebAssembly.Table({ "initial": 244, "maximum": 244 + 0, "element": "anyfunc" });
var ABORT = false;
function assert(condition, text) {
if (!condition) {
abort("Assertion failed: " + text);
}
}
function getCFunc(ident) {
var func = Module["_" + ident];
assert(func, "Cannot call unknown function " + ident + ", make sure it is exported");
return func;
}
function ccall(ident, returnType, argTypes, args, opts) {
var toC = { "string": function(str) {
var ret2 = 0;
if (str !== null && str !== void 0 && str !== 0) {
var len = (str.length << 2) + 1;
ret2 = stackAlloc(len);
stringToUTF8(str, ret2, len);
}
return ret2;
}, "array": function(arr) {
var ret2 = stackAlloc(arr.length);
writeArrayToMemory(arr, ret2);
return ret2;
} };
function convertReturnValue(ret2) {
if (returnType === "string")
return UTF8ToString(ret2);
if (returnType === "boolean")
return Boolean(ret2);
return ret2;
}
var func = getCFunc(ident);
var cArgs = [];
var stack = 0;
if (args) {
for (var i = 0; i < args.length; i++) {
var converter = toC[argTypes[i]];
if (converter) {
if (stack === 0)
stack = stackSave();
cArgs[i] = converter(args[i]);
} else {
cArgs[i] = args[i];
}
}
}
var ret = func.apply(null, cArgs);
ret = convertReturnValue(ret);
if (stack !== 0)
stackRestore(stack);
return ret;
}
var UTF8Decoder = typeof TextDecoder !== "undefined" ? new TextDecoder("utf8") : void 0;
function UTF8ArrayToString(u8Array, idx, maxBytesToRead) {
var endIdx = idx + maxBytesToRead;
var endPtr = idx;
while (u8Array[endPtr] && !(endPtr >= endIdx))
++endPtr;
if (endPtr - idx > 16 && u8Array.subarray && UTF8Decoder) {
return UTF8Decoder.decode(u8Array.subarray(idx, endPtr));
} else {
var str = "";
while (idx < endPtr) {
var u0 = u8Array[idx++];
if (!(u0 & 128)) {
str += String.fromCharCode(u0);
continue;
}
var u1 = u8Array[idx++] & 63;
if ((u0 & 224) == 192) {
str += String.fromCharCode((u0 & 31) << 6 | u1);
continue;
}
var u2 = u8Array[idx++] & 63;
if ((u0 & 240) == 224) {
u0 = (u0 & 15) << 12 | u1 << 6 | u2;
} else {
u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | u8Array[idx++] & 63;
}
if (u0 < 65536) {
str += String.fromCharCode(u0);
} else {
var ch = u0 - 65536;
str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
}
}
}
return str;
}
function UTF8ToString(ptr, maxBytesToRead) {
return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
}
function stringToUTF8Array(str, outU8Array, outIdx, maxBytesToWrite) {
if (!(maxBytesToWrite > 0))
return 0;
var startIdx = outIdx;
var endIdx = outIdx + maxBytesToWrite - 1;
for (var i = 0; i < str.length; ++i) {
var u = str.charCodeAt(i);
if (u >= 55296 && u <= 57343) {
var u1 = str.charCodeAt(++i);
u = 65536 + ((u & 1023) << 10) | u1 & 1023;
}
if (u <= 127) {
if (outIdx >= endIdx)
break;
outU8Array[outIdx++] = u;
} else if (u <= 2047) {
if (outIdx + 1 >= endIdx)
break;
outU8Array[outIdx++] = 192 | u >> 6;
outU8Array[outIdx++] = 128 | u & 63;
} else if (u <= 65535) {
if (outIdx + 2 >= endIdx)
break;
outU8Array[outIdx++] = 224 | u >> 12;
outU8Array[outIdx++] = 128 | u >> 6 & 63;
outU8Array[outIdx++] = 128 | u & 63;
} else {
if (outIdx + 3 >= endIdx)
break;
outU8Array[outIdx++] = 240 | u >> 18;
outU8Array[outIdx++] = 128 | u >> 12 & 63;
outU8Array[outIdx++] = 128 | u >> 6 & 63;
outU8Array[outIdx++] = 128 | u & 63;
}
}
outU8Array[outIdx] = 0;
return outIdx - startIdx;
}
function stringToUTF8(str, outPtr, maxBytesToWrite) {
return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
}
typeof TextDecoder !== "undefined" ? new TextDecoder("utf-16le") : void 0;
function writeArrayToMemory(array, buffer2) {
HEAP8.set(array, buffer2);
}
var WASM_PAGE_SIZE = 65536;
function alignUp(x2, multiple) {
if (x2 % multiple > 0) {
x2 += multiple - x2 % multiple;
}
return x2;
}
var buffer, HEAP8, HEAPU8, HEAP32;
function updateGlobalBufferAndViews(buf) {
buffer = buf;
Module["HEAP8"] = HEAP8 = new Int8Array(buf);
Module["HEAP16"] = new Int16Array(buf);
Module["HEAP32"] = HEAP32 = new Int32Array(buf);
Module["HEAPU8"] = HEAPU8 = new Uint8Array(buf);
Module["HEAPU16"] = new Uint16Array(buf);
Module["HEAPU32"] = new Uint32Array(buf);
Module["HEAPF32"] = new Float32Array(buf);
Module["HEAPF64"] = new Float64Array(buf);
}
var DYNAMIC_BASE = 5507664, DYNAMICTOP_PTR = 264624;
var INITIAL_TOTAL_MEMORY = Module["TOTAL_MEMORY"] || 157286400;
if (Module["wasmMemory"]) {
wasmMemory = Module["wasmMemory"];
} else {
wasmMemory = new WebAssembly.Memory({ "initial": INITIAL_TOTAL_MEMORY / WASM_PAGE_SIZE });
}
if (wasmMemory) {
buffer = wasmMemory.buffer;
}
INITIAL_TOTAL_MEMORY = buffer.byteLength;
updateGlobalBufferAndViews(buffer);
HEAP32[DYNAMICTOP_PTR >> 2] = DYNAMIC_BASE;
function callRuntimeCallbacks(callbacks) {
while (callbacks.length > 0) {
var callback = callbacks.shift();
if (typeof callback == "function") {
callback();
continue;
}
var func = callback.func;
if (typeof func === "number") {
if (callback.arg === void 0) {
Module["dynCall_v"](func);
} else {
Module["dynCall_vi"](func, callback.arg);
}
} else {
func(callback.arg === void 0 ? null : callback.arg);
}
}
}
var __ATPRERUN__ = [];
var __ATINIT__ = [];
var __ATMAIN__ = [];
var __ATPOSTRUN__ = [];
function preRun() {
if (Module["preRun"]) {
if (typeof Module["preRun"] == "function")
Module["preRun"] = [Module["preRun"]];
while (Module["preRun"].length) {
addOnPreRun(Module["preRun"].shift());
}
}
callRuntimeCallbacks(__ATPRERUN__);
}
function initRuntime() {
callRuntimeCallbacks(__ATINIT__);
}
function preMain() {
callRuntimeCallbacks(__ATMAIN__);
}
function postRun() {
if (Module["postRun"]) {
if (typeof Module["postRun"] == "function")
Module["postRun"] = [Module["postRun"]];
while (Module["postRun"].length) {
addOnPostRun(Module["postRun"].shift());
}
}
callRuntimeCallbacks(__ATPOSTRUN__);
}
function addOnPreRun(cb) {
__ATPRERUN__.unshift(cb);
}
function addOnPostRun(cb) {
__ATPOSTRUN__.unshift(cb);
}
var runDependencies = 0;
var dependenciesFulfilled = null;
function addRunDependency(id) {
runDependencies++;
if (Module["monitorRunDependencies"]) {
Module["monitorRunDependencies"](runDependencies);
}
}
function removeRunDependency(id) {
runDependencies--;
if (Module["monitorRunDependencies"]) {
Module["monitorRunDependencies"](runDependencies);
}
if (runDependencies == 0) {
if (dependenciesFulfilled) {
var callback = dependenciesFulfilled;
dependenciesFulfilled = null;
callback();
}
}
}
Module["preloadedImages"] = {};
Module["preloadedAudios"] = {};
function abort(what) {
if (Module["onAbort"]) {
Module["onAbort"](what);
}
what += "";
out(what);
err(what);
ABORT = true;
what = "abort(" + what + "). Build with -s ASSERTIONS=1 for more info.";
throw new WebAssembly.RuntimeError(what);
}
var dataURIPrefix = "data:application/octet-stream;base64,";
function isDataURI(filename) {
return String.prototype.startsWith ? filename.startsWith(dataURIPrefix) : filename.indexOf(dataURIPrefix) === 0;
}
var wasmBinaryFile = "onigasm.wasm";
if (!isDataURI(wasmBinaryFile)) {
wasmBinaryFile = locateFile(wasmBinaryFile);
}
function getBinary() {
try {
if (wasmBinary) {
return new Uint8Array(wasmBinary);
}
if (readBinary) {
return readBinary(wasmBinaryFile);
} else {
throw "both async and sync fetching of the wasm failed";
}
} catch (err2) {
abort(err2);
}
}
function getBinaryPromise() {
if (!wasmBinary && ENVIRONMENT_IS_WORKER && typeof fetch === "function") {
return fetch(wasmBinaryFile, { credentials: "same-origin" }).then(function(response) {
if (!response["ok"]) {
throw "failed to load wasm binary file at '" + wasmBinaryFile + "'";
}
return response["arrayBuffer"]();
}).catch(function() {
return getBinary();
});
}
return new Promise(function(resolve, reject) {
resolve(getBinary());
});
}
function createWasm() {
var info = { "env": asmLibraryArg, "wasi_unstable": asmLibraryArg };
function receiveInstance(instance, module2) {
var exports3 = instance.exports;
Module["asm"] = exports3;
removeRunDependency();
}
addRunDependency();
function receiveInstantiatedSource(output) {
receiveInstance(output["instance"]);
}
function instantiateArrayBuffer(receiver) {
return getBinaryPromise().then(function(binary) {
return WebAssembly.instantiate(binary, info);
}).then(receiver, function(reason) {
err("failed to asynchronously prepare wasm: " + reason);
abort(reason);
});
}
function instantiateAsync() {
if (!wasmBinary && typeof WebAssembly.instantiateStreaming === "function" && !isDataURI(wasmBinaryFile) && typeof fetch === "function") {
fetch(wasmBinaryFile, { credentials: "same-origin" }).then(function(response) {
var result = WebAssembly.instantiateStreaming(response, info);
return result.then(receiveInstantiatedSource, function(reason) {
err("wasm streaming compile failed: " + reason);
err("falling back to ArrayBuffer instantiation");
instantiateArrayBuffer(receiveInstantiatedSource);
});
});
} else {
return instantiateArrayBuffer(receiveInstantiatedSource);
}
}
if (Module["instantiateWasm"]) {
try {
var exports2 = Module["instantiateWasm"](info, receiveInstance);
return exports2;
} catch (e4) {
err("Module.instantiateWasm callback failed with error: " + e4);
return false;
}
}
instantiateAsync();
return {};
}
__ATINIT__.push({ func: function() {
___wasm_call_ctors();
} });
function _abort() {
abort();
}
function _emscripten_get_heap_size() {
return HEAP8.length;
}
function _emscripten_get_sbrk_ptr() {
return 264624;
}
function _emscripten_memcpy_big(dest, src, num) {
HEAPU8.set(HEAPU8.subarray(src, src + num), dest);
}
function emscripten_realloc_buffer(size) {
try {
wasmMemory.grow(size - buffer.byteLength + 65535 >> 16);
updateGlobalBufferAndViews(wasmMemory.buffer);
return 1;
} catch (e4) {
}
}
function _emscripten_resize_heap(requestedSize) {
var oldSize = _emscripten_get_heap_size();
var PAGE_MULTIPLE = 65536;
var LIMIT = 2147483648 - PAGE_MULTIPLE;
if (requestedSize > LIMIT) {
return false;
}
var MIN_TOTAL_MEMORY = 16777216;
var newSize = Math.max(oldSize, MIN_TOTAL_MEMORY);
while (newSize < requestedSize) {
if (newSize <= 536870912) {
newSize = alignUp(2 * newSize, PAGE_MULTIPLE);
} else {
newSize = Math.min(alignUp((3 * newSize + 2147483648) / 4, PAGE_MULTIPLE), LIMIT);
}
}
var replacement = emscripten_realloc_buffer(newSize);
if (!replacement) {
return false;
}
return true;
}
var SYSCALLS = { buffers: [null, [], []], printChar: function(stream, curr) {
var buffer2 = SYSCALLS.buffers[stream];
if (curr === 0 || curr === 10) {
(stream === 1 ? out : err)(UTF8ArrayToString(buffer2, 0));
buffer2.length = 0;
} else {
buffer2.push(curr);
}
}, varargs: 0, get: function(varargs) {
SYSCALLS.varargs += 4;
var ret = HEAP32[SYSCALLS.varargs - 4 >> 2];
return ret;
}, getStr: function() {
var ret = UTF8ToString(SYSCALLS.get());
return ret;
}, get64: function() {
var low = SYSCALLS.get();
SYSCALLS.get();
return low;
}, getZero: function() {
SYSCALLS.get();
} };
function _fd_close(fd) {
try {
return 0;
} catch (e4) {
if (typeof FS === "undefined" || !(e4 instanceof FS.ErrnoError))
abort(e4);
return e4.errno;
}
}
function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {
try {
return 0;
} catch (e4) {
if (typeof FS === "undefined" || !(e4 instanceof FS.ErrnoError))
abort(e4);
return e4.errno;
}
}
function _fd_write(fd, iov, iovcnt, pnum) {
try {
var num = 0;
for (var i = 0; i < iovcnt; i++) {
var ptr = HEAP32[iov + i * 8 >> 2];
var len = HEAP32[iov + (i * 8 + 4) >> 2];
for (var j2 = 0; j2 < len; j2++) {
SYSCALLS.printChar(fd, HEAPU8[ptr + j2]);
}
num += len;
}
HEAP32[pnum >> 2] = num;
return 0;
} catch (e4) {
if (typeof FS === "undefined" || !(e4 instanceof FS.ErrnoError))
abort(e4);
return e4.errno;
}
}
function _setTempRet0($i) {
}
var asmLibraryArg = { "abort": _abort, "emscripten_get_sbrk_ptr": _emscripten_get_sbrk_ptr, "emscripten_memcpy_big": _emscripten_memcpy_big, "emscripten_resize_heap": _emscripten_resize_heap, "fd_close": _fd_close, "fd_seek": _fd_seek, "fd_write": _fd_write, "memory": wasmMemory, "setTempRet0": _setTempRet0, "table": wasmTable };
var asm = createWasm();
Module["asm"] = asm;
var ___wasm_call_ctors = Module["___wasm_call_ctors"] = function() {
return Module["asm"]["__wasm_call_ctors"].apply(null, arguments);
};
Module["_malloc"] = function() {
return Module["asm"]["malloc"].apply(null, arguments);
};
Module["_free"] = function() {
return Module["asm"]["free"].apply(null, arguments);
};
Module["_getLastError"] = function() {
return Module["asm"]["getLastError"].apply(null, arguments);
};
Module["_compilePattern"] = function() {
return Module["asm"]["compilePattern"].apply(null, arguments);
};
Module["_disposeCompiledPatterns"] = function() {
return Module["asm"]["disposeCompiledPatterns"].apply(null, arguments);
};
Module["_findBestMatch"] = function() {
return Module["asm"]["findBestMatch"].apply(null, arguments);
};
Module["___cxa_demangle"] = function() {
return Module["asm"]["__cxa_demangle"].apply(null, arguments);
};
Module["_setThrew"] = function() {
return Module["asm"]["setThrew"].apply(null, arguments);
};
var stackSave = Module["stackSave"] = function() {
return Module["asm"]["stackSave"].apply(null, arguments);
};
var stackAlloc = Module["stackAlloc"] = function() {
return Module["asm"]["stackAlloc"].apply(null, arguments);
};
var stackRestore = Module["stackRestore"] = function() {
return Module["asm"]["stackRestore"].apply(null, arguments);
};
Module["__growWasmMemory"] = function() {
return Module["asm"]["__growWasmMemory"].apply(null, arguments);
};
Module["dynCall_vi"] = function() {
return Module["asm"]["dynCall_vi"].apply(null, arguments);
};
Module["dynCall_iiii"] = function() {
return Module["asm"]["dynCall_iiii"].apply(null, arguments);
};
Module["dynCall_iiiii"] = function() {
return Module["asm"]["dynCall_iiiii"].apply(null, arguments);
};
Module["dynCall_iii"] = function() {
return Module["asm"]["dynCall_iii"].apply(null, arguments);
};
Module["dynCall_iidiiii"] = function() {
return Module["asm"]["dynCall_iidiiii"].apply(null, arguments);
};
Module["dynCall_vii"] = function() {
return Module["asm"]["dynCall_vii"].apply(null, arguments);
};
Module["dynCall_ii"] = function() {
return Module["asm"]["dynCall_ii"].apply(null, arguments);
};
Module["dynCall_i"] = function() {
return Module["asm"]["dynCall_i"].apply(null, arguments);
};
Module["dynCall_v"] = function() {
return Module["asm"]["dynCall_v"].apply(null, arguments);
};
Module["dynCall_viiiiii"] = function() {
return Module["asm"]["dynCall_viiiiii"].apply(null, arguments);
};
Module["dynCall_viiiii"] = function() {
return Module["asm"]["dynCall_viiiii"].apply(null, arguments);
};
Module["dynCall_viiii"] = function() {
return Module["asm"]["dynCall_viiii"].apply(null, arguments);
};
Module["dynCall_jiji"] = function() {
return Module["asm"]["dynCall_jiji"].apply(null, arguments);
};
Module["asm"] = asm;
Module["ccall"] = ccall;
var calledRun;
Module["then"] = function(func) {
if (calledRun) {
func(Module);
} else {
var old = Module["onRuntimeInitialized"];
Module["onRuntimeInitialized"] = function() {
if (old)
old();
func(Module);
};
}
return Module;
};
dependenciesFulfilled = function runCaller() {
if (!calledRun)
run();
if (!calledRun)
dependenciesFulfilled = runCaller;
};
function run(args) {
if (runDependencies > 0) {
return;
}
preRun();
if (runDependencies > 0)
return;
function doRun() {
if (calledRun)
return;
calledRun = true;
if (ABORT)
return;
initRuntime();
preMain();
if (Module["onRuntimeInitialized"])
Module["onRuntimeInitialized"]();
postRun();
}
if (Module["setStatus"]) {
Module["setStatus"]("Running...");
setTimeout(function() {
setTimeout(function() {
Module["setStatus"]("");
}, 1);
doRun();
}, 1);
} else {
doRun();
}
}
Module["run"] = run;
if (Module["preInit"]) {
if (typeof Module["preInit"] == "function")
Module["preInit"] = [Module["preInit"]];
while (Module["preInit"].length > 0) {
Module["preInit"].pop()();
}
}
run();
return Onigasm2;
};
}();
module.exports = Onigasm;
})(onigasm);
Object.defineProperty(onigasmH, "__esModule", { value: true });
const OnigasmModuleFactory = onigasm.exports;
async function initModule(bytes) {
return new Promise((resolve, reject) => {
OnigasmModuleFactory({
instantiateWasm(imports, successCallback) {
WebAssembly.instantiate(bytes, imports).then((output) => {
successCallback(output.instance);
}).catch((e4) => {
throw e4;
});
return {};
}
}).then((moduleH) => {
onigasmH.onigasmH = moduleH;
resolve();
});
});
}
let isInitialized = false;
async function loadWASM$1(data) {
if (isInitialized) {
throw new Error(`Onigasm#init has been called and was succesful, subsequent calls are not allowed once initialized`);
}
if (typeof data === "string") {
const arrayBuffer = await (await fetch(data)).arrayBuffer();
await initModule(arrayBuffer);
} else if (data instanceof ArrayBuffer) {
await initModule(data);
} else {
throw new TypeError(`Expected a string (URL of .wasm file) or ArrayBuffer (.wasm file itself) as first parameter`);
}
isInitialized = true;
}
onigasmH.loadWASM = loadWASM$1;
var OnigRegExp$1 = {};
var OnigScanner$1 = {};
var yallist = Yallist$1;
Yallist$1.Node = Node;
Yallist$1.create = Yallist$1;
function Yallist$1(list) {
var self2 = this;
if (!(self2 instanceof Yallist$1)) {
self2 = new Yallist$1();
}
self2.tail = null;
self2.head = null;
self2.length = 0;
if (list && typeof list.forEach === "function") {
list.forEach(function(item) {
self2.push(item);
});
} else if (arguments.length > 0) {
for (var i = 0, l = arguments.length; i < l; i++) {
self2.push(arguments[i]);
}
}
return self2;
}
Yallist$1.prototype.removeNode = function(node) {
if (node.list !== this) {
throw new Error("removing node which does not belong to this list");
}
var next = node.next;
var prev = node.prev;
if (next) {
next.prev = prev;
}
if (prev) {
prev.next = next;
}
if (node === this.head) {
this.head = next;
}
if (node === this.tail) {
this.tail = prev;
}
node.list.length--;
node.next = null;
node.prev = null;
node.list = null;
return next;
};
Yallist$1.prototype.unshiftNode = function(node) {
if (node === this.head) {
return;
}
if (node.list) {
node.list.removeNode(node);
}
var head = this.head;
node.list = this;
node.next = head;
if (head) {
head.prev = node;
}
this.head = node;
if (!this.tail) {
this.tail = node;
}
this.length++;
};
Yallist$1.prototype.pushNode = function(node) {
if (node === this.tail) {
return;
}
if (node.list) {
node.list.removeNode(node);
}
var tail = this.tail;
node.list = this;
node.prev = tail;
if (tail) {
tail.next = node;
}
this.tail = node;
if (!this.head) {
this.head = node;
}
this.length++;
};
Yallist$1.prototype.push = function() {
for (var i = 0, l = arguments.length; i < l; i++) {
push(this, arguments[i]);
}
return this.length;
};
Yallist$1.prototype.unshift = function() {
for (var i = 0, l = arguments.length; i < l; i++) {
unshift(this, arguments[i]);
}
return this.length;
};
Yallist$1.prototype.pop = function() {
if (!this.tail) {
return void 0;
}
var res = this.tail.value;
this.tail = this.tail.prev;
if (this.tail) {
this.tail.next = null;
} else {
this.head = null;
}
this.length--;
return res;
};
Yallist$1.prototype.shift = function() {
if (!this.head) {
return void 0;
}
var res = this.head.value;
this.head = this.head.next;
if (this.head) {
this.head.prev = null;
} else {
this.tail = null;
}
this.length--;
return res;
};
Yallist$1.prototype.forEach = function(fn2, thisp) {
thisp = thisp || this;
for (var walker = this.head, i = 0; walker !== null; i++) {
fn2.call(thisp, walker.value, i, this);
walker = walker.next;
}
};
Yallist$1.prototype.forEachReverse = function(fn2, thisp) {
thisp = thisp || this;
for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {
fn2.call(thisp, walker.value, i, this);
walker = walker.prev;
}
};
Yallist$1.prototype.get = function(n) {
for (var i = 0, walker = this.head; walker !== null && i < n; i++) {
walker = walker.next;
}
if (i === n && walker !== null) {
return walker.value;
}
};
Yallist$1.prototype.getReverse = function(n) {
for (var i = 0, walker = this.tail; walker !== null && i < n; i++) {
walker = walker.prev;
}
if (i === n && walker !== null) {
return walker.value;
}
};
Yallist$1.prototype.map = function(fn2, thisp) {
thisp = thisp || this;
var res = new Yallist$1();
for (var walker = this.head; walker !== null; ) {
res.push(fn2.call(thisp, walker.value, this));
walker = walker.next;
}
return res;
};
Yallist$1.prototype.mapReverse = function(fn2, thisp) {
thisp = thisp || this;
var res = new Yallist$1();
for (var walker = this.tail; walker !== null; ) {
res.push(fn2.call(thisp, walker.value, this));
walker = walker.prev;
}
return res;
};
Yallist$1.prototype.reduce = function(fn2, initial) {
var acc;
var walker = this.head;
if (arguments.length > 1) {
acc = initial;
} else if (this.head) {
walker = this.head.next;
acc = this.head.value;
} else {
throw new TypeError("Reduce of empty list with no initial value");
}
for (var i = 0; walker !== null; i++) {
acc = fn2(acc, walker.value, i);
walker = walker.next;
}
return acc;
};
Yallist$1.prototype.reduceReverse = function(fn2, initial) {
var acc;
var walker = this.tail;
if (arguments.length > 1) {
acc = initial;
} else if (this.tail) {
walker = this.tail.prev;
acc = this.tail.value;
} else {
throw new TypeError("Reduce of empty list with no initial value");
}
for (var i = this.length - 1; walker !== null; i--) {
acc = fn2(acc, walker.value, i);
walker = walker.prev;
}
return acc;
};
Yallist$1.prototype.toArray = function() {
var arr = new Array(this.length);
for (var i = 0, walker = this.head; walker !== null; i++) {
arr[i] = walker.value;
walker = walker.next;
}
return arr;
};
Yallist$1.prototype.toArrayReverse = function() {
var arr = new Array(this.length);
for (var i = 0, walker = this.tail; walker !== null; i++) {
arr[i] = walker.value;
walker = walker.prev;
}
return arr;
};
Yallist$1.prototype.slice = function(from, to) {
to = to || this.length;
if (to < 0) {
to += this.length;
}
from = from || 0;
if (from < 0) {
from += this.length;
}
var ret = new Yallist$1();
if (to < from || to < 0) {
return ret;
}
if (from < 0) {
from = 0;
}
if (to > this.length) {
to = this.length;
}
for (var i = 0, walker = this.head; walker !== null && i < from; i++) {
walker = walker.next;
}
for (; walker !== null && i < to; i++, walker = walker.next) {
ret.push(walker.value);
}
return ret;
};
Yallist$1.prototype.sliceReverse = function(from, to) {
to = to || this.length;
if (to < 0) {
to += this.length;
}
from = from || 0;
if (from < 0) {
from += this.length;
}
var ret = new Yallist$1();
if (to < from || to < 0) {
return ret;
}
if (from < 0) {
from = 0;
}
if (to > this.length) {
to = this.length;
}
for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {
walker = walker.prev;
}
for (; walker !== null && i > from; i--, walker = walker.prev) {
ret.push(walker.value);
}
return ret;
};
Yallist$1.prototype.splice = function(start, deleteCount) {
if (start > this.length) {
start = this.length - 1;
}
if (start < 0) {
start = this.length + start;
}
for (var i = 0, walker = this.head; walker !== null && i < start; i++) {
walker = walker.next;
}
var ret = [];
for (var i = 0; walker && i < deleteCount; i++) {
ret.push(walker.value);
walker = this.removeNode(walker);
}
if (walker === null) {
walker = this.tail;
}
if (walker !== this.head && walker !== this.tail) {
walker = walker.prev;
}
for (var i = 2; i < arguments.length; i++) {
walker = insert(this, walker, arguments[i]);
}
return ret;
};
Yallist$1.prototype.reverse = function() {
var head = this.head;
var tail = this.tail;
for (var walker = head; walker !== null; walker = walker.prev) {
var p = walker.prev;
walker.prev = walker.next;
walker.next = p;
}
this.head = tail;
this.tail = head;
return this;
};
function insert(self2, node, value) {
var inserted = node === self2.head ? new Node(value, null, node, self2) : new Node(value, node, node.next, self2);
if (inserted.next === null) {
self2.tail = inserted;
}
if (inserted.prev === null) {
self2.head = inserted;
}
self2.length++;
return inserted;
}
function push(self2, item) {
self2.tail = new Node(item, self2.tail, null, self2);
if (!self2.head) {
self2.head = self2.tail;
}
self2.length++;
}
function unshift(self2, item) {
self2.head = new Node(item, null, self2.head, self2);
if (!self2.tail) {
self2.tail = self2.head;
}
self2.length++;
}
function Node(value, prev, next, list) {
if (!(this instanceof Node)) {
return new Node(value, prev, next, list);
}
this.list = list;
this.value = value;
if (prev) {
prev.next = this;
this.prev = prev;
} else {
this.prev = null;
}
if (next) {
next.prev = this;
this.next = next;
} else {
this.next = null;
}
}
try {
require("./iterator.js")(Yallist$1);
} catch (er2) {
}
const Yallist = yallist;
const MAX = Symbol("max");
const LENGTH = Symbol("length");
const LENGTH_CALCULATOR = Symbol("lengthCalculator");
const ALLOW_STALE = Symbol("allowStale");
const MAX_AGE = Symbol("maxAge");
const DISPOSE = Symbol("dispose");
const NO_DISPOSE_ON_SET = Symbol("noDisposeOnSet");
const LRU_LIST = Symbol("lruList");
const CACHE = Symbol("cache");
const UPDATE_AGE_ON_GET = Symbol("updateAgeOnGet");
const naiveLength = () => 1;
class LRUCache$1 {
constructor(options) {
if (typeof options === "number")
options = { max: options };
if (!options)
options = {};
if (options.max && (typeof options.max !== "number" || options.max < 0))
throw new TypeError("max must be a non-negative number");
this[MAX] = options.max || Infinity;
const lc = options.length || naiveLength;
this[LENGTH_CALCULATOR] = typeof lc !== "function" ? naiveLength : lc;
this[ALLOW_STALE] = options.stale || false;
if (options.maxAge && typeof options.maxAge !== "number")
throw new TypeError("maxAge must be a number");
this[MAX_AGE] = options.maxAge || 0;
this[DISPOSE] = options.dispose;
this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false;
this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false;
this.reset();
}
set max(mL) {
if (typeof mL !== "number" || mL < 0)
throw new TypeError("max must be a non-negative number");
this[MAX] = mL || Infinity;
trim(this);
}
get max() {
return this[MAX];
}
set allowStale(allowStale) {
this[ALLOW_STALE] = !!allowStale;
}
get allowStale() {
return this[ALLOW_STALE];
}
set maxAge(mA) {
if (typeof mA !== "number")
throw new TypeError("maxAge must be a non-negative number");
this[MAX_AGE] = mA;
trim(this);
}
get maxAge() {
return this[MAX_AGE];
}
set lengthCalculator(lC) {
if (typeof lC !== "function")
lC = naiveLength;
if (lC !== this[LENGTH_CALCULATOR]) {
this[LENGTH_CALCULATOR] = lC;
this[LENGTH] = 0;
this[LRU_LIST].forEach((hit) => {
hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key);
this[LENGTH] += hit.length;
});
}
trim(this);
}
get lengthCalculator() {
return this[LENGTH_CALCULATOR];
}
get length() {
return this[LENGTH];
}
get itemCount() {
return this[LRU_LIST].length;
}
rforEach(fn2, thisp) {
thisp = thisp || this;
for (let walker = this[LRU_LIST].tail; walker !== null; ) {
const prev = walker.prev;
forEachStep(this, fn2, walker, thisp);
walker = prev;
}
}
forEach(fn2, thisp) {
thisp = thisp || this;
for (let walker = this[LRU_LIST].head; walker !== null; ) {
const next = walker.next;
forEachStep(this, fn2, walker, thisp);
walker = next;
}
}
keys() {
return this[LRU_LIST].toArray().map((k) => k.key);
}
values() {
return this[LRU_LIST].toArray().map((k) => k.value);
}
reset() {
if (this[DISPOSE] && this[LRU_LIST] && this[LRU_LIST].length) {
this[LRU_LIST].forEach((hit) => this[DISPOSE](hit.key, hit.value));
}
this[CACHE] = /* @__PURE__ */ new Map();
this[LRU_LIST] = new Yallist();
this[LENGTH] = 0;
}
dump() {
return this[LRU_LIST].map((hit) => isStale(this, hit) ? false : {
k: hit.key,
v: hit.value,
e: hit.now + (hit.maxAge || 0)
}).toArray().filter((h) => h);
}
dumpLru() {
return this[LRU_LIST];
}
set(key, value, maxAge) {
maxAge = maxAge || this[MAX_AGE];
if (maxAge && typeof maxAge !== "number")
throw new TypeError("maxAge must be a number");
const now = maxAge ? Date.now() : 0;
const len = this[LENGTH_CALCULATOR](value, key);
if (this[CACHE].has(key)) {
if (len > this[MAX]) {
del(this, this[CACHE].get(key));
return false;
}
const node = this[CACHE].get(key);
const item = node.value;
if (this[DISPOSE]) {
if (!this[NO_DISPOSE_ON_SET])
this[DISPOSE](key, item.value);
}
item.now = now;
item.maxAge = maxAge;
item.value = value;
this[LENGTH] += len - item.length;
item.length = len;
this.get(key);
trim(this);
return true;
}
const hit = new Entry(key, value, len, now, maxAge);
if (hit.length > this[MAX]) {
if (this[DISPOSE])
this[DISPOSE](key, value);
return false;
}
this[LENGTH] += hit.length;
this[LRU_LIST].unshift(hit);
this[CACHE].set(key, this[LRU_LIST].head);
trim(this);
return true;
}
has(key) {
if (!this[CACHE].has(key))
return false;
const hit = this[CACHE].get(key).value;
return !isStale(this, hit);
}
get(key) {
return get(this, key, true);
}
peek(key) {
return get(this, key, false);
}
pop() {
const node = this[LRU_LIST].tail;
if (!node)
return null;
del(this, node);
return node.value;
}
del(key) {
del(this, this[CACHE].get(key));
}
load(arr) {
this.reset();
const now = Date.now();
for (let l = arr.length - 1; l >= 0; l--) {
const hit = arr[l];
const expiresAt = hit.e || 0;
if (expiresAt === 0)
this.set(hit.k, hit.v);
else {
const maxAge = expiresAt - now;
if (maxAge > 0) {
this.set(hit.k, hit.v, maxAge);
}
}
}
}
prune() {
this[CACHE].forEach((value, key) => get(this, key, false));
}
}
const get = (self2, key, doUse) => {
const node = self2[CACHE].get(key);
if (node) {
const hit = node.value;
if (isStale(self2, hit)) {
del(self2, node);
if (!self2[ALLOW_STALE])
return void 0;
} else {
if (doUse) {
if (self2[UPDATE_AGE_ON_GET])
node.value.now = Date.now();
self2[LRU_LIST].unshiftNode(node);
}
}
return hit.value;
}
};
const isStale = (self2, hit) => {
if (!hit || !hit.maxAge && !self2[MAX_AGE])
return false;
const diff = Date.now() - hit.now;
return hit.maxAge ? diff > hit.maxAge : self2[MAX_AGE] && diff > self2[MAX_AGE];
};
const trim = (self2) => {
if (self2[LENGTH] > self2[MAX]) {
for (let walker = self2[LRU_LIST].tail; self2[LENGTH] > self2[MAX] && walker !== null; ) {
const prev = walker.prev;
del(self2, walker);
walker = prev;
}
}
};
const del = (self2, node) => {
if (node) {
const hit = node.value;
if (self2[DISPOSE])
self2[DISPOSE](hit.key, hit.value);
self2[LENGTH] -= hit.length;
self2[CACHE].delete(hit.key);
self2[LRU_LIST].removeNode(node);
}
};
class Entry {
constructor(key, value, length, now, maxAge) {
this.key = key;
this.value = value;
this.length = length;
this.now = now;
this.maxAge = maxAge || 0;
}
}
const forEachStep = (self2, fn2, node, thisp) => {
let hit = node.value;
if (isStale(self2, hit)) {
del(self2, node);
if (!self2[ALLOW_STALE])
hit = void 0;
}
if (hit)
fn2.call(thisp, hit.value, hit.key, self2);
};
var lruCache = LRUCache$1;
var OnigString$1 = {};
Object.defineProperty(OnigString$1, "__esModule", { value: true });
class OnigString {
constructor(content) {
this.substring = (start, end) => {
return this.source.substring(start, end);
};
this.toString = (start, end) => {
return this.source;
};
if (typeof content !== "string") {
throw new TypeError("Argument must be a string");
}
this.source = content;
this._utf8Bytes = null;
this._utf8Indexes = null;
}
get utf8Bytes() {
if (!this._utf8Bytes) {
this.encode();
}
return this._utf8Bytes;
}
get utf8Indexes() {
if (!this._utf8Bytes) {
this.encode();
}
return this._utf8Indexes;
}
get content() {
return this.source;
}
get length() {
return this.source.length;
}
get hasMultiByteCharacters() {
return this.utf8Indexes !== null;
}
convertUtf8OffsetToUtf16(utf8Offset) {
if (utf8Offset < 0) {
return 0;
}
const utf8Array = this._utf8Bytes;
if (utf8Offset >= utf8Array.length - 1) {
return this.source.length;
}
const utf8OffsetMap = this.utf8Indexes;
if (utf8OffsetMap && utf8Offset >= this._mappingTableStartOffset) {
return findFirstInSorted(utf8OffsetMap, utf8Offset - this._mappingTableStartOffset) + this._mappingTableStartOffset;
}
return utf8Offset;
}
convertUtf16OffsetToUtf8(utf16Offset) {
if (utf16Offset < 0) {
return 0;
}
const utf8Array = this._utf8Bytes;
if (utf16Offset >= this.source.length) {
return utf8Array.length - 1;
}
const utf8OffsetMap = this.utf8Indexes;
if (utf8OffsetMap && utf16Offset >= this._mappingTableStartOffset) {
return utf8OffsetMap[utf16Offset - this._mappingTableStartOffset] + this._mappingTableStartOffset;
}
return utf16Offset;
}
encode() {
const str = this.source;
const n = str.length;
let utf16OffsetToUtf8;
let utf8Offset = 0;
let mappingTableStartOffset = 0;
function createOffsetTable(startOffset) {
const maxUtf8Len = (n - startOffset) * 3;
if (maxUtf8Len <= 255) {
utf16OffsetToUtf8 = new Uint8Array(n - startOffset);
} else if (maxUtf8Len <= 65535) {
utf16OffsetToUtf8 = new Uint16Array(n - startOffset);
} else {
utf16OffsetToUtf8 = new Uint32Array(n - startOffset);
}
mappingTableStartOffset = startOffset;
utf16OffsetToUtf8[utf8Offset++] = 0;
}
const u8view = new Uint8Array(n * 3 + 1);
let ptrHead = 0;
let i = 0;
while (i < str.length) {
let codepoint;
const c = str.charCodeAt(i);
if (utf16OffsetToUtf8) {
utf16OffsetToUtf8[utf8Offset++] = ptrHead - mappingTableStartOffset;
}
if (c < 55296 || c > 57343) {
codepoint = c;
} else if (c >= 56320) {
codepoint = 65533;
} else {
if (i === n - 1) {
codepoint = 65533;
} else {
const d2 = str.charCodeAt(i + 1);
if (56320 <= d2 && d2 <= 57343) {
if (!utf16OffsetToUtf8) {
createOffsetTable(i);
}
const a = c & 1023;
const b = d2 & 1023;
codepoint = 65536 + (a << 10) + b;
i += 1;
utf16OffsetToUtf8[utf8Offset++] = ptrHead - mappingTableStartOffset;
} else {
codepoint = 65533;
}
}
}
let bytesRequiredToEncode;
let offset;
if (codepoint <= 127) {
bytesRequiredToEncode = 1;
offset = 0;
} else if (codepoint <= 2047) {
bytesRequiredToEncode = 2;
offset = 192;
} else if (codepoint <= 65535) {
bytesRequiredToEncode = 3;
offset = 224;
} else {
bytesRequiredToEncode = 4;
offset = 240;
}
if (bytesRequiredToEncode === 1) {
u8view[ptrHead++] = codepoint;
} else {
if (!utf16OffsetToUtf8) {
createOffsetTable(ptrHead);
}
u8view[ptrHead++] = (codepoint >> 6 * --bytesRequiredToEncode) + offset;
while (bytesRequiredToEncode > 0) {
const temp = codepoint >> 6 * (bytesRequiredToEncode - 1);
u8view[ptrHead++] = 128 | temp & 63;
bytesRequiredToEncode -= 1;
}
}
i += 1;
}
const utf8 = u8view.slice(0, ptrHead + 1);
utf8[ptrHead] = 0;
this._utf8Bytes = utf8;
if (utf16OffsetToUtf8) {
this._utf8Indexes = utf16OffsetToUtf8;
this._mappingTableStartOffset = mappingTableStartOffset;
}
}
}
function findFirstInSorted(array, i) {
let low = 0;
let high = array.length;
if (high === 0) {
return 0;
}
while (low < high) {
const mid = Math.floor((low + high) / 2);
if (array[mid] >= i) {
high = mid;
} else {
low = mid + 1;
}
}
while (low > 0 && (low >= array.length || array[low] > i)) {
low--;
}
if (low > 0 && array[low] === array[low - 1]) {
low--;
}
return low;
}
OnigString$1.default = OnigString;
Object.defineProperty(OnigScanner$1, "__esModule", { value: true });
const LRUCache = lruCache;
const onigasmH_1$1 = onigasmH;
const OnigString_1$1 = OnigString$1;
function mallocAndWriteString(str) {
const ptr = onigasmH_1$1.onigasmH._malloc(str.utf8Bytes.length);
onigasmH_1$1.onigasmH.HEAPU8.set(str.utf8Bytes, ptr);
return ptr;
}
function convertUTF8BytesFromPtrToString(ptr) {
const chars = [];
let i = 0;
while (onigasmH_1$1.onigasmH.HEAPU8[ptr] !== 0) {
chars[i++] = onigasmH_1$1.onigasmH.HEAPU8[ptr++];
}
return chars.join();
}
const cache = new LRUCache({
dispose: (scanner, info) => {
const regexTPtrsPtr = onigasmH_1$1.onigasmH._malloc(info.regexTPtrs.length);
onigasmH_1$1.onigasmH.HEAPU8.set(info.regexTPtrs, regexTPtrsPtr);
const status = onigasmH_1$1.onigasmH._disposeCompiledPatterns(regexTPtrsPtr, scanner.patterns.length);
if (status !== 0) {
const errMessage = convertUTF8BytesFromPtrToString(onigasmH_1$1.onigasmH._getLastError());
throw new Error(errMessage);
}
onigasmH_1$1.onigasmH._free(regexTPtrsPtr);
},
max: 1e3
});
class OnigScanner {
constructor(patterns) {
if (onigasmH_1$1.onigasmH === null) {
throw new Error(`Onigasm has not been initialized, call loadWASM from 'onigasm' exports before using any other API`);
}
for (let i = 0; i < patterns.length; i++) {
const pattern = patterns[i];
if (typeof pattern !== "string") {
throw new TypeError(`First parameter to OnigScanner constructor must be array of (pattern) strings`);
}
}
this.sources = patterns.slice();
}
get patterns() {
return this.sources.slice();
}
findNextMatch(string, startPosition, callback) {
if (startPosition == null) {
startPosition = 0;
}
if (typeof startPosition === "function") {
callback = startPosition;
startPosition = 0;
}
try {
const match = this.findNextMatchSync(string, startPosition);
callback(null, match);
} catch (error) {
callback(error);
}
}
findNextMatchSync(string, startPosition) {
if (startPosition == null) {
startPosition = 0;
}
startPosition = this.convertToNumber(startPosition);
let onigNativeInfo = cache.get(this);
let status = 0;
if (!onigNativeInfo) {
const regexTAddrRecieverPtr = onigasmH_1$1.onigasmH._malloc(4);
const regexTPtrs = [];
for (let i = 0; i < this.sources.length; i++) {
const pattern = this.sources[i];
const patternStrPtr = mallocAndWriteString(new OnigString_1$1.default(pattern));
status = onigasmH_1$1.onigasmH._compilePattern(patternStrPtr, regexTAddrRecieverPtr);
if (status !== 0) {
const errMessage = convertUTF8BytesFromPtrToString(onigasmH_1$1.onigasmH._getLastError());
throw new Error(errMessage);
}
const regexTAddress = onigasmH_1$1.onigasmH.HEAP32[regexTAddrRecieverPtr / 4];
regexTPtrs.push(regexTAddress);
onigasmH_1$1.onigasmH._free(patternStrPtr);
}
onigNativeInfo = {
regexTPtrs: new Uint8Array(Uint32Array.from(regexTPtrs).buffer)
};
onigasmH_1$1.onigasmH._free(regexTAddrRecieverPtr);
cache.set(this, onigNativeInfo);
}
const onigString = string instanceof OnigString_1$1.default ? string : new OnigString_1$1.default(this.convertToString(string));
const strPtr = mallocAndWriteString(onigString);
const resultInfoReceiverPtr = onigasmH_1$1.onigasmH._malloc(8);
const regexTPtrsPtr = onigasmH_1$1.onigasmH._malloc(onigNativeInfo.regexTPtrs.length);
onigasmH_1$1.onigasmH.HEAPU8.set(onigNativeInfo.regexTPtrs, regexTPtrsPtr);
status = onigasmH_1$1.onigasmH._findBestMatch(
regexTPtrsPtr,
this.sources.length,
strPtr,
onigString.utf8Bytes.length - 1,
onigString.convertUtf16OffsetToUtf8(startPosition),
resultInfoReceiverPtr
);
if (status !== 0) {
const errMessage = convertUTF8BytesFromPtrToString(onigasmH_1$1.onigasmH._getLastError());
throw new Error(errMessage);
}
const [
bestPatternIdx,
encodedResultBeginAddress,
encodedResultLength
] = new Uint32Array(onigasmH_1$1.onigasmH.HEAPU32.buffer, resultInfoReceiverPtr, 3);
onigasmH_1$1.onigasmH._free(strPtr);
onigasmH_1$1.onigasmH._free(resultInfoReceiverPtr);
onigasmH_1$1.onigasmH._free(regexTPtrsPtr);
if (encodedResultLength > 0) {
const encodedResult = new Uint32Array(onigasmH_1$1.onigasmH.HEAPU32.buffer, encodedResultBeginAddress, encodedResultLength);
const captureIndices = [];
let i = 0;
let captureIdx = 0;
while (i < encodedResultLength) {
const index = captureIdx++;
let start = encodedResult[i++];
let end = encodedResult[i++];
if (onigString.hasMultiByteCharacters) {
start = onigString.convertUtf8OffsetToUtf16(start);
end = onigString.convertUtf8OffsetToUtf16(end);
}
captureIndices.push({
end,
index,
length: end - start,
start
});
}
onigasmH_1$1.onigasmH._free(encodedResultBeginAddress);
return {
captureIndices,
index: bestPatternIdx,
scanner: this
};
}
return null;
}
convertToString(value) {
if (value === void 0) {
return "undefined";
}
if (value === null) {
return "null";
}
if (value instanceof OnigString_1$1.default) {
return value.content;
}
return value.toString();
}
convertToNumber(value) {
value = parseInt(value, 10);
if (!isFinite(value)) {
value = 0;
}
value = Math.max(value, 0);
return value;
}
}
OnigScanner$1.OnigScanner = OnigScanner;
OnigScanner$1.default = OnigScanner;
Object.defineProperty(OnigRegExp$1, "__esModule", { value: true });
const OnigScanner_1$1 = OnigScanner$1;
class OnigRegExp {
constructor(source) {
this.source = source;
try {
this.scanner = new OnigScanner_1$1.default([this.source]);
} catch (error) {
}
}
searchSync(string, startPosition) {
let match;
if (startPosition == null) {
startPosition = 0;
}
match = this.scanner.findNextMatchSync(string, startPosition);
return this.captureIndicesForMatch(string, match);
}
search(string, startPosition, callback) {
if (startPosition == null) {
startPosition = 0;
}
if (typeof startPosition === "function") {
callback = startPosition;
startPosition = 0;
}
try {
const ret = this.searchSync(string, startPosition);
callback(null, ret);
} catch (error) {
callback(error);
}
}
testSync(string) {
if (typeof this.source === "boolean" || typeof string === "boolean") {
return this.source === string;
}
return this.searchSync(string) != null;
}
test(string, callback) {
if (typeof callback !== "function") {
callback = () => {
};
}
try {
callback(null, this.testSync(string));
} catch (error) {
callback(error);
}
}
captureIndicesForMatch(string, match) {
if (match != null) {
const { captureIndices } = match;
let capture;
string = this.scanner.convertToString(string);
for (let i = 0; i < captureIndices.length; i++) {
capture = captureIndices[i];
capture.match = string.slice(capture.start, capture.end);
}
return captureIndices;
} else {
return null;
}
}
}
OnigRegExp$1.default = OnigRegExp;
Object.defineProperty(lib, "__esModule", { value: true });
const onigasmH_1 = onigasmH;
var loadWASM = lib.loadWASM = onigasmH_1.loadWASM;
const OnigRegExp_1 = OnigRegExp$1;
lib.OnigRegExp = OnigRegExp_1.default;
const OnigScanner_1 = OnigScanner$1;
lib.OnigScanner = OnigScanner_1.default;
const OnigString_1 = OnigString$1;
lib.OnigString = OnigString_1.default;
var __extends = commonjsGlobal && commonjsGlobal.__extends || function() {
var extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b) {
d2.__proto__ = b;
} || function(d2, b) {
for (var p in b)
if (b.hasOwnProperty(p))
d2[p] = b[p];
};
return function(d2, b) {
extendStatics(d2, b);
function __() {
this.constructor = d2;
}
d2.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
}();
Object.defineProperty(rule, "__esModule", { value: true });
var path = require$$0;
var utils_1$1 = utils;
var onigasm_1 = lib;
var HAS_BACK_REFERENCES = /\\(\d+)/;
var BACK_REFERENCING_END = /\\(\d+)/g;
var Rule = function() {
function Rule2($location, id, name, contentName) {
this.$location = $location;
this.id = id;
this._name = name || null;
this._nameIsCapturing = utils_1$1.RegexSource.hasCaptures(this._name);
this._contentName = contentName || null;
this._contentNameIsCapturing = utils_1$1.RegexSource.hasCaptures(this._contentName);
}
Object.defineProperty(Rule2.prototype, "debugName", {
get: function() {
return this.constructor.name + "#" + this.id + " @ " + path.basename(this.$location.filename) + ":" + this.$location.line;
},
enumerable: true,
configurable: true
});
Rule2.prototype.getName = function(lineText, captureIndices) {
if (!this._nameIsCapturing) {
return this._name;
}
return utils_1$1.RegexSource.replaceCaptures(this._name, lineText, captureIndices);
};
Rule2.prototype.getContentName = function(lineText, captureIndices) {
if (!this._contentNameIsCapturing) {
return this._contentName;
}
return utils_1$1.RegexSource.replaceCaptures(this._contentName, lineText, captureIndices);
};
Rule2.prototype.collectPatternsRecursive = function(grammar2, out, isFirst) {
throw new Error("Implement me!");
};
Rule2.prototype.compile = function(grammar2, endRegexSource, allowA, allowG) {
throw new Error("Implement me!");
};
return Rule2;
}();
rule.Rule = Rule;
var CaptureRule = function(_super) {
__extends(CaptureRule2, _super);
function CaptureRule2($location, id, name, contentName, retokenizeCapturedWithRuleId) {
var _this = _super.call(this, $location, id, name, contentName) || this;
_this.retokenizeCapturedWithRuleId = retokenizeCapturedWithRuleId;
return _this;
}
return CaptureRule2;
}(Rule);
rule.CaptureRule = CaptureRule;
var RegExpSource = function() {
function RegExpSource2(regExpSource, ruleId, handleAnchors) {
if (handleAnchors === void 0) {
handleAnchors = true;
}
if (handleAnchors) {
this._handleAnchors(regExpSource);
} else {
this.source = regExpSource;
this.hasAnchor = false;
}
if (this.hasAnchor) {
this._anchorCache = this._buildAnchorCache();
}
this.ruleId = ruleId;
this.hasBackReferences = HAS_BACK_REFERENCES.test(this.source);
}
RegExpSource2.prototype.clone = function() {
return new RegExpSource2(this.source, this.ruleId, true);
};
RegExpSource2.prototype.setSource = function(newSource) {
if (this.source === newSource) {
return;
}
this.source = newSource;
if (this.hasAnchor) {
this._anchorCache = this._buildAnchorCache();
}
};
RegExpSource2.prototype._handleAnchors = function(regExpSource) {
if (regExpSource) {
var pos = void 0, len = void 0, ch = void 0, nextCh = void 0, lastPushedPos = 0, output = [];
var hasAnchor = false;
for (pos = 0, len = regExpSource.length; pos < len; pos++) {
ch = regExpSource.charAt(pos);
if (ch === "\\") {
if (pos + 1 < len) {
nextCh = regExpSource.charAt(pos + 1);
if (nextCh === "z") {
output.push(regExpSource.substring(lastPushedPos, pos));
output.push("$(?!\\n)(?<!\\n)");
lastPushedPos = pos + 2;
} else if (nextCh === "A" || nextCh === "G") {
hasAnchor = true;
}
pos++;
}
}
}
this.hasAnchor = hasAnchor;
if (lastPushedPos === 0) {
this.source = regExpSource;
} else {
output.push(regExpSource.substring(lastPushedPos, len));
this.source = output.join("");
}
} else {
this.hasAnchor = false;
this.source = regExpSource;
}
};
RegExpSource2.prototype.resolveBackReferences = function(lineText, captureIndices) {
var capturedValues = captureIndices.map(function(capture) {
return lineText.substring(capture.start, capture.end);
});
BACK_REFERENCING_END.lastIndex = 0;
return this.source.replace(BACK_REFERENCING_END, function(match, g1) {
return escapeRegExpCharacters(capturedValues[parseInt(g1, 10)] || "");
});
};
RegExpSource2.prototype._buildAnchorCache = function() {
var A0_G0_result = [];
var A0_G1_result = [];
var A1_G0_result = [];
var A1_G1_result = [];
var pos, len, ch, nextCh;
for (pos = 0, len = this.source.length; pos < len; pos++) {
ch = this.source.charAt(pos);
A0_G0_result[pos] = ch;
A0_G1_result[pos] = ch;
A1_G0_result[pos] = ch;
A1_G1_result[pos] = ch;
if (ch === "\\") {
if (pos + 1 < len) {
nextCh = this.source.charAt(pos + 1);
if (nextCh === "A") {
A0_G0_result[pos + 1] = "\uFFFF";
A0_G1_result[pos + 1] = "\uFFFF";
A1_G0_result[pos + 1] = "A";
A1_G1_result[pos + 1] = "A";
} else if (nextCh === "G") {
A0_G0_result[pos + 1] = "\uFFFF";
A0_G1_result[pos + 1] = "G";
A1_G0_result[pos + 1] = "\uFFFF";
A1_G1_result[pos + 1] = "G";
} else {
A0_G0_result[pos + 1] = nextCh;
A0_G1_result[pos + 1] = nextCh;
A1_G0_result[pos + 1] = nextCh;
A1_G1_result[pos + 1] = nextCh;
}
pos++;
}
}
}
return {
A0_G0: A0_G0_result.join(""),
A0_G1: A0_G1_result.join(""),
A1_G0: A1_G0_result.join(""),
A1_G1: A1_G1_result.join("")
};
};
RegExpSource2.prototype.resolveAnchors = function(allowA, allowG) {
if (!this.hasAnchor) {
return this.source;
}
if (allowA) {
if (allowG) {
return this._anchorCache.A1_G1;
} else {
return this._anchorCache.A1_G0;
}
} else {
if (allowG) {
return this._anchorCache.A0_G1;
} else {
return this._anchorCache.A0_G0;
}
}
};
return RegExpSource2;
}();
rule.RegExpSource = RegExpSource;
function createOnigScanner(sources) {
return new onigasm_1.OnigScanner(sources);
}
function createOnigString(sources) {
var r = new onigasm_1.OnigString(sources);
r.$str = sources;
return r;
}
rule.createOnigString = createOnigString;
function getString(str) {
return str.$str;
}
rule.getString = getString;
var RegExpSourceList = function() {
function RegExpSourceList2() {
this._items = [];
this._hasAnchors = false;
this._cached = null;
this._cachedSources = null;
this._anchorCache = {
A0_G0: null,
A0_G1: null,
A1_G0: null,
A1_G1: null
};
}
RegExpSourceList2.prototype.push = function(item) {
this._items.push(item);
this._hasAnchors = this._hasAnchors || item.hasAnchor;
};
RegExpSourceList2.prototype.unshift = function(item) {
this._items.unshift(item);
this._hasAnchors = this._hasAnchors || item.hasAnchor;
};
RegExpSourceList2.prototype.length = function() {
return this._items.length;
};
RegExpSourceList2.prototype.setSource = function(index, newSource) {
if (this._items[index].source !== newSource) {
this._cached = null;
this._anchorCache.A0_G0 = null;
this._anchorCache.A0_G1 = null;
this._anchorCache.A1_G0 = null;
this._anchorCache.A1_G1 = null;
this._items[index].setSource(newSource);
}
};
RegExpSourceList2.prototype.compile = function(grammar2, allowA, allowG) {
if (!this._hasAnchors) {
if (!this._cached) {
var regExps = this._items.map(function(e4) {
return e4.source;
});
this._cached = {
scanner: createOnigScanner(regExps),
rules: this._items.map(function(e4) {
return e4.ruleId;
}),
debugRegExps: regExps
};
}
return this._cached;
} else {
this._anchorCache = {
A0_G0: this._anchorCache.A0_G0 || (allowA === false && allowG === false ? this._resolveAnchors(allowA, allowG) : null),
A0_G1: this._anchorCache.A0_G1 || (allowA === false && allowG === true ? this._resolveAnchors(allowA, allowG) : null),
A1_G0: this._anchorCache.A1_G0 || (allowA === true && allowG === false ? this._resolveAnchors(allowA, allowG) : null),
A1_G1: this._anchorCache.A1_G1 || (allowA === true && allowG === true ? this._resolveAnchors(allowA, allowG) : null)
};
if (allowA) {
if (allowG) {
return this._anchorCache.A1_G1;
} else {
return this._anchorCache.A1_G0;
}
} else {
if (allowG) {
return this._anchorCache.A0_G1;
} else {
return this._anchorCache.A0_G0;
}
}
}
};
RegExpSourceList2.prototype._resolveAnchors = function(allowA, allowG) {
var regExps = this._items.map(function(e4) {
return e4.resolveAnchors(allowA, allowG);
});
return {
scanner: createOnigScanner(regExps),
rules: this._items.map(function(e4) {
return e4.ruleId;
}),
debugRegExps: regExps
};
};
return RegExpSourceList2;
}();
rule.RegExpSourceList = RegExpSourceList;
var MatchRule = function(_super) {
__extends(MatchRule2, _super);
function MatchRule2($location, id, name, match, captures) {
var _this = _super.call(this, $location, id, name, null) || this;
_this._match = new RegExpSource(match, _this.id);
_this.captures = captures;
_this._cachedCompiledPatterns = null;
return _this;
}
Object.defineProperty(MatchRule2.prototype, "debugMatchRegExp", {
get: function() {
return "" + this._match.source;
},
enumerable: true,
configurable: true
});
MatchRule2.prototype.collectPatternsRecursive = function(grammar2, out, isFirst) {
out.push(this._match);
};
MatchRule2.prototype.compile = function(grammar2, endRegexSource, allowA, allowG) {
if (!this._cachedCompiledPatterns) {
this._cachedCompiledPatterns = new RegExpSourceList();
this.collectPatternsRecursive(grammar2, this._cachedCompiledPatterns, true);
}
return this._cachedCompiledPatterns.compile(grammar2, allowA, allowG);
};
return MatchRule2;
}(Rule);
rule.MatchRule = MatchRule;
var IncludeOnlyRule = function(_super) {
__extends(IncludeOnlyRule2, _super);
function IncludeOnlyRule2($location, id, name, contentName, patterns) {
var _this = _super.call(this, $location, id, name, contentName) || this;
_this.patterns = patterns.patterns;
_this.hasMissingPatterns = patterns.hasMissingPatterns;
_this._cachedCompiledPatterns = null;
return _this;
}
IncludeOnlyRule2.prototype.collectPatternsRecursive = function(grammar2, out, isFirst) {
var i, len, rule2;
for (i = 0, len = this.patterns.length; i < len; i++) {
rule2 = grammar2.getRule(this.patterns[i]);
rule2.collectPatternsRecursive(grammar2, out, false);
}
};
IncludeOnlyRule2.prototype.compile = function(grammar2, endRegexSource, allowA, allowG) {
if (!this._cachedCompiledPatterns) {
this._cachedCompiledPatterns = new RegExpSourceList();
this.collectPatternsRecursive(grammar2, this._cachedCompiledPatterns, true);
}
return this._cachedCompiledPatterns.compile(grammar2, allowA, allowG);
};
return IncludeOnlyRule2;
}(Rule);
rule.IncludeOnlyRule = IncludeOnlyRule;
function escapeRegExpCharacters(value) {
return value.replace(/[\-\\\{\}\*\+\?\|\^\$\.\,\[\]\(\)\#\s]/g, "\\$&");
}
var BeginEndRule = function(_super) {
__extends(BeginEndRule2, _super);
function BeginEndRule2($location, id, name, contentName, begin, beginCaptures, end, endCaptures, applyEndPatternLast, patterns) {
var _this = _super.call(this, $location, id, name, contentName) || this;
_this._begin = new RegExpSource(begin, _this.id);
_this.beginCaptures = beginCaptures;
_this._end = new RegExpSource(end, -1);
_this.endHasBackReferences = _this._end.hasBackReferences;
_this.endCaptures = endCaptures;
_this.applyEndPatternLast = applyEndPatternLast || false;
_this.patterns = patterns.patterns;
_this.hasMissingPatterns = patterns.hasMissingPatterns;
_this._cachedCompiledPatterns = null;
return _this;
}
Object.defineProperty(BeginEndRule2.prototype, "debugBeginRegExp", {
get: function() {
return "" + this._begin.source;
},
enumerable: true,
configurable: true
});
Object.defineProperty(BeginEndRule2.prototype, "debugEndRegExp", {
get: function() {
return "" + this._end.source;
},
enumerable: true,
configurable: true
});
BeginEndRule2.prototype.getEndWithResolvedBackReferences = function(lineText, captureIndices) {
return this._end.resolveBackReferences(lineText, captureIndices);
};
BeginEndRule2.prototype.collectPatternsRecursive = function(grammar2, out, isFirst) {
if (isFirst) {
var i = void 0, len = void 0, rule2 = void 0;
for (i = 0, len = this.patterns.length; i < len; i++) {
rule2 = grammar2.getRule(this.patterns[i]);
rule2.collectPatternsRecursive(grammar2, out, false);
}
} else {
out.push(this._begin);
}
};
BeginEndRule2.prototype.compile = function(grammar2, endRegexSource, allowA, allowG) {
var precompiled = this._precompile(grammar2);
if (this._end.hasBackReferences) {
if (this.applyEndPatternLast) {
precompiled.setSource(precompiled.length() - 1, endRegexSource);
} else {
precompiled.setSource(0, endRegexSource);
}
}
return this._cachedCompiledPatterns.compile(grammar2, allowA, allowG);
};
BeginEndRule2.prototype._precompile = function(grammar2) {
if (!this._cachedCompiledPatterns) {
this._cachedCompiledPatterns = new RegExpSourceList();
this.collectPatternsRecursive(grammar2, this._cachedCompiledPatterns, true);
if (this.applyEndPatternLast) {
this._cachedCompiledPatterns.push(this._end.hasBackReferences ? this._end.clone() : this._end);
} else {
this._cachedCompiledPatterns.unshift(this._end.hasBackReferences ? this._end.clone() : this._end);
}
}
return this._cachedCompiledPatterns;
};
return BeginEndRule2;
}(Rule);
rule.BeginEndRule = BeginEndRule;
var BeginWhileRule = function(_super) {
__extends(BeginWhileRule2, _super);
function BeginWhileRule2($location, id, name, contentName, begin, beginCaptures, _while, whileCaptures, patterns) {
var _this = _super.call(this, $location, id, name, contentName) || this;
_this._begin = new RegExpSource(begin, _this.id);
_this.beginCaptures = beginCaptures;
_this.whileCaptures = whileCaptures;
_this._while = new RegExpSource(_while, -2);
_this.whileHasBackReferences = _this._while.hasBackReferences;
_this.patterns = patterns.patterns;
_this.hasMissingPatterns = patterns.hasMissingPatterns;
_this._cachedCompiledPatterns = null;
_this._cachedCompiledWhilePatterns = null;
return _this;
}
BeginWhileRule2.prototype.getWhileWithResolvedBackReferences = function(lineText, captureIndices) {
return this._while.resolveBackReferences(lineText, captureIndices);
};
BeginWhileRule2.prototype.collectPatternsRecursive = function(grammar2, out, isFirst) {
if (isFirst) {
var i = void 0, len = void 0, rule2 = void 0;
for (i = 0, len = this.patterns.length; i < len; i++) {
rule2 = grammar2.getRule(this.patterns[i]);
rule2.collectPatternsRecursive(grammar2, out, false);
}
} else {
out.push(this._begin);
}
};
BeginWhileRule2.prototype.compile = function(grammar2, endRegexSource, allowA, allowG) {
this._precompile(grammar2);
return this._cachedCompiledPatterns.compile(grammar2, allowA, allowG);
};
BeginWhileRule2.prototype._precompile = function(grammar2) {
if (!this._cachedCompiledPatterns) {
this._cachedCompiledPatterns = new RegExpSourceList();
this.collectPatternsRecursive(grammar2, this._cachedCompiledPatterns, true);
}
};
BeginWhileRule2.prototype.compileWhile = function(grammar2, endRegexSource, allowA, allowG) {
this._precompileWhile(grammar2);
if (this._while.hasBackReferences) {
this._cachedCompiledWhilePatterns.setSource(0, endRegexSource);
}
return this._cachedCompiledWhilePatterns.compile(grammar2, allowA, allowG);
};
BeginWhileRule2.prototype._precompileWhile = function(grammar2) {
if (!this._cachedCompiledWhilePatterns) {
this._cachedCompiledWhilePatterns = new RegExpSourceList();
this._cachedCompiledWhilePatterns.push(this._while.hasBackReferences ? this._while.clone() : this._while);
}
};
return BeginWhileRule2;
}(Rule);
rule.BeginWhileRule = BeginWhileRule;
var RuleFactory = function() {
function RuleFactory2() {
}
RuleFactory2.createCaptureRule = function(helper, $location, name, contentName, retokenizeCapturedWithRuleId) {
return helper.registerRule(function(id) {
return new CaptureRule($location, id, name, contentName, retokenizeCapturedWithRuleId);
});
};
RuleFactory2.getCompiledRuleId = function(desc, helper, repository) {
if (!desc.id) {
helper.registerRule(function(id) {
desc.id = id;
if (desc.match) {
return new MatchRule(desc.$vscodeTextmateLocation, desc.id, desc.name, desc.match, RuleFactory2._compileCaptures(desc.captures, helper, repository));
}
if (!desc.begin) {
if (desc.repository) {
repository = utils_1$1.mergeObjects({}, repository, desc.repository);
}
return new IncludeOnlyRule(desc.$vscodeTextmateLocation, desc.id, desc.name, desc.contentName, RuleFactory2._compilePatterns(desc.patterns, helper, repository));
}
if (desc.while) {
return new BeginWhileRule(desc.$vscodeTextmateLocation, desc.id, desc.name, desc.contentName, desc.begin, RuleFactory2._compileCaptures(desc.beginCaptures || desc.captures, helper, repository), desc.while, RuleFactory2._compileCaptures(desc.whileCaptures || desc.captures, helper, repository), RuleFactory2._compilePatterns(desc.patterns, helper, repository));
}
return new BeginEndRule(desc.$vscodeTextmateLocation, desc.id, desc.name, desc.contentName, desc.begin, RuleFactory2._compileCaptures(desc.beginCaptures || desc.captures, helper, repository), desc.end, RuleFactory2._compileCaptures(desc.endCaptures || desc.captures, helper, repository), desc.applyEndPatternLast, RuleFactory2._compilePatterns(desc.patterns, helper, repository));
});
}
return desc.id;
};
RuleFactory2._compileCaptures = function(captures, helper, repository) {
var r = [], numericCaptureId, maximumCaptureId, i, captureId;
if (captures) {
maximumCaptureId = 0;
for (captureId in captures) {
if (captureId === "$vscodeTextmateLocation") {
continue;
}
numericCaptureId = parseInt(captureId, 10);
if (numericCaptureId > maximumCaptureId) {
maximumCaptureId = numericCaptureId;
}
}
for (i = 0; i <= maximumCaptureId; i++) {
r[i] = null;
}
for (captureId in captures) {
if (captureId === "$vscodeTextmateLocation") {
continue;
}
numericCaptureId = parseInt(captureId, 10);
var retokenizeCapturedWithRuleId = 0;
if (captures[captureId].patterns) {
retokenizeCapturedWithRuleId = RuleFactory2.getCompiledRuleId(captures[captureId], helper, repository);
}
r[numericCaptureId] = RuleFactory2.createCaptureRule(helper, captures[captureId].$vscodeTextmateLocation, captures[captureId].name, captures[captureId].contentName, retokenizeCapturedWithRuleId);
}
}
return r;
};
RuleFactory2._compilePatterns = function(patterns, helper, repository) {
var r = [], pattern, i, len, patternId, externalGrammar, rule2, skipRule;
if (patterns) {
for (i = 0, len = patterns.length; i < len; i++) {
pattern = patterns[i];
patternId = -1;
if (pattern.include) {
if (pattern.include.charAt(0) === "#") {
var localIncludedRule = repository[pattern.include.substr(1)];
if (localIncludedRule) {
patternId = RuleFactory2.getCompiledRuleId(localIncludedRule, helper, repository);
}
} else if (pattern.include === "$base" || pattern.include === "$self") {
patternId = RuleFactory2.getCompiledRuleId(repository[pattern.include], helper, repository);
} else {
var externalGrammarName = null, externalGrammarInclude = null, sharpIndex = pattern.include.indexOf("#");
if (sharpIndex >= 0) {
externalGrammarName = pattern.include.substring(0, sharpIndex);
externalGrammarInclude = pattern.include.substring(sharpIndex + 1);
} else {
externalGrammarName = pattern.include;
}
externalGrammar = helper.getExternalGrammar(externalGrammarName, repository);
if (externalGrammar) {
if (externalGrammarInclude) {
var externalIncludedRule = externalGrammar.repository[externalGrammarInclude];
if (externalIncludedRule) {
patternId = RuleFactory2.getCompiledRuleId(externalIncludedRule, helper, externalGrammar.repository);
}
} else {
patternId = RuleFactory2.getCompiledRuleId(externalGrammar.repository.$self, helper, externalGrammar.repository);
}
}
}
} else {
patternId = RuleFactory2.getCompiledRuleId(pattern, helper, repository);
}
if (patternId !== -1) {
rule2 = helper.getRule(patternId);
skipRule = false;
if (rule2 instanceof IncludeOnlyRule || rule2 instanceof BeginEndRule || rule2 instanceof BeginWhileRule) {
if (rule2.hasMissingPatterns && rule2.patterns.length === 0) {
skipRule = true;
}
}
if (skipRule) {
continue;
}
r.push(patternId);
}
}
}
return {
patterns: r,
hasMissingPatterns: (patterns ? patterns.length : 0) !== r.length
};
};
return RuleFactory2;
}();
rule.RuleFactory = RuleFactory;
var matcher = {};
Object.defineProperty(matcher, "__esModule", { value: true });
function createMatchers(selector, matchesName) {
var results = [];
var tokenizer = newTokenizer(selector);
var token = tokenizer.next();
while (token !== null) {
var priority = 0;
if (token.length === 2 && token.charAt(1) === ":") {
switch (token.charAt(0)) {
case "R":
priority = 1;
break;
case "L":
priority = -1;
break;
default:
console.log("Unknown priority " + token + " in scope selector");
}
token = tokenizer.next();
}
var matcher2 = parseConjunction();
if (matcher2) {
results.push({ matcher: matcher2, priority });
}
if (token !== ",") {
break;
}
token = tokenizer.next();
}
return results;
function parseOperand() {
if (token === "-") {
token = tokenizer.next();
var expressionToNegate = parseOperand();
return function(matcherInput) {
return expressionToNegate && !expressionToNegate(matcherInput);
};
}
if (token === "(") {
token = tokenizer.next();
var expressionInParents = parseInnerExpression();
if (token === ")") {
token = tokenizer.next();
}
return expressionInParents;
}
if (isIdentifier(token)) {
var identifiers = [];
do {
identifiers.push(token);
token = tokenizer.next();
} while (isIdentifier(token));
return function(matcherInput) {
return matchesName(identifiers, matcherInput);
};
}
return null;
}
function parseConjunction() {
var matchers = [];
var matcher3 = parseOperand();
while (matcher3) {
matchers.push(matcher3);
matcher3 = parseOperand();
}
return function(matcherInput) {
return matchers.every(function(matcher4) {
return matcher4(matcherInput);
});
};
}
function parseInnerExpression() {
var matchers = [];
var matcher3 = parseConjunction();
while (matcher3) {
matchers.push(matcher3);
if (token === "|" || token === ",") {
do {
token = tokenizer.next();
} while (token === "|" || token === ",");
} else {
break;
}
matcher3 = parseConjunction();
}
return function(matcherInput) {
return matchers.some(function(matcher4) {
return matcher4(matcherInput);
});
};
}
}
matcher.createMatchers = createMatchers;
function isIdentifier(token) {
return token && token.match(/[\w\.:]+/);
}
function newTokenizer(input) {
var regex = /([LR]:|[\w\.:][\w\.:\-]*|[\,\|\-\(\)])/g;
var match = regex.exec(input);
return {
next: function() {
if (!match) {
return null;
}
var res = match[0];
match = regex.exec(input);
return res;
}
};
}
var debug = {};
Object.defineProperty(debug, "__esModule", { value: true });
debug.CAPTURE_METADATA = typeof process === "undefined" ? false : !!process.env["VSCODE_TEXTMATE_DEBUG"];
debug.IN_DEBUG_MODE = typeof process === "undefined" ? false : !!process.env["VSCODE_TEXTMATE_DEBUG"];
Object.defineProperty(grammar, "__esModule", { value: true });
var utils_1 = utils;
var rule_1 = rule;
var matcher_1 = matcher;
var debug_1$1 = debug;
function createGrammar(grammar2, initialLanguage, embeddedLanguages, tokenTypes, grammarRepository) {
return new Grammar(grammar2, initialLanguage, embeddedLanguages, tokenTypes, grammarRepository);
}
grammar.createGrammar = createGrammar;
function _extractIncludedScopesInPatterns(result, patterns) {
for (var i = 0, len = patterns.length; i < len; i++) {
if (Array.isArray(patterns[i].patterns)) {
_extractIncludedScopesInPatterns(result, patterns[i].patterns);
}
var include = patterns[i].include;
if (!include) {
continue;
}
if (include === "$base" || include === "$self") {
continue;
}
if (include.charAt(0) === "#") {
continue;
}
var sharpIndex = include.indexOf("#");
if (sharpIndex >= 0) {
result[include.substring(0, sharpIndex)] = true;
} else {
result[include] = true;
}
}
}
function _extractIncludedScopesInRepository(result, repository) {
for (var name in repository) {
var rule2 = repository[name];
if (rule2.patterns && Array.isArray(rule2.patterns)) {
_extractIncludedScopesInPatterns(result, rule2.patterns);
}
if (rule2.repository) {
_extractIncludedScopesInRepository(result, rule2.repository);
}
}
}
function collectIncludedScopes(result, grammar2) {
if (grammar2.patterns && Array.isArray(grammar2.patterns)) {
_extractIncludedScopesInPatterns(result, grammar2.patterns);
}
if (grammar2.repository) {
_extractIncludedScopesInRepository(result, grammar2.repository);
}
delete result[grammar2.scopeName];
}
grammar.collectIncludedScopes = collectIncludedScopes;
function scopesAreMatching(thisScopeName, scopeName) {
if (!thisScopeName) {
return false;
}
if (thisScopeName === scopeName) {
return true;
}
var len = scopeName.length;
return thisScopeName.length > len && thisScopeName.substr(0, len) === scopeName && thisScopeName[len] === ".";
}
function nameMatcher(identifers, scopes) {
if (scopes.length < identifers.length) {
return false;
}
var lastIndex = 0;
return identifers.every(function(identifier) {
for (var i = lastIndex; i < scopes.length; i++) {
if (scopesAreMatching(scopes[i], identifier)) {
lastIndex = i + 1;
return true;
}
}
return false;
});
}
function collectInjections(result, selector, rule2, ruleFactoryHelper, grammar2) {
var matchers = matcher_1.createMatchers(selector, nameMatcher);
var ruleId = rule_1.RuleFactory.getCompiledRuleId(rule2, ruleFactoryHelper, grammar2.repository);
for (var _i2 = 0, matchers_1 = matchers; _i2 < matchers_1.length; _i2++) {
var matcher2 = matchers_1[_i2];
result.push({
matcher: matcher2.matcher,
ruleId,
grammar: grammar2,
priority: matcher2.priority
});
}
}
var ScopeMetadata = function() {
function ScopeMetadata2(scopeName, languageId, tokenType, themeData) {
this.scopeName = scopeName;
this.languageId = languageId;
this.tokenType = tokenType;
this.themeData = themeData;
}
return ScopeMetadata2;
}();
grammar.ScopeMetadata = ScopeMetadata;
var ScopeMetadataProvider = function() {
function ScopeMetadataProvider2(initialLanguage, themeProvider, embeddedLanguages) {
this._initialLanguage = initialLanguage;
this._themeProvider = themeProvider;
this.onDidChangeTheme();
this._embeddedLanguages = /* @__PURE__ */ Object.create(null);
if (embeddedLanguages) {
var scopes = Object.keys(embeddedLanguages);
for (var i = 0, len = scopes.length; i < len; i++) {
var scope = scopes[i];
var language = embeddedLanguages[scope];
if (typeof language !== "number" || language === 0) {
console.warn("Invalid embedded language found at scope " + scope + ": <<" + language + ">>");
continue;
}
this._embeddedLanguages[scope] = language;
}
}
var escapedScopes = Object.keys(this._embeddedLanguages).map(function(scopeName) {
return ScopeMetadataProvider2._escapeRegExpCharacters(scopeName);
});
if (escapedScopes.length === 0) {
this._embeddedLanguagesRegex = null;
} else {
escapedScopes.sort();
escapedScopes.reverse();
this._embeddedLanguagesRegex = new RegExp("^((" + escapedScopes.join(")|(") + "))($|\\.)", "");
}
}
ScopeMetadataProvider2.prototype.onDidChangeTheme = function() {
this._cache = /* @__PURE__ */ Object.create(null);
this._defaultMetaData = new ScopeMetadata("", this._initialLanguage, 0, [this._themeProvider.getDefaults()]);
};
ScopeMetadataProvider2.prototype.getDefaultMetadata = function() {
return this._defaultMetaData;
};
ScopeMetadataProvider2._escapeRegExpCharacters = function(value) {
return value.replace(/[\-\\\{\}\*\+\?\|\^\$\.\,\[\]\(\)\#\s]/g, "\\$&");
};
ScopeMetadataProvider2.prototype.getMetadataForScope = function(scopeName) {
if (scopeName === null) {
return ScopeMetadataProvider2._NULL_SCOPE_METADATA;
}
var value = this._cache[scopeName];
if (value) {
return value;
}
value = this._doGetMetadataForScope(scopeName);
this._cache[scopeName] = value;
return value;
};
ScopeMetadataProvider2.prototype._doGetMetadataForScope = function(scopeName) {
var languageId = this._scopeToLanguage(scopeName);
var standardTokenType = this._toStandardTokenType(scopeName);
var themeData = this._themeProvider.themeMatch(scopeName);
return new ScopeMetadata(scopeName, languageId, standardTokenType, themeData);
};
ScopeMetadataProvider2.prototype._scopeToLanguage = function(scope) {
if (!scope) {
return 0;
}
if (!this._embeddedLanguagesRegex) {
return 0;
}
var m = scope.match(this._embeddedLanguagesRegex);
if (!m) {
return 0;
}
var language = this._embeddedLanguages[m[1]] || 0;
if (!language) {
return 0;
}
return language;
};
ScopeMetadataProvider2.prototype._toStandardTokenType = function(tokenType) {
var m = tokenType.match(ScopeMetadataProvider2.STANDARD_TOKEN_TYPE_REGEXP);
if (!m) {
return 0;
}
switch (m[1]) {
case "comment":
return 1;
case "string":
return 2;
case "regex":
return 4;
case "meta.embedded":
return 8;
}
throw new Error("Unexpected match for standard token type!");
};
ScopeMetadataProvider2._NULL_SCOPE_METADATA = new ScopeMetadata("", 0, 0, null);
ScopeMetadataProvider2.STANDARD_TOKEN_TYPE_REGEXP = /\b(comment|string|regex|meta\.embedded)\b/;
return ScopeMetadataProvider2;
}();
var Grammar = function() {
function Grammar2(grammar2, initialLanguage, embeddedLanguages, tokenTypes, grammarRepository) {
this._scopeMetadataProvider = new ScopeMetadataProvider(initialLanguage, grammarRepository, embeddedLanguages);
this._rootId = -1;
this._lastRuleId = 0;
this._ruleId2desc = [];
this._includedGrammars = {};
this._grammarRepository = grammarRepository;
this._grammar = initGrammar(grammar2, null);
this._tokenTypeMatchers = [];
if (tokenTypes) {
for (var _i2 = 0, _a2 = Object.keys(tokenTypes); _i2 < _a2.length; _i2++) {
var selector = _a2[_i2];
var matchers = matcher_1.createMatchers(selector, nameMatcher);
for (var _b2 = 0, matchers_2 = matchers; _b2 < matchers_2.length; _b2++) {
var matcher2 = matchers_2[_b2];
this._tokenTypeMatchers.push({
matcher: matcher2.matcher,
type: tokenTypes[selector]
});
}
}
}
}
Grammar2.prototype.onDidChangeTheme = function() {
this._scopeMetadataProvider.onDidChangeTheme();
};
Grammar2.prototype.getMetadataForScope = function(scope) {
return this._scopeMetadataProvider.getMetadataForScope(scope);
};
Grammar2.prototype.getInjections = function() {
var _this = this;
if (!this._injections) {
this._injections = [];
var rawInjections = this._grammar.injections;
if (rawInjections) {
for (var expression in rawInjections) {
collectInjections(this._injections, expression, rawInjections[expression], this, this._grammar);
}
}
if (this._grammarRepository) {
var injectionScopeNames = this._grammarRepository.injections(this._grammar.scopeName);
if (injectionScopeNames) {
injectionScopeNames.forEach(function(injectionScopeName) {
var injectionGrammar = _this.getExternalGrammar(injectionScopeName);
if (injectionGrammar) {
var selector = injectionGrammar.injectionSelector;
if (selector) {
collectInjections(_this._injections, selector, injectionGrammar, _this, injectionGrammar);
}
}
});
}
}
this._injections.sort(function(i1, i2) {
return i1.priority - i2.priority;
});
}
if (this._injections.length === 0) {
return this._injections;
}
return this._injections;
};
Grammar2.prototype.registerRule = function(factory) {
var id = ++this._lastRuleId;
var result = factory(id);
this._ruleId2desc[id] = result;
return result;
};
Grammar2.prototype.getRule = function(patternId) {
return this._ruleId2desc[patternId];
};
Grammar2.prototype.getExternalGrammar = function(scopeName, repository) {
if (this._includedGrammars[scopeName]) {
return this._includedGrammars[scopeName];
} else if (this._grammarRepository) {
var rawIncludedGrammar = this._grammarRepository.lookup(scopeName);
if (rawIncludedGrammar) {
this._includedGrammars[scopeName] = initGrammar(rawIncludedGrammar, repository && repository.$base);
return this._includedGrammars[scopeName];
}
}
};
Grammar2.prototype.tokenizeLine = function(lineText, prevState) {
var r = this._tokenize(lineText, prevState, false);
return {
tokens: r.lineTokens.getResult(r.ruleStack, r.lineLength),
ruleStack: r.ruleStack
};
};
Grammar2.prototype.tokenizeLine2 = function(lineText, prevState) {
var r = this._tokenize(lineText, prevState, true);
return {
tokens: r.lineTokens.getBinaryResult(r.ruleStack, r.lineLength),
ruleStack: r.ruleStack
};
};
Grammar2.prototype._tokenize = function(lineText, prevState, emitBinaryTokens) {
if (this._rootId === -1) {
this._rootId = rule_1.RuleFactory.getCompiledRuleId(this._grammar.repository.$self, this, this._grammar.repository);
}
var isFirstLine;
if (!prevState || prevState === StackElement.NULL) {
isFirstLine = true;
var rawDefaultMetadata = this._scopeMetadataProvider.getDefaultMetadata();
var defaultTheme = rawDefaultMetadata.themeData[0];
var defaultMetadata = StackElementMetadata.set(0, rawDefaultMetadata.languageId, rawDefaultMetadata.tokenType, defaultTheme.fontStyle, defaultTheme.foreground, defaultTheme.background);
var rootScopeName = this.getRule(this._rootId).getName(null, null);
var rawRootMetadata = this._scopeMetadataProvider.getMetadataForScope(rootScopeName);
var rootMetadata = ScopeListElement.mergeMetadata(defaultMetadata, null, rawRootMetadata);
var scopeList = new ScopeListElement(null, rootScopeName, rootMetadata);
prevState = new StackElement(null, this._rootId, -1, null, scopeList, scopeList);
} else {
isFirstLine = false;
prevState.reset();
}
lineText = lineText + "\n";
var onigLineText = rule_1.createOnigString(lineText);
var lineLength = rule_1.getString(onigLineText).length;
var lineTokens = new LineTokens(emitBinaryTokens, lineText, this._tokenTypeMatchers);
var nextState = _tokenizeString(this, onigLineText, isFirstLine, 0, prevState, lineTokens);
return {
lineLength,
lineTokens,
ruleStack: nextState
};
};
return Grammar2;
}();
grammar.Grammar = Grammar;
function initGrammar(grammar2, base) {
grammar2 = utils_1.clone(grammar2);
grammar2.repository = grammar2.repository || {};
grammar2.repository.$self = {
$vscodeTextmateLocation: grammar2.$vscodeTextmateLocation,
patterns: grammar2.patterns,
name: grammar2.scopeName
};
grammar2.repository.$base = base || grammar2.repository.$self;
return grammar2;
}
function handleCaptures(grammar2, lineText, isFirstLine, stack, lineTokens, captures, captureIndices) {
if (captures.length === 0) {
return;
}
var len = Math.min(captures.length, captureIndices.length);
var localStack = [];
var maxEnd = captureIndices[0].end;
for (var i = 0; i < len; i++) {
var captureRule = captures[i];
if (captureRule === null) {
continue;
}
var captureIndex = captureIndices[i];
if (captureIndex.length === 0) {
continue;
}
if (captureIndex.start > maxEnd) {
break;
}
while (localStack.length > 0 && localStack[localStack.length - 1].endPos <= captureIndex.start) {
lineTokens.produceFromScopes(localStack[localStack.length - 1].scopes, localStack[localStack.length - 1].endPos);
localStack.pop();
}
if (localStack.length > 0) {
lineTokens.produceFromScopes(localStack[localStack.length - 1].scopes, captureIndex.start);
} else {
lineTokens.produce(stack, captureIndex.start);
}
if (captureRule.retokenizeCapturedWithRuleId) {
var scopeName = captureRule.getName(rule_1.getString(lineText), captureIndices);
var nameScopesList = stack.contentNameScopesList.push(grammar2, scopeName);
var contentName = captureRule.getContentName(rule_1.getString(lineText), captureIndices);
var contentNameScopesList = nameScopesList.push(grammar2, contentName);
var stackClone = stack.push(captureRule.retokenizeCapturedWithRuleId, captureIndex.start, null, nameScopesList, contentNameScopesList);
_tokenizeString(grammar2, rule_1.createOnigString(rule_1.getString(lineText).substring(0, captureIndex.end)), isFirstLine && captureIndex.start === 0, captureIndex.start, stackClone, lineTokens);
continue;
}
var captureRuleScopeName = captureRule.getName(rule_1.getString(lineText), captureIndices);
if (captureRuleScopeName !== null) {
var base = localStack.length > 0 ? localStack[localStack.length - 1].scopes : stack.contentNameScopesList;
var captureRuleScopesList = base.push(grammar2, captureRuleScopeName);
localStack.push(new LocalStackElement(captureRuleScopesList, captureIndex.end));
}
}
while (localStack.length > 0) {
lineTokens.produceFromScopes(localStack[localStack.length - 1].scopes, localStack[localStack.length - 1].endPos);
localStack.pop();
}
}
function debugCompiledRuleToString(ruleScanner) {
var r = [];
for (var i = 0, len = ruleScanner.rules.length; i < len; i++) {
r.push(" - " + ruleScanner.rules[i] + ": " + ruleScanner.debugRegExps[i]);
}
return r.join("\n");
}
function matchInjections(injections, grammar2, lineText, isFirstLine, linePos, stack, anchorPosition) {
var bestMatchRating = Number.MAX_VALUE;
var bestMatchCaptureIndices = null;
var bestMatchRuleId;
var bestMatchResultPriority = 0;
var scopes = stack.contentNameScopesList.generateScopes();
for (var i = 0, len = injections.length; i < len; i++) {
var injection = injections[i];
if (!injection.matcher(scopes)) {
continue;
}
var ruleScanner = grammar2.getRule(injection.ruleId).compile(grammar2, null, isFirstLine, linePos === anchorPosition);
var matchResult = ruleScanner.scanner.findNextMatchSync(lineText, linePos);
if (debug_1$1.IN_DEBUG_MODE) {
console.log(" scanning for injections");
console.log(debugCompiledRuleToString(ruleScanner));
}
if (!matchResult) {
continue;
}
var matchRating = matchResult.captureIndices[0].start;
if (matchRating >= bestMatchRating) {
continue;
}
bestMatchRating = matchRating;
bestMatchCaptureIndices = matchResult.captureIndices;
bestMatchRuleId = ruleScanner.rules[matchResult.index];
bestMatchResultPriority = injection.priority;
if (bestMatchRating === linePos) {
break;
}
}
if (bestMatchCaptureIndices) {
return {
priorityMatch: bestMatchResultPriority === -1,
captureIndices: bestMatchCaptureIndices,
matchedRuleId: bestMatchRuleId
};
}
return null;
}
function matchRule(grammar2, lineText, isFirstLine, linePos, stack, anchorPosition) {
var rule2 = stack.getRule(grammar2);
var ruleScanner = rule2.compile(grammar2, stack.endRule, isFirstLine, linePos === anchorPosition);
var r = ruleScanner.scanner.findNextMatchSync(lineText, linePos);
if (debug_1$1.IN_DEBUG_MODE) {
console.log(" scanning for");
console.log(debugCompiledRuleToString(ruleScanner));
}
if (r) {
return {
captureIndices: r.captureIndices,
matchedRuleId: ruleScanner.rules[r.index]
};
}
return null;
}
function matchRuleOrInjections(grammar2, lineText, isFirstLine, linePos, stack, anchorPosition) {
var matchResult = matchRule(grammar2, lineText, isFirstLine, linePos, stack, anchorPosition);
var injections = grammar2.getInjections();
if (injections.length === 0) {
return matchResult;
}
var injectionResult = matchInjections(injections, grammar2, lineText, isFirstLine, linePos, stack, anchorPosition);
if (!injectionResult) {
return matchResult;
}
if (!matchResult) {
return injectionResult;
}
var matchResultScore = matchResult.captureIndices[0].start;
var injectionResultScore = injectionResult.captureIndices[0].start;
if (injectionResultScore < matchResultScore || injectionResult.priorityMatch && injectionResultScore === matchResultScore) {
return injectionResult;
}
return matchResult;
}
function _checkWhileConditions(grammar2, lineText, isFirstLine, linePos, stack, lineTokens) {
var anchorPosition = -1;
var whileRules = [];
for (var node = stack; node; node = node.pop()) {
var nodeRule = node.getRule(grammar2);
if (nodeRule instanceof rule_1.BeginWhileRule) {
whileRules.push({
rule: nodeRule,
stack: node
});
}
}
for (var whileRule = whileRules.pop(); whileRule; whileRule = whileRules.pop()) {
var ruleScanner = whileRule.rule.compileWhile(grammar2, whileRule.stack.endRule, isFirstLine, anchorPosition === linePos);
var r = ruleScanner.scanner.findNextMatchSync(lineText, linePos);
if (debug_1$1.IN_DEBUG_MODE) {
console.log(" scanning for while rule");
console.log(debugCompiledRuleToString(ruleScanner));
}
if (r) {
var matchedRuleId = ruleScanner.rules[r.index];
if (matchedRuleId !== -2) {
stack = whileRule.stack.pop();
break;
}
if (r.captureIndices && r.captureIndices.length) {
lineTokens.produce(whileRule.stack, r.captureIndices[0].start);
handleCaptures(grammar2, lineText, isFirstLine, whileRule.stack, lineTokens, whileRule.rule.whileCaptures, r.captureIndices);
lineTokens.produce(whileRule.stack, r.captureIndices[0].end);
anchorPosition = r.captureIndices[0].end;
if (r.captureIndices[0].end > linePos) {
linePos = r.captureIndices[0].end;
isFirstLine = false;
}
}
} else {
stack = whileRule.stack.pop();
break;
}
}
return { stack, linePos, anchorPosition, isFirstLine };
}
function _tokenizeString(grammar2, lineText, isFirstLine, linePos, stack, lineTokens) {
var lineLength = rule_1.getString(lineText).length;
var STOP = false;
var whileCheckResult = _checkWhileConditions(grammar2, lineText, isFirstLine, linePos, stack, lineTokens);
stack = whileCheckResult.stack;
linePos = whileCheckResult.linePos;
isFirstLine = whileCheckResult.isFirstLine;
var anchorPosition = whileCheckResult.anchorPosition;
while (!STOP) {
scanNext();
}
function scanNext() {
if (debug_1$1.IN_DEBUG_MODE) {
console.log("");
console.log("@@scanNext: |" + rule_1.getString(lineText).replace(/\n$/, "\\n").substr(linePos) + "|");
}
var r = matchRuleOrInjections(grammar2, lineText, isFirstLine, linePos, stack, anchorPosition);
if (!r) {
if (debug_1$1.IN_DEBUG_MODE) {
console.log(" no more matches.");
}
lineTokens.produce(stack, lineLength);
STOP = true;
return;
}
var captureIndices = r.captureIndices;
var matchedRuleId = r.matchedRuleId;
var hasAdvanced = captureIndices && captureIndices.length > 0 ? captureIndices[0].end > linePos : false;
if (matchedRuleId === -1) {
var poppedRule = stack.getRule(grammar2);
if (debug_1$1.IN_DEBUG_MODE) {
console.log(" popping " + poppedRule.debugName + " - " + poppedRule.debugEndRegExp);
}
lineTokens.produce(stack, captureIndices[0].start);
stack = stack.setContentNameScopesList(stack.nameScopesList);
handleCaptures(grammar2, lineText, isFirstLine, stack, lineTokens, poppedRule.endCaptures, captureIndices);
lineTokens.produce(stack, captureIndices[0].end);
var popped = stack;
stack = stack.pop();
if (!hasAdvanced && popped.getEnterPos() === linePos) {
console.error("[1] - Grammar is in an endless loop - Grammar pushed & popped a rule without advancing");
stack = popped;
lineTokens.produce(stack, lineLength);
STOP = true;
return;
}
} else {
var _rule = grammar2.getRule(matchedRuleId);
lineTokens.produce(stack, captureIndices[0].start);
var beforePush = stack;
var scopeName = _rule.getName(rule_1.getString(lineText), captureIndices);
var nameScopesList = stack.contentNameScopesList.push(grammar2, scopeName);
stack = stack.push(matchedRuleId, linePos, null, nameScopesList, nameScopesList);
if (_rule instanceof rule_1.BeginEndRule) {
var pushedRule = _rule;
if (debug_1$1.IN_DEBUG_MODE) {
console.log(" pushing " + pushedRule.debugName + " - " + pushedRule.debugBeginRegExp);
}
handleCaptures(grammar2, lineText, isFirstLine, stack, lineTokens, pushedRule.beginCaptures, captureIndices);
lineTokens.produce(stack, captureIndices[0].end);
anchorPosition = captureIndices[0].end;
var contentName = pushedRule.getContentName(rule_1.getString(lineText), captureIndices);
var contentNameScopesList = nameScopesList.push(grammar2, contentName);
stack = stack.setContentNameScopesList(contentNameScopesList);
if (pushedRule.endHasBackReferences) {
stack = stack.setEndRule(pushedRule.getEndWithResolvedBackReferences(rule_1.getString(lineText), captureIndices));
}
if (!hasAdvanced && beforePush.hasSameRuleAs(stack)) {
console.error("[2] - Grammar is in an endless loop - Grammar pushed the same rule without advancing");
stack = stack.pop();
lineTokens.produce(stack, lineLength);
STOP = true;
return;
}
} else if (_rule instanceof rule_1.BeginWhileRule) {
var pushedRule = _rule;
if (debug_1$1.IN_DEBUG_MODE) {
console.log(" pushing " + pushedRule.debugName);
}
handleCaptures(grammar2, lineText, isFirstLine, stack, lineTokens, pushedRule.beginCaptures, captureIndices);
lineTokens.produce(stack, captureIndices[0].end);
anchorPosition = captureIndices[0].end;
var contentName = pushedRule.getContentName(rule_1.getString(lineText), captureIndices);
var contentNameScopesList = nameScopesList.push(grammar2, contentName);
stack = stack.setContentNameScopesList(contentNameScopesList);
if (pushedRule.whileHasBackReferences) {
stack = stack.setEndRule(pushedRule.getWhileWithResolvedBackReferences(rule_1.getString(lineText), captureIndices));
}
if (!hasAdvanced && beforePush.hasSameRuleAs(stack)) {
console.error("[3] - Grammar is in an endless loop - Grammar pushed the same rule without advancing");
stack = stack.pop();
lineTokens.produce(stack, lineLength);
STOP = true;
return;
}
} else {
var matchingRule = _rule;
if (debug_1$1.IN_DEBUG_MODE) {
console.log(" matched " + matchingRule.debugName + " - " + matchingRule.debugMatchRegExp);
}
handleCaptures(grammar2, lineText, isFirstLine, stack, lineTokens, matchingRule.captures, captureIndices);
lineTokens.produce(stack, captureIndices[0].end);
stack = stack.pop();
if (!hasAdvanced) {
console.error("[4] - Grammar is in an endless loop - Grammar is not advancing, nor is it pushing/popping");
stack = stack.safePop();
lineTokens.produce(stack, lineLength);
STOP = true;
return;
}
}
}
if (captureIndices[0].end > linePos) {
linePos = captureIndices[0].end;
isFirstLine = false;
}
}
return stack;
}
var StackElementMetadata = function() {
function StackElementMetadata2() {
}
StackElementMetadata2.toBinaryStr = function(metadata) {
var r = metadata.toString(2);
while (r.length < 32) {
r = "0" + r;
}
return r;
};
StackElementMetadata2.printMetadata = function(metadata) {
var languageId = StackElementMetadata2.getLanguageId(metadata);
var tokenType = StackElementMetadata2.getTokenType(metadata);
var fontStyle = StackElementMetadata2.getFontStyle(metadata);
var foreground = StackElementMetadata2.getForeground(metadata);
var background = StackElementMetadata2.getBackground(metadata);
console.log({
languageId,
tokenType,
fontStyle,
foreground,
background
});
};
StackElementMetadata2.getLanguageId = function(metadata) {
return (metadata & 255) >>> 0;
};
StackElementMetadata2.getTokenType = function(metadata) {
return (metadata & 1792) >>> 8;
};
StackElementMetadata2.getFontStyle = function(metadata) {
return (metadata & 14336) >>> 11;
};
StackElementMetadata2.getForeground = function(metadata) {
return (metadata & 8372224) >>> 14;
};
StackElementMetadata2.getBackground = function(metadata) {
return (metadata & 4286578688) >>> 23;
};
StackElementMetadata2.set = function(metadata, languageId, tokenType, fontStyle, foreground, background) {
var _languageId = StackElementMetadata2.getLanguageId(metadata);
var _tokenType = StackElementMetadata2.getTokenType(metadata);
var _fontStyle = StackElementMetadata2.getFontStyle(metadata);
var _foreground = StackElementMetadata2.getForeground(metadata);
var _background = StackElementMetadata2.getBackground(metadata);
if (languageId !== 0) {
_languageId = languageId;
}
if (tokenType !== 0) {
_tokenType = tokenType === 8 ? 0 : tokenType;
}
if (fontStyle !== -1) {
_fontStyle = fontStyle;
}
if (foreground !== 0) {
_foreground = foreground;
}
if (background !== 0) {
_background = background;
}
return (_languageId << 0 | _tokenType << 8 | _fontStyle << 11 | _foreground << 14 | _background << 23) >>> 0;
};
return StackElementMetadata2;
}();
grammar.StackElementMetadata = StackElementMetadata;
var ScopeListElement = function() {
function ScopeListElement2(parent, scope, metadata) {
this.parent = parent;
this.scope = scope;
this.metadata = metadata;
}
ScopeListElement2._equals = function(a, b) {
do {
if (a === b) {
return true;
}
if (a.scope !== b.scope || a.metadata !== b.metadata) {
return false;
}
a = a.parent;
b = b.parent;
if (!a && !b) {
return true;
}
if (!a || !b) {
return false;
}
} while (true);
};
ScopeListElement2.prototype.equals = function(other) {
return ScopeListElement2._equals(this, other);
};
ScopeListElement2._matchesScope = function(scope, selector, selectorWithDot) {
return selector === scope || scope.substring(0, selectorWithDot.length) === selectorWithDot;
};
ScopeListElement2._matches = function(target, parentScopes) {
if (parentScopes === null) {
return true;
}
var len = parentScopes.length;
var index = 0;
var selector = parentScopes[index];
var selectorWithDot = selector + ".";
while (target) {
if (this._matchesScope(target.scope, selector, selectorWithDot)) {
index++;
if (index === len) {
return true;
}
selector = parentScopes[index];
selectorWithDot = selector + ".";
}
target = target.parent;
}
return false;
};
ScopeListElement2.mergeMetadata = function(metadata, scopesList, source) {
if (source === null) {
return metadata;
}
var fontStyle = -1;
var foreground = 0;
var background = 0;
if (source.themeData !== null) {
for (var i = 0, len = source.themeData.length; i < len; i++) {
var themeData = source.themeData[i];
if (this._matches(scopesList, themeData.parentScopes)) {
fontStyle = themeData.fontStyle;
foreground = themeData.foreground;
background = themeData.background;
break;
}
}
}
return StackElementMetadata.set(metadata, source.languageId, source.tokenType, fontStyle, foreground, background);
};
ScopeListElement2._push = function(target, grammar2, scopes) {
for (var i = 0, len = scopes.length; i < len; i++) {
var scope = scopes[i];
var rawMetadata = grammar2.getMetadataForScope(scope);
var metadata = ScopeListElement2.mergeMetadata(target.metadata, target, rawMetadata);
target = new ScopeListElement2(target, scope, metadata);
}
return target;
};
ScopeListElement2.prototype.push = function(grammar2, scope) {
if (scope === null) {
return this;
}
if (scope.indexOf(" ") >= 0) {
return ScopeListElement2._push(this, grammar2, scope.split(/ /g));
}
return ScopeListElement2._push(this, grammar2, [scope]);
};
ScopeListElement2._generateScopes = function(scopesList) {
var result = [], resultLen = 0;
while (scopesList) {
result[resultLen++] = scopesList.scope;
scopesList = scopesList.parent;
}
result.reverse();
return result;
};
ScopeListElement2.prototype.generateScopes = function() {
return ScopeListElement2._generateScopes(this);
};
return ScopeListElement2;
}();
grammar.ScopeListElement = ScopeListElement;
var StackElement = function() {
function StackElement2(parent, ruleId, enterPos, endRule, nameScopesList, contentNameScopesList) {
this.parent = parent;
this.depth = this.parent ? this.parent.depth + 1 : 1;
this.ruleId = ruleId;
this._enterPos = enterPos;
this.endRule = endRule;
this.nameScopesList = nameScopesList;
this.contentNameScopesList = contentNameScopesList;
}
StackElement2._structuralEquals = function(a, b) {
do {
if (a === b) {
return true;
}
if (a.depth !== b.depth || a.ruleId !== b.ruleId || a.endRule !== b.endRule) {
return false;
}
a = a.parent;
b = b.parent;
if (!a && !b) {
return true;
}
if (!a || !b) {
return false;
}
} while (true);
};
StackElement2._equals = function(a, b) {
if (a === b) {
return true;
}
if (!this._structuralEquals(a, b)) {
return false;
}
return a.contentNameScopesList.equals(b.contentNameScopesList);
};
StackElement2.prototype.clone = function() {
return this;
};
StackElement2.prototype.equals = function(other) {
if (other === null) {
return false;
}
return StackElement2._equals(this, other);
};
StackElement2._reset = function(el) {
while (el) {
el._enterPos = -1;
el = el.parent;
}
};
StackElement2.prototype.reset = function() {
StackElement2._reset(this);
};
StackElement2.prototype.pop = function() {
return this.parent;
};
StackElement2.prototype.safePop = function() {
if (this.parent) {
return this.parent;
}
return this;
};
StackElement2.prototype.push = function(ruleId, enterPos, endRule, nameScopesList, contentNameScopesList) {
return new StackElement2(this, ruleId, enterPos, endRule, nameScopesList, contentNameScopesList);
};
StackElement2.prototype.getEnterPos = function() {
return this._enterPos;
};
StackElement2.prototype.getRule = function(grammar2) {
return grammar2.getRule(this.ruleId);
};
StackElement2.prototype._writeString = function(res, outIndex) {
if (this.parent) {
outIndex = this.parent._writeString(res, outIndex);
}
res[outIndex++] = "(" + this.ruleId + ", TODO-" + this.nameScopesList + ", TODO-" + this.contentNameScopesList + ")";
return outIndex;
};
StackElement2.prototype.toString = function() {
var r = [];
this._writeString(r, 0);
return "[" + r.join(",") + "]";
};
StackElement2.prototype.setContentNameScopesList = function(contentNameScopesList) {
if (this.contentNameScopesList === contentNameScopesList) {
return this;
}
return this.parent.push(this.ruleId, this._enterPos, this.endRule, this.nameScopesList, contentNameScopesList);
};
StackElement2.prototype.setEndRule = function(endRule) {
if (this.endRule === endRule) {
return this;
}
return new StackElement2(this.parent, this.ruleId, this._enterPos, endRule, this.nameScopesList, this.contentNameScopesList);
};
StackElement2.prototype.hasSameRuleAs = function(other) {
return this.ruleId === other.ruleId;
};
StackElement2.NULL = new StackElement2(null, 0, 0, null, null, null);
return StackElement2;
}();
grammar.StackElement = StackElement;
var LocalStackElement = function() {
function LocalStackElement2(scopes, endPos) {
this.scopes = scopes;
this.endPos = endPos;
}
return LocalStackElement2;
}();
grammar.LocalStackElement = LocalStackElement;
var LineTokens = function() {
function LineTokens2(emitBinaryTokens, lineText, tokenTypeOverrides) {
this._emitBinaryTokens = emitBinaryTokens;
this._tokenTypeOverrides = tokenTypeOverrides;
if (debug_1$1.IN_DEBUG_MODE) {
this._lineText = lineText;
}
if (this._emitBinaryTokens) {
this._binaryTokens = [];
} else {
this._tokens = [];
}
this._lastTokenEndIndex = 0;
}
LineTokens2.prototype.produce = function(stack, endIndex) {
this.produceFromScopes(stack.contentNameScopesList, endIndex);
};
LineTokens2.prototype.produceFromScopes = function(scopesList, endIndex) {
if (this._lastTokenEndIndex >= endIndex) {
return;
}
if (this._emitBinaryTokens) {
var metadata = scopesList.metadata;
for (var _i2 = 0, _a2 = this._tokenTypeOverrides; _i2 < _a2.length; _i2++) {
var tokenType = _a2[_i2];
if (tokenType.matcher(scopesList.generateScopes())) {
metadata = StackElementMetadata.set(metadata, 0, toTemporaryType(tokenType.type), -1, 0, 0);
}
}
if (this._binaryTokens.length > 0 && this._binaryTokens[this._binaryTokens.length - 1] === metadata) {
this._lastTokenEndIndex = endIndex;
return;
}
this._binaryTokens.push(this._lastTokenEndIndex);
this._binaryTokens.push(metadata);
this._lastTokenEndIndex = endIndex;
return;
}
var scopes = scopesList.generateScopes();
if (debug_1$1.IN_DEBUG_MODE) {
console.log(" token: |" + this._lineText.substring(this._lastTokenEndIndex, endIndex).replace(/\n$/, "\\n") + "|");
for (var k = 0; k < scopes.length; k++) {
console.log(" * " + scopes[k]);
}
}
this._tokens.push({
startIndex: this._lastTokenEndIndex,
endIndex,
scopes
});
this._lastTokenEndIndex = endIndex;
};
LineTokens2.prototype.getResult = function(stack, lineLength) {
if (this._tokens.length > 0 && this._tokens[this._tokens.length - 1].startIndex === lineLength - 1) {
this._tokens.pop();
}
if (this._tokens.length === 0) {
this._lastTokenEndIndex = -1;
this.produce(stack, lineLength);
this._tokens[this._tokens.length - 1].startIndex = 0;
}
return this._tokens;
};
LineTokens2.prototype.getBinaryResult = function(stack, lineLength) {
if (this._binaryTokens.length > 0 && this._binaryTokens[this._binaryTokens.length - 2] === lineLength - 1) {
this._binaryTokens.pop();
this._binaryTokens.pop();
}
if (this._binaryTokens.length === 0) {
this._lastTokenEndIndex = -1;
this.produce(stack, lineLength);
this._binaryTokens[this._binaryTokens.length - 2] = 0;
}
var result = new Uint32Array(this._binaryTokens.length);
for (var i = 0, len = this._binaryTokens.length; i < len; i++) {
result[i] = this._binaryTokens[i];
}
return result;
};
return LineTokens2;
}();
function toTemporaryType(standardType) {
switch (standardType) {
case 4:
return 4;
case 2:
return 2;
case 1:
return 1;
case 0:
default:
return 8;
}
}
Object.defineProperty(registry, "__esModule", { value: true });
var grammar_1$1 = grammar;
var SyncRegistry = function() {
function SyncRegistry2(theme2) {
this._theme = theme2;
this._grammars = {};
this._rawGrammars = {};
this._injectionGrammars = {};
}
SyncRegistry2.prototype.setTheme = function(theme2) {
var _this = this;
this._theme = theme2;
Object.keys(this._grammars).forEach(function(scopeName) {
var grammar2 = _this._grammars[scopeName];
grammar2.onDidChangeTheme();
});
};
SyncRegistry2.prototype.getColorMap = function() {
return this._theme.getColorMap();
};
SyncRegistry2.prototype.addGrammar = function(grammar2, injectionScopeNames) {
this._rawGrammars[grammar2.scopeName] = grammar2;
var includedScopes = {};
grammar_1$1.collectIncludedScopes(includedScopes, grammar2);
if (injectionScopeNames) {
this._injectionGrammars[grammar2.scopeName] = injectionScopeNames;
injectionScopeNames.forEach(function(scopeName) {
includedScopes[scopeName] = true;
});
}
return Object.keys(includedScopes);
};
SyncRegistry2.prototype.lookup = function(scopeName) {
return this._rawGrammars[scopeName];
};
SyncRegistry2.prototype.injections = function(targetScope) {
return this._injectionGrammars[targetScope];
};
SyncRegistry2.prototype.getDefaults = function() {
return this._theme.getDefaults();
};
SyncRegistry2.prototype.themeMatch = function(scopeName) {
return this._theme.match(scopeName);
};
SyncRegistry2.prototype.grammarForScopeName = function(scopeName, initialLanguage, embeddedLanguages, tokenTypes) {
if (!this._grammars[scopeName]) {
var rawGrammar = this._rawGrammars[scopeName];
if (!rawGrammar) {
return null;
}
this._grammars[scopeName] = grammar_1$1.createGrammar(rawGrammar, initialLanguage, embeddedLanguages, tokenTypes, this);
}
return this._grammars[scopeName];
};
return SyncRegistry2;
}();
registry.SyncRegistry = SyncRegistry;
var grammarReader = {};
var main = {};
main.__esModule = true;
main.parse = main.parseWithLocation = void 0;
function parseWithLocation(content, filename, locationKeyName) {
return _parse(content, filename, locationKeyName);
}
main.parseWithLocation = parseWithLocation;
function parse$1(content) {
return _parse(content, null, null);
}
main.parse = parse$1;
function _parse(content, filename, locationKeyName) {
var len = content.length;
var pos = 0;
var line = 1;
var char = 0;
if (len > 0 && content.charCodeAt(0) === 65279) {
pos = 1;
}
function advancePosBy(by) {
if (locationKeyName === null) {
pos = pos + by;
} else {
while (by > 0) {
var chCode2 = content.charCodeAt(pos);
if (chCode2 === 10) {
pos++;
line++;
char = 0;
} else {
pos++;
char++;
}
by--;
}
}
}
function advancePosTo(to) {
if (locationKeyName === null) {
pos = to;
} else {
advancePosBy(to - pos);
}
}
function skipWhitespace() {
while (pos < len) {
var chCode2 = content.charCodeAt(pos);
if (chCode2 !== 32 && chCode2 !== 9 && chCode2 !== 13 && chCode2 !== 10) {
break;
}
advancePosBy(1);
}
}
function advanceIfStartsWith(str) {
if (content.substr(pos, str.length) === str) {
advancePosBy(str.length);
return true;
}
return false;
}
function advanceUntil(str) {
var nextOccurence = content.indexOf(str, pos);
if (nextOccurence !== -1) {
advancePosTo(nextOccurence + str.length);
} else {
advancePosTo(len);
}
}
function captureUntil(str) {
var nextOccurence = content.indexOf(str, pos);
if (nextOccurence !== -1) {
var r = content.substring(pos, nextOccurence);
advancePosTo(nextOccurence + str.length);
return r;
} else {
var r = content.substr(pos);
advancePosTo(len);
return r;
}
}
var state = 0;
var cur = null;
var stateStack = [];
var objStack = [];
var curKey = null;
function pushState(newState, newCur) {
stateStack.push(state);
objStack.push(cur);
state = newState;
cur = newCur;
}
function popState() {
if (stateStack.length === 0) {
return fail("illegal state stack");
}
state = stateStack.pop();
cur = objStack.pop();
}
function fail(msg) {
throw new Error("Near offset " + pos + ": " + msg + " ~~~" + content.substr(pos, 50) + "~~~");
}
var dictState = {
enterDict: function() {
if (curKey === null) {
return fail("missing <key>");
}
var newDict = {};
if (locationKeyName !== null) {
newDict[locationKeyName] = {
filename,
line,
char
};
}
cur[curKey] = newDict;
curKey = null;
pushState(1, newDict);
},
enterArray: function() {
if (curKey === null) {
return fail("missing <key>");
}
var newArr = [];
cur[curKey] = newArr;
curKey = null;
pushState(2, newArr);
}
};
var arrState = {
enterDict: function() {
var newDict = {};
if (locationKeyName !== null) {
newDict[locationKeyName] = {
filename,
line,
char
};
}
cur.push(newDict);
pushState(1, newDict);
},
enterArray: function() {
var newArr = [];
cur.push(newArr);
pushState(2, newArr);
}
};
function enterDict() {
if (state === 1) {
dictState.enterDict();
} else if (state === 2) {
arrState.enterDict();
} else {
cur = {};
if (locationKeyName !== null) {
cur[locationKeyName] = {
filename,
line,
char
};
}
pushState(1, cur);
}
}
function leaveDict() {
if (state === 1) {
popState();
} else if (state === 2) {
return fail("unexpected </dict>");
} else {
return fail("unexpected </dict>");
}
}
function enterArray() {
if (state === 1) {
dictState.enterArray();
} else if (state === 2) {
arrState.enterArray();
} else {
cur = [];
pushState(2, cur);
}
}
function leaveArray() {
if (state === 1) {
return fail("unexpected </array>");
} else if (state === 2) {
popState();
} else {
return fail("unexpected </array>");
}
}
function acceptKey(val) {
if (state === 1) {
if (curKey !== null) {
return fail("too many <key>");
}
curKey = val;
} else if (state === 2) {
return fail("unexpected <key>");
} else {
return fail("unexpected <key>");
}
}
function acceptString(val) {
if (state === 1) {
if (curKey === null) {
return fail("missing <key>");
}
cur[curKey] = val;
curKey = null;
} else if (state === 2) {
cur.push(val);
} else {
cur = val;
}
}
function acceptReal(val) {
if (isNaN(val)) {
return fail("cannot parse float");
}
if (state === 1) {
if (curKey === null) {
return fail("missing <key>");
}
cur[curKey] = val;
curKey = null;
} else if (state === 2) {
cur.push(val);
} else {
cur = val;
}
}
function acceptInteger(val) {
if (isNaN(val)) {
return fail("cannot parse integer");
}
if (state === 1) {
if (curKey === null) {
return fail("missing <key>");
}
cur[curKey] = val;
curKey = null;
} else if (state === 2) {
cur.push(val);
} else {
cur = val;
}
}
function acceptDate(val) {
if (state === 1) {
if (curKey === null) {
return fail("missing <key>");
}
cur[curKey] = val;
curKey = null;
} else if (state === 2) {
cur.push(val);
} else {
cur = val;
}
}
function acceptData(val) {
if (state === 1) {
if (curKey === null) {
return fail("missing <key>");
}
cur[curKey] = val;
curKey = null;
} else if (state === 2) {
cur.push(val);
} else {
cur = val;
}
}
function acceptBool(val) {
if (state === 1) {
if (curKey === null) {
return fail("missing <key>");
}
cur[curKey] = val;
curKey = null;
} else if (state === 2) {
cur.push(val);
} else {
cur = val;
}
}
function escapeVal(str) {
return str.replace(/&#([0-9]+);/g, function(_2, m0) {
return String.fromCodePoint(parseInt(m0, 10));
}).replace(/&#x([0-9a-f]+);/g, function(_2, m0) {
return String.fromCodePoint(parseInt(m0, 16));
}).replace(/&|<|>|"|'/g, function(_2) {
switch (_2) {
case "&":
return "&";
case "<":
return "<";
case ">":
return ">";
case """:
return '"';
case "'":
return "'";
}
return _2;
});
}
function parseOpenTag() {
var r = captureUntil(">");
var isClosed = false;
if (r.charCodeAt(r.length - 1) === 47) {
isClosed = true;
r = r.substring(0, r.length - 1);
}
return {
name: r.trim(),
isClosed
};
}
function parseTagValue(tag2) {
if (tag2.isClosed) {
return "";
}
var val = captureUntil("</");
advanceUntil(">");
return escapeVal(val);
}
while (pos < len) {
skipWhitespace();
if (pos >= len) {
break;
}
var chCode = content.charCodeAt(pos);
advancePosBy(1);
if (chCode !== 60) {
return fail("expected <");
}
if (pos >= len) {
return fail("unexpected end of input");
}
var peekChCode = content.charCodeAt(pos);
if (peekChCode === 63) {
advancePosBy(1);
advanceUntil("?>");
continue;
}
if (peekChCode === 33) {
advancePosBy(1);
if (advanceIfStartsWith("--")) {
advanceUntil("-->");
continue;
}
advanceUntil(">");
continue;
}
if (peekChCode === 47) {
advancePosBy(1);
skipWhitespace();
if (advanceIfStartsWith("plist")) {
advanceUntil(">");
continue;
}
if (advanceIfStartsWith("dict")) {
advanceUntil(">");
leaveDict();
continue;
}
if (advanceIfStartsWith("array")) {
advanceUntil(">");
leaveArray();
continue;
}
return fail("unexpected closed tag");
}
var tag = parseOpenTag();
switch (tag.name) {
case "dict":
enterDict();
if (tag.isClosed) {
leaveDict();
}
continue;
case "array":
enterArray();
if (tag.isClosed) {
leaveArray();
}
continue;
case "key":
acceptKey(parseTagValue(tag));
continue;
case "string":
acceptString(parseTagValue(tag));
continue;
case "real":
acceptReal(parseFloat(parseTagValue(tag)));
continue;
case "integer":
acceptInteger(parseInt(parseTagValue(tag), 10));
continue;
case "date":
acceptDate(new Date(parseTagValue(tag)));
continue;
case "data":
acceptData(parseTagValue(tag));
continue;
case "true":
parseTagValue(tag);
acceptBool(true);
continue;
case "false":
parseTagValue(tag);
acceptBool(false);
continue;
}
if (/^plist/.test(tag.name)) {
continue;
}
return fail("unexpected opened tag " + tag.name);
}
return cur;
}
var json = {};
Object.defineProperty(json, "__esModule", { value: true });
function doFail(streamState, msg) {
throw new Error("Near offset " + streamState.pos + ": " + msg + " ~~~" + streamState.source.substr(streamState.pos, 50) + "~~~");
}
function parse(source, filename, withMetadata) {
var streamState = new JSONStreamState(source);
var token = new JSONToken();
var state = 0;
var cur = null;
var stateStack = [];
var objStack = [];
function pushState() {
stateStack.push(state);
objStack.push(cur);
}
function popState() {
state = stateStack.pop();
cur = objStack.pop();
}
function fail(msg) {
doFail(streamState, msg);
}
while (nextJSONToken(streamState, token)) {
if (state === 0) {
if (cur !== null) {
fail("too many constructs in root");
}
if (token.type === 3) {
cur = {};
if (withMetadata) {
cur.$vscodeTextmateLocation = token.toLocation(filename);
}
pushState();
state = 1;
continue;
}
if (token.type === 2) {
cur = [];
pushState();
state = 4;
continue;
}
fail("unexpected token in root");
}
if (state === 2) {
if (token.type === 5) {
popState();
continue;
}
if (token.type === 7) {
state = 3;
continue;
}
fail("expected , or }");
}
if (state === 1 || state === 3) {
if (state === 1 && token.type === 5) {
popState();
continue;
}
if (token.type === 1) {
var keyValue = token.value;
if (!nextJSONToken(streamState, token) || token.type !== 6) {
fail("expected colon");
}
if (!nextJSONToken(streamState, token)) {
fail("expected value");
}
state = 2;
if (token.type === 1) {
cur[keyValue] = token.value;
continue;
}
if (token.type === 8) {
cur[keyValue] = null;
continue;
}
if (token.type === 9) {
cur[keyValue] = true;
continue;
}
if (token.type === 10) {
cur[keyValue] = false;
continue;
}
if (token.type === 11) {
cur[keyValue] = parseFloat(token.value);
continue;
}
if (token.type === 2) {
var newArr = [];
cur[keyValue] = newArr;
pushState();
state = 4;
cur = newArr;
continue;
}
if (token.type === 3) {
var newDict = {};
if (withMetadata) {
newDict.$vscodeTextmateLocation = token.toLocation(filename);
}
cur[keyValue] = newDict;
pushState();
state = 1;
cur = newDict;
continue;
}
}
fail("unexpected token in dict");
}
if (state === 5) {
if (token.type === 4) {
popState();
continue;
}
if (token.type === 7) {
state = 6;
continue;
}
fail("expected , or ]");
}
if (state === 4 || state === 6) {
if (state === 4 && token.type === 4) {
popState();
continue;
}
state = 5;
if (token.type === 1) {
cur.push(token.value);
continue;
}
if (token.type === 8) {
cur.push(null);
continue;
}
if (token.type === 9) {
cur.push(true);
continue;
}
if (token.type === 10) {
cur.push(false);
continue;
}
if (token.type === 11) {
cur.push(parseFloat(token.value));
continue;
}
if (token.type === 2) {
var newArr = [];
cur.push(newArr);
pushState();
state = 4;
cur = newArr;
continue;
}
if (token.type === 3) {
var newDict = {};
if (withMetadata) {
newDict.$vscodeTextmateLocation = token.toLocation(filename);
}
cur.push(newDict);
pushState();
state = 1;
cur = newDict;
continue;
}
fail("unexpected token in array");
}
fail("unknown state");
}
if (objStack.length !== 0) {
fail("unclosed constructs");
}
return cur;
}
json.parse = parse;
var JSONStreamState = function() {
function JSONStreamState2(source) {
this.source = source;
this.pos = 0;
this.len = source.length;
this.line = 1;
this.char = 0;
}
return JSONStreamState2;
}();
var JSONToken = function() {
function JSONToken2() {
this.value = null;
this.offset = -1;
this.len = -1;
this.line = -1;
this.char = -1;
}
JSONToken2.prototype.toLocation = function(filename) {
return {
filename,
line: this.line,
char: this.char
};
};
return JSONToken2;
}();
function nextJSONToken(_state, _out) {
_out.value = null;
_out.type = 0;
_out.offset = -1;
_out.len = -1;
_out.line = -1;
_out.char = -1;
var source = _state.source;
var pos = _state.pos;
var len = _state.len;
var line = _state.line;
var char = _state.char;
var chCode;
do {
if (pos >= len) {
return false;
}
chCode = source.charCodeAt(pos);
if (chCode === 32 || chCode === 9 || chCode === 13) {
pos++;
char++;
continue;
}
if (chCode === 10) {
pos++;
line++;
char = 0;
continue;
}
break;
} while (true);
_out.offset = pos;
_out.line = line;
_out.char = char;
if (chCode === 34) {
_out.type = 1;
pos++;
char++;
do {
if (pos >= len) {
return false;
}
chCode = source.charCodeAt(pos);
pos++;
char++;
if (chCode === 92) {
pos++;
char++;
continue;
}
if (chCode === 34) {
break;
}
} while (true);
_out.value = source.substring(_out.offset + 1, pos - 1).replace(/\\u([0-9A-Fa-f]{4})/g, function(_2, m0) {
return String.fromCodePoint(parseInt(m0, 16));
}).replace(/\\(.)/g, function(_2, m0) {
switch (m0) {
case '"':
return '"';
case "\\":
return "\\";
case "/":
return "/";
case "b":
return "\b";
case "f":
return "\f";
case "n":
return "\n";
case "r":
return "\r";
case "t":
return " ";
default:
doFail(_state, "invalid escape sequence");
}
});
} else if (chCode === 91) {
_out.type = 2;
pos++;
char++;
} else if (chCode === 123) {
_out.type = 3;
pos++;
char++;
} else if (chCode === 93) {
_out.type = 4;
pos++;
char++;
} else if (chCode === 125) {
_out.type = 5;
pos++;
char++;
} else if (chCode === 58) {
_out.type = 6;
pos++;
char++;
} else if (chCode === 44) {
_out.type = 7;
pos++;
char++;
} else if (chCode === 110) {
_out.type = 8;
pos++;
char++;
chCode = source.charCodeAt(pos);
if (chCode !== 117) {
return false;
}
pos++;
char++;
chCode = source.charCodeAt(pos);
if (chCode !== 108) {
return false;
}
pos++;
char++;
chCode = source.charCodeAt(pos);
if (chCode !== 108) {
return false;
}
pos++;
char++;
} else if (chCode === 116) {
_out.type = 9;
pos++;
char++;
chCode = source.charCodeAt(pos);
if (chCode !== 114) {
return false;
}
pos++;
char++;
chCode = source.charCodeAt(pos);
if (chCode !== 117) {
return false;
}
pos++;
char++;
chCode = source.charCodeAt(pos);
if (chCode !== 101) {
return false;
}
pos++;
char++;
} else if (chCode === 102) {
_out.type = 10;
pos++;
char++;
chCode = source.charCodeAt(pos);
if (chCode !== 97) {
return false;
}
pos++;
char++;
chCode = source.charCodeAt(pos);
if (chCode !== 108) {
return false;
}
pos++;
char++;
chCode = source.charCodeAt(pos);
if (chCode !== 115) {
return false;
}
pos++;
char++;
chCode = source.charCodeAt(pos);
if (chCode !== 101) {
return false;
}
pos++;
char++;
} else {
_out.type = 11;
do {
if (pos >= len) {
return false;
}
chCode = source.charCodeAt(pos);
if (chCode === 46 || chCode >= 48 && chCode <= 57 || (chCode === 101 || chCode === 69) || (chCode === 45 || chCode === 43)) {
pos++;
char++;
continue;
}
break;
} while (true);
}
_out.len = pos - _out.offset;
if (_out.value === null) {
_out.value = source.substr(_out.offset, _out.len);
}
_state.pos = pos;
_state.line = line;
_state.char = char;
return true;
}
Object.defineProperty(grammarReader, "__esModule", { value: true });
var plist = main;
var debug_1 = debug;
var json_1 = json;
function parseJSONGrammar(contents, filename) {
if (debug_1.CAPTURE_METADATA) {
return json_1.parse(contents, filename, true);
}
return JSON.parse(contents);
}
grammarReader.parseJSONGrammar = parseJSONGrammar;
function parsePLISTGrammar(contents, filename) {
if (debug_1.CAPTURE_METADATA) {
return plist.parseWithLocation(contents, filename, "$vscodeTextmateLocation");
}
return plist.parse(contents);
}
grammarReader.parsePLISTGrammar = parsePLISTGrammar;
var theme = {};
Object.defineProperty(theme, "__esModule", { value: true });
var ParsedThemeRule = function() {
function ParsedThemeRule2(scope, parentScopes, index, fontStyle, foreground, background) {
this.scope = scope;
this.parentScopes = parentScopes;
this.index = index;
this.fontStyle = fontStyle;
this.foreground = foreground;
this.background = background;
}
return ParsedThemeRule2;
}();
theme.ParsedThemeRule = ParsedThemeRule;
function isValidHexColor(hex) {
if (/^#[0-9a-f]{6}$/i.test(hex)) {
return true;
}
if (/^#[0-9a-f]{8}$/i.test(hex)) {
return true;
}
if (/^#[0-9a-f]{3}$/i.test(hex)) {
return true;
}
if (/^#[0-9a-f]{4}$/i.test(hex)) {
return true;
}
return false;
}
function parseTheme(source) {
if (!source) {
return [];
}
if (!source.settings || !Array.isArray(source.settings)) {
return [];
}
var settings = source.settings;
var result = [], resultLen = 0;
for (var i = 0, len = settings.length; i < len; i++) {
var entry = settings[i];
if (!entry.settings) {
continue;
}
var scopes = void 0;
if (typeof entry.scope === "string") {
var _scope = entry.scope;
_scope = _scope.replace(/^[,]+/, "");
_scope = _scope.replace(/[,]+$/, "");
scopes = _scope.split(",");
} else if (Array.isArray(entry.scope)) {
scopes = entry.scope;
} else {
scopes = [""];
}
var fontStyle = -1;
if (typeof entry.settings.fontStyle === "string") {
fontStyle = 0;
var segments = entry.settings.fontStyle.split(" ");
for (var j2 = 0, lenJ = segments.length; j2 < lenJ; j2++) {
var segment = segments[j2];
switch (segment) {
case "italic":
fontStyle = fontStyle | 1;
break;
case "bold":
fontStyle = fontStyle | 2;
break;
case "underline":
fontStyle = fontStyle | 4;
break;
}
}
}
var foreground = null;
if (typeof entry.settings.foreground === "string" && isValidHexColor(entry.settings.foreground)) {
foreground = entry.settings.foreground;
}
var background = null;
if (typeof entry.settings.background === "string" && isValidHexColor(entry.settings.background)) {
background = entry.settings.background;
}
for (var j2 = 0, lenJ = scopes.length; j2 < lenJ; j2++) {
var _scope = scopes[j2].trim();
var segments = _scope.split(" ");
var scope = segments[segments.length - 1];
var parentScopes = null;
if (segments.length > 1) {
parentScopes = segments.slice(0, segments.length - 1);
parentScopes.reverse();
}
result[resultLen++] = new ParsedThemeRule(scope, parentScopes, i, fontStyle, foreground, background);
}
}
return result;
}
theme.parseTheme = parseTheme;
function resolveParsedThemeRules(parsedThemeRules) {
parsedThemeRules.sort(function(a, b) {
var r = strcmp(a.scope, b.scope);
if (r !== 0) {
return r;
}
r = strArrCmp(a.parentScopes, b.parentScopes);
if (r !== 0) {
return r;
}
return a.index - b.index;
});
var defaultFontStyle = 0;
var defaultForeground = "#000000";
var defaultBackground = "#ffffff";
while (parsedThemeRules.length >= 1 && parsedThemeRules[0].scope === "") {
var incomingDefaults = parsedThemeRules.shift();
if (incomingDefaults.fontStyle !== -1) {
defaultFontStyle = incomingDefaults.fontStyle;
}
if (incomingDefaults.foreground !== null) {
defaultForeground = incomingDefaults.foreground;
}
if (incomingDefaults.background !== null) {
defaultBackground = incomingDefaults.background;
}
}
var colorMap = new ColorMap();
var defaults = new ThemeTrieElementRule(0, null, defaultFontStyle, colorMap.getId(defaultForeground), colorMap.getId(defaultBackground));
var root = new ThemeTrieElement(new ThemeTrieElementRule(0, null, -1, 0, 0), []);
for (var i = 0, len = parsedThemeRules.length; i < len; i++) {
var rule2 = parsedThemeRules[i];
root.insert(0, rule2.scope, rule2.parentScopes, rule2.fontStyle, colorMap.getId(rule2.foreground), colorMap.getId(rule2.background));
}
return new Theme(colorMap, defaults, root);
}
var ColorMap = function() {
function ColorMap2() {
this._lastColorId = 0;
this._id2color = [];
this._color2id = /* @__PURE__ */ Object.create(null);
}
ColorMap2.prototype.getId = function(color) {
if (color === null) {
return 0;
}
color = color.toUpperCase();
var value = this._color2id[color];
if (value) {
return value;
}
value = ++this._lastColorId;
this._color2id[color] = value;
this._id2color[value] = color;
return value;
};
ColorMap2.prototype.getColorMap = function() {
return this._id2color.slice(0);
};
return ColorMap2;
}();
theme.ColorMap = ColorMap;
var Theme = function() {
function Theme2(colorMap, defaults, root) {
this._colorMap = colorMap;
this._root = root;
this._defaults = defaults;
this._cache = {};
}
Theme2.createFromRawTheme = function(source) {
return this.createFromParsedTheme(parseTheme(source));
};
Theme2.createFromParsedTheme = function(source) {
return resolveParsedThemeRules(source);
};
Theme2.prototype.getColorMap = function() {
return this._colorMap.getColorMap();
};
Theme2.prototype.getDefaults = function() {
return this._defaults;
};
Theme2.prototype.match = function(scopeName) {
if (!this._cache.hasOwnProperty(scopeName)) {
this._cache[scopeName] = this._root.match(scopeName);
}
return this._cache[scopeName];
};
return Theme2;
}();
theme.Theme = Theme;
function strcmp(a, b) {
if (a < b) {
return -1;
}
if (a > b) {
return 1;
}
return 0;
}
theme.strcmp = strcmp;
function strArrCmp(a, b) {
if (a === null && b === null) {
return 0;
}
if (!a) {
return -1;
}
if (!b) {
return 1;
}
var len1 = a.length;
var len2 = b.length;
if (len1 === len2) {
for (var i = 0; i < len1; i++) {
var res = strcmp(a[i], b[i]);
if (res !== 0) {
return res;
}
}
return 0;
}
return len1 - len2;
}
theme.strArrCmp = strArrCmp;
var ThemeTrieElementRule = function() {
function ThemeTrieElementRule2(scopeDepth, parentScopes, fontStyle, foreground, background) {
this.scopeDepth = scopeDepth;
this.parentScopes = parentScopes;
this.fontStyle = fontStyle;
this.foreground = foreground;
this.background = background;
}
ThemeTrieElementRule2.prototype.clone = function() {
return new ThemeTrieElementRule2(this.scopeDepth, this.parentScopes, this.fontStyle, this.foreground, this.background);
};
ThemeTrieElementRule2.cloneArr = function(arr) {
var r = [];
for (var i = 0, len = arr.length; i < len; i++) {
r[i] = arr[i].clone();
}
return r;
};
ThemeTrieElementRule2.prototype.acceptOverwrite = function(scopeDepth, fontStyle, foreground, background) {
if (this.scopeDepth > scopeDepth) {
console.log("how did this happen?");
} else {
this.scopeDepth = scopeDepth;
}
if (fontStyle !== -1) {
this.fontStyle = fontStyle;
}
if (foreground !== 0) {
this.foreground = foreground;
}
if (background !== 0) {
this.background = background;
}
};
return ThemeTrieElementRule2;
}();
theme.ThemeTrieElementRule = ThemeTrieElementRule;
var ThemeTrieElement = function() {
function ThemeTrieElement2(mainRule, rulesWithParentScopes, children) {
if (rulesWithParentScopes === void 0) {
rulesWithParentScopes = [];
}
if (children === void 0) {
children = {};
}
this._mainRule = mainRule;
this._rulesWithParentScopes = rulesWithParentScopes;
this._children = children;
}
ThemeTrieElement2._sortBySpecificity = function(arr) {
if (arr.length === 1) {
return arr;
}
arr.sort(this._cmpBySpecificity);
return arr;
};
ThemeTrieElement2._cmpBySpecificity = function(a, b) {
if (a.scopeDepth === b.scopeDepth) {
var aParentScopes = a.parentScopes;
var bParentScopes = b.parentScopes;
var aParentScopesLen = aParentScopes === null ? 0 : aParentScopes.length;
var bParentScopesLen = bParentScopes === null ? 0 : bParentScopes.length;
if (aParentScopesLen === bParentScopesLen) {
for (var i = 0; i < aParentScopesLen; i++) {
var aLen = aParentScopes[i].length;
var bLen = bParentScopes[i].length;
if (aLen !== bLen) {
return bLen - aLen;
}
}
}
return bParentScopesLen - aParentScopesLen;
}
return b.scopeDepth - a.scopeDepth;
};
ThemeTrieElement2.prototype.match = function(scope) {
if (scope === "") {
return ThemeTrieElement2._sortBySpecificity([].concat(this._mainRule).concat(this._rulesWithParentScopes));
}
var dotIndex = scope.indexOf(".");
var head;
var tail;
if (dotIndex === -1) {
head = scope;
tail = "";
} else {
head = scope.substring(0, dotIndex);
tail = scope.substring(dotIndex + 1);
}
if (this._children.hasOwnProperty(head)) {
return this._children[head].match(tail);
}
return ThemeTrieElement2._sortBySpecificity([].concat(this._mainRule).concat(this._rulesWithParentScopes));
};
ThemeTrieElement2.prototype.insert = function(scopeDepth, scope, parentScopes, fontStyle, foreground, background) {
if (scope === "") {
this._doInsertHere(scopeDepth, parentScopes, fontStyle, foreground, background);
return;
}
var dotIndex = scope.indexOf(".");
var head;
var tail;
if (dotIndex === -1) {
head = scope;
tail = "";
} else {
head = scope.substring(0, dotIndex);
tail = scope.substring(dotIndex + 1);
}
var child;
if (this._children.hasOwnProperty(head)) {
child = this._children[head];
} else {
child = new ThemeTrieElement2(this._mainRule.clone(), ThemeTrieElementRule.cloneArr(this._rulesWithParentScopes));
this._children[head] = child;
}
child.insert(scopeDepth + 1, tail, parentScopes, fontStyle, foreground, background);
};
ThemeTrieElement2.prototype._doInsertHere = function(scopeDepth, parentScopes, fontStyle, foreground, background) {
if (parentScopes === null) {
this._mainRule.acceptOverwrite(scopeDepth, fontStyle, foreground, background);
return;
}
for (var i = 0, len = this._rulesWithParentScopes.length; i < len; i++) {
var rule2 = this._rulesWithParentScopes[i];
if (strArrCmp(rule2.parentScopes, parentScopes) === 0) {
rule2.acceptOverwrite(scopeDepth, fontStyle, foreground, background);
return;
}
}
if (fontStyle === -1) {
fontStyle = this._mainRule.fontStyle;
}
if (foreground === 0) {
foreground = this._mainRule.foreground;
}
if (background === 0) {
background = this._mainRule.background;
}
this._rulesWithParentScopes.push(new ThemeTrieElementRule(scopeDepth, parentScopes, fontStyle, foreground, background));
};
return ThemeTrieElement2;
}();
theme.ThemeTrieElement = ThemeTrieElement;
var __awaiter = commonjsGlobal && commonjsGlobal.__awaiter || function(thisArg, _arguments, P2, generator) {
return new (P2 || (P2 = Promise))(function(resolve, reject) {
function fulfilled(value) {
try {
step(generator.next(value));
} catch (e4) {
reject(e4);
}
}
function rejected(value) {
try {
step(generator["throw"](value));
} catch (e4) {
reject(e4);
}
}
function step(result) {
result.done ? resolve(result.value) : new P2(function(resolve2) {
resolve2(result.value);
}).then(fulfilled, rejected);
}
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = commonjsGlobal && commonjsGlobal.__generator || function(thisArg, body) {
var _2 = { label: 0, sent: function() {
if (t[0] & 1)
throw t[1];
return t[1];
}, trys: [], ops: [] }, f2, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
return this;
}), g;
function verb(n) {
return function(v) {
return step([n, v]);
};
}
function step(op) {
if (f2)
throw new TypeError("Generator is already executing.");
while (_2)
try {
if (f2 = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
return t;
if (y = 0, t)
op = [op[0] & 2, t.value];
switch (op[0]) {
case 0:
case 1:
t = op;
break;
case 4:
_2.label++;
return { value: op[1], done: false };
case 5:
_2.label++;
y = op[1];
op = [0];
continue;
case 7:
op = _2.ops.pop();
_2.trys.pop();
continue;
default:
if (!(t = _2.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
_2 = 0;
continue;
}
if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
_2.label = op[1];
break;
}
if (op[0] === 6 && _2.label < t[1]) {
_2.label = t[1];
t = op;
break;
}
if (t && _2.label < t[2]) {
_2.label = t[2];
_2.ops.push(op);
break;
}
if (t[2])
_2.ops.pop();
_2.trys.pop();
continue;
}
op = body.call(thisArg, _2);
} catch (e4) {
op = [6, e4];
y = 0;
} finally {
f2 = t = 0;
}
if (op[0] & 5)
throw op[1];
return { value: op[0] ? op[1] : void 0, done: true };
}
};
Object.defineProperty(main$1, "__esModule", { value: true });
var registry_1 = registry;
var grammarReader_1 = grammarReader;
var theme_1 = theme;
var grammar_1 = grammar;
var DEFAULT_OPTIONS = {
getGrammarDefinition: function(scopeName) {
return null;
},
getInjections: function(scopeName) {
return null;
}
};
var Registry = function() {
function Registry2(locator) {
if (locator === void 0) {
locator = DEFAULT_OPTIONS;
}
this._locator = locator;
this._syncRegistry = new registry_1.SyncRegistry(theme_1.Theme.createFromRawTheme(locator.theme));
this.installationQueue = /* @__PURE__ */ new Map();
}
Registry2.prototype.setTheme = function(theme2) {
this._syncRegistry.setTheme(theme_1.Theme.createFromRawTheme(theme2));
};
Registry2.prototype.getColorMap = function() {
return this._syncRegistry.getColorMap();
};
Registry2.prototype.loadGrammarWithEmbeddedLanguages = function(initialScopeName, initialLanguage, embeddedLanguages) {
return this.loadGrammarWithConfiguration(initialScopeName, initialLanguage, { embeddedLanguages });
};
Registry2.prototype.loadGrammarWithConfiguration = function(initialScopeName, initialLanguage, configuration) {
return __awaiter(this, void 0, void 0, function() {
return __generator(this, function(_a2) {
switch (_a2.label) {
case 0:
return [4, this._loadGrammar(initialScopeName)];
case 1:
_a2.sent();
return [2, this.grammarForScopeName(initialScopeName, initialLanguage, configuration.embeddedLanguages, configuration.tokenTypes)];
}
});
});
};
Registry2.prototype.loadGrammar = function(initialScopeName) {
return __awaiter(this, void 0, void 0, function() {
return __generator(this, function(_a2) {
return [2, this._loadGrammar(initialScopeName)];
});
});
};
Registry2.prototype._loadGrammar = function(initialScopeName, dependentScope) {
if (dependentScope === void 0) {
dependentScope = null;
}
return __awaiter(this, void 0, void 0, function() {
var prom;
var _this = this;
return __generator(this, function(_a2) {
switch (_a2.label) {
case 0:
if (this._syncRegistry.lookup(initialScopeName)) {
return [2, this.grammarForScopeName(initialScopeName)];
}
if (this.installationQueue.has(initialScopeName)) {
return [2, this.installationQueue.get(initialScopeName)];
}
prom = new Promise(function(resolve, reject) {
return __awaiter(_this, void 0, void 0, function() {
var grammarDefinition, rawGrammar, injections, deps;
var _this2 = this;
return __generator(this, function(_a3) {
switch (_a3.label) {
case 0:
return [4, this._locator.getGrammarDefinition(initialScopeName, dependentScope)];
case 1:
grammarDefinition = _a3.sent();
if (!grammarDefinition) {
throw new Error("A tmGrammar load was requested but registry host failed to provide grammar definition");
}
if (grammarDefinition.format !== "json" && grammarDefinition.format !== "plist" || grammarDefinition.format === "json" && typeof grammarDefinition.content !== "object" && typeof grammarDefinition.content !== "string" || grammarDefinition.format === "plist" && typeof grammarDefinition.content !== "string") {
throw new TypeError('Grammar definition must be an object, either `{ content: string | object, format: "json" }` OR `{ content: string, format: "plist" }`)');
}
rawGrammar = grammarDefinition.format === "json" ? typeof grammarDefinition.content === "string" ? grammarReader_1.parseJSONGrammar(grammarDefinition.content, "c://fakepath/grammar.json") : grammarDefinition.content : grammarReader_1.parsePLISTGrammar(grammarDefinition.content, "c://fakepath/grammar.plist");
injections = typeof this._locator.getInjections === "function" && this._locator.getInjections(initialScopeName);
rawGrammar.scopeName = initialScopeName;
deps = this._syncRegistry.addGrammar(rawGrammar, injections);
return [4, Promise.all(deps.map(function(scopeNameD) {
return __awaiter(_this2, void 0, void 0, function() {
return __generator(this, function(_a4) {
try {
return [2, this._loadGrammar(scopeNameD, initialScopeName)];
} catch (error) {
throw new Error("While trying to load tmGrammar with scopeId: '" + initialScopeName + "', it's dependency (scopeId: " + scopeNameD + ") loading errored: " + error.message);
}
return [2];
});
});
}))];
case 2:
_a3.sent();
resolve(this.grammarForScopeName(initialScopeName));
return [2];
}
});
});
});
this.installationQueue.set(initialScopeName, prom);
return [4, prom];
case 1:
_a2.sent();
this.installationQueue.delete(initialScopeName);
return [2, prom];
}
});
});
};
Registry2.prototype.grammarForScopeName = function(scopeName, initialLanguage, embeddedLanguages, tokenTypes) {
if (initialLanguage === void 0) {
initialLanguage = 0;
}
if (embeddedLanguages === void 0) {
embeddedLanguages = null;
}
if (tokenTypes === void 0) {
tokenTypes = null;
}
return this._syncRegistry.grammarForScopeName(scopeName, initialLanguage, embeddedLanguages, tokenTypes);
};
return Registry2;
}();
var Registry_1 = main$1.Registry = Registry;
main$1.INITIAL = grammar_1.StackElement.NULL;
var dist = {};
var tmToMonacoToken = {};
Object.defineProperty(tmToMonacoToken, "__esModule", { value: true });
tmToMonacoToken.TMToMonacoToken = void 0;
const TMToMonacoToken = (editor, scopes) => {
let scopeName = "";
for (let i = scopes[0].length - 1; i >= 0; i -= 1) {
const char = scopes[0][i];
if (char === ".") {
break;
}
scopeName = char + scopeName;
}
for (let i = scopes.length - 1; i >= 0; i -= 1) {
const scope = scopes[i];
for (let i2 = scope.length - 1; i2 >= 0; i2 -= 1) {
const char = scope[i2];
if (char === ".") {
const token = scope.slice(0, i2);
if (editor["_themeService"]._theme._tokenTheme._match(token + "." + scopeName)._foreground > 1) {
return token + "." + scopeName;
}
if (editor["_themeService"]._theme._tokenTheme._match(token)._foreground > 1) {
return token;
}
}
}
}
return "";
};
tmToMonacoToken.TMToMonacoToken = TMToMonacoToken;
Object.defineProperty(dist, "__esModule", { value: true });
var wireTmGrammars_1 = dist.wireTmGrammars = void 0;
const monaco_textmate_1 = main$1;
const tm_to_monaco_token_1 = tmToMonacoToken;
class TokenizerState {
constructor(_ruleStack) {
__publicField(this, "_ruleStack");
this._ruleStack = _ruleStack;
}
get ruleStack() {
return this._ruleStack;
}
clone() {
return new TokenizerState(this._ruleStack);
}
equals(other) {
if (!other || !(other instanceof TokenizerState) || other !== this || other._ruleStack !== this._ruleStack) {
return false;
}
return true;
}
}
function wireTmGrammars(monaco, registry2, languages, editor) {
return Promise.all(Array.from(languages.keys()).map(async (languageId) => {
const grammar2 = await registry2.loadGrammar(languages.get(languageId));
monaco.languages.setTokensProvider(languageId, {
getInitialState: () => new TokenizerState(monaco_textmate_1.INITIAL),
tokenize: (line, state) => {
const res = grammar2.tokenizeLine(line, state.ruleStack);
return {
endState: new TokenizerState(res.ruleStack),
tokens: res.tokens.map((token) => ({
...token,
scopes: editor ? (0, tm_to_monaco_token_1.TMToMonacoToken)(editor, token.scopes) : token.scopes[token.scopes.length - 1]
}))
};
}
});
}));
}
wireTmGrammars_1 = dist.wireTmGrammars = wireTmGrammars;
const initMonacoEditor = async () => {
await loadWASM(`${"https://baozoulolw.oss-cn-chengdu.aliyuncs.com/codeSet/data"}/onigasm/onigasm.wasm`);
};
const wire = async (languageId, editor, monaco) => {
languageId = ["vue2", "vue3", "vue"].includes(languageId) ? "vue" : languageId;
if (!scopeNameMap[languageId]) {
return;
}
const grammars = /* @__PURE__ */ new Map();
grammars.set(languageId, scopeNameMap[languageId]);
const registry2 = new Registry_1({
getGrammarDefinition: async (scopeName) => {
let jsonMap = tmGrammarJsonMap[scopeName];
if (!jsonMap) {
return null;
}
let format = "json";
let path2 = jsonMap;
if (typeof jsonMap !== "string") {
format = jsonMap.format;
path2 = jsonMap.path;
}
let text = await (await fetch(`${"https://baozoulolw.oss-cn-chengdu.aliyuncs.com/codeSet/data"}/grammars/${path2}`)).text();
return {
format,
content: text
};
}
});
if (!monacoEditorInnerLanguages.includes(languageId)) {
monaco.languages.register({ id: languageId });
}
await wireTmGrammars_1(monaco, registry2, grammars, editor);
};
var E;
(function(e4) {
e4[e4.Canceled = 1] = "Canceled", e4[e4.Unknown = 2] = "Unknown", e4[e4.InvalidArgument = 3] = "InvalidArgument", e4[e4.DeadlineExceeded = 4] = "DeadlineExceeded", e4[e4.NotFound = 5] = "NotFound", e4[e4.AlreadyExists = 6] = "AlreadyExists", e4[e4.PermissionDenied = 7] = "PermissionDenied", e4[e4.ResourceExhausted = 8] = "ResourceExhausted", e4[e4.FailedPrecondition = 9] = "FailedPrecondition", e4[e4.Aborted = 10] = "Aborted", e4[e4.OutOfRange = 11] = "OutOfRange", e4[e4.Unimplemented = 12] = "Unimplemented", e4[e4.Internal = 13] = "Internal", e4[e4.Unavailable = 14] = "Unavailable", e4[e4.DataLoss = 15] = "DataLoss", e4[e4.Unauthenticated = 16] = "Unauthenticated";
})(E || (E = {}));
function N(e4, t) {
if (!e4)
throw new Error(t);
}
var On = 34028234663852886e22, Un = -34028234663852886e22, Rn = 4294967295, Fn = 2147483647, _n = -2147483648;
function L(e4) {
if (typeof e4 != "number")
throw new Error("invalid int 32: " + typeof e4);
if (!Number.isInteger(e4) || e4 > Fn || e4 < _n)
throw new Error("invalid int 32: " + e4);
}
function j(e4) {
if (typeof e4 != "number")
throw new Error("invalid uint 32: " + typeof e4);
if (!Number.isInteger(e4) || e4 > Rn || e4 < 0)
throw new Error("invalid uint 32: " + e4);
}
function oe(e4) {
if (typeof e4 != "number")
throw new Error("invalid float 32: " + typeof e4);
if (Number.isFinite(e4) && (e4 > On || e4 < Un))
throw new Error("invalid float 32: " + e4);
}
var Tt = Symbol("@bufbuild/protobuf/enum-type");
function St(e4) {
let t = e4[Tt];
return N(t, "missing enum type on enum object"), t;
}
function $e(e4, t, n, r) {
e4[Tt] = je(t, n.map((o) => ({ no: o.no, name: o.name, localName: e4[o.no] })));
}
function je(e4, t, n) {
let r = /* @__PURE__ */ Object.create(null), o = /* @__PURE__ */ Object.create(null), i = [];
for (let s of t) {
let a = Nt(s);
i.push(a), r[s.name] = a, o[s.no] = a;
}
return { typeName: e4, values: i, findName(s) {
return r[s];
}, findNumber(s) {
return o[s];
} };
}
function At(e4, t, n) {
let r = {};
for (let o of t) {
let i = Nt(o);
r[i.localName] = i.no, r[i.no] = i.localName;
}
return $e(r, e4, t), r;
}
function Nt(e4) {
return "localName" in e4 ? e4 : Object.assign(Object.assign({}, e4), { localName: e4.name });
}
var w = class {
equals(t) {
return this.getType().runtime.util.equals(this.getType(), this, t);
}
clone() {
return this.getType().runtime.util.clone(this);
}
fromBinary(t, n) {
let r = this.getType(), o = r.runtime.bin, i = o.makeReadOptions(n);
return o.readMessage(this, i.readerFactory(t), t.byteLength, i), this;
}
fromJson(t, n) {
let r = this.getType(), o = r.runtime.json, i = o.makeReadOptions(n);
return o.readMessage(r, t, i, this), this;
}
fromJsonString(t, n) {
let r;
try {
r = JSON.parse(t);
} catch (o) {
throw new Error(`cannot decode ${this.getType().typeName} from JSON: ${o instanceof Error ? o.message : String(o)}`);
}
return this.fromJson(r, n);
}
toBinary(t) {
let n = this.getType(), r = n.runtime.bin, o = r.makeWriteOptions(t), i = o.writerFactory();
return r.writeMessage(this, i, o), i.finish();
}
toJson(t) {
let n = this.getType(), r = n.runtime.json, o = r.makeWriteOptions(t);
return r.writeMessage(this, o);
}
toJsonString(t) {
var n;
let r = this.toJson(t);
return JSON.stringify(r, null, (n = t == null ? void 0 : t.prettySpaces) !== null && n !== void 0 ? n : 0);
}
toJSON() {
return this.toJson({ emitDefaultValues: true });
}
getType() {
return Object.getPrototypeOf(this).constructor;
}
};
function Pt(e4, t, n, r) {
var o;
let i = (o = r == null ? void 0 : r.localName) !== null && o !== void 0 ? o : t.substring(t.lastIndexOf(".") + 1), s = { [i]: function(a) {
e4.util.initFields(this), e4.util.initPartial(a, this);
} }[i];
return Object.setPrototypeOf(s.prototype, new w()), Object.assign(s, { runtime: e4, typeName: t, fields: e4.util.newFieldList(n), fromBinary(a, c) {
return new s().fromBinary(a, c);
}, fromJson(a, c) {
return new s().fromJson(a, c);
}, fromJsonString(a, c) {
return new s().fromJsonString(a, c);
}, equals(a, c) {
return e4.util.equals(s, a, c);
} }), s;
}
function vt(e4, t, n, r) {
return { syntax: e4, json: t, bin: n, util: r, makeMessageType(o, i, s) {
return Pt(this, o, i, s);
}, makeEnum: At, makeEnumType: je, getEnumType: St };
}
var f;
(function(e4) {
e4[e4.DOUBLE = 1] = "DOUBLE", e4[e4.FLOAT = 2] = "FLOAT", e4[e4.INT64 = 3] = "INT64", e4[e4.UINT64 = 4] = "UINT64", e4[e4.INT32 = 5] = "INT32", e4[e4.FIXED64 = 6] = "FIXED64", e4[e4.FIXED32 = 7] = "FIXED32", e4[e4.BOOL = 8] = "BOOL", e4[e4.STRING = 9] = "STRING", e4[e4.BYTES = 12] = "BYTES", e4[e4.UINT32 = 13] = "UINT32", e4[e4.SFIXED32 = 15] = "SFIXED32", e4[e4.SFIXED64 = 16] = "SFIXED64", e4[e4.SINT32 = 17] = "SINT32", e4[e4.SINT64 = 18] = "SINT64";
})(f || (f = {}));
var R;
(function(e4) {
e4[e4.BIGINT = 0] = "BIGINT", e4[e4.STRING = 1] = "STRING";
})(R || (R = {}));
function kt() {
let e4 = 0, t = 0;
for (let r = 0; r < 28; r += 7) {
let o = this.buf[this.pos++];
if (e4 |= (o & 127) << r, !(o & 128))
return this.assertBounds(), [e4, t];
}
let n = this.buf[this.pos++];
if (e4 |= (n & 15) << 28, t = (n & 112) >> 4, !(n & 128))
return this.assertBounds(), [e4, t];
for (let r = 3; r <= 31; r += 7) {
let o = this.buf[this.pos++];
if (t |= (o & 127) << r, !(o & 128))
return this.assertBounds(), [e4, t];
}
throw new Error("invalid varint");
}
function se(e4, t, n) {
for (let i = 0; i < 28; i = i + 7) {
let s = e4 >>> i, a = !(!(s >>> 7) && t == 0), c = (a ? s | 128 : s) & 255;
if (n.push(c), !a)
return;
}
let r = e4 >>> 28 & 15 | (t & 7) << 4, o = !!(t >> 3);
if (n.push((o ? r | 128 : r) & 255), !!o) {
for (let i = 3; i < 31; i = i + 7) {
let s = t >>> i, a = !!(s >>> 7), c = (a ? s | 128 : s) & 255;
if (n.push(c), !a)
return;
}
n.push(t >>> 31 & 1);
}
}
var ie = 4294967296;
function He(e4) {
let t = e4[0] === "-";
t && (e4 = e4.slice(1));
let n = 1e6, r = 0, o = 0;
function i(s, a) {
let c = Number(e4.slice(s, a));
o *= n, r = r * n + c, r >= ie && (o = o + (r / ie | 0), r = r % ie);
}
return i(-24, -18), i(-18, -12), i(-12, -6), i(-6), t ? Ut(r, o) : ze(r, o);
}
function Ot(e4, t) {
let n = ze(e4, t), r = n.hi & 2147483648;
r && (n = Ut(n.lo, n.hi));
let o = Xe(n.lo, n.hi);
return r ? "-" + o : o;
}
function Xe(e4, t) {
if ({ lo: e4, hi: t } = Jn(e4, t), t <= 2097151)
return String(ie * t + e4);
let n = e4 & 16777215, r = (e4 >>> 24 | t << 8) & 16777215, o = t >> 16 & 65535, i = n + r * 6777216 + o * 6710656, s = r + o * 8147497, a = o * 2, c = 1e7;
return i >= c && (s += Math.floor(i / c), i %= c), s >= c && (a += Math.floor(s / c), s %= c), a.toString() + Ct(s) + Ct(i);
}
function Jn(e4, t) {
return { lo: e4 >>> 0, hi: t >>> 0 };
}
function ze(e4, t) {
return { lo: e4 | 0, hi: t | 0 };
}
function Ut(e4, t) {
return t = ~t, e4 ? e4 = ~e4 + 1 : t += 1, ze(e4, t);
}
var Ct = (e4) => {
let t = String(e4);
return "0000000".slice(t.length) + t;
};
function Ye(e4, t) {
if (e4 >= 0) {
for (; e4 > 127; )
t.push(e4 & 127 | 128), e4 = e4 >>> 7;
t.push(e4);
} else {
for (let n = 0; n < 9; n++)
t.push(e4 & 127 | 128), e4 = e4 >> 7;
t.push(1);
}
}
function Rt() {
let e4 = this.buf[this.pos++], t = e4 & 127;
if (!(e4 & 128))
return this.assertBounds(), t;
if (e4 = this.buf[this.pos++], t |= (e4 & 127) << 7, !(e4 & 128))
return this.assertBounds(), t;
if (e4 = this.buf[this.pos++], t |= (e4 & 127) << 14, !(e4 & 128))
return this.assertBounds(), t;
if (e4 = this.buf[this.pos++], t |= (e4 & 127) << 21, !(e4 & 128))
return this.assertBounds(), t;
e4 = this.buf[this.pos++], t |= (e4 & 15) << 28;
for (let n = 5; e4 & 128 && n < 10; n++)
e4 = this.buf[this.pos++];
if (e4 & 128)
throw new Error("invalid varint");
return this.assertBounds(), t >>> 0;
}
function Mn() {
let e4 = new DataView(new ArrayBuffer(8));
if (typeof BigInt == "function" && typeof e4.getBigInt64 == "function" && typeof e4.getBigUint64 == "function" && typeof e4.setBigInt64 == "function" && typeof e4.setBigUint64 == "function" && (typeof process != "object" || typeof process.env != "object" || {}.BUF_BIGINT_DISABLE !== "1")) {
let o = BigInt("-9223372036854775808"), i = BigInt("9223372036854775807"), s = BigInt("0"), a = BigInt("18446744073709551615");
return { zero: BigInt(0), supported: true, parse(c) {
let l = typeof c == "bigint" ? c : BigInt(c);
if (l > i || l < o)
throw new Error(`int64 invalid: ${c}`);
return l;
}, uParse(c) {
let l = typeof c == "bigint" ? c : BigInt(c);
if (l > a || l < s)
throw new Error(`uint64 invalid: ${c}`);
return l;
}, enc(c) {
return e4.setBigInt64(0, this.parse(c), true), { lo: e4.getInt32(0, true), hi: e4.getInt32(4, true) };
}, uEnc(c) {
return e4.setBigInt64(0, this.uParse(c), true), { lo: e4.getInt32(0, true), hi: e4.getInt32(4, true) };
}, dec(c, l) {
return e4.setInt32(0, c, true), e4.setInt32(4, l, true), e4.getBigInt64(0, true);
}, uDec(c, l) {
return e4.setInt32(0, c, true), e4.setInt32(4, l, true), e4.getBigUint64(0, true);
} };
}
let n = (o) => N(/^-?[0-9]+$/.test(o), `int64 invalid: ${o}`), r = (o) => N(/^[0-9]+$/.test(o), `uint64 invalid: ${o}`);
return { zero: "0", supported: false, parse(o) {
return typeof o != "string" && (o = o.toString()), n(o), o;
}, uParse(o) {
return typeof o != "string" && (o = o.toString()), r(o), o;
}, enc(o) {
return typeof o != "string" && (o = o.toString()), n(o), He(o);
}, uEnc(o) {
return typeof o != "string" && (o = o.toString()), r(o), He(o);
}, dec(o, i) {
return Ot(o, i);
}, uDec(o, i) {
return Xe(o, i);
} };
}
var x = Mn();
var A;
(function(e4) {
e4[e4.Varint = 0] = "Varint", e4[e4.Bit64 = 1] = "Bit64", e4[e4.LengthDelimited = 2] = "LengthDelimited", e4[e4.StartGroup = 3] = "StartGroup", e4[e4.EndGroup = 4] = "EndGroup", e4[e4.Bit32 = 5] = "Bit32";
})(A || (A = {}));
var ae = class {
constructor(t) {
this.stack = [], this.textEncoder = t != null ? t : new TextEncoder(), this.chunks = [], this.buf = [];
}
finish() {
this.chunks.push(new Uint8Array(this.buf));
let t = 0;
for (let o = 0; o < this.chunks.length; o++)
t += this.chunks[o].length;
let n = new Uint8Array(t), r = 0;
for (let o = 0; o < this.chunks.length; o++)
n.set(this.chunks[o], r), r += this.chunks[o].length;
return this.chunks = [], n;
}
fork() {
return this.stack.push({ chunks: this.chunks, buf: this.buf }), this.chunks = [], this.buf = [], this;
}
join() {
let t = this.finish(), n = this.stack.pop();
if (!n)
throw new Error("invalid state, fork stack empty");
return this.chunks = n.chunks, this.buf = n.buf, this.uint32(t.byteLength), this.raw(t);
}
tag(t, n) {
return this.uint32((t << 3 | n) >>> 0);
}
raw(t) {
return this.buf.length && (this.chunks.push(new Uint8Array(this.buf)), this.buf = []), this.chunks.push(t), this;
}
uint32(t) {
for (j(t); t > 127; )
this.buf.push(t & 127 | 128), t = t >>> 7;
return this.buf.push(t), this;
}
int32(t) {
return L(t), Ye(t, this.buf), this;
}
bool(t) {
return this.buf.push(t ? 1 : 0), this;
}
bytes(t) {
return this.uint32(t.byteLength), this.raw(t);
}
string(t) {
let n = this.textEncoder.encode(t);
return this.uint32(n.byteLength), this.raw(n);
}
float(t) {
oe(t);
let n = new Uint8Array(4);
return new DataView(n.buffer).setFloat32(0, t, true), this.raw(n);
}
double(t) {
let n = new Uint8Array(8);
return new DataView(n.buffer).setFloat64(0, t, true), this.raw(n);
}
fixed32(t) {
j(t);
let n = new Uint8Array(4);
return new DataView(n.buffer).setUint32(0, t, true), this.raw(n);
}
sfixed32(t) {
L(t);
let n = new Uint8Array(4);
return new DataView(n.buffer).setInt32(0, t, true), this.raw(n);
}
sint32(t) {
return L(t), t = (t << 1 ^ t >> 31) >>> 0, Ye(t, this.buf), this;
}
sfixed64(t) {
let n = new Uint8Array(8), r = new DataView(n.buffer), o = x.enc(t);
return r.setInt32(0, o.lo, true), r.setInt32(4, o.hi, true), this.raw(n);
}
fixed64(t) {
let n = new Uint8Array(8), r = new DataView(n.buffer), o = x.uEnc(t);
return r.setInt32(0, o.lo, true), r.setInt32(4, o.hi, true), this.raw(n);
}
int64(t) {
let n = x.enc(t);
return se(n.lo, n.hi, this.buf), this;
}
sint64(t) {
let n = x.enc(t), r = n.hi >> 31, o = n.lo << 1 ^ r, i = (n.hi << 1 | n.lo >>> 31) ^ r;
return se(o, i, this.buf), this;
}
uint64(t) {
let n = x.uEnc(t);
return se(n.lo, n.hi, this.buf), this;
}
}, ce = class {
constructor(t, n) {
this.varint64 = kt, this.uint32 = Rt, this.buf = t, this.len = t.length, this.pos = 0, this.view = new DataView(t.buffer, t.byteOffset, t.byteLength), this.textDecoder = n != null ? n : new TextDecoder();
}
tag() {
let t = this.uint32(), n = t >>> 3, r = t & 7;
if (n <= 0 || r < 0 || r > 5)
throw new Error("illegal tag: field no " + n + " wire type " + r);
return [n, r];
}
skip(t) {
let n = this.pos;
switch (t) {
case A.Varint:
for (; this.buf[this.pos++] & 128; )
;
break;
case A.Bit64:
this.pos += 4;
case A.Bit32:
this.pos += 4;
break;
case A.LengthDelimited:
let r = this.uint32();
this.pos += r;
break;
case A.StartGroup:
let o;
for (; (o = this.tag()[1]) !== A.EndGroup; )
this.skip(o);
break;
default:
throw new Error("cant skip wire type " + t);
}
return this.assertBounds(), this.buf.subarray(n, this.pos);
}
assertBounds() {
if (this.pos > this.len)
throw new RangeError("premature EOF");
}
int32() {
return this.uint32() | 0;
}
sint32() {
let t = this.uint32();
return t >>> 1 ^ -(t & 1);
}
int64() {
return x.dec(...this.varint64());
}
uint64() {
return x.uDec(...this.varint64());
}
sint64() {
let [t, n] = this.varint64(), r = -(t & 1);
return t = (t >>> 1 | (n & 1) << 31) ^ r, n = n >>> 1 ^ r, x.dec(t, n);
}
bool() {
let [t, n] = this.varint64();
return t !== 0 || n !== 0;
}
fixed32() {
return this.view.getUint32((this.pos += 4) - 4, true);
}
sfixed32() {
return this.view.getInt32((this.pos += 4) - 4, true);
}
fixed64() {
return x.uDec(this.sfixed32(), this.sfixed32());
}
sfixed64() {
return x.dec(this.sfixed32(), this.sfixed32());
}
float() {
return this.view.getFloat32((this.pos += 4) - 4, true);
}
double() {
return this.view.getFloat64((this.pos += 8) - 8, true);
}
bytes() {
let t = this.uint32(), n = this.pos;
return this.pos += t, this.assertBounds(), this.buf.subarray(n, n + t);
}
string() {
return this.textDecoder.decode(this.bytes());
}
};
function H(e4, t) {
return t instanceof w || !e4.fieldWrapper ? t : e4.fieldWrapper.wrapField(t);
}
({ "google.protobuf.DoubleValue": f.DOUBLE, "google.protobuf.FloatValue": f.FLOAT, "google.protobuf.Int64Value": f.INT64, "google.protobuf.UInt64Value": f.UINT64, "google.protobuf.Int32Value": f.INT32, "google.protobuf.UInt32Value": f.UINT32, "google.protobuf.BoolValue": f.BOOL, "google.protobuf.StringValue": f.STRING, "google.protobuf.BytesValue": f.BYTES });
function F(e4, t, n) {
if (t === n)
return true;
if (e4 == f.BYTES) {
if (!(t instanceof Uint8Array) || !(n instanceof Uint8Array) || t.length !== n.length)
return false;
for (let r = 0; r < t.length; r++)
if (t[r] !== n[r])
return false;
return true;
}
switch (e4) {
case f.UINT64:
case f.FIXED64:
case f.INT64:
case f.SFIXED64:
case f.SINT64:
return t == n;
}
return false;
}
function X(e4, t) {
switch (e4) {
case f.BOOL:
return false;
case f.UINT64:
case f.FIXED64:
case f.INT64:
case f.SFIXED64:
case f.SINT64:
return t == 0 ? x.zero : "0";
case f.DOUBLE:
case f.FLOAT:
return 0;
case f.BYTES:
return new Uint8Array(0);
case f.STRING:
return "";
default:
return 0;
}
}
function Ke(e4, t) {
let n = t === void 0, r = A.Varint, o = t === 0;
switch (e4) {
case f.STRING:
o = n || !t.length, r = A.LengthDelimited;
break;
case f.BOOL:
o = t === false;
break;
case f.DOUBLE:
r = A.Bit64;
break;
case f.FLOAT:
r = A.Bit32;
break;
case f.INT64:
o = n || t == 0;
break;
case f.UINT64:
o = n || t == 0;
break;
case f.FIXED64:
o = n || t == 0, r = A.Bit64;
break;
case f.BYTES:
o = n || !t.byteLength, r = A.LengthDelimited;
break;
case f.FIXED32:
r = A.Bit32;
break;
case f.SFIXED32:
r = A.Bit32;
break;
case f.SFIXED64:
o = n || t == 0, r = A.Bit64;
break;
case f.SINT64:
o = n || t == 0;
break;
}
let i = f[e4].toLowerCase();
return [r, i, n || o];
}
var D = Symbol("@bufbuild/protobuf/unknown-fields"), Ft = { readUnknownFields: true, readerFactory: (e4) => new ce(e4) }, _t = { writeUnknownFields: true, writerFactory: () => new ae() };
function Gn(e4) {
return e4 ? Object.assign(Object.assign({}, Ft), e4) : Ft;
}
function Bn(e4) {
return e4 ? Object.assign(Object.assign({}, _t), e4) : _t;
}
function Jt() {
return { makeReadOptions: Gn, makeWriteOptions: Bn, listUnknownFields(e4) {
var t;
return (t = e4[D]) !== null && t !== void 0 ? t : [];
}, discardUnknownFields(e4) {
delete e4[D];
}, writeUnknownFields(e4, t) {
let r = e4[D];
if (r)
for (let o of r)
t.tag(o.no, o.wireType).raw(o.data);
}, onUnknownField(e4, t, n, r) {
let o = e4;
Array.isArray(o[D]) || (o[D] = []), o[D].push({ no: t, wireType: n, data: r });
}, readMessage(e4, t, n, r) {
let o = e4.getType(), i = n === void 0 ? t.len : t.pos + n;
for (; t.pos < i; ) {
let [s, a] = t.tag(), c = o.fields.find(s);
if (!c) {
let m = t.skip(a);
r.readUnknownFields && this.onUnknownField(e4, s, a, m);
continue;
}
let l = e4, h = c.repeated, y = c.localName;
switch (c.oneof && (l = l[c.oneof.localName], l.case != y && delete l.value, l.case = y, y = "value"), c.kind) {
case "scalar":
case "enum":
let m = c.kind == "enum" ? f.INT32 : c.T, p = ue;
if (c.kind == "scalar" && c.L > 0 && (p = Dn), h) {
let v = l[y];
if (a == A.LengthDelimited && m != f.STRING && m != f.BYTES) {
let T = t.uint32() + t.pos;
for (; t.pos < T; )
v.push(p(t, m));
} else
v.push(p(t, m));
} else
l[y] = p(t, m);
break;
case "message":
let g = c.T;
h ? l[y].push(le(t, new g(), r)) : l[y] instanceof w ? le(t, l[y], r) : (l[y] = le(t, new g(), r), g.fieldWrapper && !c.oneof && !c.repeated && (l[y] = g.fieldWrapper.unwrapField(l[y])));
break;
case "map":
let [b, I] = Ln(c, t, r);
l[y][b] = I;
break;
}
}
} };
}
function le(e4, t, n) {
return t.getType().runtime.bin.readMessage(t, e4, e4.uint32(), n), t;
}
function Ln(e4, t, n) {
let r = t.uint32(), o = t.pos + r, i, s;
for (; t.pos < o; ) {
let [a] = t.tag();
switch (a) {
case 1:
i = ue(t, e4.K);
break;
case 2:
switch (e4.V.kind) {
case "scalar":
s = ue(t, e4.V.T);
break;
case "enum":
s = t.int32();
break;
case "message":
s = le(t, new e4.V.T(), n);
break;
}
break;
}
}
if (i === void 0) {
let a = X(e4.K, R.BIGINT);
i = e4.K == f.BOOL ? a.toString() : a;
}
if (typeof i != "string" && typeof i != "number" && (i = i.toString()), s === void 0)
switch (e4.V.kind) {
case "scalar":
s = X(e4.V.T, R.BIGINT);
break;
case "enum":
s = 0;
break;
case "message":
s = new e4.V.T();
break;
}
return [i, s];
}
function Dn(e4, t) {
let n = ue(e4, t);
return typeof n == "bigint" ? n.toString() : n;
}
function ue(e4, t) {
switch (t) {
case f.STRING:
return e4.string();
case f.BOOL:
return e4.bool();
case f.DOUBLE:
return e4.double();
case f.FLOAT:
return e4.float();
case f.INT32:
return e4.int32();
case f.INT64:
return e4.int64();
case f.UINT64:
return e4.uint64();
case f.FIXED64:
return e4.fixed64();
case f.BYTES:
return e4.bytes();
case f.FIXED32:
return e4.fixed32();
case f.SFIXED32:
return e4.sfixed32();
case f.SFIXED64:
return e4.sfixed64();
case f.SINT64:
return e4.sint64();
case f.UINT32:
return e4.uint32();
case f.SINT32:
return e4.sint32();
}
}
function Mt(e4, t, n, r, o) {
e4.tag(n.no, A.LengthDelimited), e4.fork();
let i = r;
switch (n.K) {
case f.INT32:
case f.FIXED32:
case f.UINT32:
case f.SFIXED32:
case f.SINT32:
i = Number.parseInt(r);
break;
case f.BOOL:
N(r == "true" || r == "false"), i = r == "true";
break;
}
switch (V(e4, n.K, 1, i, true), n.V.kind) {
case "scalar":
V(e4, n.V.T, 2, o, true);
break;
case "enum":
V(e4, f.INT32, 2, o, true);
break;
case "message":
fe(e4, t, n.V.T, 2, o);
break;
}
e4.join();
}
function fe(e4, t, n, r, o) {
if (o !== void 0) {
let i = H(n, o);
e4.tag(r, A.LengthDelimited).bytes(i.toBinary(t));
}
}
function V(e4, t, n, r, o) {
let [i, s, a] = Ke(t, r);
(!a || o) && e4.tag(n, i)[s](r);
}
function Gt(e4, t, n, r) {
if (!r.length)
return;
e4.tag(n, A.LengthDelimited).fork();
let [, o] = Ke(t);
for (let i = 0; i < r.length; i++)
e4[o](r[i]);
e4.join();
}
function Bt() {
return Object.assign(Object.assign({}, Jt()), { writeMessage(e4, t, n) {
let r = e4.getType();
for (let o of r.fields.byNumber()) {
let i, s = o.repeated, a = o.localName;
if (o.oneof) {
let c = e4[o.oneof.localName];
if (c.case !== a)
continue;
i = c.value;
} else
i = e4[a];
switch (o.kind) {
case "scalar":
case "enum":
let c = o.kind == "enum" ? f.INT32 : o.T;
if (s)
if (o.packed)
Gt(t, c, o.no, i);
else
for (let l of i)
V(t, c, o.no, l, true);
else
i !== void 0 && V(t, c, o.no, i, !!o.oneof || o.opt);
break;
case "message":
if (s)
for (let l of i)
fe(t, n, o.T, o.no, l);
else
fe(t, n, o.T, o.no, i);
break;
case "map":
for (let [l, h] of Object.entries(i))
Mt(t, n, o, l, h);
break;
}
}
return n.writeUnknownFields && this.writeUnknownFields(e4, t), t;
} });
}
var _$2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split(""), me = [];
for (let e4 = 0; e4 < _$2.length; e4++)
me[_$2[e4].charCodeAt(0)] = e4;
me[45] = _$2.indexOf("+");
me[95] = _$2.indexOf("/");
var J = { dec(e4) {
let t = e4.length * 3 / 4;
e4[e4.length - 2] == "=" ? t -= 2 : e4[e4.length - 1] == "=" && (t -= 1);
let n = new Uint8Array(t), r = 0, o = 0, i, s = 0;
for (let a = 0; a < e4.length; a++) {
if (i = me[e4.charCodeAt(a)], i === void 0)
switch (e4[a]) {
case "=":
o = 0;
case `
`:
case "\r":
case " ":
case " ":
continue;
default:
throw Error("invalid base64 string.");
}
switch (o) {
case 0:
s = i, o = 1;
break;
case 1:
n[r++] = s << 2 | (i & 48) >> 4, s = i, o = 2;
break;
case 2:
n[r++] = (s & 15) << 4 | (i & 60) >> 2, s = i, o = 3;
break;
case 3:
n[r++] = (s & 3) << 6 | i, o = 0;
break;
}
}
if (o == 1)
throw Error("invalid base64 string.");
return n.subarray(0, r);
}, enc(e4) {
let t = "", n = 0, r, o = 0;
for (let i = 0; i < e4.length; i++)
switch (r = e4[i], n) {
case 0:
t += _$2[r >> 2], o = (r & 3) << 4, n = 1;
break;
case 1:
t += _$2[o | r >> 4], o = (r & 15) << 2, n = 2;
break;
case 2:
t += _$2[o | r >> 6], t += _$2[r & 63], n = 0;
break;
}
return n && (t += _$2[o], t += "=", n == 1 && (t += "=")), t;
} };
var Lt = { ignoreUnknownFields: false }, Dt = { emitDefaultValues: false, enumAsInteger: false, useProtoFieldName: false, prettySpaces: 0 };
function Vn(e4) {
return e4 ? Object.assign(Object.assign({}, Lt), e4) : Lt;
}
function qn(e4) {
return e4 ? Object.assign(Object.assign({}, Dt), e4) : Dt;
}
function qt(e4) {
let t = e4($n, Vt);
return { makeReadOptions: Vn, makeWriteOptions: qn, readMessage(n, r, o, i) {
if (r == null || Array.isArray(r) || typeof r != "object")
throw new Error(`cannot decode message ${n.typeName} from JSON: ${this.debug(r)}`);
i = i != null ? i : new n();
let s = {};
for (let [a, c] of Object.entries(r)) {
let l = n.fields.findJsonName(a);
if (!l) {
if (!o.ignoreUnknownFields)
throw new Error(`cannot decode message ${n.typeName} from JSON: key "${a}" is unknown`);
continue;
}
let h = l.localName, y = i;
if (l.oneof) {
if (c === null && l.kind == "scalar")
continue;
let m = s[l.oneof.localName];
if (m)
throw new Error(`cannot decode message ${n.typeName} from JSON: multiple keys for oneof "${l.oneof.name}" present: "${m}", "${a}"`);
s[l.oneof.localName] = a, y = y[l.oneof.localName] = { case: h }, h = "value";
}
if (l.repeated) {
if (c === null)
continue;
if (!Array.isArray(c))
throw new Error(`cannot decode field ${n.typeName}.${l.name} from JSON: ${this.debug(c)}`);
let m = y[h];
for (let p of c) {
if (p === null)
throw new Error(`cannot decode field ${n.typeName}.${l.name} from JSON: ${this.debug(p)}`);
let g;
switch (l.kind) {
case "message":
g = l.T.fromJson(p, o);
break;
case "enum":
if (g = We(l.T, p, o.ignoreUnknownFields), g === void 0)
continue;
break;
case "scalar":
try {
g = z(l.T, p, l.L);
} catch (b) {
let I = `cannot decode field ${n.typeName}.${l.name} from JSON: ${this.debug(p)}`;
throw b instanceof Error && b.message.length > 0 && (I += `: ${b.message}`), new Error(I);
}
break;
}
m.push(g);
}
} else if (l.kind == "map") {
if (c === null)
continue;
if (Array.isArray(c) || typeof c != "object")
throw new Error(`cannot decode field ${n.typeName}.${l.name} from JSON: ${this.debug(c)}`);
let m = y[h];
for (let [p, g] of Object.entries(c)) {
if (g === null)
throw new Error(`cannot decode field ${n.typeName}.${l.name} from JSON: map value null`);
let b;
switch (l.V.kind) {
case "message":
b = l.V.T.fromJson(g, o);
break;
case "enum":
if (b = We(l.V.T, g, o.ignoreUnknownFields), b === void 0)
continue;
break;
case "scalar":
try {
b = z(l.V.T, g, R.BIGINT);
} catch (I) {
let v = `cannot decode map value for field ${n.typeName}.${l.name} from JSON: ${this.debug(c)}`;
throw I instanceof Error && I.message.length > 0 && (v += `: ${I.message}`), new Error(v);
}
break;
}
try {
m[z(l.K, l.K == f.BOOL ? p == "true" ? true : p == "false" ? false : p : p, R.BIGINT).toString()] = b;
} catch (I) {
let v = `cannot decode map key for field ${n.typeName}.${l.name} from JSON: ${this.debug(c)}`;
throw I instanceof Error && I.message.length > 0 && (v += `: ${I.message}`), new Error(v);
}
}
} else
switch (l.kind) {
case "message":
let m = l.T;
if (c === null && m.typeName != "google.protobuf.Value") {
if (l.oneof)
throw new Error(`cannot decode field ${n.typeName}.${l.name} from JSON: null is invalid for oneof field "${a}"`);
continue;
}
y[h] instanceof w ? y[h].fromJson(c, o) : (y[h] = m.fromJson(c, o), m.fieldWrapper && !l.oneof && (y[h] = m.fieldWrapper.unwrapField(y[h])));
break;
case "enum":
let p = We(l.T, c, o.ignoreUnknownFields);
p !== void 0 && (y[h] = p);
break;
case "scalar":
try {
y[h] = z(l.T, c, l.L);
} catch (g) {
let b = `cannot decode field ${n.typeName}.${l.name} from JSON: ${this.debug(c)}`;
throw g instanceof Error && g.message.length > 0 && (b += `: ${g.message}`), new Error(b);
}
break;
}
}
return i;
}, writeMessage(n, r) {
let o = n.getType(), i = {}, s;
try {
for (let a of o.fields.byMember()) {
let c;
if (a.kind == "oneof") {
let l = n[a.localName];
if (l.value === void 0)
continue;
if (s = a.findField(l.case), !s)
throw "oneof case not found: " + l.case;
c = t(s, l.value, r);
} else
s = a, c = t(s, n[s.localName], r);
c !== void 0 && (i[r.useProtoFieldName ? s.name : s.jsonName] = c);
}
} catch (a) {
let c = s ? `cannot encode field ${o.typeName}.${s.name} to JSON` : `cannot encode message ${o.typeName} to JSON`, l = a instanceof Error ? a.message : String(a);
throw new Error(c + (l.length > 0 ? `: ${l}` : ""));
}
return i;
}, readScalar: z, writeScalar: Vt, debug: $t };
}
function $t(e4) {
if (e4 === null)
return "null";
switch (typeof e4) {
case "object":
return Array.isArray(e4) ? "array" : "object";
case "string":
return e4.length > 100 ? "string" : `"${e4.split('"').join('\\"')}"`;
default:
return String(e4);
}
}
function z(e4, t, n) {
switch (e4) {
case f.DOUBLE:
case f.FLOAT:
if (t === null)
return 0;
if (t === "NaN")
return Number.NaN;
if (t === "Infinity")
return Number.POSITIVE_INFINITY;
if (t === "-Infinity")
return Number.NEGATIVE_INFINITY;
if (t === "" || typeof t == "string" && t.trim().length !== t.length || typeof t != "string" && typeof t != "number")
break;
let r = Number(t);
if (Number.isNaN(r) || !Number.isFinite(r))
break;
return e4 == f.FLOAT && oe(r), r;
case f.INT32:
case f.FIXED32:
case f.SFIXED32:
case f.SINT32:
case f.UINT32:
if (t === null)
return 0;
let o;
if (typeof t == "number" ? o = t : typeof t == "string" && t.length > 0 && t.trim().length === t.length && (o = Number(t)), o === void 0)
break;
return e4 == f.UINT32 ? j(o) : L(o), o;
case f.INT64:
case f.SFIXED64:
case f.SINT64:
if (t === null)
return x.zero;
if (typeof t != "number" && typeof t != "string")
break;
let i = x.parse(t);
return n ? i.toString() : i;
case f.FIXED64:
case f.UINT64:
if (t === null)
return x.zero;
if (typeof t != "number" && typeof t != "string")
break;
let s = x.uParse(t);
return n ? s.toString() : s;
case f.BOOL:
if (t === null)
return false;
if (typeof t != "boolean")
break;
return t;
case f.STRING:
if (t === null)
return "";
if (typeof t != "string")
break;
try {
encodeURIComponent(t);
} catch {
throw new Error("invalid UTF8");
}
return t;
case f.BYTES:
if (t === null || t === "")
return new Uint8Array(0);
if (typeof t != "string")
break;
return J.dec(t);
}
throw new Error();
}
function We(e4, t, n) {
if (t === null)
return 0;
switch (typeof t) {
case "number":
if (Number.isInteger(t))
return t;
break;
case "string":
let r = e4.findName(t);
if (r || n)
return r == null ? void 0 : r.no;
break;
}
throw new Error(`cannot decode enum ${e4.typeName} from JSON: ${$t(t)}`);
}
function $n(e4, t, n, r) {
var o;
if (t === void 0)
return t;
if (t === 0 && !n)
return;
if (r)
return t;
if (e4.typeName == "google.protobuf.NullValue")
return null;
let i = e4.findNumber(t);
return (o = i == null ? void 0 : i.name) !== null && o !== void 0 ? o : t;
}
function Vt(e4, t, n) {
if (t !== void 0)
switch (e4) {
case f.INT32:
case f.SFIXED32:
case f.SINT32:
case f.FIXED32:
case f.UINT32:
return N(typeof t == "number"), t != 0 || n ? t : void 0;
case f.FLOAT:
case f.DOUBLE:
return N(typeof t == "number"), Number.isNaN(t) ? "NaN" : t === Number.POSITIVE_INFINITY ? "Infinity" : t === Number.NEGATIVE_INFINITY ? "-Infinity" : t !== 0 || n ? t : void 0;
case f.STRING:
return N(typeof t == "string"), t.length > 0 || n ? t : void 0;
case f.BOOL:
return N(typeof t == "boolean"), t || n ? t : void 0;
case f.UINT64:
case f.FIXED64:
case f.INT64:
case f.SFIXED64:
case f.SINT64:
return N(typeof t == "bigint" || typeof t == "string" || typeof t == "number"), n || t != 0 ? t.toString(10) : void 0;
case f.BYTES:
return N(t instanceof Uint8Array), n || t.byteLength > 0 ? J.enc(t) : void 0;
}
}
function jt() {
return qt((e4, t) => function(r, o, i) {
if (r.kind == "map") {
let s = {};
switch (r.V.kind) {
case "scalar":
for (let [c, l] of Object.entries(o)) {
let h = t(r.V.T, l, true);
N(h !== void 0), s[c.toString()] = h;
}
break;
case "message":
for (let [c, l] of Object.entries(o))
s[c.toString()] = l.toJson(i);
break;
case "enum":
let a = r.V.T;
for (let [c, l] of Object.entries(o)) {
N(l === void 0 || typeof l == "number");
let h = e4(a, l, true, i.enumAsInteger);
N(h !== void 0), s[c.toString()] = h;
}
break;
}
return i.emitDefaultValues || Object.keys(s).length > 0 ? s : void 0;
} else if (r.repeated) {
let s = [];
switch (r.kind) {
case "scalar":
for (let a = 0; a < o.length; a++)
s.push(t(r.T, o[a], true));
break;
case "enum":
for (let a = 0; a < o.length; a++)
s.push(e4(r.T, o[a], true, i.enumAsInteger));
break;
case "message":
for (let a = 0; a < o.length; a++)
s.push(H(r.T, o[a]).toJson(i));
break;
}
return i.emitDefaultValues || s.length > 0 ? s : void 0;
} else
switch (r.kind) {
case "scalar":
return t(r.T, o, !!r.oneof || r.opt || i.emitDefaultValues);
case "enum":
return e4(r.T, o, !!r.oneof || r.opt || i.emitDefaultValues, i.enumAsInteger);
case "message":
return o !== void 0 ? H(r.T, o).toJson(i) : void 0;
}
});
}
function Ht() {
return { setEnumType: $e, initPartial(e4, t) {
if (e4 === void 0)
return;
let n = t.getType();
for (let r of n.fields.byMember()) {
let o = r.localName, i = t, s = e4;
if (s[o] !== void 0)
switch (r.kind) {
case "oneof":
let a = s[o].case;
if (a === void 0)
continue;
let c = r.findField(a), l = s[o].value;
c && c.kind == "message" && !(l instanceof c.T) ? l = new c.T(l) : c && c.kind === "scalar" && c.T === f.BYTES && (l = Y(l)), i[o] = { case: a, value: l };
break;
case "scalar":
case "enum":
let h = s[o];
r.T === f.BYTES && (h = r.repeated ? h.map(Y) : Y(h)), i[o] = h;
break;
case "map":
switch (r.V.kind) {
case "scalar":
case "enum":
if (r.V.T === f.BYTES)
for (let [p, g] of Object.entries(s[o]))
i[o][p] = Y(g);
else
Object.assign(i[o], s[o]);
break;
case "message":
let m = r.V.T;
for (let p of Object.keys(s[o])) {
let g = s[o][p];
m.fieldWrapper || (g = new m(g)), i[o][p] = g;
}
break;
}
break;
case "message":
let y = r.T;
if (r.repeated)
i[o] = s[o].map((m) => m instanceof y ? m : new y(m));
else if (s[o] !== void 0) {
let m = s[o];
y.fieldWrapper ? y.typeName === "google.protobuf.BytesValue" ? i[o] = Y(m) : i[o] = m : i[o] = m instanceof y ? m : new y(m);
}
break;
}
}
}, equals(e4, t, n) {
return t === n ? true : !t || !n ? false : e4.fields.byMember().every((r) => {
let o = t[r.localName], i = n[r.localName];
if (r.repeated) {
if (o.length !== i.length)
return false;
switch (r.kind) {
case "message":
return o.every((s, a) => r.T.equals(s, i[a]));
case "scalar":
return o.every((s, a) => F(r.T, s, i[a]));
case "enum":
return o.every((s, a) => F(f.INT32, s, i[a]));
}
throw new Error(`repeated cannot contain ${r.kind}`);
}
switch (r.kind) {
case "message":
return r.T.equals(o, i);
case "enum":
return F(f.INT32, o, i);
case "scalar":
return F(r.T, o, i);
case "oneof":
if (o.case !== i.case)
return false;
let s = r.findField(o.case);
if (s === void 0)
return true;
switch (s.kind) {
case "message":
return s.T.equals(o.value, i.value);
case "enum":
return F(f.INT32, o.value, i.value);
case "scalar":
return F(s.T, o.value, i.value);
}
throw new Error(`oneof cannot contain ${s.kind}`);
case "map":
let a = Object.keys(o).concat(Object.keys(i));
switch (r.V.kind) {
case "message":
let c = r.V.T;
return a.every((h) => c.equals(o[h], i[h]));
case "enum":
return a.every((h) => F(f.INT32, o[h], i[h]));
case "scalar":
let l = r.V.T;
return a.every((h) => F(l, o[h], i[h]));
}
break;
}
});
}, clone(e4) {
let t = e4.getType(), n = new t(), r = n;
for (let o of t.fields.byMember()) {
let i = e4[o.localName], s;
if (o.repeated)
s = i.map(de);
else if (o.kind == "map") {
s = r[o.localName];
for (let [a, c] of Object.entries(i))
s[a] = de(c);
} else
o.kind == "oneof" ? s = o.findField(i.case) ? { case: i.case, value: de(i.value) } : { case: void 0 } : s = de(i);
r[o.localName] = s;
}
return n;
} };
}
function de(e4) {
if (e4 === void 0)
return e4;
if (e4 instanceof w)
return e4.clone();
if (e4 instanceof Uint8Array) {
let t = new Uint8Array(e4.byteLength);
return t.set(e4), t;
}
return e4;
}
function Y(e4) {
return e4 instanceof Uint8Array ? e4 : new Uint8Array(e4);
}
var pe = class {
constructor(t, n) {
this._fields = t, this._normalizer = n;
}
findJsonName(t) {
if (!this.jsonNames) {
let n = {};
for (let r of this.list())
n[r.jsonName] = n[r.name] = r;
this.jsonNames = n;
}
return this.jsonNames[t];
}
find(t) {
if (!this.numbers) {
let n = {};
for (let r of this.list())
n[r.no] = r;
this.numbers = n;
}
return this.numbers[t];
}
list() {
return this.all || (this.all = this._normalizer(this._fields)), this.all;
}
byNumber() {
return this.numbersAsc || (this.numbersAsc = this.list().concat().sort((t, n) => t.no - n.no)), this.numbersAsc;
}
byMember() {
if (!this.members) {
this.members = [];
let t = this.members, n;
for (let r of this.list())
r.oneof ? r.oneof !== n && (n = r.oneof, t.push(n)) : t.push(r);
}
return this.members;
}
};
function Qe(e4, t) {
let n = Yt(e4);
return t ? n : zn(Xn(n));
}
function Xt(e4) {
return Qe(e4, false);
}
var zt = Yt;
function Yt(e4) {
let t = false, n = [];
for (let r = 0; r < e4.length; r++) {
let o = e4.charAt(r);
switch (o) {
case "_":
t = true;
break;
case "0":
case "1":
case "2":
case "3":
case "4":
case "5":
case "6":
case "7":
case "8":
case "9":
n.push(o), t = false;
break;
default:
t && (t = false, o = o.toUpperCase()), n.push(o);
break;
}
}
return n.join("");
}
var jn = /* @__PURE__ */ new Set(["constructor", "toString", "toJSON", "valueOf"]), Hn = /* @__PURE__ */ new Set(["getType", "clone", "equals", "fromBinary", "fromJson", "fromJsonString", "toBinary", "toJson", "toJsonString", "toObject"]), Kt = (e4) => `${e4}$`, Xn = (e4) => Hn.has(e4) ? Kt(e4) : e4, zn = (e4) => jn.has(e4) ? Kt(e4) : e4;
var he = class {
constructor(t) {
this.kind = "oneof", this.repeated = false, this.packed = false, this.opt = false, this.default = void 0, this.fields = [], this.name = t, this.localName = Xt(t);
}
addField(t) {
N(t.oneof === this, `field ${t.name} not one of ${this.name}`), this.fields.push(t);
}
findField(t) {
if (!this._lookup) {
this._lookup = /* @__PURE__ */ Object.create(null);
for (let n = 0; n < this.fields.length; n++)
this._lookup[this.fields[n].localName] = this.fields[n];
}
return this._lookup[t];
}
};
var d = vt("proto3", jt(), Bt(), Object.assign(Object.assign({}, Ht()), { newFieldList(e4) {
return new pe(e4, Yn);
}, initFields(e4) {
for (let t of e4.getType().fields.byMember()) {
if (t.opt)
continue;
let n = t.localName, r = e4;
if (t.repeated) {
r[n] = [];
continue;
}
switch (t.kind) {
case "oneof":
r[n] = { case: void 0 };
break;
case "enum":
r[n] = 0;
break;
case "map":
r[n] = {};
break;
case "scalar":
r[n] = X(t.T, t.L);
break;
}
}
} }));
function Yn(e4) {
var t, n, r, o;
let i = [], s;
for (let a of typeof e4 == "function" ? e4() : e4) {
let c = a;
if (c.localName = Qe(a.name, a.oneof !== void 0), c.jsonName = (t = a.jsonName) !== null && t !== void 0 ? t : zt(a.name), c.repeated = (n = a.repeated) !== null && n !== void 0 ? n : false, a.kind == "scalar" && (c.L = (r = a.L) !== null && r !== void 0 ? r : R.BIGINT), c.packed = (o = a.packed) !== null && o !== void 0 ? o : a.kind == "enum" || a.kind == "scalar" && a.T != f.BYTES && a.T != f.STRING, a.oneof !== void 0) {
let l = typeof a.oneof == "string" ? a.oneof : a.oneof.name;
(!s || s.name != l) && (s = new he(l)), c.oneof = s, s.addField(c);
}
i.push(c);
}
return i;
}
var P;
(function(e4) {
e4[e4.Unary = 0] = "Unary", e4[e4.ServerStreaming = 1] = "ServerStreaming", e4[e4.ClientStreaming = 2] = "ClientStreaming", e4[e4.BiDiStreaming = 3] = "BiDiStreaming";
})(P || (P = {}));
var K;
(function(e4) {
e4[e4.NoSideEffects = 1] = "NoSideEffects", e4[e4.Idempotent = 2] = "Idempotent";
})(K || (K = {}));
function W(e4) {
let t = E[e4];
return typeof t != "string" ? e4.toString() : t[0].toLowerCase() + t.substring(1).replace(/[A-Z]/g, (n) => "_" + n.toLowerCase());
}
var ye;
function Wt(e4) {
if (!ye) {
ye = {};
for (let t of Object.values(E))
typeof t != "string" && (ye[W(t)] = t);
}
return ye[e4];
}
var S = class e extends Error {
constructor(t, n = E.Unknown, r, o, i) {
super(Kn(t, n)), this.name = "ConnectError", Object.setPrototypeOf(this, new.target.prototype), this.rawMessage = t, this.code = n, this.metadata = new Headers(r != null ? r : {}), this.details = o != null ? o : [], this.cause = i;
}
static from(t, n = E.Unknown) {
return t instanceof e ? t : t instanceof Error ? t.name == "AbortError" ? new e(t.message, E.Canceled) : new e(t.message, n, void 0, void 0, t) : new e(String(t), n, void 0, void 0, t);
}
findDetails(t) {
let n = "typeName" in t ? { findMessage: (o) => o === t.typeName ? t : void 0 } : t, r = [];
for (let o of this.details) {
if (o instanceof w) {
n.findMessage(o.getType().typeName) && r.push(o);
continue;
}
let i = n.findMessage(o.type);
if (i)
try {
r.push(i.fromBinary(o.value));
} catch {
}
}
return r;
}
};
function Kn(e4, t) {
return e4.length ? `[${W(t)}] ${e4}` : `[${W(t)}]`;
}
function Ze(...e4) {
let t = new Headers();
for (let n of e4)
n.forEach((r, o) => {
t.append(o, r);
});
return t;
}
function Qt(e4, t) {
let n = {};
for (let [r, o] of Object.entries(e4.methods)) {
let i = t(Object.assign(Object.assign({}, o), { localName: r, service: e4 }));
i != null && (n[r] = i);
}
return n;
}
function et(e4) {
let t, n = new Uint8Array(0);
function r(o) {
let i = new Uint8Array(n.length + o.length);
i.set(n), i.set(o, n.length), n = i;
}
return new ReadableStream({ start() {
t = e4.getReader();
}, async pull(o) {
let i;
for (; ; ) {
if (i === void 0 && n.byteLength >= 5) {
let c = 0;
for (let l = 1; l < 5; l++)
c = (c << 8) + n[l];
i = { flags: n[0], length: c };
}
if (i !== void 0 && n.byteLength >= i.length + 5)
break;
let a = await t.read();
if (a.done)
break;
r(a.value);
}
if (i === void 0) {
if (n.byteLength == 0) {
o.close();
return;
}
o.error(new S("premature end of stream", E.DataLoss));
return;
}
let s = n.subarray(5, 5 + i.length);
n = n.subarray(5 + i.length), o.enqueue({ flags: i.flags, data: s });
} });
}
function tt(e4, t) {
let n = new Uint8Array(t.length + 5);
n.set(t, 5);
let r = new DataView(n.buffer, n.byteOffset, n.byteLength);
return r.setUint8(0, e4), r.setUint32(1, t.length), n;
}
var Wn = function(e4) {
if (!Symbol.asyncIterator)
throw new TypeError("Symbol.asyncIterator is not defined.");
var t = e4[Symbol.asyncIterator], n;
return t ? t.call(e4) : (e4 = typeof __values == "function" ? __values(e4) : e4[Symbol.iterator](), n = {}, r("next"), r("throw"), r("return"), n[Symbol.asyncIterator] = function() {
return this;
}, n);
function r(i) {
n[i] = e4[i] && function(s) {
return new Promise(function(a, c) {
s = e4[i](s), o(a, c, s.done, s.value);
});
};
}
function o(i, s, a, c) {
Promise.resolve(c).then(function(l) {
i({ value: l, done: a });
}, s);
}
}, Q = function(e4) {
return this instanceof Q ? (this.v = e4, this) : new Q(e4);
}, Qn = function(e4, t, n) {
if (!Symbol.asyncIterator)
throw new TypeError("Symbol.asyncIterator is not defined.");
var r = n.apply(e4, t || []), o, i = [];
return o = {}, s("next"), s("throw"), s("return"), o[Symbol.asyncIterator] = function() {
return this;
}, o;
function s(m) {
r[m] && (o[m] = function(p) {
return new Promise(function(g, b) {
i.push([m, p, g, b]) > 1 || a(m, p);
});
});
}
function a(m, p) {
try {
c(r[m](p));
} catch (g) {
y(i[0][3], g);
}
}
function c(m) {
m.value instanceof Q ? Promise.resolve(m.value.v).then(l, h) : y(i[0][2], m);
}
function l(m) {
a("next", m);
}
function h(m) {
a("throw", m);
}
function y(m, p) {
m(p), i.shift(), i.length && a(i[0][0], i[0][1]);
}
}, Zn = function(e4) {
var t, n;
return t = {}, r("next"), r("throw", function(o) {
throw o;
}), r("return"), t[Symbol.iterator] = function() {
return this;
}, t;
function r(o, i) {
t[o] = e4[o] ? function(s) {
return (n = !n) ? { value: Q(e4[o](s)), done: false } : i ? i(s) : s;
} : i;
}
};
function Zt(e4) {
return Qn(this, arguments, function* () {
yield Q(yield* Zn(Wn(e4)));
});
}
var en = function(e4) {
if (!Symbol.asyncIterator)
throw new TypeError("Symbol.asyncIterator is not defined.");
var t = e4[Symbol.asyncIterator], n;
return t ? t.call(e4) : (e4 = typeof __values == "function" ? __values(e4) : e4[Symbol.iterator](), n = {}, r("next"), r("throw"), r("return"), n[Symbol.asyncIterator] = function() {
return this;
}, n);
function r(i) {
n[i] = e4[i] && function(s) {
return new Promise(function(a, c) {
s = e4[i](s), o(a, c, s.done, s.value);
});
};
}
function o(i, s, a, c) {
Promise.resolve(c).then(function(l) {
i({ value: l, done: a });
}, s);
}
}, q = function(e4) {
return this instanceof q ? (this.v = e4, this) : new q(e4);
}, er = function(e4) {
var t, n;
return t = {}, r("next"), r("throw", function(o) {
throw o;
}), r("return"), t[Symbol.iterator] = function() {
return this;
}, t;
function r(o, i) {
t[o] = e4[o] ? function(s) {
return (n = !n) ? { value: q(e4[o](s)), done: false } : i ? i(s) : s;
} : i;
}
}, tr = function(e4, t, n) {
if (!Symbol.asyncIterator)
throw new TypeError("Symbol.asyncIterator is not defined.");
var r = n.apply(e4, t || []), o, i = [];
return o = {}, s("next"), s("throw"), s("return"), o[Symbol.asyncIterator] = function() {
return this;
}, o;
function s(m) {
r[m] && (o[m] = function(p) {
return new Promise(function(g, b) {
i.push([m, p, g, b]) > 1 || a(m, p);
});
});
}
function a(m, p) {
try {
c(r[m](p));
} catch (g) {
y(i[0][3], g);
}
}
function c(m) {
m.value instanceof q ? Promise.resolve(m.value.v).then(l, h) : y(i[0][2], m);
}
function l(m) {
a("next", m);
}
function h(m) {
a("throw", m);
}
function y(m, p) {
m(p), i.shift(), i.length && a(i[0][0], i[0][1]);
}
};
function nt(e4, t) {
return Qt(e4, (n) => {
switch (n.kind) {
case P.Unary:
return nr(t, e4, n);
case P.ServerStreaming:
return rr(t, e4, n);
case P.ClientStreaming:
return or(t, e4, n);
case P.BiDiStreaming:
return ir(t, e4, n);
default:
return null;
}
});
}
function nr(e4, t, n) {
return async function(r, o) {
var i, s;
let a = await e4.unary(t, n, o == null ? void 0 : o.signal, o == null ? void 0 : o.timeoutMs, o == null ? void 0 : o.headers, r, o == null ? void 0 : o.contextValues);
return (i = o == null ? void 0 : o.onHeader) === null || i === void 0 || i.call(o, a.header), (s = o == null ? void 0 : o.onTrailer) === null || s === void 0 || s.call(o, a.trailer), a.message;
};
}
function rr(e4, t, n) {
return function(r, o) {
return tn(e4.stream(t, n, o == null ? void 0 : o.signal, o == null ? void 0 : o.timeoutMs, o == null ? void 0 : o.headers, Zt([r]), o == null ? void 0 : o.contextValues), o);
};
}
function or(e4, t, n) {
return async function(r, o) {
var i, s, a, c, l, h;
let y = await e4.stream(t, n, o == null ? void 0 : o.signal, o == null ? void 0 : o.timeoutMs, o == null ? void 0 : o.headers, r, o == null ? void 0 : o.contextValues);
(l = o == null ? void 0 : o.onHeader) === null || l === void 0 || l.call(o, y.header);
let m;
try {
for (var p = true, g = en(y.message), b; b = await g.next(), i = b.done, !i; p = true)
c = b.value, p = false, m = c;
} catch (I) {
s = { error: I };
} finally {
try {
!p && !i && (a = g.return) && await a.call(g);
} finally {
if (s)
throw s.error;
}
}
if (!m)
throw new S("protocol error: missing response message", E.Internal);
return (h = o == null ? void 0 : o.onTrailer) === null || h === void 0 || h.call(o, y.trailer), m;
};
}
function ir(e4, t, n) {
return function(r, o) {
return tn(e4.stream(t, n, o == null ? void 0 : o.signal, o == null ? void 0 : o.timeoutMs, o == null ? void 0 : o.headers, r, o == null ? void 0 : o.contextValues), o);
};
}
function tn(e4, t) {
let n = function() {
var r, o;
return tr(this, arguments, function* () {
let i = yield q(e4);
(r = t == null ? void 0 : t.onHeader) === null || r === void 0 || r.call(t, i.header), yield q(yield* er(en(i.message))), (o = t == null ? void 0 : t.onTrailer) === null || o === void 0 || o.call(t, i.trailer);
});
}()[Symbol.asyncIterator]();
return { [Symbol.asyncIterator]: () => ({ next: () => n.next() }) };
}
function nn(...e4) {
let t = new AbortController(), n = e4.filter((o) => o !== void 0).concat(t.signal);
for (let o of n) {
if (o.aborted) {
r.apply(o);
break;
}
o.addEventListener("abort", r);
}
function r() {
t.signal.aborted || t.abort(rt(this));
for (let o of n)
o.removeEventListener("abort", r);
}
return t;
}
function rn(e4) {
let t = new AbortController(), n = () => {
t.abort(new S("the operation timed out", E.DeadlineExceeded));
}, r;
return e4 !== void 0 && (e4 <= 0 ? n() : r = setTimeout(n, e4)), { signal: t.signal, cleanup: () => clearTimeout(r) };
}
function rt(e4) {
if (!e4.aborted)
return;
if (e4.reason !== void 0)
return e4.reason;
let t = new Error("This operation was aborted");
return t.name = "AbortError", t;
}
function ge() {
return { get(e4) {
return e4.id in this ? this[e4.id] : e4.defaultValue;
}, set(e4, t) {
return this[e4.id] = t, this;
}, delete(e4) {
return delete this[e4.id], this;
} };
}
function be(e4, t, n) {
let r = typeof t == "string" ? t : t.typeName, o = typeof n == "string" ? n : n.name;
return e4.toString().replace(/\/?$/, `/${r}/${o}`);
}
function ot(e4, t) {
return t instanceof w ? t : new e4(t);
}
function on(e4, t) {
function n(r) {
return r.done === true ? r : { done: r.done, value: ot(e4, r.value) };
}
return { [Symbol.asyncIterator]() {
let r = t[Symbol.asyncIterator](), o = { next: () => r.next().then(n) };
return r.throw !== void 0 && (o.throw = (i) => r.throw(i).then(n)), r.return !== void 0 && (o.return = (i) => r.return(i).then(n)), o;
} };
}
function Ee(e4) {
var t;
let n = Object.assign({}, e4);
return (t = n.ignoreUnknownFields) !== null && t !== void 0 || (n.ignoreUnknownFields = true), n;
}
function we(e4, t, n, r) {
let o = t ? sn(e4.I, r) : an(e4.I, n);
return { parse: (t ? sn(e4.O, r) : an(e4.O, n)).parse, serialize: o.serialize };
}
function sn(e4, t) {
return { parse(n) {
try {
return e4.fromBinary(n, t);
} catch (r) {
let o = r instanceof Error ? r.message : String(r);
throw new S(`parse binary: ${o}`, E.InvalidArgument);
}
}, serialize(n) {
try {
return n.toBinary(t);
} catch (r) {
let o = r instanceof Error ? r.message : String(r);
throw new S(`serialize binary: ${o}`, E.Internal);
}
} };
}
function an(e4, t) {
var n, r;
let o = (n = t == null ? void 0 : t.textEncoder) !== null && n !== void 0 ? n : new TextEncoder(), i = (r = t == null ? void 0 : t.textDecoder) !== null && r !== void 0 ? r : new TextDecoder(), s = Ee(t);
return { parse(a) {
try {
let c = i.decode(a);
return e4.fromJsonString(c, s);
} catch (c) {
throw S.from(c, E.InvalidArgument);
}
}, serialize(a) {
try {
let c = a.toJsonString(s);
return o.encode(c);
} catch (c) {
throw S.from(c, E.Internal);
}
} };
}
var sr = /^application\/(connect\+)?(?:(json)(?:; ?charset=utf-?8)?|(proto))$/i;
var cn = "application/proto", ln = "application/json", un = "application/connect+proto", fn = "application/connect+json";
function mn(e4) {
let t = e4 == null ? void 0 : e4.match(sr);
if (!t)
return;
let n = !!t[1], r = !!t[3];
return { stream: n, binary: r };
}
function Z(e4, t, n) {
if (t && new Headers(t).forEach((s, a) => n.metadata.append(a, s)), typeof e4 != "object" || e4 == null || Array.isArray(e4) || !("code" in e4) || typeof e4.code != "string")
throw n;
let r = Wt(e4.code);
if (r === void 0)
throw n;
let o = e4.message;
if (o != null && typeof o != "string")
throw n;
let i = new S(o != null ? o : "", r, t);
if ("details" in e4 && Array.isArray(e4.details))
for (let s of e4.details) {
if (s === null || typeof s != "object" || Array.isArray(s) || typeof s.type != "string" || typeof s.value != "string" || "debug" in s && typeof s.debug != "object")
throw n;
try {
i.details.push({ type: s.type, value: J.dec(s.value), debug: s.debug });
} catch {
throw n;
}
}
return i;
}
var xe = 2;
function it(e4) {
let t = new S("invalid end stream", E.InvalidArgument), n;
try {
n = JSON.parse(typeof e4 == "string" ? e4 : new TextDecoder().decode(e4));
} catch {
throw t;
}
if (typeof n != "object" || n == null || Array.isArray(n))
throw t;
let r = new Headers();
if ("metadata" in n) {
if (typeof n.metadata != "object" || n.metadata == null || Array.isArray(n.metadata))
throw t;
for (let [i, s] of Object.entries(n.metadata)) {
if (!Array.isArray(s) || s.some((a) => typeof a != "string"))
throw t;
for (let a of s)
r.append(i, a);
}
}
let o = "error" in n ? Z(n.error, r, t) : void 0;
return { metadata: r, error: o };
}
var ee = "Content-Type", dn = "Content-Length", Ie = "Content-Encoding";
var st = "Accept-Encoding";
var pn = "Connect-Timeout-Ms", Te = "Connect-Protocol-Version", hn = "User-Agent";
function yn(e4) {
switch (e4) {
case 400:
return E.InvalidArgument;
case 401:
return E.Unauthenticated;
case 403:
return E.PermissionDenied;
case 404:
return E.Unimplemented;
case 408:
return E.DeadlineExceeded;
case 409:
return E.Aborted;
case 412:
return E.FailedPrecondition;
case 413:
return E.ResourceExhausted;
case 415:
return E.Internal;
case 429:
return E.Unavailable;
case 431:
return E.ResourceExhausted;
case 502:
return E.Unavailable;
case 503:
return E.Unavailable;
case 504:
return E.Unavailable;
default:
return E.Unknown;
}
}
function Se(e4) {
let t = new Headers(), n = new Headers();
return e4.forEach((r, o) => {
o.toLowerCase().startsWith("trailer-") ? n.set(o.substring(8), r) : t.set(o, r);
}), [t, n];
}
var Ae = "1";
function Ne(e4, t, n, r) {
let o = new Headers(r != null ? r : {});
return n !== void 0 && o.set(pn, `${n}`), o.set(ee, e4 == P.Unary ? t ? cn : ln : t ? un : fn), o.set(Te, Ae), o.set(hn, "connect-es/1.1.3"), o;
}
function Pe(e4, t, n) {
let r = n.get("Content-Type"), o = mn(r);
if (t !== 200) {
let i = new S(`HTTP ${t}`, yn(t), n);
if (e4 == P.Unary && o && !o.binary)
return { isUnaryError: true, unaryError: i };
throw i;
}
return { isUnaryError: false };
}
var gn = "application/";
function cr(e4, t) {
return t ? J.enc(e4).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "") : encodeURIComponent(new TextDecoder().decode(e4));
}
function at(e4, t, n) {
let r = `?connect=v${Ae}`, o = e4.header.get(ee);
(o == null ? void 0 : o.indexOf(gn)) === 0 && (r += "&encoding=" + encodeURIComponent(o.slice(gn.length)));
let i = e4.header.get(Ie);
i !== null && i !== "identity" && (r += "&compression=" + encodeURIComponent(i), n = true), n && (r += "&base64=1"), r += "&message=" + cr(t, n);
let s = e4.url + r, a = new Headers(e4.header);
return [Te, ee, dn, Ie, st].forEach((c) => a.delete(c)), Object.assign(Object.assign({}, e4), { init: Object.assign(Object.assign({}, e4.init), { method: "GET" }), url: s, header: a });
}
function ct(e4) {
let t = En(e4.next, e4.interceptors), [n, r, o] = bn(e4), i = Object.assign(Object.assign({}, e4.req), { message: ot(e4.req.method.I, e4.req.message), signal: n });
return t(i).then((s) => (o(), s), r);
}
function lt(e4) {
let t = En(e4.next, e4.interceptors), [n, r, o] = bn(e4), i = Object.assign(Object.assign({}, e4.req), { message: on(e4.req.method.I, e4.req.message), signal: n }), s = false;
return n.addEventListener("abort", function() {
var a, c;
let l = e4.req.message[Symbol.asyncIterator]();
s || (a = l.throw) === null || a === void 0 || a.call(l, this.reason).catch(() => {
}), (c = l.return) === null || c === void 0 || c.call(l).catch(() => {
});
}), t(i).then((a) => Object.assign(Object.assign({}, a), { message: { [Symbol.asyncIterator]() {
let c = a.message[Symbol.asyncIterator]();
return { next() {
return c.next().then((l) => (l.done == true && (s = true, o()), l), r);
} };
} } }), r);
}
function bn(e4) {
let { signal: t, cleanup: n } = rn(e4.timeoutMs), r = nn(e4.signal, t);
return [r.signal, function(i) {
let s = S.from(t.aborted ? rt(t) : i);
return r.abort(s), n(), Promise.reject(s);
}, function() {
n(), r.abort();
}];
}
function En(e4, t) {
var n;
return (n = t == null ? void 0 : t.concat().reverse().reduce((r, o) => o(r), e4)) !== null && n !== void 0 ? n : e4;
}
var ke = ((n) => (n[n.UNSPECIFIED = 0] = "UNSPECIFIED", n[n.JUPYTER_FORMAT = 77] = "JUPYTER_FORMAT", n))(ke || {});
d.util.setEnumType(ke, "exa.codeium_common_pb.ExperimentKey", [{ no: 0, name: "UNSPECIFIED" }, { no: 77, name: "JUPYTER_FORMAT" }]);
var ut = ((t) => (t[t.CODEIUM = 0] = "CODEIUM", t))(ut || {});
d.util.setEnumType(ut, "exa.codeium_common_pb.AuthSource", [{ no: 0, name: "AUTH_SOURCE_CODEIUM" }]);
var ft = ((i) => (i[i.UNSPECIFIED = 0] = "UNSPECIFIED", i[i.ENABLE_CODEIUM = 1] = "ENABLE_CODEIUM", i[i.DISABLE_CODEIUM = 2] = "DISABLE_CODEIUM", i[i.SHOW_PREVIOUS_COMPLETION = 3] = "SHOW_PREVIOUS_COMPLETION", i[i.SHOW_NEXT_COMPLETION = 4] = "SHOW_NEXT_COMPLETION", i))(ft || {});
d.util.setEnumType(ft, "exa.codeium_common_pb.EventType", [{ no: 0, name: "EVENT_TYPE_UNSPECIFIED" }, { no: 1, name: "EVENT_TYPE_ENABLE_CODEIUM" }, { no: 2, name: "EVENT_TYPE_DISABLE_CODEIUM" }, { no: 3, name: "EVENT_TYPE_SHOW_PREVIOUS_COMPLETION" }, { no: 4, name: "EVENT_TYPE_SHOW_NEXT_COMPLETION" }]);
var Oe = ((o) => (o[o.UNSPECIFIED = 0] = "UNSPECIFIED", o[o.TYPING_AS_SUGGESTED = 1] = "TYPING_AS_SUGGESTED", o[o.CACHE = 2] = "CACHE", o[o.NETWORK = 3] = "NETWORK", o))(Oe || {});
d.util.setEnumType(Oe, "exa.codeium_common_pb.CompletionSource", [{ no: 0, name: "COMPLETION_SOURCE_UNSPECIFIED" }, { no: 1, name: "COMPLETION_SOURCE_TYPING_AS_SUGGESTED" }, { no: 2, name: "COMPLETION_SOURCE_CACHE" }, { no: 3, name: "COMPLETION_SOURCE_NETWORK" }]);
var $ = ((u) => (u[u.UNSPECIFIED = 0] = "UNSPECIFIED", u[u.C = 1] = "C", u[u.CLOJURE = 2] = "CLOJURE", u[u.COFFEESCRIPT = 3] = "COFFEESCRIPT", u[u.CPP = 4] = "CPP", u[u.CSHARP = 5] = "CSHARP", u[u.CSS = 6] = "CSS", u[u.CUDACPP = 7] = "CUDACPP", u[u.DOCKERFILE = 8] = "DOCKERFILE", u[u.GO = 9] = "GO", u[u.GROOVY = 10] = "GROOVY", u[u.HANDLEBARS = 11] = "HANDLEBARS", u[u.HASKELL = 12] = "HASKELL", u[u.HCL = 13] = "HCL", u[u.HTML = 14] = "HTML", u[u.INI = 15] = "INI", u[u.JAVA = 16] = "JAVA", u[u.JAVASCRIPT = 17] = "JAVASCRIPT", u[u.JSON = 18] = "JSON", u[u.JULIA = 19] = "JULIA", u[u.KOTLIN = 20] = "KOTLIN", u[u.LATEX = 21] = "LATEX", u[u.LESS = 22] = "LESS", u[u.LUA = 23] = "LUA", u[u.MAKEFILE = 24] = "MAKEFILE", u[u.MARKDOWN = 25] = "MARKDOWN", u[u.OBJECTIVEC = 26] = "OBJECTIVEC", u[u.OBJECTIVECPP = 27] = "OBJECTIVECPP", u[u.PERL = 28] = "PERL", u[u.PHP = 29] = "PHP", u[u.PLAINTEXT = 30] = "PLAINTEXT", u[u.PROTOBUF = 31] = "PROTOBUF", u[u.PBTXT = 32] = "PBTXT", u[u.PYTHON = 33] = "PYTHON", u[u.R = 34] = "R", u[u.RUBY = 35] = "RUBY", u[u.RUST = 36] = "RUST", u[u.SASS = 37] = "SASS", u[u.SCALA = 38] = "SCALA", u[u.SCSS = 39] = "SCSS", u[u.SHELL = 40] = "SHELL", u[u.SQL = 41] = "SQL", u[u.STARLARK = 42] = "STARLARK", u[u.SWIFT = 43] = "SWIFT", u[u.TSX = 44] = "TSX", u[u.TYPESCRIPT = 45] = "TYPESCRIPT", u[u.VISUALBASIC = 46] = "VISUALBASIC", u[u.VUE = 47] = "VUE", u[u.XML = 48] = "XML", u[u.XSL = 49] = "XSL", u[u.YAML = 50] = "YAML", u[u.SVELTE = 51] = "SVELTE", u[u.TOML = 52] = "TOML", u[u.DART = 53] = "DART", u[u.RST = 54] = "RST", u[u.OCAML = 55] = "OCAML", u[u.CMAKE = 56] = "CMAKE", u[u.PASCAL = 57] = "PASCAL", u[u.ELIXIR = 58] = "ELIXIR", u[u.FSHARP = 59] = "FSHARP", u[u.LISP = 60] = "LISP", u[u.MATLAB = 61] = "MATLAB", u[u.POWERSHELL = 62] = "POWERSHELL", u[u.SOLIDITY = 63] = "SOLIDITY", u[u.ADA = 64] = "ADA", u[u.OCAML_INTERFACE = 65] = "OCAML_INTERFACE", u))($ || {});
d.util.setEnumType($, "exa.codeium_common_pb.Language", [{ no: 0, name: "LANGUAGE_UNSPECIFIED" }, { no: 1, name: "LANGUAGE_C" }, { no: 2, name: "LANGUAGE_CLOJURE" }, { no: 3, name: "LANGUAGE_COFFEESCRIPT" }, { no: 4, name: "LANGUAGE_CPP" }, { no: 5, name: "LANGUAGE_CSHARP" }, { no: 6, name: "LANGUAGE_CSS" }, { no: 7, name: "LANGUAGE_CUDACPP" }, { no: 8, name: "LANGUAGE_DOCKERFILE" }, { no: 9, name: "LANGUAGE_GO" }, { no: 10, name: "LANGUAGE_GROOVY" }, { no: 11, name: "LANGUAGE_HANDLEBARS" }, { no: 12, name: "LANGUAGE_HASKELL" }, { no: 13, name: "LANGUAGE_HCL" }, { no: 14, name: "LANGUAGE_HTML" }, { no: 15, name: "LANGUAGE_INI" }, { no: 16, name: "LANGUAGE_JAVA" }, { no: 17, name: "LANGUAGE_JAVASCRIPT" }, { no: 18, name: "LANGUAGE_JSON" }, { no: 19, name: "LANGUAGE_JULIA" }, { no: 20, name: "LANGUAGE_KOTLIN" }, { no: 21, name: "LANGUAGE_LATEX" }, { no: 22, name: "LANGUAGE_LESS" }, { no: 23, name: "LANGUAGE_LUA" }, { no: 24, name: "LANGUAGE_MAKEFILE" }, { no: 25, name: "LANGUAGE_MARKDOWN" }, { no: 26, name: "LANGUAGE_OBJECTIVEC" }, { no: 27, name: "LANGUAGE_OBJECTIVECPP" }, { no: 28, name: "LANGUAGE_PERL" }, { no: 29, name: "LANGUAGE_PHP" }, { no: 30, name: "LANGUAGE_PLAINTEXT" }, { no: 31, name: "LANGUAGE_PROTOBUF" }, { no: 32, name: "LANGUAGE_PBTXT" }, { no: 33, name: "LANGUAGE_PYTHON" }, { no: 34, name: "LANGUAGE_R" }, { no: 35, name: "LANGUAGE_RUBY" }, { no: 36, name: "LANGUAGE_RUST" }, { no: 37, name: "LANGUAGE_SASS" }, { no: 38, name: "LANGUAGE_SCALA" }, { no: 39, name: "LANGUAGE_SCSS" }, { no: 40, name: "LANGUAGE_SHELL" }, { no: 41, name: "LANGUAGE_SQL" }, { no: 42, name: "LANGUAGE_STARLARK" }, { no: 43, name: "LANGUAGE_SWIFT" }, { no: 44, name: "LANGUAGE_TSX" }, { no: 45, name: "LANGUAGE_TYPESCRIPT" }, { no: 46, name: "LANGUAGE_VISUALBASIC" }, { no: 47, name: "LANGUAGE_VUE" }, { no: 48, name: "LANGUAGE_XML" }, { no: 49, name: "LANGUAGE_XSL" }, { no: 50, name: "LANGUAGE_YAML" }, { no: 51, name: "LANGUAGE_SVELTE" }, { no: 52, name: "LANGUAGE_TOML" }, { no: 53, name: "LANGUAGE_DART" }, { no: 54, name: "LANGUAGE_RST" }, { no: 55, name: "LANGUAGE_OCAML" }, { no: 56, name: "LANGUAGE_CMAKE" }, { no: 57, name: "LANGUAGE_PASCAL" }, { no: 58, name: "LANGUAGE_ELIXIR" }, { no: 59, name: "LANGUAGE_FSHARP" }, { no: 60, name: "LANGUAGE_LISP" }, { no: 61, name: "LANGUAGE_MATLAB" }, { no: 62, name: "LANGUAGE_POWERSHELL" }, { no: 63, name: "LANGUAGE_SOLIDITY" }, { no: 64, name: "LANGUAGE_ADA" }, { no: 65, name: "LANGUAGE_OCAML_INTERFACE" }]);
var ve = (_a = class extends w {
constructor(n) {
super();
this.completionId = "";
this.text = "";
this.prefix = "";
this.stop = "";
this.score = 0;
this.tokens = [];
this.decodedTokens = [];
this.probabilities = [];
this.adjustedProbabilities = [];
this.generatedLength = x.zero;
d.util.initPartial(n, this);
}
static fromBinary(n, r) {
return new _a().fromBinary(n, r);
}
static fromJson(n, r) {
return new _a().fromJson(n, r);
}
static fromJsonString(n, r) {
return new _a().fromJsonString(n, r);
}
static equals(n, r) {
return d.util.equals(_a, n, r);
}
}, (() => {
_a.runtime = d;
})(), (() => {
_a.typeName = "exa.codeium_common_pb.Completion";
})(), (() => {
_a.fields = d.util.newFieldList(() => [{ no: 1, name: "completion_id", kind: "scalar", T: 9 }, { no: 2, name: "text", kind: "scalar", T: 9 }, { no: 3, name: "prefix", kind: "scalar", T: 9 }, { no: 4, name: "stop", kind: "scalar", T: 9 }, { no: 5, name: "score", kind: "scalar", T: 1 }, { no: 6, name: "tokens", kind: "scalar", T: 4, repeated: true }, { no: 7, name: "decoded_tokens", kind: "scalar", T: 9, repeated: true }, { no: 8, name: "probabilities", kind: "scalar", T: 1, repeated: true }, { no: 9, name: "adjusted_probabilities", kind: "scalar", T: 1, repeated: true }, { no: 10, name: "generated_length", kind: "scalar", T: 4 }]);
})(), _a), G = (_b = class extends w {
constructor(n) {
super();
this.ideName = "";
this.ideVersion = "";
this.extensionName = "";
this.extensionVersion = "";
this.apiKey = "";
this.locale = "";
this.sessionId = "";
this.requestId = x.zero;
this.userAgent = "";
this.url = "";
this.authSource = 0;
d.util.initPartial(n, this);
}
static fromBinary(n, r) {
return new _b().fromBinary(n, r);
}
static fromJson(n, r) {
return new _b().fromJson(n, r);
}
static fromJsonString(n, r) {
return new _b().fromJsonString(n, r);
}
static equals(n, r) {
return d.util.equals(_b, n, r);
}
}, (() => {
_b.runtime = d;
})(), (() => {
_b.typeName = "exa.codeium_common_pb.Metadata";
})(), (() => {
_b.fields = d.util.newFieldList(() => [{ no: 1, name: "ide_name", kind: "scalar", T: 9 }, { no: 7, name: "ide_version", kind: "scalar", T: 9 }, { no: 12, name: "extension_name", kind: "scalar", T: 9 }, { no: 2, name: "extension_version", kind: "scalar", T: 9 }, { no: 3, name: "api_key", kind: "scalar", T: 9 }, { no: 4, name: "locale", kind: "scalar", T: 9 }, { no: 10, name: "session_id", kind: "scalar", T: 9 }, { no: 9, name: "request_id", kind: "scalar", T: 4 }, { no: 13, name: "user_agent", kind: "scalar", T: 9 }, { no: 14, name: "url", kind: "scalar", T: 9 }, { no: 15, name: "auth_source", kind: "enum", T: d.getEnumType(ut) }]);
})(), _b), Ce = (_c = class extends w {
constructor(n) {
super();
this.tabSize = x.zero;
this.insertSpaces = false;
d.util.initPartial(n, this);
}
static fromBinary(n, r) {
return new _c().fromBinary(n, r);
}
static fromJson(n, r) {
return new _c().fromJson(n, r);
}
static fromJsonString(n, r) {
return new _c().fromJsonString(n, r);
}
static equals(n, r) {
return d.util.equals(_c, n, r);
}
}, (() => {
_c.runtime = d;
})(), (() => {
_c.typeName = "exa.codeium_common_pb.EditorOptions";
})(), (() => {
_c.fields = d.util.newFieldList(() => [{ no: 1, name: "tab_size", kind: "scalar", T: 4 }, { no: 2, name: "insert_spaces", kind: "scalar", T: 8 }]);
})(), _c);
_d = class extends w {
constructor(n) {
super();
this.eventType = 0;
this.eventJson = "";
this.timestampUnixMs = x.zero;
d.util.initPartial(n, this);
}
static fromBinary(n, r) {
return new _d().fromBinary(n, r);
}
static fromJson(n, r) {
return new _d().fromJson(n, r);
}
static fromJsonString(n, r) {
return new _d().fromJsonString(n, r);
}
static equals(n, r) {
return d.util.equals(_d, n, r);
}
}, (() => {
_d.runtime = d;
})(), (() => {
_d.typeName = "exa.codeium_common_pb.Event";
})(), (() => {
_d.fields = d.util.newFieldList(() => [{ no: 1, name: "event_type", kind: "enum", T: d.getEnumType(ft) }, { no: 2, name: "event_json", kind: "scalar", T: 9 }, { no: 3, name: "timestamp_unix_ms", kind: "scalar", T: 3 }]);
})();
var bt = ((s) => (s[s.UNSPECIFIED = 0] = "UNSPECIFIED", s[s.INACTIVE = 1] = "INACTIVE", s[s.PROCESSING = 2] = "PROCESSING", s[s.SUCCESS = 3] = "SUCCESS", s[s.WARNING = 4] = "WARNING", s[s.ERROR = 5] = "ERROR", s))(bt || {});
d.util.setEnumType(bt, "exa.language_server_pb.CodeiumState", [{ no: 0, name: "CODEIUM_STATE_UNSPECIFIED" }, { no: 1, name: "CODEIUM_STATE_INACTIVE" }, { no: 2, name: "CODEIUM_STATE_PROCESSING" }, { no: 3, name: "CODEIUM_STATE_SUCCESS" }, { no: 4, name: "CODEIUM_STATE_WARNING" }, { no: 5, name: "CODEIUM_STATE_ERROR" }]);
var xn = ((r) => (r[r.UNSPECIFIED = 0] = "UNSPECIFIED", r[r.SINGLE = 1] = "SINGLE", r[r.MULTI = 2] = "MULTI", r))(xn || {});
d.util.setEnumType(xn, "exa.language_server_pb.LineType", [{ no: 0, name: "LINE_TYPE_UNSPECIFIED" }, { no: 1, name: "LINE_TYPE_SINGLE" }, { no: 2, name: "LINE_TYPE_MULTI" }]);
var Et = ((o) => (o[o.UNSPECIFIED = 0] = "UNSPECIFIED", o[o.INLINE = 1] = "INLINE", o[o.BLOCK = 2] = "BLOCK", o[o.INLINE_MASK = 3] = "INLINE_MASK", o))(Et || {});
d.util.setEnumType(Et, "exa.language_server_pb.CompletionPartType", [{ no: 0, name: "COMPLETION_PART_TYPE_UNSPECIFIED" }, { no: 1, name: "COMPLETION_PART_TYPE_INLINE" }, { no: 2, name: "COMPLETION_PART_TYPE_BLOCK" }, { no: 3, name: "COMPLETION_PART_TYPE_INLINE_MASK" }]);
var Ue = (_e2 = class extends w {
constructor(n) {
super();
this.otherDocuments = [];
this.modelName = "";
d.util.initPartial(n, this);
}
static fromBinary(n, r) {
return new _e2().fromBinary(n, r);
}
static fromJson(n, r) {
return new _e2().fromJson(n, r);
}
static fromJsonString(n, r) {
return new _e2().fromJsonString(n, r);
}
static equals(n, r) {
return d.util.equals(_e2, n, r);
}
}, (() => {
_e2.runtime = d;
})(), (() => {
_e2.typeName = "exa.language_server_pb.GetCompletionsRequest";
})(), (() => {
_e2.fields = d.util.newFieldList(() => [{ no: 1, name: "metadata", kind: "message", T: G }, { no: 2, name: "document", kind: "message", T: M }, { no: 3, name: "editor_options", kind: "message", T: Ce }, { no: 5, name: "other_documents", kind: "message", T: M, repeated: true }, { no: 7, name: "experiment_config", kind: "message", T: mt }, { no: 10, name: "model_name", kind: "scalar", T: 9 }]);
})(), _e2), Re = (_f = class extends w {
constructor(n) {
super();
this.completionItems = [];
d.util.initPartial(n, this);
}
static fromBinary(n, r) {
return new _f().fromBinary(n, r);
}
static fromJson(n, r) {
return new _f().fromJson(n, r);
}
static fromJsonString(n, r) {
return new _f().fromJsonString(n, r);
}
static equals(n, r) {
return d.util.equals(_f, n, r);
}
}, (() => {
_f.runtime = d;
})(), (() => {
_f.typeName = "exa.language_server_pb.GetCompletionsResponse";
})(), (() => {
_f.fields = d.util.newFieldList(() => [{ no: 1, name: "state", kind: "message", T: dt }, { no: 2, name: "completion_items", kind: "message", T: gt, repeated: true }]);
})(), _f), Fe = (_g = class extends w {
constructor(n) {
super();
this.completionId = "";
d.util.initPartial(n, this);
}
static fromBinary(n, r) {
return new _g().fromBinary(n, r);
}
static fromJson(n, r) {
return new _g().fromJson(n, r);
}
static fromJsonString(n, r) {
return new _g().fromJsonString(n, r);
}
static equals(n, r) {
return d.util.equals(_g, n, r);
}
}, (() => {
_g.runtime = d;
})(), (() => {
_g.typeName = "exa.language_server_pb.AcceptCompletionRequest";
})(), (() => {
_g.fields = d.util.newFieldList(() => [{ no: 1, name: "metadata", kind: "message", T: G }, { no: 2, name: "completion_id", kind: "scalar", T: 9 }]);
})(), _g), _e = (_h = class extends w {
constructor(t) {
super(), d.util.initPartial(t, this);
}
static fromBinary(t, n) {
return new _h().fromBinary(t, n);
}
static fromJson(t, n) {
return new _h().fromJson(t, n);
}
static fromJsonString(t, n) {
return new _h().fromJsonString(t, n);
}
static equals(t, n) {
return d.util.equals(_h, t, n);
}
}, (() => {
_h.runtime = d;
})(), (() => {
_h.typeName = "exa.language_server_pb.AcceptCompletionResponse";
})(), (() => {
_h.fields = d.util.newFieldList(() => []);
})(), _h), Je = (_i = class extends w {
constructor(t) {
super(), d.util.initPartial(t, this);
}
static fromBinary(t, n) {
return new _i().fromBinary(t, n);
}
static fromJson(t, n) {
return new _i().fromJson(t, n);
}
static fromJsonString(t, n) {
return new _i().fromJsonString(t, n);
}
static equals(t, n) {
return d.util.equals(_i, t, n);
}
}, (() => {
_i.runtime = d;
})(), (() => {
_i.typeName = "exa.language_server_pb.GetAuthTokenRequest";
})(), (() => {
_i.fields = d.util.newFieldList(() => []);
})(), _i), Me = (_j = class extends w {
constructor(n) {
super();
this.authToken = "";
this.uuid = "";
d.util.initPartial(n, this);
}
static fromBinary(n, r) {
return new _j().fromBinary(n, r);
}
static fromJson(n, r) {
return new _j().fromJson(n, r);
}
static fromJsonString(n, r) {
return new _j().fromJsonString(n, r);
}
static equals(n, r) {
return d.util.equals(_j, n, r);
}
}, (() => {
_j.runtime = d;
})(), (() => {
_j.typeName = "exa.language_server_pb.GetAuthTokenResponse";
})(), (() => {
_j.fields = d.util.newFieldList(() => [{ no: 1, name: "auth_token", kind: "scalar", T: 9 }, { no: 2, name: "uuid", kind: "scalar", T: 9 }]);
})(), _j), te = (_k = class extends w {
constructor(n) {
super();
this.row = x.zero;
this.col = x.zero;
d.util.initPartial(n, this);
}
static fromBinary(n, r) {
return new _k().fromBinary(n, r);
}
static fromJson(n, r) {
return new _k().fromJson(n, r);
}
static fromJsonString(n, r) {
return new _k().fromJsonString(n, r);
}
static equals(n, r) {
return d.util.equals(_k, n, r);
}
}, (() => {
_k.runtime = d;
})(), (() => {
_k.typeName = "exa.language_server_pb.DocumentPosition";
})(), (() => {
_k.fields = d.util.newFieldList(() => [{ no: 1, name: "row", kind: "scalar", T: 4 }, { no: 2, name: "col", kind: "scalar", T: 4 }]);
})(), _k), M = (_l = class extends w {
constructor(n) {
super();
this.absolutePath = "";
this.relativePath = "";
this.text = "";
this.editorLanguage = "";
this.language = 0;
this.cursorOffset = x.zero;
this.lineEnding = "";
d.util.initPartial(n, this);
}
static fromBinary(n, r) {
return new _l().fromBinary(n, r);
}
static fromJson(n, r) {
return new _l().fromJson(n, r);
}
static fromJsonString(n, r) {
return new _l().fromJsonString(n, r);
}
static equals(n, r) {
return d.util.equals(_l, n, r);
}
}, (() => {
_l.runtime = d;
})(), (() => {
_l.typeName = "exa.language_server_pb.Document";
})(), (() => {
_l.fields = d.util.newFieldList(() => [{ no: 1, name: "absolute_path", kind: "scalar", T: 9 }, { no: 2, name: "relative_path", kind: "scalar", T: 9 }, { no: 3, name: "text", kind: "scalar", T: 9 }, { no: 4, name: "editor_language", kind: "scalar", T: 9 }, { no: 5, name: "language", kind: "enum", T: d.getEnumType($) }, { no: 6, name: "cursor_offset", kind: "scalar", T: 4 }, { no: 8, name: "cursor_position", kind: "message", T: te }, { no: 7, name: "line_ending", kind: "scalar", T: 9 }]);
})(), _l), mt = (_m = class extends w {
constructor(n) {
super();
this.forceEnableExperiments = [];
d.util.initPartial(n, this);
}
static fromBinary(n, r) {
return new _m().fromBinary(n, r);
}
static fromJson(n, r) {
return new _m().fromJson(n, r);
}
static fromJsonString(n, r) {
return new _m().fromJsonString(n, r);
}
static equals(n, r) {
return d.util.equals(_m, n, r);
}
}, (() => {
_m.runtime = d;
})(), (() => {
_m.typeName = "exa.language_server_pb.ExperimentConfig";
})(), (() => {
_m.fields = d.util.newFieldList(() => [{ no: 1, name: "force_enable_experiments", kind: "enum", T: d.getEnumType(ke), repeated: true }]);
})(), _m), dt = (_n2 = class extends w {
constructor(n) {
super();
this.state = 0;
this.message = "";
d.util.initPartial(n, this);
}
static fromBinary(n, r) {
return new _n2().fromBinary(n, r);
}
static fromJson(n, r) {
return new _n2().fromJson(n, r);
}
static fromJsonString(n, r) {
return new _n2().fromJsonString(n, r);
}
static equals(n, r) {
return d.util.equals(_n2, n, r);
}
}, (() => {
_n2.runtime = d;
})(), (() => {
_n2.typeName = "exa.language_server_pb.State";
})(), (() => {
_n2.fields = d.util.newFieldList(() => [{ no: 1, name: "state", kind: "enum", T: d.getEnumType(bt) }, { no: 2, name: "message", kind: "scalar", T: 9 }]);
})(), _n2), pt = (_o = class extends w {
constructor(n) {
super();
this.startOffset = x.zero;
this.endOffset = x.zero;
d.util.initPartial(n, this);
}
static fromBinary(n, r) {
return new _o().fromBinary(n, r);
}
static fromJson(n, r) {
return new _o().fromJson(n, r);
}
static fromJsonString(n, r) {
return new _o().fromJsonString(n, r);
}
static equals(n, r) {
return d.util.equals(_o, n, r);
}
}, (() => {
_o.runtime = d;
})(), (() => {
_o.typeName = "exa.language_server_pb.Range";
})(), (() => {
_o.fields = d.util.newFieldList(() => [{ no: 1, name: "start_offset", kind: "scalar", T: 4 }, { no: 2, name: "end_offset", kind: "scalar", T: 4 }, { no: 3, name: "start_position", kind: "message", T: te }, { no: 4, name: "end_position", kind: "message", T: te }]);
})(), _o), ht = (_p = class extends w {
constructor(n) {
super();
this.text = "";
this.deltaCursorOffset = x.zero;
d.util.initPartial(n, this);
}
static fromBinary(n, r) {
return new _p().fromBinary(n, r);
}
static fromJson(n, r) {
return new _p().fromJson(n, r);
}
static fromJsonString(n, r) {
return new _p().fromJsonString(n, r);
}
static equals(n, r) {
return d.util.equals(_p, n, r);
}
}, (() => {
_p.runtime = d;
})(), (() => {
_p.typeName = "exa.language_server_pb.Suffix";
})(), (() => {
_p.fields = d.util.newFieldList(() => [{ no: 1, name: "text", kind: "scalar", T: 9 }, { no: 2, name: "delta_cursor_offset", kind: "scalar", T: 3 }]);
})(), _p), yt = (_q = class extends w {
constructor(n) {
super();
this.text = "";
this.offset = x.zero;
this.type = 0;
this.prefix = "";
this.line = x.zero;
d.util.initPartial(n, this);
}
static fromBinary(n, r) {
return new _q().fromBinary(n, r);
}
static fromJson(n, r) {
return new _q().fromJson(n, r);
}
static fromJsonString(n, r) {
return new _q().fromJsonString(n, r);
}
static equals(n, r) {
return d.util.equals(_q, n, r);
}
}, (() => {
_q.runtime = d;
})(), (() => {
_q.typeName = "exa.language_server_pb.CompletionPart";
})(), (() => {
_q.fields = d.util.newFieldList(() => [{ no: 1, name: "text", kind: "scalar", T: 9 }, { no: 2, name: "offset", kind: "scalar", T: 4 }, { no: 3, name: "type", kind: "enum", T: d.getEnumType(Et) }, { no: 4, name: "prefix", kind: "scalar", T: 9 }, { no: 5, name: "line", kind: "scalar", T: 4 }]);
})(), _q), gt = (_r = class extends w {
constructor(n) {
super();
this.source = 0;
this.completionParts = [];
d.util.initPartial(n, this);
}
static fromBinary(n, r) {
return new _r().fromBinary(n, r);
}
static fromJson(n, r) {
return new _r().fromJson(n, r);
}
static fromJsonString(n, r) {
return new _r().fromJsonString(n, r);
}
static equals(n, r) {
return d.util.equals(_r, n, r);
}
}, (() => {
_r.runtime = d;
})(), (() => {
_r.typeName = "exa.language_server_pb.CompletionItem";
})(), (() => {
_r.fields = d.util.newFieldList(() => [{ no: 1, name: "completion", kind: "message", T: ve }, { no: 5, name: "suffix", kind: "message", T: ht }, { no: 2, name: "range", kind: "message", T: pt }, { no: 3, name: "source", kind: "enum", T: d.getEnumType(Oe) }, { no: 8, name: "completion_parts", kind: "message", T: yt, repeated: true }]);
})(), _r);
var O = class e2 {
constructor(t, n) {
this.line = t, this.character = n, this.lineNumber = t + 1, this.column = n + 1;
}
static fromMonaco(t) {
return new e2(t.lineNumber - 1, t.column - 1);
}
static fromPosition(t) {
return new e2(t.line, t.character);
}
}, B = class e3 {
constructor(t, n) {
this.start = t, this.end = n, this.startLineNumber = t.line + 1, this.startColumn = t.character + 1, this.endLineNumber = n.line + 1, this.endColumn = n.character + 1;
}
static fromMonaco(t) {
return new e3(new O(t.startLineNumber - 1, t.startColumn - 1), new O(t.endLineNumber - 1, t.endColumn - 1));
}
static fromRange(t) {
return new e3(t.start, t.end);
}
};
var Ge = class {
constructor(t, n) {
this.text = t, this.range = n;
}
};
var Be = class {
constructor(t) {
this.model = t, this.uri = t.uri, this.languageId = t.getLanguageId();
}
get lineCount() {
return this.model.getLineCount();
}
lineAt(t) {
return typeof t != "number" && (t = t.line), new Ge(this.model.getLineContent(t + 1), new B(new O(t, 0), new O(t, this.model.getLineLength(t + 1))));
}
offsetAt(t) {
return this.model.getOffsetAt(O.fromPosition(t));
}
positionAt(t) {
return O.fromMonaco(this.model.getPositionAt(t));
}
getText(t) {
return t ? this.model.getValueInRange(B.fromRange(t)) : this.model.getValue();
}
};
var In = () => {
try {
return window.location.origin;
} catch {
return null;
}
}, Tn = () => "1.0.10";
function Sn(e4) {
return e4 < 128 ? 1 : e4 < 2048 ? 2 : e4 < 65536 ? 3 : 4;
}
function An(e4, t) {
if (t === 0)
return 0;
let n = 0, r = 0;
for (let o of e4)
if (r += o.length, n += Sn(o.codePointAt(0)), t !== void 0 && r >= t)
break;
return n;
}
function wt(e4, t) {
if (t === 0)
return 0;
let n = 0, r = 0;
for (let o of e4)
if (r += Sn(o.codePointAt(0)), n += o.length, t !== void 0 && r >= t)
break;
return n;
}
var Nn = () => "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (e4) => {
let t = Math.random() * 16 | 0;
return (e4 === "x" ? t : t & 3 | 8).toString(16);
}), Le = (e4) => {
switch (e4.toLowerCase()) {
case "c":
return 1;
case "clojure":
return 2;
case "coffeescript":
return 3;
case "cpp":
return 4;
case "csharp":
return 5;
case "css":
return 6;
case "cudacpp":
return 7;
case "dockerfile":
return 8;
case "go":
return 9;
case "groovy":
return 10;
case "handlebars":
return 11;
case "haskell":
return 12;
case "hcl":
return 13;
case "html":
return 14;
case "ini":
return 15;
case "java":
return 16;
case "javascript":
return 17;
case "json":
return 18;
case "julia":
return 19;
case "kotlin":
return 20;
case "latex":
return 21;
case "less":
return 22;
case "lua":
return 23;
case "makefile":
return 24;
case "markdown":
return 25;
case "objectivec":
return 26;
case "objectivecpp":
return 27;
case "perl":
return 28;
case "php":
return 29;
case "plaintext":
return 30;
case "protobuf":
return 31;
case "pbtxt":
return 32;
case "python":
return 33;
case "r":
return 34;
case "ruby":
return 35;
case "rust":
return 36;
case "sass":
return 37;
case "scala":
return 38;
case "scss":
return 39;
case "shell":
return 40;
case "sql":
return 41;
case "starlark":
return 42;
case "swift":
return 43;
case "tsx":
return 44;
case "typescript":
return 45;
case "visualbasic":
return 46;
case "vue":
return 47;
case "xml":
return 48;
case "xsl":
return 49;
case "yaml":
return 50;
case "svelte":
return 51;
case "toml":
return 52;
case "dart":
return 53;
case "rst":
return 54;
case "ocaml":
return 55;
case "cmake":
return 56;
case "pascal":
return 57;
case "elixir":
return 58;
case "fsharp":
return 59;
case "lisp":
return 60;
case "matlab":
return 61;
case "powershell":
return 62;
case "solidity":
return 63;
case "ada":
return 64;
case "ocaml_interface":
return 65;
default:
return 0;
}
};
var xt = class {
constructor(t, n, r) {
this.insertText = t, this.text = t, this.range = n, this.command = { id: "codeium.acceptCompletion", title: "Accept Completion", arguments: [r, t] };
}
}, ur = "d49954eb-cfba-4992-980f-d8fb37f0e942", De = class {
constructor(t, n, r, o) {
this.setStatus = n;
this.setMessage = r;
this.apiKey = o;
this.otherDocuments = [];
this.sessionId = `react-editor-${Nn()}`, this.client = t;
}
getAuthHeader() {
let t = this.getMetadata();
return { Authorization: `Basic ${t.apiKey}-${t.sessionId}` };
}
getMetadata() {
var _a2, _b2;
return new G({ ideName: "web", ideVersion: (_a2 = In()) != null ? _a2 : "unknown", extensionName: "@codeium/react-code-editor", extensionVersion: Tn(), apiKey: (_b2 = this.apiKey) != null ? _b2 : ur, sessionId: this.sessionId });
}
async provideInlineCompletions(t, n, r) {
let o = new Be(t), i = O.fromMonaco(n);
r.onCancellationRequested(() => {
var _a2;
return (_a2 = r.cancellationCallback) == null ? void 0 : _a2.call(r);
});
let s = new AbortController();
r.onCancellationRequested(() => {
s.abort();
});
let a = s.signal;
this.setStatus("processing"), this.setMessage("Generating completions...");
let c = this.getDocumentInfo(o, i), l = { tabSize: BigInt(t.getOptions().tabSize), insertSpaces: t.getOptions().insertSpaces }, h = this.otherDocuments;
h.length > 10 && (h = h.slice(0, 10));
let y;
try {
y = await this.client.getCompletions({ metadata: this.getMetadata(), document: c, editorOptions: l, otherDocuments: h }, { signal: a, headers: this.getAuthHeader() });
} catch (b) {
b instanceof S && b.code === E.Canceled || (this.setStatus("error"), this.setMessage("Something went wrong; please try again."));
return;
}
if (!y.completionItems) {
let b = " No completions were generated";
this.setStatus("success"), this.setMessage(b);
return;
}
let p = y.completionItems.map((b) => this.createInlineCompletionItem(b, o)).filter((b) => !!b);
this.setStatus("success");
let g = `Generated ${p.length} completions`;
return p.length === 1 && (g = "Generated 1 completion"), this.setMessage(g), { items: p };
}
acceptedLastCompletion(t) {
new Promise((n, r) => {
this.client.acceptCompletion({ metadata: this.getMetadata(), completionId: t }, { headers: this.getAuthHeader() }).then(n).catch((o) => {
});
});
}
getDocumentInfo(t, n) {
let r = t.getText(), o = t.offsetAt(n), i = An(r, o), s = Le(t.languageId);
return new M({ text: r, editorLanguage: t.languageId, language: s, cursorOffset: BigInt(i), lineEnding: `
` });
}
createInlineCompletionItem(t, n) {
if (!t.completion || !t.range)
return;
let r = n.getText(), o = n.positionAt(wt(r, Number(t.range.startOffset))), i = n.positionAt(wt(r, Number(t.range.endOffset))), s = new B(o, i);
return new xt(t.completion.text, s, t.completion.completionId);
}
};
var Ve = class {
constructor(t, n, r, o, i, s) {
this.setCompletionCount = n;
this.getEditorDocuments = i;
this.numCompletionsProvided = 0, this.completionProvider = new De(t, r, o, s);
}
freeInlineCompletions() {
}
async provideInlineCompletions(t, n, r, o) {
this.updateOtherDocuments(this.getEditorDocuments(t));
let i = await this.completionProvider.provideInlineCompletions(t, n, o);
return i && (this.numCompletionsProvided += 1, this.setCompletionCount(this.numCompletionsProvided)), i;
}
acceptedLastCompletion(t) {
this.completionProvider.acceptedLastCompletion(t);
}
updateOtherDocuments(t) {
this.completionProvider.otherDocuments = t;
}
};
function Pn() {
try {
new Headers();
} catch {
throw new Error("connect-web requires the fetch API. Are you running on an old version of Node.js? Node.js is not supported in Connect for Web - please stay tuned for Connect for Node.");
}
}
var ne = function(e4) {
return this instanceof ne ? (this.v = e4, this) : new ne(e4);
}, fr = function(e4, t, n) {
if (!Symbol.asyncIterator)
throw new TypeError("Symbol.asyncIterator is not defined.");
var r = n.apply(e4, t || []), o, i = [];
return o = {}, s("next"), s("throw"), s("return"), o[Symbol.asyncIterator] = function() {
return this;
}, o;
function s(m) {
r[m] && (o[m] = function(p) {
return new Promise(function(g, b) {
i.push([m, p, g, b]) > 1 || a(m, p);
});
});
}
function a(m, p) {
try {
c(r[m](p));
} catch (g) {
y(i[0][3], g);
}
}
function c(m) {
m.value instanceof ne ? Promise.resolve(m.value.v).then(l, h) : y(i[0][2], m);
}
function l(m) {
a("next", m);
}
function h(m) {
a("throw", m);
}
function y(m, p) {
m(p), i.shift(), i.length && a(i[0][0], i[0][1]);
}
};
function It(e4) {
var t;
Pn();
let n = (t = e4.useBinaryFormat) !== null && t !== void 0 ? t : false;
return { async unary(r, o, i, s, a, c, l) {
var h;
let { serialize: y, parse: m } = we(o, n, e4.jsonOptions, e4.binaryOptions);
return s = s === void 0 ? e4.defaultTimeoutMs : s <= 0 ? void 0 : s, await ct({ interceptors: e4.interceptors, signal: i, timeoutMs: s, req: { stream: false, service: r, method: o, url: be(e4.baseUrl, r, o), init: { method: "POST", credentials: (h = e4.credentials) !== null && h !== void 0 ? h : "same-origin", redirect: "error", mode: "cors" }, header: Ne(o.kind, n, s, a), contextValues: l != null ? l : ge(), message: c }, next: async (p) => {
var g;
let b = e4.useHttpGet === true && o.idempotency === K.NoSideEffects, I = null;
b ? p = at(p, y(p.message), n) : I = y(p.message);
let T = await ((g = e4.fetch) !== null && g !== void 0 ? g : globalThis.fetch)(p.url, Object.assign(Object.assign({}, p.init), { headers: p.header, signal: p.signal, body: I })), { isUnaryError: k, unaryError: U } = Pe(o.kind, T.status, T.headers);
if (k)
throw Z(await T.json(), Ze(...Se(T.headers)), U);
let [C, re] = Se(T.headers);
return { stream: false, service: r, method: o, header: C, message: n ? m(new Uint8Array(await T.arrayBuffer())) : o.O.fromJson(await T.json(), Ee(e4.jsonOptions)), trailer: re };
} });
}, async stream(r, o, i, s, a, c, l) {
var h;
let { serialize: y, parse: m } = we(o, n, e4.jsonOptions, e4.binaryOptions);
function p(b, I) {
return fr(this, arguments, function* () {
let T = et(b).getReader(), k = false;
for (; ; ) {
let U = yield ne(T.read());
if (U.done)
break;
let { flags: C, data: re } = U.value;
if ((C & xe) === xe) {
k = true;
let qe = it(re);
if (qe.error)
throw qe.error;
qe.metadata.forEach((Cn, kn) => I.set(kn, Cn));
continue;
}
yield yield ne(m(re));
}
if (!k)
throw "missing EndStreamResponse";
});
}
async function g(b) {
if (o.kind != P.ServerStreaming)
throw "The fetch API does not support streaming request bodies";
let I = await b[Symbol.asyncIterator]().next();
if (I.done == true)
throw "missing request message";
return tt(0, y(I.value));
}
return s = s === void 0 ? e4.defaultTimeoutMs : s <= 0 ? void 0 : s, await lt({ interceptors: e4.interceptors, timeoutMs: s, signal: i, req: { stream: true, service: r, method: o, url: be(e4.baseUrl, r, o), init: { method: "POST", credentials: (h = e4.credentials) !== null && h !== void 0 ? h : "same-origin", redirect: "error", mode: "cors" }, header: Ne(o.kind, n, s, a), contextValues: l != null ? l : ge(), message: c }, next: async (b) => {
var I;
let T = await ((I = e4.fetch) !== null && I !== void 0 ? I : globalThis.fetch)(b.url, Object.assign(Object.assign({}, b.init), { headers: b.header, signal: b.signal, body: await g(b.message) }));
if (Pe(o.kind, T.status, T.headers), T.body === null)
throw "missing response body";
let k = new Headers();
return Object.assign(Object.assign({}, b), { header: T.headers, trailer: k, message: p(T.body, k) });
} });
} };
}
var vn = { typeName: "exa.language_server_pb.LanguageServerService", methods: { getCompletions: { name: "GetCompletions", I: Ue, O: Re, kind: P.Unary }, acceptCompletion: { name: "AcceptCompletion", I: Fe, O: _e, kind: P.Unary }, getAuthToken: { name: "GetAuthToken", I: Je, O: Me, kind: P.Unary } } };
var mr = (e4, { onAutocomplete: t, languageServer: n = "https://web-backend.codeium.com", apiKey: r, getEditors: o = () => [] } = {}) => {
let i = 1, s = 0, a = (T) => {
s = T;
}, c = "inactive", l = (T) => {
c = T;
}, h = "", y = (T) => {
h = T;
}, m = It({ baseUrl: n, useBinaryFormat: true }), p = nt(vn, m), g = new Ve(p, a, l, y, v, r), b = e4.languages.registerInlineCompletionsProvider({ pattern: "**" }, g), I = e4.editor.registerCommand("codeium.acceptCompletion", (T, k, U) => {
try {
typeof t == "function" && t(U), i = i + 1, g.acceptedLastCompletion(k);
} catch {
}
});
function v(T) {
let k = [];
return o().forEach((U) => {
let C = U.getModel();
!C || C === T || k.push(new M({ absolutePath: C.uri.path, relativePath: C.uri.path.startsWith("/") ? C.uri.path.slice(1) : C.uri.path, text: U.getValue(), editorLanguage: C.getLanguageId(), language: Le(C.getLanguageId()) }));
}), k;
}
return { getCompletionCount: () => s, getCodeiumStatus: () => c, getCodeiumStatusMessage: () => h, getAcceptedCompletionCount: () => i, dispose: () => {
b.dispose(), I.dispose();
} };
};
const _$1 = _unsafeWindow._;
const regTheme = async (theme2) => {
let themes = _unsafeWindow.codeThemes;
let themeItem = themes.find((i) => i.themeName === theme2);
if (themeItem.out)
return;
if (themeItem.loaded && themeItem.cache)
return;
let editor = _unsafeWindow.monaco.editor;
const response = await fetch(`${"https://baozoulolw.oss-cn-chengdu.aliyuncs.com/codeSet/data"}/theme/${themeItem.group}/${themeItem.path}`);
if (response.ok) {
const json2 = await response.json();
editor.defineTheme(theme2, json2);
themeItem.loaded = true;
themeItem.cache = json2;
}
};
const setFeature = (font = {}) => {
let dom = document.querySelector(
".view-lines.monaco-mouse-cursor-text"
);
if (!dom)
return;
dom.style["fontFamily"] = font.value;
};
const regTips = (language, monaco) => {
var _a2;
let allTips = _unsafeWindow.editorTips;
const tipsList = allTips.filter((i) => i.supportLanguage === language);
const completionItems = tipsList.map((tip) => {
let kind = completionItemKinds.find((i) => i.value === tip.kind).name;
let rule2 = tip.insertTextRules.map((i) => insertTextRules.find((fi) => fi.value === i).name);
let result;
for (let i = 0; i < rule2.length; i++) {
result |= monaco.languages.CompletionItemInsertTextRule[rule2];
}
return {
label: tip.label,
kind: monaco.languages.CompletionItemKind[kind],
insertText: tip.insertText,
documentation: tip.documentation,
detail: tip.detail,
insertTextRules: result,
sortText: tip.sortText
};
});
if (_$1.isEmpty(completionItems))
return;
let { [language]: disposable = {} } = (_a2 = _unsafeWindow.disposables) != null ? _a2 : {};
if (!_$1.isEmpty(disposable)) {
disposable.dispose();
}
disposable = monaco.languages.registerCompletionItemProvider(language, {
provideCompletionItems(model, position) {
return { suggestions: completionItems };
}
});
_unsafeWindow.disposables[language] = disposable;
};
const editorCreated = async (monaco) => {
await setDefaultSetting();
useDTS(monaco, "lodash");
useDTS(monaco, "Big");
_unsafeWindow.disposables = {};
let create = monaco.editor.create;
monaco.editor.create = (ref, options, ...params) => {
var _a2;
let settings = (_a2 = JSON.parse(_unsafeWindow.localStorage.getItem("codeSettings"))) != null ? _a2 : {};
let option = _$1.omit(options, ["theme", "fontFamily", "fontSize", "tabSize", "fontFeatureSettings"]);
let font = fontFamilys.find((i) => i.value === settings.fontFamily);
let editor = create(ref, {
...option,
theme: settings.theme,
fontFamily: settings.fontFamily,
fontSize: settings.fontSize,
tabSize: settings.tabSize,
cursorSmoothCaretAnimation: true,
roundedSelection: true,
fontLigatures: true,
formatOnType: true,
minimap: {
enabled: false
},
EditorAutoClosingEditStrategy: "auto",
autoClosingComments: true,
cursorBlinking: "smooth",
overviewRulerBorder: true
}, ...params);
setFeature(font);
setOther(option.language, editor, monaco);
regTips(option.language, monaco);
if (settings.aiCode) {
addCodeium(monaco);
}
return editor;
};
previewEditor(monaco);
monaco.editor.onWillDisposeModel(async function(editor) {
disposeAi();
});
};
const setOther = async (mode, editor, monaco) => {
await wire(mode, editor, monaco);
};
const defineTheme = async () => {
var _a2;
const { theme: theme2 = "vs" } = (_a2 = JSON.parse(_unsafeWindow.localStorage.getItem("codeSettings"))) != null ? _a2 : {};
await regTheme(theme2);
};
const setDefaultSetting = async () => {
let defaultSetting = {
fontSize: 13,
fontFamily: "Menlo, Monaco, Courier New, monospace",
theme: "vs",
tabSize: 2,
aiCode: false
};
let settings = _unsafeWindow.localStorage.getItem("codeSettings");
if (_$1.isEmpty(settings)) {
_unsafeWindow.localStorage.setItem("codeSettings", JSON.stringify(defaultSetting));
} else {
settings = JSON.parse(settings);
Object.keys(defaultSetting).forEach((key) => {
if (!_$1.has(settings, key)) {
settings[key] = defaultSetting[key];
}
});
_unsafeWindow.localStorage.setItem("codeSettings", JSON.stringify(settings));
defineTheme();
}
};
const initWork = () => {
_unsafeWindow.MonacoEnvironment = {
getWorkerUrl: function(workerId, label) {
var _a2, _b2;
let editorPath = ((_a2 = _unsafeWindow.$GLOBAL_CONFIG) == null ? void 0 : _a2.editorPath) ? _unsafeWindow.$GLOBAL_CONFIG.editorPath : `${((_b2 = _unsafeWindow.$GLOBAL_CONFIG) == null ? void 0 : _b2.resRoot) || ""}/fe_components/lowcode/third-party/monaco-editor/min`;
return `data:text/javascript;charset=utf-8,${encodeURIComponent(`
self.MonacoEnvironment = {
baseUrl: '${editorPath}'
};
importScripts('${editorPath}/vs/base/worker/workerMain.js');`)}`;
}
};
};
const previewEditor = async (monaco) => {
initWork();
let editor = monaco.editor.create(document.createElement("div"), {
language: "javascript",
regTip: false
});
editor.dispose();
};
const addCodeium = async (monaco) => {
_unsafeWindow.codeiumProvider = mr(
monaco,
{
languageServer: "https://web-backend.codeium.com",
apiKey: "d49954eb-cfba-4992-980f-d8fb37f0e942",
onAutocomplete: (acceptedText) => {
},
getEditors: () => {
return [];
}
}
);
};
const disposeAi = () => {
if (_$1.has(_unsafeWindow, "codeiumProvider")) {
_unsafeWindow.codeiumProvider.dispose();
delete _unsafeWindow.codeiumProvider;
}
};
const useDTS = async (monaco, type) => {
const response = await fetch(`${"https://baozoulolw.oss-cn-chengdu.aliyuncs.com/codeSet/data"}/type/${type}.d.ts`);
const text = await response.text();
const libUrl = `ts:fileName/${type}.d.ts`;
monaco.languages.typescript.javascriptDefaults.addExtraLib(text, libUrl);
monaco.editor.createModel(text, "typescript", monaco.Uri.parse(libUrl));
};
var render$1 = function() {
var _vm = this;
var _h2 = _vm.$createElement;
var _c2 = _vm._self._c || _h2;
return _c2("div", {
attrs: {
"id": "self_dialog"
}
}, [_c2("el-popover", {
attrs: {
"placement": "bottom",
"width": "250",
"trigger": "click"
}
}, [_c2("el-form", {
attrs: {
"label-width": "50px"
}
}, [_c2("el-form-item", {
attrs: {
"label": "\u5B57\u53F7"
}
}, [_c2("el-input-number", {
staticClass: "tw-w-full",
attrs: {
"controls-position": "right"
},
model: {
value: _vm.setting.fontSize,
callback: function($$v) {
_vm.$set(_vm.setting, "fontSize", $$v);
},
expression: "setting.fontSize"
}
})], 1), _c2("el-form-item", {
attrs: {
"label": "\u5B57\u4F53"
}
}, [_c2("el-select", {
staticClass: "tw-w-full",
model: {
value: _vm.setting.fontFamily,
callback: function($$v) {
_vm.$set(_vm.setting, "fontFamily", $$v);
},
expression: "setting.fontFamily"
}
}, _vm._l(_vm.fontFamilys, function(item) {
return _c2("el-option", {
key: item.value,
attrs: {
"label": item.label,
"value": item.value
}
});
}), 1)], 1), _c2("el-form-item", {
attrs: {
"label": "\u7F29\u8FDB"
}
}, [_c2("el-input-number", {
staticClass: "tw-w-full",
attrs: {
"controls-position": "right"
},
model: {
value: _vm.setting.tabSize,
callback: function($$v) {
_vm.$set(_vm.setting, "tabSize", $$v);
},
expression: "setting.tabSize"
}
})], 1), _c2("el-form-item", {
attrs: {
"label": "\u4E3B\u9898"
}
}, [_c2("el-select", {
staticClass: "tw-w-full",
attrs: {
"filterable": true
},
on: {
"change": _vm.themeChange
},
model: {
value: _vm.setting.theme,
callback: function($$v) {
_vm.$set(_vm.setting, "theme", $$v);
},
expression: "setting.theme"
}
}, _vm._l(_vm.themes, function(list, index) {
return _c2("el-option-group", {
key: index,
attrs: {
"label": list.group,
"divider": true
}
}, _vm._l(list.children, function(item) {
return _c2("el-option", {
key: item.themeName,
attrs: {
"value": item.themeName,
"label": item.name
}
});
}), 1);
}), 1)], 1), _c2("el-form-item", {
attrs: {
"label": "AI"
}
}, [_c2("el-switch", {
attrs: {
"active-color": "#13ce66",
"inactive-color": "#ff4949",
"inactive-text": "",
"active-text": _vm.setting.aiCode ? "\u5DF2\u5F00\u542F" : "\u5DF2\u5173\u95ED"
},
on: {
"change": _vm.aiCodeChange
},
model: {
value: _vm.setting.aiCode,
callback: function($$v) {
_vm.$set(_vm.setting, "aiCode", $$v);
},
expression: "setting.aiCode"
}
})], 1)], 1), _c2("el-button", {
staticStyle: {
"float": "right"
},
on: {
"click": _vm.regTips
}
}, [_vm._v("\u6CE8\u518C\u4EE3\u7801\u63D0\u793A")]), _c2("el-button", {
attrs: {
"slot": "reference",
"icon": "el-icon-setting"
},
on: {
"click": _vm.initData
},
slot: "reference"
}, [_vm._v("\u8BBE\u7F6E")])], 1), _c2("el-drawer", {
attrs: {
"title": "\u6CE8\u518C\u4EE3\u7801\u63D0\u793A",
"visible": _vm.drawer,
"size": 500,
"append-to-body": ""
},
on: {
"update:visible": function($event) {
_vm.drawer = $event;
}
}
}, [_c2("tips")], 1)], 1);
};
var staticRenderFns = [];
const _ = _unsafeWindow._;
const __vue2_script = {
props: {},
components: { Tips },
data() {
return {
setting: {},
themes: [],
fontFamilys: [],
drawer: false
};
},
watch: {
setting: {
handler: function(n, o) {
this.setData(n);
},
deep: true
}
},
methods: {
initData() {
let settings = _unsafeWindow.localStorage.getItem(
"codeSettings"
);
if (!_.isEmpty(settings)) {
let obj = JSON.parse(settings);
Object.keys(obj).forEach((key) => {
this.$set(this.setting, key, obj[key]);
});
}
},
themeChange(theme2) {
if (_.isEmpty(theme2))
return;
regTheme(theme2);
},
setData(val) {
_unsafeWindow.localStorage.setItem(
"codeSettings",
JSON.stringify(val)
);
},
initOptions() {
let obj = _.groupBy(codeThemeList, "group");
Object.keys(obj).forEach((key) => {
this.themes.push({
group: key === "undefined" ? "\u5176\u4ED6" : key,
children: obj[key]
});
});
},
regTips: function() {
this.drawer = true;
},
aiCodeChange(val) {
}
},
mounted() {
this.initData();
this.initOptions();
this.fontFamilys = fontFamilys;
}
};
const __cssModules = {};
var __component__ = /* @__PURE__ */ normalizeComponent(
__vue2_script,
render$1,
staticRenderFns,
false,
__vue2_injectStyles,
"93c5e0b4",
null,
null
);
function __vue2_injectStyles(context) {
for (let o in __cssModules) {
this[o] = __cssModules[o];
}
}
var App = /* @__PURE__ */ function() {
return __component__.exports;
}();
const Vue = _unsafeWindow.Vue;
window.Vue = Vue;
const render = (el) => {
new Vue({
render: (h) => h(App)
}).$mount("#self_dialog");
};
let renderHeader = async (dom) => {
dom.className = dom.className + " head-right";
const app = document.createElement("div");
app.setAttribute("id", "self_dialog");
dom.insertBefore(app, dom.firstChild);
render();
};
if (_unsafeWindow.location.hash.startsWith("#/widgetPage")) {
let selector = ".design-container .header-box>span:nth-child(2)";
let dom = document.querySelector(selector);
if (dom) {
await( renderHeader(dom));
} else {
waitForElementByClass("edit-page-design", async (e4) => {
if (!document.getElementById("self_dialog")) {
dom = document.querySelector(selector);
await renderHeader(dom);
}
});
}
await( initMonacoEditor());
_unsafeWindow.codeThemes = codeThemeList;
_unsafeWindow.editorTips = tips;
_unsafeWindow.require(["vs/editor/editor.main"], (monaco) => editorCreated(monaco));
}
})();