codeTheme

修改editor样式

ของเมื่อวันที่ 23-07-2024 ดู เวอร์ชันล่าสุด

// ==UserScript==
// @name         codeTheme
// @namespace    Baozoulolw
// @version      0.0.9
// @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-9714e280] .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;
  };
  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",
    "html",
    "javascript",
    "less",
    "pug",
    "scss",
    "typescript",
    "coffee"
  ];
  const scopeNameMap = {
    html: "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: 3,
      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: 3,
      documentation: "watchEffectOnce",
      detail: "watchEffectOnce",
      insertTextRules: [2],
      sortText: "001",
      supportLanguage: "javascript"
    },
    {
      id: "2",
      label: "<xtypeRender",
      insertText: 'xtypeRender v-bind="\\$attrs" v-model="value"></xtypeRender>',
      kind: 3,
      documentation: "xtypeRender",
      detail: "xtypeRender",
      insertTextRules: [2],
      sortText: "001",
      supportLanguage: "html"
    }
  ];
  var render$2 = function() {
    var _vm = this;
    var _h = _vm.$createElement;
    var _c = _vm._self._c || _h;
    return _c("div", [_c("el-tree", {
      attrs: {
        "data": _vm.languages,
        "props": _vm.defaultProps
      },
      scopedSlots: _vm._u([{
        key: "default",
        fn: function(_ref) {
          var node = _ref.node;
          _ref.data;
          return _c("span", {
            staticClass: "custom-tree-node"
          }, [_c("span", [_vm._v(_vm._s(node.label))])]);
        }
      }])
    }), _c("el-dialog", {
      attrs: {
        "append-to-body": "",
        "title": "\u65B0\u589E\u4EE3\u7801\u7247\u6BB5",
        "visible": _vm.formShow,
        "before-close": _vm.dialogClose
      }
    }, [_c("el-form", {
      ref: "form",
      attrs: {
        "rules": _vm.rules,
        "label-width": "120px",
        "model": _vm.editTips
      }
    }, [_c("el-form-item", {
      attrs: {
        "label": "label"
      }
    }, [_c("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), _c("el-form-item", {
      attrs: {
        "label": "insertText"
      }
    }, [_c("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), _c("el-form-item", {
      attrs: {
        "label": "kind"
      }
    }, [_c("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 _c("el-option", {
        key: item.value,
        attrs: {
          "label": item.name,
          "value": item.value
        }
      });
    }), 1)], 1), _c("el-form-item", {
      attrs: {
        "label": "documentation"
      }
    }, [_c("el-input", {
      model: {
        value: _vm.editTips.documentation,
        callback: function($$v) {
          _vm.$set(_vm.editTips, "documentation", $$v);
        },
        expression: "editTips.documentation"
      }
    })], 1), _c("el-form-item", {
      attrs: {
        "label": "detail"
      }
    }, [_c("el-input", {
      model: {
        value: _vm.editTips.detail,
        callback: function($$v) {
          _vm.$set(_vm.editTips, "detail", $$v);
        },
        expression: "editTips.detail"
      }
    })], 1), _c("el-form-item", {
      attrs: {
        "label": "insertTextRules"
      }
    }, [_c("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 _c("el-option", {
        key: item.value,
        attrs: {
          "label": item.name,
          "value": item.value
        }
      });
    }), 1), _c("div", _vm._l(_vm.showTags, function(item) {
      return _c("el-tag", {
        key: item.value
      }, [_vm._v(_vm._s(item.name))]);
    }), 1)], 1), _c("el-form-item", {
      attrs: {
        "label": "sortText"
      }
    }, [_c("el-input", {
      model: {
        value: _vm.editTips.sortText,
        callback: function($$v) {
          _vm.$set(_vm.editTips, "sortText", $$v);
        },
        expression: "editTips.sortText"
      }
    })], 1)], 1), _c("span", {
      staticClass: "dialog-footer",
      attrs: {
        "slot": "footer"
      },
      slot: "footer"
    }, [_c("el-button", {
      on: {
        "click": _vm.cancel
      }
    }, [_vm._v("\u53D6 \u6D88")]), _c("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 _$2 = _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 = _$2.groupBy(codeSnippets, "supportLanguage");
        this.languages.forEach((language) => {
          var _a;
          let arr = (_a = obj[language.name]) != null ? _a : [];
          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" },
    {
      name: "Catppuccin Mocha",
      value: "CatppuccinMocha",
      group: "Catppuccin",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Atlantic Night",
      value: "AtlanticNight",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Atom One Dark",
      value: "AtomOneDark",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Aurora X",
      value: "AuroraX",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Ayu Dark",
      group: "Ayu",
      value: "AyuDark",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Ayu Light",
      group: "Ayu",
      value: "AyuLight",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Bluloco Light",
      value: "BlulocoLight",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Brackets Light Pro",
      value: "BracketsLightPro",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Code Sand Box",
      value: "CodeSandBox",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Darktooth",
      value: "Darktooth",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Dracula",
      value: "Dracula",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Eva Light",
      value: "EvaLight",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Flat UI",
      value: "FlatUI",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Hopscotch",
      value: "Hopscotch",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Horla Light Theme",
      value: "HorlaLightTheme",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Hybrid Next",
      value: "HybridNext",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Kimbie Dark",
      value: "KimbieDark",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Laser Wave",
      value: "LaserWave",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Lucario",
      value: "Lucario",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Min",
      value: "Min",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Monokai Dimmed",
      value: "MonokaiDimmed",
      group: "Monokai",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Monokai Pro",
      value: "MonokaiPro",
      group: "Monokai",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Nebula",
      value: "Nebula",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Noctis Azureus",
      value: "NoctisAzureus",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Noctis Bordo",
      value: "NoctisBordo",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Noctis Lux",
      value: "NoctisLux",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "One Dark Pro",
      value: "OneDarkPro",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "One Monokai",
      value: "OneMonokai",
      group: "Monokai",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Panda",
      value: "Panda",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Re U I",
      value: "ReUI",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Remedy Dark",
      value: "RemedyDark",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Shades Of Purple",
      value: "ShadesOfPurple",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Snazzy Light",
      value: "SnazzyLight",
      group: "Snazzy",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Snazzy Operator",
      value: "SnazzyOperator",
      group: "Snazzy",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Sublime Material Theme Dark",
      value: "SublimeMaterialThemeDark",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Synth Wave84",
      value: "SynthWave84",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Tokyo Night Storm",
      value: "TokyoNightStorm",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Tomorrow Night Blue",
      value: "TomorrowNightBlue",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Twilight",
      value: "Twilight",
      custom: true,
      loaded: false,
      cache: ""
    },
    {
      name: "Winter Is Coming",
      value: "WinterIsComing",
      custom: true,
      loaded: false,
      cache: ""
    }
  ];
  const fontFamilys = [
    { label: "Fira Code", value: "Fira Code, Monoid, Consolas, monospace", feature: '"liga" on' },
    { label: "Menlo", value: "Menlo, Monaco, Courier New, monospace;", feature: '"liga" 0, "calt" 1' }
  ];
  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 d = Object.getOwnPropertyDescriptor(n, k);
      Object.defineProperty(a, k, d.get ? d : {
        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 _i = 1; _i < arguments.length; _i++) {
      sources[_i - 1] = arguments[_i];
    }
    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(f) {
            var data;
            if (typeof readbuffer === "function") {
              return new Uint8Array(readbuffer(f));
            }
            data = read(f, "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(x, multiple) {
          if (x % multiple > 0) {
            x += multiple - x % multiple;
          }
          return x;
        }
        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 (e) {
              err("Module.instantiateWasm callback failed with error: " + e);
              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 (e) {
          }
        }
        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 (e) {
            if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError))
              abort(e);
            return e.errno;
          }
        }
        function _fd_seek(fd, offset_low, offset_high, whence, newOffset) {
          try {
            return 0;
          } catch (e) {
            if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError))
              abort(e);
            return e.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 j = 0; j < len; j++) {
                SYSCALLS.printChar(fd, HEAPU8[ptr + j]);
              }
              num += len;
            }
            HEAP32[pnum >> 2] = num;
            return 0;
          } catch (e) {
            if (typeof FS === "undefined" || !(e instanceof FS.ErrnoError))
              abort(e);
            return e.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((e) => {
            throw e;
          });
          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(fn, thisp) {
    thisp = thisp || this;
    for (var walker = this.head, i = 0; walker !== null; i++) {
      fn.call(thisp, walker.value, i, this);
      walker = walker.next;
    }
  };
  Yallist$1.prototype.forEachReverse = function(fn, thisp) {
    thisp = thisp || this;
    for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {
      fn.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(fn, thisp) {
    thisp = thisp || this;
    var res = new Yallist$1();
    for (var walker = this.head; walker !== null; ) {
      res.push(fn.call(thisp, walker.value, this));
      walker = walker.next;
    }
    return res;
  };
  Yallist$1.prototype.mapReverse = function(fn, thisp) {
    thisp = thisp || this;
    var res = new Yallist$1();
    for (var walker = this.tail; walker !== null; ) {
      res.push(fn.call(thisp, walker.value, this));
      walker = walker.prev;
    }
    return res;
  };
  Yallist$1.prototype.reduce = function(fn, 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 = fn(acc, walker.value, i);
      walker = walker.next;
    }
    return acc;
  };
  Yallist$1.prototype.reduceReverse = function(fn, 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 = fn(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 (er) {
  }
  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(fn, thisp) {
      thisp = thisp || this;
      for (let walker = this[LRU_LIST].tail; walker !== null; ) {
        const prev = walker.prev;
        forEachStep(this, fn, walker, thisp);
        walker = prev;
      }
    }
    forEach(fn, thisp) {
      thisp = thisp || this;
      for (let walker = this[LRU_LIST].head; walker !== null; ) {
        const next = walker.next;
        forEachStep(this, fn, 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, fn, node, thisp) => {
    let hit = node.value;
    if (isStale(self2, hit)) {
      del(self2, node);
      if (!self2[ALLOW_STALE])
        hit = void 0;
    }
    if (hit)
      fn.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 d = str.charCodeAt(i + 1);
            if (56320 <= d && d <= 57343) {
              if (!utf16OffsetToUtf8) {
                createOffsetTable(i);
              }
              const a = c & 1023;
              const b = d & 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(d, b) {
      d.__proto__ = b;
    } || function(d, b) {
      for (var p in b)
        if (b.hasOwnProperty(p))
          d[p] = b[p];
    };
    return function(d, b) {
      extendStatics(d, b);
      function __() {
        this.constructor = d;
      }
      d.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(e) {
            return e.source;
          });
          this._cached = {
            scanner: createOnigScanner(regExps),
            rules: this._items.map(function(e) {
              return e.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(e) {
        return e.resolveAnchors(allowA, allowG);
      });
      return {
        scanner: createOnigScanner(regExps),
        rules: this._items.map(function(e) {
          return e.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 _i = 0, matchers_1 = matchers; _i < matchers_1.length; _i++) {
      var matcher2 = matchers_1[_i];
      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 _i = 0, _a = Object.keys(tokenTypes); _i < _a.length; _i++) {
          var selector = _a[_i];
          var matchers = matcher_1.createMatchers(selector, nameMatcher);
          for (var _b = 0, matchers_2 = matchers; _b < matchers_2.length; _b++) {
            var matcher2 = matchers_2[_b];
            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 _i = 0, _a = this._tokenTypeOverrides; _i < _a.length; _i++) {
          var tokenType = _a[_i];
          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(/&amp;|&lt;|&gt;|&quot;|&apos;/g, function(_2) {
        switch (_2) {
          case "&amp;":
            return "&";
          case "&lt;":
            return "<";
          case "&gt;":
            return ">";
          case "&quot;":
            return '"';
          case "&apos;":
            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 j = 0, lenJ = segments.length; j < lenJ; j++) {
          var segment = segments[j];
          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 j = 0, lenJ = scopes.length; j < lenJ; j++) {
        var _scope = scopes[j].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, P, generator) {
    return new (P || (P = Promise))(function(resolve, reject) {
      function fulfilled(value) {
        try {
          step(generator.next(value));
        } catch (e) {
          reject(e);
        }
      }
      function rejected(value) {
        try {
          step(generator["throw"](value));
        } catch (e) {
          reject(e);
        }
      }
      function step(result) {
        result.done ? resolve(result.value) : new P(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: [] }, f, 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 (f)
        throw new TypeError("Generator is already executing.");
      while (_2)
        try {
          if (f = 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 (e) {
          op = [6, e];
          y = 0;
        } finally {
          f = 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(_a) {
          switch (_a.label) {
            case 0:
              return [4, this._loadGrammar(initialScopeName)];
            case 1:
              _a.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(_a) {
          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(_a) {
          switch (_a.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(_a2) {
                    switch (_a2.label) {
                      case 0:
                        return [4, this._locator.getGrammarDefinition(initialScopeName, dependentScope)];
                      case 1:
                        grammarDefinition = _a2.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(_a3) {
                              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:
                        _a2.sent();
                        resolve(this.grammarForScopeName(initialScopeName));
                        return [2];
                    }
                  });
                });
              });
              this.installationQueue.set(initialScopeName, prom);
              return [4, prom];
            case 1:
              _a.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 = languageId === "vue2" || languageId === "vue3" ? "html" : 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);
  };
  const _$1 = _unsafeWindow._;
  const regTheme = async (theme2) => {
    let themes = _unsafeWindow.codeThemes;
    let themeItem = themes.find((i) => i.value === 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/themes/${theme2}.json`);
    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["fontFeatureSettings"] = font.feature;
    dom.style["fontFamily"] = font.value;
  };
  const regTips = (language, monaco) => {
    var _a;
    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 = {} } = (_a = _unsafeWindow.disposables) != null ? _a : {};
    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();
    _unsafeWindow.disposables = {};
    let create = monaco.editor.create;
    monaco.editor.create = (ref, options, ...params) => {
      var _a;
      let settings = (_a = JSON.parse(_unsafeWindow.localStorage.getItem("codeSettings"))) != null ? _a : {};
      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,
        fontFeatureSettings: font.feature,
        fontSize: settings.fontSize,
        tabSize: settings.tabSize
      }, ...params);
      setFeature(font);
      setOther(option.language, editor, monaco);
      regTips(option.language, monaco);
      return editor;
    };
    previewEditor(monaco);
  };
  const setOther = async (mode, editor, monaco) => {
    await wire(mode, editor, monaco);
  };
  const defineTheme = async () => {
    var _a;
    const { theme: theme2 = "vs" } = (_a = JSON.parse(_unsafeWindow.localStorage.getItem("codeSettings"))) != null ? _a : {};
    await regTheme(theme2);
  };
  const setDefaultSetting = async () => {
    let defaultSetting = {
      fontSize: 13,
      fontFamily: "Menlo, Monaco, Courier New, monospace;",
      theme: "vs",
      tabSize: 2
    };
    let settings = _unsafeWindow.localStorage.getItem("codeSettings");
    if (_$1.isEmpty(settings)) {
      _unsafeWindow.localStorage.setItem("codeSettings", JSON.stringify(defaultSetting));
    } else {
      defineTheme();
    }
  };
  const previewEditor = (monaco) => {
    let editor = monaco.editor.create(document.createElement("div"), {
      language: "javascript"
    });
    editor.dispose();
  };
  var render$1 = function() {
    var _vm = this;
    var _h = _vm.$createElement;
    var _c = _vm._self._c || _h;
    return _c("div", {
      attrs: {
        "id": "self_dialog"
      }
    }, [_c("el-popover", {
      attrs: {
        "placement": "bottom",
        "width": "250",
        "trigger": "click"
      }
    }, [_c("el-form", {
      attrs: {
        "label-width": "50px"
      }
    }, [_c("el-form-item", {
      attrs: {
        "label": "\u5B57\u53F7"
      }
    }, [_c("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), _c("el-form-item", {
      attrs: {
        "label": "\u5B57\u4F53"
      }
    }, [_c("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 _c("el-option", {
        key: item.value,
        attrs: {
          "label": item.label,
          "value": item.value
        }
      });
    }), 1)], 1), _c("el-form-item", {
      attrs: {
        "label": "\u7F29\u8FDB"
      }
    }, [_c("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), _c("el-form-item", {
      attrs: {
        "label": "\u4E3B\u9898"
      }
    }, [_c("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 _c("el-option-group", {
        key: index,
        attrs: {
          "label": list.group,
          "divider": true
        }
      }, _vm._l(list.children, function(item) {
        return _c("el-option", {
          key: item.value,
          attrs: {
            "value": item.value,
            "label": item.name
          }
        });
      }), 1);
    }), 1)], 1)], 1), _c("el-button", {
      staticStyle: {
        "float": "right"
      },
      on: {
        "click": _vm.regTips
      }
    }, [_vm._v("\u6CE8\u518C\u4EE3\u7801\u63D0\u793A")]), _c("el-button", {
      attrs: {
        "slot": "reference",
        "icon": "el-icon-setting"
      },
      slot: "reference"
    }, [_vm._v("\u8BBE\u7F6E")])], 1), _c("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;
        }
      }
    }, [_c("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;
      }
    },
    mounted() {
      this.initData();
      this.initOptions();
      this.fontFamilys = fontFamilys;
    }
  };
  const __cssModules = {};
  var __component__ = /* @__PURE__ */ normalizeComponent(
    __vue2_script,
    render$1,
    staticRenderFns,
    false,
    __vue2_injectStyles,
    "9714e280",
    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;
  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 (e) => {
        if (!document.getElementById("self_dialog")) {
          dom = document.querySelector(selector);
          await renderHeader(dom);
        }
      });
    }
    await( initMonacoEditor());
    _unsafeWindow.require(["vs/editor/editor.main"], (monaco) => editorCreated(monaco));
    _unsafeWindow.codeThemes = codeThemeList;
    _unsafeWindow.editorTips = tips;
  }

})();