@shikijs/core 1.16.0 → 1.16.2

package/dist/index.mjs

@@ -1,4 +1,6 @@
 import { FontStyle } from './types.mjs';
+import { INITIAL, EncodedTokenMetadata, Registry as Registry$1, Theme } from '@shikijs/vscode-textmate';
+export { EncodedTokenMetadata as StackElementMetadata } from '@shikijs/vscode-textmate';
 
 function toArray(x) {
     return Array.isArray(x) ? x : [x];
@@ -104,7 +106,8 @@ function splitToken(token, offsets) {
  * Split 2D tokens array by given breakpoints.
  */
 function splitTokens(tokens, breakpoints) {
-    const sorted = Array.from(breakpoints instanceof Set ? breakpoints : new Set(breakpoints))
+    const sorted = Array
+        .from(breakpoints instanceof Set ? breakpoints : new Set(breakpoints))
         .sort((a, b) => a - b);
     if (!sorted.length)
         return tokens;
@@ -387,3010 +390,6 @@ function getTransformers(options) {
     ];
 }
 
-// src/utils.ts
-function clone(something) {
-  return doClone(something);
-}
-function doClone(something) {
-  if (Array.isArray(something)) {
-    return cloneArray(something);
-  }
-  if (typeof something === "object") {
-    return cloneObj(something);
-  }
-  return something;
-}
-function cloneArray(arr) {
-  let r = [];
-  for (let i = 0, len = arr.length; i < len; i++) {
-    r[i] = doClone(arr[i]);
-  }
-  return r;
-}
-function cloneObj(obj) {
-  let r = {};
-  for (let key in obj) {
-    r[key] = doClone(obj[key]);
-  }
-  return r;
-}
-function mergeObjects(target, ...sources) {
-  sources.forEach((source) => {
-    for (let key in source) {
-      target[key] = source[key];
-    }
-  });
-  return target;
-}
-function basename(path) {
-  const idx = ~path.lastIndexOf("/") || ~path.lastIndexOf("\\");
-  if (idx === 0) {
-    return path;
-  } else if (~idx === path.length - 1) {
-    return basename(path.substring(0, path.length - 1));
-  } else {
-    return path.substr(~idx + 1);
-  }
-}
-var CAPTURING_REGEX_SOURCE = /\$(\d+)|\${(\d+):\/(downcase|upcase)}/g;
-var RegexSource = class {
-  static hasCaptures(regexSource) {
-    if (regexSource === null) {
-      return false;
-    }
-    CAPTURING_REGEX_SOURCE.lastIndex = 0;
-    return CAPTURING_REGEX_SOURCE.test(regexSource);
-  }
-  static replaceCaptures(regexSource, captureSource, captureIndices) {
-    return regexSource.replace(CAPTURING_REGEX_SOURCE, (match, index, commandIndex, command) => {
-      let capture = captureIndices[parseInt(index || commandIndex, 10)];
-      if (capture) {
-        let 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;
-      }
-    });
-  }
-};
-function strcmp(a, b) {
-  if (a < b) {
-    return -1;
-  }
-  if (a > b) {
-    return 1;
-  }
-  return 0;
-}
-function strArrCmp(a, b) {
-  if (a === null && b === null) {
-    return 0;
-  }
-  if (!a) {
-    return -1;
-  }
-  if (!b) {
-    return 1;
-  }
-  let len1 = a.length;
-  let len2 = b.length;
-  if (len1 === len2) {
-    for (let i = 0; i < len1; i++) {
-      let res = strcmp(a[i], b[i]);
-      if (res !== 0) {
-        return res;
-      }
-    }
-    return 0;
-  }
-  return len1 - len2;
-}
-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 escapeRegExpCharacters(value) {
-  return value.replace(/[\-\\\{\}\*\+\?\|\^\$\.\,\[\]\(\)\#\s]/g, "\\$&");
-}
-var CachedFn = class {
-  constructor(fn) {
-    this.fn = fn;
-    this.cache = /* @__PURE__ */ new Map();
-  }
-  get(key) {
-    if (this.cache.has(key)) {
-      return this.cache.get(key);
-    }
-    const value = this.fn(key);
-    this.cache.set(key, value);
-    return value;
-  }
-};
-
-// src/theme.ts
-var Theme = class {
-  constructor(_colorMap, _defaults, _root) {
-    this._colorMap = _colorMap;
-    this._defaults = _defaults;
-    this._root = _root;
-    this._cachedMatchRoot = new CachedFn(
-      (scopeName) => this._root.match(scopeName)
-    );
-  }
-  static createFromRawTheme(source, colorMap) {
-    return this.createFromParsedTheme(parseTheme(source), colorMap);
-  }
-  static createFromParsedTheme(source, colorMap) {
-    return resolveParsedThemeRules(source, colorMap);
-  }
-  getColorMap() {
-    return this._colorMap.getColorMap();
-  }
-  getDefaults() {
-    return this._defaults;
-  }
-  match(scopePath) {
-    if (scopePath === null) {
-      return this._defaults;
-    }
-    const scopeName = scopePath.scopeName;
-    const matchingTrieElements = this._cachedMatchRoot.get(scopeName);
-    const effectiveRule = matchingTrieElements.find(
-      (v) => _scopePathMatchesParentScopes(scopePath.parent, v.parentScopes)
-    );
-    if (!effectiveRule) {
-      return null;
-    }
-    return new StyleAttributes(
-      effectiveRule.fontStyle,
-      effectiveRule.foreground,
-      effectiveRule.background
-    );
-  }
-};
-var ScopeStack = class _ScopeStack {
-  constructor(parent, scopeName) {
-    this.parent = parent;
-    this.scopeName = scopeName;
-  }
-  static push(path, scopeNames) {
-    for (const name of scopeNames) {
-      path = new _ScopeStack(path, name);
-    }
-    return path;
-  }
-  static from(...segments) {
-    let result = null;
-    for (let i = 0; i < segments.length; i++) {
-      result = new _ScopeStack(result, segments[i]);
-    }
-    return result;
-  }
-  push(scopeName) {
-    return new _ScopeStack(this, scopeName);
-  }
-  getSegments() {
-    let item = this;
-    const result = [];
-    while (item) {
-      result.push(item.scopeName);
-      item = item.parent;
-    }
-    result.reverse();
-    return result;
-  }
-  toString() {
-    return this.getSegments().join(" ");
-  }
-  extends(other) {
-    if (this === other) {
-      return true;
-    }
-    if (this.parent === null) {
-      return false;
-    }
-    return this.parent.extends(other);
-  }
-  getExtensionIfDefined(base) {
-    const result = [];
-    let item = this;
-    while (item && item !== base) {
-      result.push(item.scopeName);
-      item = item.parent;
-    }
-    return item === base ? result.reverse() : void 0;
-  }
-};
-function _scopePathMatchesParentScopes(scopePath, parentScopes) {
-  if (parentScopes.length === 0) {
-    return true;
-  }
-  for (let index = 0; index < parentScopes.length; index++) {
-    let scopePattern = parentScopes[index];
-    let scopeMustMatch = false;
-    if (scopePattern === ">") {
-      if (index === parentScopes.length - 1) {
-        return false;
-      }
-      scopePattern = parentScopes[++index];
-      scopeMustMatch = true;
-    }
-    while (scopePath) {
-      if (_matchesScope(scopePath.scopeName, scopePattern)) {
-        break;
-      }
-      if (scopeMustMatch) {
-        return false;
-      }
-      scopePath = scopePath.parent;
-    }
-    if (!scopePath) {
-      return false;
-    }
-    scopePath = scopePath.parent;
-  }
-  return true;
-}
-function _matchesScope(scopeName, scopePattern) {
-  return scopePattern === scopeName || scopeName.startsWith(scopePattern) && scopeName[scopePattern.length] === ".";
-}
-var StyleAttributes = class {
-  constructor(fontStyle, foregroundId, backgroundId) {
-    this.fontStyle = fontStyle;
-    this.foregroundId = foregroundId;
-    this.backgroundId = backgroundId;
-  }
-};
-function parseTheme(source) {
-  if (!source) {
-    return [];
-  }
-  if (!source.settings || !Array.isArray(source.settings)) {
-    return [];
-  }
-  let settings = source.settings;
-  let result = [], resultLen = 0;
-  for (let i = 0, len = settings.length; i < len; i++) {
-    let entry = settings[i];
-    if (!entry.settings) {
-      continue;
-    }
-    let scopes;
-    if (typeof entry.scope === "string") {
-      let _scope = entry.scope;
-      _scope = _scope.replace(/^[,]+/, "");
-      _scope = _scope.replace(/[,]+$/, "");
-      scopes = _scope.split(",");
-    } else if (Array.isArray(entry.scope)) {
-      scopes = entry.scope;
-    } else {
-      scopes = [""];
-    }
-    let fontStyle = -1 /* NotSet */;
-    if (typeof entry.settings.fontStyle === "string") {
-      fontStyle = 0 /* None */;
-      let segments = entry.settings.fontStyle.split(" ");
-      for (let j = 0, lenJ = segments.length; j < lenJ; j++) {
-        let segment = segments[j];
-        switch (segment) {
-          case "italic":
-            fontStyle = fontStyle | 1 /* Italic */;
-            break;
-          case "bold":
-            fontStyle = fontStyle | 2 /* Bold */;
-            break;
-          case "underline":
-            fontStyle = fontStyle | 4 /* Underline */;
-            break;
-          case "strikethrough":
-            fontStyle = fontStyle | 8 /* Strikethrough */;
-            break;
-        }
-      }
-    }
-    let foreground = null;
-    if (typeof entry.settings.foreground === "string" && isValidHexColor(entry.settings.foreground)) {
-      foreground = entry.settings.foreground;
-    }
-    let background = null;
-    if (typeof entry.settings.background === "string" && isValidHexColor(entry.settings.background)) {
-      background = entry.settings.background;
-    }
-    for (let j = 0, lenJ = scopes.length; j < lenJ; j++) {
-      let _scope = scopes[j].trim();
-      let segments = _scope.split(" ");
-      let scope = segments[segments.length - 1];
-      let 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;
-}
-var ParsedThemeRule = class {
-  constructor(scope, parentScopes, index, fontStyle, foreground, background) {
-    this.scope = scope;
-    this.parentScopes = parentScopes;
-    this.index = index;
-    this.fontStyle = fontStyle;
-    this.foreground = foreground;
-    this.background = background;
-  }
-};
-function resolveParsedThemeRules(parsedThemeRules, _colorMap) {
-  parsedThemeRules.sort((a, b) => {
-    let 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;
-  });
-  let defaultFontStyle = 0 /* None */;
-  let defaultForeground = "#000000";
-  let defaultBackground = "#ffffff";
-  while (parsedThemeRules.length >= 1 && parsedThemeRules[0].scope === "") {
-    let incomingDefaults = parsedThemeRules.shift();
-    if (incomingDefaults.fontStyle !== -1 /* NotSet */) {
-      defaultFontStyle = incomingDefaults.fontStyle;
-    }
-    if (incomingDefaults.foreground !== null) {
-      defaultForeground = incomingDefaults.foreground;
-    }
-    if (incomingDefaults.background !== null) {
-      defaultBackground = incomingDefaults.background;
-    }
-  }
-  let colorMap = new ColorMap(_colorMap);
-  let defaults = new StyleAttributes(defaultFontStyle, colorMap.getId(defaultForeground), colorMap.getId(defaultBackground));
-  let root = new ThemeTrieElement(new ThemeTrieElementRule(0, null, -1 /* NotSet */, 0, 0), []);
-  for (let i = 0, len = parsedThemeRules.length; i < len; i++) {
-    let rule = parsedThemeRules[i];
-    root.insert(0, rule.scope, rule.parentScopes, rule.fontStyle, colorMap.getId(rule.foreground), colorMap.getId(rule.background));
-  }
-  return new Theme(colorMap, defaults, root);
-}
-var ColorMap = class {
-  constructor(_colorMap) {
-    this._lastColorId = 0;
-    this._id2color = [];
-    this._color2id = /* @__PURE__ */ Object.create(null);
-    if (Array.isArray(_colorMap)) {
-      this._isFrozen = true;
-      for (let i = 0, len = _colorMap.length; i < len; i++) {
-        this._color2id[_colorMap[i]] = i;
-        this._id2color[i] = _colorMap[i];
-      }
-    } else {
-      this._isFrozen = false;
-    }
-  }
-  getId(color) {
-    if (color === null) {
-      return 0;
-    }
-    color = color.toUpperCase();
-    let value = this._color2id[color];
-    if (value) {
-      return value;
-    }
-    if (this._isFrozen) {
-      throw new Error(`Missing color in color map - ${color}`);
-    }
-    value = ++this._lastColorId;
-    this._color2id[color] = value;
-    this._id2color[value] = color;
-    return value;
-  }
-  getColorMap() {
-    return this._id2color.slice(0);
-  }
-};
-var emptyParentScopes = Object.freeze([]);
-var ThemeTrieElementRule = class _ThemeTrieElementRule {
-  constructor(scopeDepth, parentScopes, fontStyle, foreground, background) {
-    this.scopeDepth = scopeDepth;
-    this.parentScopes = parentScopes || emptyParentScopes;
-    this.fontStyle = fontStyle;
-    this.foreground = foreground;
-    this.background = background;
-  }
-  clone() {
-    return new _ThemeTrieElementRule(this.scopeDepth, this.parentScopes, this.fontStyle, this.foreground, this.background);
-  }
-  static cloneArr(arr) {
-    let r = [];
-    for (let i = 0, len = arr.length; i < len; i++) {
-      r[i] = arr[i].clone();
-    }
-    return r;
-  }
-  acceptOverwrite(scopeDepth, fontStyle, foreground, background) {
-    if (this.scopeDepth > scopeDepth) {
-      console.log("how did this happen?");
-    } else {
-      this.scopeDepth = scopeDepth;
-    }
-    if (fontStyle !== -1 /* NotSet */) {
-      this.fontStyle = fontStyle;
-    }
-    if (foreground !== 0) {
-      this.foreground = foreground;
-    }
-    if (background !== 0) {
-      this.background = background;
-    }
-  }
-};
-var ThemeTrieElement = class _ThemeTrieElement {
-  constructor(_mainRule, rulesWithParentScopes = [], _children = {}) {
-    this._mainRule = _mainRule;
-    this._children = _children;
-    this._rulesWithParentScopes = rulesWithParentScopes;
-  }
-  static _cmpBySpecificity(a, b) {
-    if (a.scopeDepth !== b.scopeDepth) {
-      return b.scopeDepth - a.scopeDepth;
-    }
-    let aParentIndex = 0;
-    let bParentIndex = 0;
-    while (true) {
-      if (a.parentScopes[aParentIndex] === ">") {
-        aParentIndex++;
-      }
-      if (b.parentScopes[bParentIndex] === ">") {
-        bParentIndex++;
-      }
-      if (aParentIndex >= a.parentScopes.length || bParentIndex >= b.parentScopes.length) {
-        break;
-      }
-      const parentScopeLengthDiff = b.parentScopes[bParentIndex].length - a.parentScopes[aParentIndex].length;
-      if (parentScopeLengthDiff !== 0) {
-        return parentScopeLengthDiff;
-      }
-      aParentIndex++;
-      bParentIndex++;
-    }
-    return b.parentScopes.length - a.parentScopes.length;
-  }
-  match(scope) {
-    if (scope !== "") {
-      let dotIndex = scope.indexOf(".");
-      let head;
-      let 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);
-      }
-    }
-    const rules = this._rulesWithParentScopes.concat(this._mainRule);
-    rules.sort(_ThemeTrieElement._cmpBySpecificity);
-    return rules;
-  }
-  insert(scopeDepth, scope, parentScopes, fontStyle, foreground, background) {
-    if (scope === "") {
-      this._doInsertHere(scopeDepth, parentScopes, fontStyle, foreground, background);
-      return;
-    }
-    let dotIndex = scope.indexOf(".");
-    let head;
-    let tail;
-    if (dotIndex === -1) {
-      head = scope;
-      tail = "";
-    } else {
-      head = scope.substring(0, dotIndex);
-      tail = scope.substring(dotIndex + 1);
-    }
-    let child;
-    if (this._children.hasOwnProperty(head)) {
-      child = this._children[head];
-    } else {
-      child = new _ThemeTrieElement(this._mainRule.clone(), ThemeTrieElementRule.cloneArr(this._rulesWithParentScopes));
-      this._children[head] = child;
-    }
-    child.insert(scopeDepth + 1, tail, parentScopes, fontStyle, foreground, background);
-  }
-  _doInsertHere(scopeDepth, parentScopes, fontStyle, foreground, background) {
-    if (parentScopes === null) {
-      this._mainRule.acceptOverwrite(scopeDepth, fontStyle, foreground, background);
-      return;
-    }
-    for (let i = 0, len = this._rulesWithParentScopes.length; i < len; i++) {
-      let rule = this._rulesWithParentScopes[i];
-      if (strArrCmp(rule.parentScopes, parentScopes) === 0) {
-        rule.acceptOverwrite(scopeDepth, fontStyle, foreground, background);
-        return;
-      }
-    }
-    if (fontStyle === -1 /* NotSet */) {
-      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));
-  }
-};
-
-// src/encodedTokenAttributes.ts
-var EncodedTokenAttributes;
-((EncodedTokenAttributes2) => {
-  function toBinaryStr(encodedTokenAttributes) {
-    return encodedTokenAttributes.toString(2).padStart(32, "0");
-  }
-  EncodedTokenAttributes2.toBinaryStr = toBinaryStr;
-  function print(encodedTokenAttributes) {
-    const languageId = EncodedTokenAttributes2.getLanguageId(encodedTokenAttributes);
-    const tokenType = EncodedTokenAttributes2.getTokenType(encodedTokenAttributes);
-    const fontStyle = EncodedTokenAttributes2.getFontStyle(encodedTokenAttributes);
-    const foreground = EncodedTokenAttributes2.getForeground(encodedTokenAttributes);
-    const background = EncodedTokenAttributes2.getBackground(encodedTokenAttributes);
-    console.log({
-      languageId,
-      tokenType,
-      fontStyle,
-      foreground,
-      background
-    });
-  }
-  EncodedTokenAttributes2.print = print;
-  function getLanguageId(encodedTokenAttributes) {
-    return (encodedTokenAttributes & 255 /* LANGUAGEID_MASK */) >>> 0 /* LANGUAGEID_OFFSET */;
-  }
-  EncodedTokenAttributes2.getLanguageId = getLanguageId;
-  function getTokenType(encodedTokenAttributes) {
-    return (encodedTokenAttributes & 768 /* TOKEN_TYPE_MASK */) >>> 8 /* TOKEN_TYPE_OFFSET */;
-  }
-  EncodedTokenAttributes2.getTokenType = getTokenType;
-  function containsBalancedBrackets(encodedTokenAttributes) {
-    return (encodedTokenAttributes & 1024 /* BALANCED_BRACKETS_MASK */) !== 0;
-  }
-  EncodedTokenAttributes2.containsBalancedBrackets = containsBalancedBrackets;
-  function getFontStyle(encodedTokenAttributes) {
-    return (encodedTokenAttributes & 30720 /* FONT_STYLE_MASK */) >>> 11 /* FONT_STYLE_OFFSET */;
-  }
-  EncodedTokenAttributes2.getFontStyle = getFontStyle;
-  function getForeground(encodedTokenAttributes) {
-    return (encodedTokenAttributes & 16744448 /* FOREGROUND_MASK */) >>> 15 /* FOREGROUND_OFFSET */;
-  }
-  EncodedTokenAttributes2.getForeground = getForeground;
-  function getBackground(encodedTokenAttributes) {
-    return (encodedTokenAttributes & 4278190080 /* BACKGROUND_MASK */) >>> 24 /* BACKGROUND_OFFSET */;
-  }
-  EncodedTokenAttributes2.getBackground = getBackground;
-  function set(encodedTokenAttributes, languageId, tokenType, containsBalancedBrackets2, fontStyle, foreground, background) {
-    let _languageId = EncodedTokenAttributes2.getLanguageId(encodedTokenAttributes);
-    let _tokenType = EncodedTokenAttributes2.getTokenType(encodedTokenAttributes);
-    let _containsBalancedBracketsBit = EncodedTokenAttributes2.containsBalancedBrackets(encodedTokenAttributes) ? 1 : 0;
-    let _fontStyle = EncodedTokenAttributes2.getFontStyle(encodedTokenAttributes);
-    let _foreground = EncodedTokenAttributes2.getForeground(encodedTokenAttributes);
-    let _background = EncodedTokenAttributes2.getBackground(encodedTokenAttributes);
-    if (languageId !== 0) {
-      _languageId = languageId;
-    }
-    if (tokenType !== 8 /* NotSet */) {
-      _tokenType = fromOptionalTokenType(tokenType);
-    }
-    if (containsBalancedBrackets2 !== null) {
-      _containsBalancedBracketsBit = containsBalancedBrackets2 ? 1 : 0;
-    }
-    if (fontStyle !== -1 /* NotSet */) {
-      _fontStyle = fontStyle;
-    }
-    if (foreground !== 0) {
-      _foreground = foreground;
-    }
-    if (background !== 0) {
-      _background = background;
-    }
-    return (_languageId << 0 /* LANGUAGEID_OFFSET */ | _tokenType << 8 /* TOKEN_TYPE_OFFSET */ | _containsBalancedBracketsBit << 10 /* BALANCED_BRACKETS_OFFSET */ | _fontStyle << 11 /* FONT_STYLE_OFFSET */ | _foreground << 15 /* FOREGROUND_OFFSET */ | _background << 24 /* BACKGROUND_OFFSET */) >>> 0;
-  }
-  EncodedTokenAttributes2.set = set;
-})(EncodedTokenAttributes || (EncodedTokenAttributes = {}));
-function toOptionalTokenType(standardType) {
-  return standardType;
-}
-function fromOptionalTokenType(standardType) {
-  return standardType;
-}
-
-// src/matcher.ts
-function createMatchers(selector, matchesName) {
-  const results = [];
-  const tokenizer = newTokenizer(selector);
-  let token = tokenizer.next();
-  while (token !== null) {
-    let 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();
-    }
-    let matcher = parseConjunction();
-    results.push({ matcher, priority });
-    if (token !== ",") {
-      break;
-    }
-    token = tokenizer.next();
-  }
-  return results;
-  function parseOperand() {
-    if (token === "-") {
-      token = tokenizer.next();
-      const expressionToNegate = parseOperand();
-      return (matcherInput) => !!expressionToNegate && !expressionToNegate(matcherInput);
-    }
-    if (token === "(") {
-      token = tokenizer.next();
-      const expressionInParents = parseInnerExpression();
-      if (token === ")") {
-        token = tokenizer.next();
-      }
-      return expressionInParents;
-    }
-    if (isIdentifier(token)) {
-      const identifiers = [];
-      do {
-        identifiers.push(token);
-        token = tokenizer.next();
-      } while (isIdentifier(token));
-      return (matcherInput) => matchesName(identifiers, matcherInput);
-    }
-    return null;
-  }
-  function parseConjunction() {
-    const matchers = [];
-    let matcher = parseOperand();
-    while (matcher) {
-      matchers.push(matcher);
-      matcher = parseOperand();
-    }
-    return (matcherInput) => matchers.every((matcher2) => matcher2(matcherInput));
-  }
-  function parseInnerExpression() {
-    const matchers = [];
-    let matcher = parseConjunction();
-    while (matcher) {
-      matchers.push(matcher);
-      if (token === "|" || token === ",") {
-        do {
-          token = tokenizer.next();
-        } while (token === "|" || token === ",");
-      } else {
-        break;
-      }
-      matcher = parseConjunction();
-    }
-    return (matcherInput) => matchers.some((matcher2) => matcher2(matcherInput));
-  }
-}
-function isIdentifier(token) {
-  return !!token && !!token.match(/[\w\.:]+/);
-}
-function newTokenizer(input) {
-  let regex = /([LR]:|[\w\.:][\w\.:\-]*|[\,\|\-\(\)])/g;
-  let match = regex.exec(input);
-  return {
-    next: () => {
-      if (!match) {
-        return null;
-      }
-      const res = match[0];
-      match = regex.exec(input);
-      return res;
-    }
-  };
-}
-function disposeOnigString(str) {
-  if (typeof str.dispose === "function") {
-    str.dispose();
-  }
-}
-
-// src/grammar/grammarDependencies.ts
-var TopLevelRuleReference = class {
-  constructor(scopeName) {
-    this.scopeName = scopeName;
-  }
-  toKey() {
-    return this.scopeName;
-  }
-};
-var TopLevelRepositoryRuleReference = class {
-  constructor(scopeName, ruleName) {
-    this.scopeName = scopeName;
-    this.ruleName = ruleName;
-  }
-  toKey() {
-    return `${this.scopeName}#${this.ruleName}`;
-  }
-};
-var ExternalReferenceCollector = class {
-  constructor() {
-    this._references = [];
-    this._seenReferenceKeys = /* @__PURE__ */ new Set();
-    this.visitedRule = /* @__PURE__ */ new Set();
-  }
-  get references() {
-    return this._references;
-  }
-  add(reference) {
-    const key = reference.toKey();
-    if (this._seenReferenceKeys.has(key)) {
-      return;
-    }
-    this._seenReferenceKeys.add(key);
-    this._references.push(reference);
-  }
-};
-var ScopeDependencyProcessor = class {
-  constructor(repo, initialScopeName) {
-    this.repo = repo;
-    this.initialScopeName = initialScopeName;
-    this.seenFullScopeRequests = /* @__PURE__ */ new Set();
-    this.seenPartialScopeRequests = /* @__PURE__ */ new Set();
-    this.seenFullScopeRequests.add(this.initialScopeName);
-    this.Q = [new TopLevelRuleReference(this.initialScopeName)];
-  }
-  processQueue() {
-    const q = this.Q;
-    this.Q = [];
-    const deps = new ExternalReferenceCollector();
-    for (const dep of q) {
-      collectReferencesOfReference(dep, this.initialScopeName, this.repo, deps);
-    }
-    for (const dep of deps.references) {
-      if (dep instanceof TopLevelRuleReference) {
-        if (this.seenFullScopeRequests.has(dep.scopeName)) {
-          continue;
-        }
-        this.seenFullScopeRequests.add(dep.scopeName);
-        this.Q.push(dep);
-      } else {
-        if (this.seenFullScopeRequests.has(dep.scopeName)) {
-          continue;
-        }
-        if (this.seenPartialScopeRequests.has(dep.toKey())) {
-          continue;
-        }
-        this.seenPartialScopeRequests.add(dep.toKey());
-        this.Q.push(dep);
-      }
-    }
-  }
-};
-function collectReferencesOfReference(reference, baseGrammarScopeName, repo, result) {
-  const selfGrammar = repo.lookup(reference.scopeName);
-  if (!selfGrammar) {
-    if (reference.scopeName === baseGrammarScopeName) {
-      throw new Error(`No grammar provided for <${baseGrammarScopeName}>`);
-    }
-    return;
-  }
-  const baseGrammar = repo.lookup(baseGrammarScopeName);
-  if (reference instanceof TopLevelRuleReference) {
-    collectExternalReferencesInTopLevelRule({ baseGrammar, selfGrammar }, result);
-  } else {
-    collectExternalReferencesInTopLevelRepositoryRule(
-      reference.ruleName,
-      { baseGrammar, selfGrammar, repository: selfGrammar.repository },
-      result
-    );
-  }
-  const injections = repo.injections(reference.scopeName);
-  if (injections) {
-    for (const injection of injections) {
-      result.add(new TopLevelRuleReference(injection));
-    }
-  }
-}
-function collectExternalReferencesInTopLevelRepositoryRule(ruleName, context, result) {
-  if (context.repository && context.repository[ruleName]) {
-    const rule = context.repository[ruleName];
-    collectExternalReferencesInRules([rule], context, result);
-  }
-}
-function collectExternalReferencesInTopLevelRule(context, result) {
-  if (context.selfGrammar.patterns && Array.isArray(context.selfGrammar.patterns)) {
-    collectExternalReferencesInRules(
-      context.selfGrammar.patterns,
-      { ...context, repository: context.selfGrammar.repository },
-      result
-    );
-  }
-  if (context.selfGrammar.injections) {
-    collectExternalReferencesInRules(
-      Object.values(context.selfGrammar.injections),
-      { ...context, repository: context.selfGrammar.repository },
-      result
-    );
-  }
-}
-function collectExternalReferencesInRules(rules, context, result) {
-  for (const rule of rules) {
-    if (result.visitedRule.has(rule)) {
-      continue;
-    }
-    result.visitedRule.add(rule);
-    const patternRepository = rule.repository ? mergeObjects({}, context.repository, rule.repository) : context.repository;
-    if (Array.isArray(rule.patterns)) {
-      collectExternalReferencesInRules(rule.patterns, { ...context, repository: patternRepository }, result);
-    }
-    const include = rule.include;
-    if (!include) {
-      continue;
-    }
-    const reference = parseInclude(include);
-    switch (reference.kind) {
-      case 0 /* Base */:
-        collectExternalReferencesInTopLevelRule({ ...context, selfGrammar: context.baseGrammar }, result);
-        break;
-      case 1 /* Self */:
-        collectExternalReferencesInTopLevelRule(context, result);
-        break;
-      case 2 /* RelativeReference */:
-        collectExternalReferencesInTopLevelRepositoryRule(reference.ruleName, { ...context, repository: patternRepository }, result);
-        break;
-      case 3 /* TopLevelReference */:
-      case 4 /* TopLevelRepositoryReference */:
-        const selfGrammar = reference.scopeName === context.selfGrammar.scopeName ? context.selfGrammar : reference.scopeName === context.baseGrammar.scopeName ? context.baseGrammar : void 0;
-        if (selfGrammar) {
-          const newContext = { baseGrammar: context.baseGrammar, selfGrammar, repository: patternRepository };
-          if (reference.kind === 4 /* TopLevelRepositoryReference */) {
-            collectExternalReferencesInTopLevelRepositoryRule(reference.ruleName, newContext, result);
-          } else {
-            collectExternalReferencesInTopLevelRule(newContext, result);
-          }
-        } else {
-          if (reference.kind === 4 /* TopLevelRepositoryReference */) {
-            result.add(new TopLevelRepositoryRuleReference(reference.scopeName, reference.ruleName));
-          } else {
-            result.add(new TopLevelRuleReference(reference.scopeName));
-          }
-        }
-        break;
-    }
-  }
-}
-var BaseReference = class {
-  constructor() {
-    this.kind = 0 /* Base */;
-  }
-};
-var SelfReference = class {
-  constructor() {
-    this.kind = 1 /* Self */;
-  }
-};
-var RelativeReference = class {
-  constructor(ruleName) {
-    this.ruleName = ruleName;
-    this.kind = 2 /* RelativeReference */;
-  }
-};
-var TopLevelReference = class {
-  constructor(scopeName) {
-    this.scopeName = scopeName;
-    this.kind = 3 /* TopLevelReference */;
-  }
-};
-var TopLevelRepositoryReference = class {
-  constructor(scopeName, ruleName) {
-    this.scopeName = scopeName;
-    this.ruleName = ruleName;
-    this.kind = 4 /* TopLevelRepositoryReference */;
-  }
-};
-function parseInclude(include) {
-  if (include === "$base") {
-    return new BaseReference();
-  } else if (include === "$self") {
-    return new SelfReference();
-  }
-  const indexOfSharp = include.indexOf("#");
-  if (indexOfSharp === -1) {
-    return new TopLevelReference(include);
-  } else if (indexOfSharp === 0) {
-    return new RelativeReference(include.substring(1));
-  } else {
-    const scopeName = include.substring(0, indexOfSharp);
-    const ruleName = include.substring(indexOfSharp + 1);
-    return new TopLevelRepositoryReference(scopeName, ruleName);
-  }
-}
-
-// src/rule.ts
-var HAS_BACK_REFERENCES = /\\(\d+)/;
-var BACK_REFERENCING_END = /\\(\d+)/g;
-var endRuleId = -1;
-var whileRuleId = -2;
-function ruleIdFromNumber(id) {
-  return id;
-}
-function ruleIdToNumber(id) {
-  return id;
-}
-var Rule = class {
-  constructor($location, id, name, contentName) {
-    this.$location = $location;
-    this.id = id;
-    this._name = name || null;
-    this._nameIsCapturing = RegexSource.hasCaptures(this._name);
-    this._contentName = contentName || null;
-    this._contentNameIsCapturing = RegexSource.hasCaptures(this._contentName);
-  }
-  get debugName() {
-    const location = this.$location ? `${basename(this.$location.filename)}:${this.$location.line}` : "unknown";
-    return `${this.constructor.name}#${this.id} @ ${location}`;
-  }
-  getName(lineText, captureIndices) {
-    if (!this._nameIsCapturing || this._name === null || lineText === null || captureIndices === null) {
-      return this._name;
-    }
-    return RegexSource.replaceCaptures(this._name, lineText, captureIndices);
-  }
-  getContentName(lineText, captureIndices) {
-    if (!this._contentNameIsCapturing || this._contentName === null) {
-      return this._contentName;
-    }
-    return RegexSource.replaceCaptures(this._contentName, lineText, captureIndices);
-  }
-};
-var CaptureRule = class extends Rule {
-  constructor($location, id, name, contentName, retokenizeCapturedWithRuleId) {
-    super($location, id, name, contentName);
-    this.retokenizeCapturedWithRuleId = retokenizeCapturedWithRuleId;
-  }
-  dispose() {
-  }
-  collectPatterns(grammar, out) {
-    throw new Error("Not supported!");
-  }
-  compile(grammar, endRegexSource) {
-    throw new Error("Not supported!");
-  }
-  compileAG(grammar, endRegexSource, allowA, allowG) {
-    throw new Error("Not supported!");
-  }
-};
-var MatchRule = class extends Rule {
-  constructor($location, id, name, match, captures) {
-    super($location, id, name, null);
-    this._match = new RegExpSource(match, this.id);
-    this.captures = captures;
-    this._cachedCompiledPatterns = null;
-  }
-  dispose() {
-    if (this._cachedCompiledPatterns) {
-      this._cachedCompiledPatterns.dispose();
-      this._cachedCompiledPatterns = null;
-    }
-  }
-  get debugMatchRegExp() {
-    return `${this._match.source}`;
-  }
-  collectPatterns(grammar, out) {
-    out.push(this._match);
-  }
-  compile(grammar, endRegexSource) {
-    return this._getCachedCompiledPatterns(grammar).compile(grammar);
-  }
-  compileAG(grammar, endRegexSource, allowA, allowG) {
-    return this._getCachedCompiledPatterns(grammar).compileAG(grammar, allowA, allowG);
-  }
-  _getCachedCompiledPatterns(grammar) {
-    if (!this._cachedCompiledPatterns) {
-      this._cachedCompiledPatterns = new RegExpSourceList();
-      this.collectPatterns(grammar, this._cachedCompiledPatterns);
-    }
-    return this._cachedCompiledPatterns;
-  }
-};
-var IncludeOnlyRule = class extends Rule {
-  constructor($location, id, name, contentName, patterns) {
-    super($location, id, name, contentName);
-    this.patterns = patterns.patterns;
-    this.hasMissingPatterns = patterns.hasMissingPatterns;
-    this._cachedCompiledPatterns = null;
-  }
-  dispose() {
-    if (this._cachedCompiledPatterns) {
-      this._cachedCompiledPatterns.dispose();
-      this._cachedCompiledPatterns = null;
-    }
-  }
-  collectPatterns(grammar, out) {
-    for (const pattern of this.patterns) {
-      const rule = grammar.getRule(pattern);
-      rule.collectPatterns(grammar, out);
-    }
-  }
-  compile(grammar, endRegexSource) {
-    return this._getCachedCompiledPatterns(grammar).compile(grammar);
-  }
-  compileAG(grammar, endRegexSource, allowA, allowG) {
-    return this._getCachedCompiledPatterns(grammar).compileAG(grammar, allowA, allowG);
-  }
-  _getCachedCompiledPatterns(grammar) {
-    if (!this._cachedCompiledPatterns) {
-      this._cachedCompiledPatterns = new RegExpSourceList();
-      this.collectPatterns(grammar, this._cachedCompiledPatterns);
-    }
-    return this._cachedCompiledPatterns;
-  }
-};
-var BeginEndRule = class extends Rule {
-  constructor($location, id, name, contentName, begin, beginCaptures, end, endCaptures, applyEndPatternLast, patterns) {
-    super($location, id, name, contentName);
-    this._begin = new RegExpSource(begin, this.id);
-    this.beginCaptures = beginCaptures;
-    this._end = new RegExpSource(end ? end : "\uFFFF", -1);
-    this.endHasBackReferences = this._end.hasBackReferences;
-    this.endCaptures = endCaptures;
-    this.applyEndPatternLast = applyEndPatternLast || false;
-    this.patterns = patterns.patterns;
-    this.hasMissingPatterns = patterns.hasMissingPatterns;
-    this._cachedCompiledPatterns = null;
-  }
-  dispose() {
-    if (this._cachedCompiledPatterns) {
-      this._cachedCompiledPatterns.dispose();
-      this._cachedCompiledPatterns = null;
-    }
-  }
-  get debugBeginRegExp() {
-    return `${this._begin.source}`;
-  }
-  get debugEndRegExp() {
-    return `${this._end.source}`;
-  }
-  getEndWithResolvedBackReferences(lineText, captureIndices) {
-    return this._end.resolveBackReferences(lineText, captureIndices);
-  }
-  collectPatterns(grammar, out) {
-    out.push(this._begin);
-  }
-  compile(grammar, endRegexSource) {
-    return this._getCachedCompiledPatterns(grammar, endRegexSource).compile(grammar);
-  }
-  compileAG(grammar, endRegexSource, allowA, allowG) {
-    return this._getCachedCompiledPatterns(grammar, endRegexSource).compileAG(grammar, allowA, allowG);
-  }
-  _getCachedCompiledPatterns(grammar, endRegexSource) {
-    if (!this._cachedCompiledPatterns) {
-      this._cachedCompiledPatterns = new RegExpSourceList();
-      for (const pattern of this.patterns) {
-        const rule = grammar.getRule(pattern);
-        rule.collectPatterns(grammar, this._cachedCompiledPatterns);
-      }
-      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);
-      }
-    }
-    if (this._end.hasBackReferences) {
-      if (this.applyEndPatternLast) {
-        this._cachedCompiledPatterns.setSource(this._cachedCompiledPatterns.length() - 1, endRegexSource);
-      } else {
-        this._cachedCompiledPatterns.setSource(0, endRegexSource);
-      }
-    }
-    return this._cachedCompiledPatterns;
-  }
-};
-var BeginWhileRule = class extends Rule {
-  constructor($location, id, name, contentName, begin, beginCaptures, _while, whileCaptures, patterns) {
-    super($location, id, name, contentName);
-    this._begin = new RegExpSource(begin, this.id);
-    this.beginCaptures = beginCaptures;
-    this.whileCaptures = whileCaptures;
-    this._while = new RegExpSource(_while, whileRuleId);
-    this.whileHasBackReferences = this._while.hasBackReferences;
-    this.patterns = patterns.patterns;
-    this.hasMissingPatterns = patterns.hasMissingPatterns;
-    this._cachedCompiledPatterns = null;
-    this._cachedCompiledWhilePatterns = null;
-  }
-  dispose() {
-    if (this._cachedCompiledPatterns) {
-      this._cachedCompiledPatterns.dispose();
-      this._cachedCompiledPatterns = null;
-    }
-    if (this._cachedCompiledWhilePatterns) {
-      this._cachedCompiledWhilePatterns.dispose();
-      this._cachedCompiledWhilePatterns = null;
-    }
-  }
-  get debugBeginRegExp() {
-    return `${this._begin.source}`;
-  }
-  get debugWhileRegExp() {
-    return `${this._while.source}`;
-  }
-  getWhileWithResolvedBackReferences(lineText, captureIndices) {
-    return this._while.resolveBackReferences(lineText, captureIndices);
-  }
-  collectPatterns(grammar, out) {
-    out.push(this._begin);
-  }
-  compile(grammar, endRegexSource) {
-    return this._getCachedCompiledPatterns(grammar).compile(grammar);
-  }
-  compileAG(grammar, endRegexSource, allowA, allowG) {
-    return this._getCachedCompiledPatterns(grammar).compileAG(grammar, allowA, allowG);
-  }
-  _getCachedCompiledPatterns(grammar) {
-    if (!this._cachedCompiledPatterns) {
-      this._cachedCompiledPatterns = new RegExpSourceList();
-      for (const pattern of this.patterns) {
-        const rule = grammar.getRule(pattern);
-        rule.collectPatterns(grammar, this._cachedCompiledPatterns);
-      }
-    }
-    return this._cachedCompiledPatterns;
-  }
-  compileWhile(grammar, endRegexSource) {
-    return this._getCachedCompiledWhilePatterns(grammar, endRegexSource).compile(grammar);
-  }
-  compileWhileAG(grammar, endRegexSource, allowA, allowG) {
-    return this._getCachedCompiledWhilePatterns(grammar, endRegexSource).compileAG(grammar, allowA, allowG);
-  }
-  _getCachedCompiledWhilePatterns(grammar, endRegexSource) {
-    if (!this._cachedCompiledWhilePatterns) {
-      this._cachedCompiledWhilePatterns = new RegExpSourceList();
-      this._cachedCompiledWhilePatterns.push(this._while.hasBackReferences ? this._while.clone() : this._while);
-    }
-    if (this._while.hasBackReferences) {
-      this._cachedCompiledWhilePatterns.setSource(0, endRegexSource ? endRegexSource : "\uFFFF");
-    }
-    return this._cachedCompiledWhilePatterns;
-  }
-};
-var RuleFactory = class _RuleFactory {
-  static createCaptureRule(helper, $location, name, contentName, retokenizeCapturedWithRuleId) {
-    return helper.registerRule((id) => {
-      return new CaptureRule($location, id, name, contentName, retokenizeCapturedWithRuleId);
-    });
-  }
-  static getCompiledRuleId(desc, helper, repository) {
-    if (!desc.id) {
-      helper.registerRule((id) => {
-        desc.id = id;
-        if (desc.match) {
-          return new MatchRule(
-            desc.$vscodeTextmateLocation,
-            desc.id,
-            desc.name,
-            desc.match,
-            _RuleFactory._compileCaptures(desc.captures, helper, repository)
-          );
-        }
-        if (typeof desc.begin === "undefined") {
-          if (desc.repository) {
-            repository = mergeObjects({}, repository, desc.repository);
-          }
-          let patterns = desc.patterns;
-          if (typeof patterns === "undefined" && desc.include) {
-            patterns = [{ include: desc.include }];
-          }
-          return new IncludeOnlyRule(
-            desc.$vscodeTextmateLocation,
-            desc.id,
-            desc.name,
-            desc.contentName,
-            _RuleFactory._compilePatterns(patterns, helper, repository)
-          );
-        }
-        if (desc.while) {
-          return new BeginWhileRule(
-            desc.$vscodeTextmateLocation,
-            desc.id,
-            desc.name,
-            desc.contentName,
-            desc.begin,
-            _RuleFactory._compileCaptures(desc.beginCaptures || desc.captures, helper, repository),
-            desc.while,
-            _RuleFactory._compileCaptures(desc.whileCaptures || desc.captures, helper, repository),
-            _RuleFactory._compilePatterns(desc.patterns, helper, repository)
-          );
-        }
-        return new BeginEndRule(
-          desc.$vscodeTextmateLocation,
-          desc.id,
-          desc.name,
-          desc.contentName,
-          desc.begin,
-          _RuleFactory._compileCaptures(desc.beginCaptures || desc.captures, helper, repository),
-          desc.end,
-          _RuleFactory._compileCaptures(desc.endCaptures || desc.captures, helper, repository),
-          desc.applyEndPatternLast,
-          _RuleFactory._compilePatterns(desc.patterns, helper, repository)
-        );
-      });
-    }
-    return desc.id;
-  }
-  static _compileCaptures(captures, helper, repository) {
-    let r = [];
-    if (captures) {
-      let maximumCaptureId = 0;
-      for (const captureId in captures) {
-        if (captureId === "$vscodeTextmateLocation") {
-          continue;
-        }
-        const numericCaptureId = parseInt(captureId, 10);
-        if (numericCaptureId > maximumCaptureId) {
-          maximumCaptureId = numericCaptureId;
-        }
-      }
-      for (let i = 0; i <= maximumCaptureId; i++) {
-        r[i] = null;
-      }
-      for (const captureId in captures) {
-        if (captureId === "$vscodeTextmateLocation") {
-          continue;
-        }
-        const numericCaptureId = parseInt(captureId, 10);
-        let retokenizeCapturedWithRuleId = 0;
-        if (captures[captureId].patterns) {
-          retokenizeCapturedWithRuleId = _RuleFactory.getCompiledRuleId(captures[captureId], helper, repository);
-        }
-        r[numericCaptureId] = _RuleFactory.createCaptureRule(helper, captures[captureId].$vscodeTextmateLocation, captures[captureId].name, captures[captureId].contentName, retokenizeCapturedWithRuleId);
-      }
-    }
-    return r;
-  }
-  static _compilePatterns(patterns, helper, repository) {
-    let r = [];
-    if (patterns) {
-      for (let i = 0, len = patterns.length; i < len; i++) {
-        const pattern = patterns[i];
-        let ruleId = -1;
-        if (pattern.include) {
-          const reference = parseInclude(pattern.include);
-          switch (reference.kind) {
-            case 0 /* Base */:
-            case 1 /* Self */:
-              ruleId = _RuleFactory.getCompiledRuleId(repository[pattern.include], helper, repository);
-              break;
-            case 2 /* RelativeReference */:
-              let localIncludedRule = repository[reference.ruleName];
-              if (localIncludedRule) {
-                ruleId = _RuleFactory.getCompiledRuleId(localIncludedRule, helper, repository);
-              }
-              break;
-            case 3 /* TopLevelReference */:
-            case 4 /* TopLevelRepositoryReference */:
-              const externalGrammarName = reference.scopeName;
-              const externalGrammarInclude = reference.kind === 4 /* TopLevelRepositoryReference */ ? reference.ruleName : null;
-              const externalGrammar = helper.getExternalGrammar(externalGrammarName, repository);
-              if (externalGrammar) {
-                if (externalGrammarInclude) {
-                  let externalIncludedRule = externalGrammar.repository[externalGrammarInclude];
-                  if (externalIncludedRule) {
-                    ruleId = _RuleFactory.getCompiledRuleId(externalIncludedRule, helper, externalGrammar.repository);
-                  }
-                } else {
-                  ruleId = _RuleFactory.getCompiledRuleId(externalGrammar.repository.$self, helper, externalGrammar.repository);
-                }
-              }
-              break;
-          }
-        } else {
-          ruleId = _RuleFactory.getCompiledRuleId(pattern, helper, repository);
-        }
-        if (ruleId !== -1) {
-          const rule = helper.getRule(ruleId);
-          let skipRule = false;
-          if (rule instanceof IncludeOnlyRule || rule instanceof BeginEndRule || rule instanceof BeginWhileRule) {
-            if (rule.hasMissingPatterns && rule.patterns.length === 0) {
-              skipRule = true;
-            }
-          }
-          if (skipRule) {
-            continue;
-          }
-          r.push(ruleId);
-        }
-      }
-    }
-    return {
-      patterns: r,
-      hasMissingPatterns: (patterns ? patterns.length : 0) !== r.length
-    };
-  }
-};
-var RegExpSource = class _RegExpSource {
-  constructor(regExpSource, ruleId) {
-    if (regExpSource) {
-      const len = regExpSource.length;
-      let lastPushedPos = 0;
-      let output = [];
-      let hasAnchor = false;
-      for (let pos = 0; pos < len; pos++) {
-        const ch = regExpSource.charAt(pos);
-        if (ch === "\\") {
-          if (pos + 1 < len) {
-            const 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;
-    }
-    if (this.hasAnchor) {
-      this._anchorCache = this._buildAnchorCache();
-    } else {
-      this._anchorCache = null;
-    }
-    this.ruleId = ruleId;
-    this.hasBackReferences = HAS_BACK_REFERENCES.test(this.source);
-  }
-  clone() {
-    return new _RegExpSource(this.source, this.ruleId);
-  }
-  setSource(newSource) {
-    if (this.source === newSource) {
-      return;
-    }
-    this.source = newSource;
-    if (this.hasAnchor) {
-      this._anchorCache = this._buildAnchorCache();
-    }
-  }
-  resolveBackReferences(lineText, captureIndices) {
-    let capturedValues = captureIndices.map((capture) => {
-      return lineText.substring(capture.start, capture.end);
-    });
-    BACK_REFERENCING_END.lastIndex = 0;
-    return this.source.replace(BACK_REFERENCING_END, (match, g1) => {
-      return escapeRegExpCharacters(capturedValues[parseInt(g1, 10)] || "");
-    });
-  }
-  _buildAnchorCache() {
-    let A0_G0_result = [];
-    let A0_G1_result = [];
-    let A1_G0_result = [];
-    let A1_G1_result = [];
-    let 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("")
-    };
-  }
-  resolveAnchors(allowA, allowG) {
-    if (!this.hasAnchor || !this._anchorCache) {
-      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;
-      }
-    }
-  }
-};
-var RegExpSourceList = class {
-  constructor() {
-    this._items = [];
-    this._hasAnchors = false;
-    this._cached = null;
-    this._anchorCache = {
-      A0_G0: null,
-      A0_G1: null,
-      A1_G0: null,
-      A1_G1: null
-    };
-  }
-  dispose() {
-    this._disposeCaches();
-  }
-  _disposeCaches() {
-    if (this._cached) {
-      this._cached.dispose();
-      this._cached = null;
-    }
-    if (this._anchorCache.A0_G0) {
-      this._anchorCache.A0_G0.dispose();
-      this._anchorCache.A0_G0 = null;
-    }
-    if (this._anchorCache.A0_G1) {
-      this._anchorCache.A0_G1.dispose();
-      this._anchorCache.A0_G1 = null;
-    }
-    if (this._anchorCache.A1_G0) {
-      this._anchorCache.A1_G0.dispose();
-      this._anchorCache.A1_G0 = null;
-    }
-    if (this._anchorCache.A1_G1) {
-      this._anchorCache.A1_G1.dispose();
-      this._anchorCache.A1_G1 = null;
-    }
-  }
-  push(item) {
-    this._items.push(item);
-    this._hasAnchors = this._hasAnchors || item.hasAnchor;
-  }
-  unshift(item) {
-    this._items.unshift(item);
-    this._hasAnchors = this._hasAnchors || item.hasAnchor;
-  }
-  length() {
-    return this._items.length;
-  }
-  setSource(index, newSource) {
-    if (this._items[index].source !== newSource) {
-      this._disposeCaches();
-      this._items[index].setSource(newSource);
-    }
-  }
-  compile(onigLib) {
-    if (!this._cached) {
-      let regExps = this._items.map((e) => e.source);
-      this._cached = new CompiledRule(onigLib, regExps, this._items.map((e) => e.ruleId));
-    }
-    return this._cached;
-  }
-  compileAG(onigLib, allowA, allowG) {
-    if (!this._hasAnchors) {
-      return this.compile(onigLib);
-    } else {
-      if (allowA) {
-        if (allowG) {
-          if (!this._anchorCache.A1_G1) {
-            this._anchorCache.A1_G1 = this._resolveAnchors(onigLib, allowA, allowG);
-          }
-          return this._anchorCache.A1_G1;
-        } else {
-          if (!this._anchorCache.A1_G0) {
-            this._anchorCache.A1_G0 = this._resolveAnchors(onigLib, allowA, allowG);
-          }
-          return this._anchorCache.A1_G0;
-        }
-      } else {
-        if (allowG) {
-          if (!this._anchorCache.A0_G1) {
-            this._anchorCache.A0_G1 = this._resolveAnchors(onigLib, allowA, allowG);
-          }
-          return this._anchorCache.A0_G1;
-        } else {
-          if (!this._anchorCache.A0_G0) {
-            this._anchorCache.A0_G0 = this._resolveAnchors(onigLib, allowA, allowG);
-          }
-          return this._anchorCache.A0_G0;
-        }
-      }
-    }
-  }
-  _resolveAnchors(onigLib, allowA, allowG) {
-    let regExps = this._items.map((e) => e.resolveAnchors(allowA, allowG));
-    return new CompiledRule(onigLib, regExps, this._items.map((e) => e.ruleId));
-  }
-};
-var CompiledRule = class {
-  constructor(onigLib, regExps, rules) {
-    this.regExps = regExps;
-    this.rules = rules;
-    this.scanner = onigLib.createOnigScanner(regExps);
-  }
-  dispose() {
-    if (typeof this.scanner.dispose === "function") {
-      this.scanner.dispose();
-    }
-  }
-  toString() {
-    const r = [];
-    for (let i = 0, len = this.rules.length; i < len; i++) {
-      r.push("   - " + this.rules[i] + ": " + this.regExps[i]);
-    }
-    return r.join("\n");
-  }
-  findNextMatchSync(string, startPosition, options) {
-    const result = this.scanner.findNextMatchSync(string, startPosition, options);
-    if (!result) {
-      return null;
-    }
-    return {
-      ruleId: this.rules[result.index],
-      captureIndices: result.captureIndices
-    };
-  }
-};
-
-// src/grammar/basicScopesAttributeProvider.ts
-var BasicScopeAttributes = class {
-  constructor(languageId, tokenType) {
-    this.languageId = languageId;
-    this.tokenType = tokenType;
-  }
-};
-var _BasicScopeAttributesProvider = class _BasicScopeAttributesProvider {
-  constructor(initialLanguageId, embeddedLanguages) {
-    this._getBasicScopeAttributes = new CachedFn((scopeName) => {
-      const languageId = this._scopeToLanguage(scopeName);
-      const standardTokenType = this._toStandardTokenType(scopeName);
-      return new BasicScopeAttributes(languageId, standardTokenType);
-    });
-    this._defaultAttributes = new BasicScopeAttributes(initialLanguageId, 8 /* NotSet */);
-    this._embeddedLanguagesMatcher = new ScopeMatcher(Object.entries(embeddedLanguages || {}));
-  }
-  getDefaultAttributes() {
-    return this._defaultAttributes;
-  }
-  getBasicScopeAttributes(scopeName) {
-    if (scopeName === null) {
-      return _BasicScopeAttributesProvider._NULL_SCOPE_METADATA;
-    }
-    return this._getBasicScopeAttributes.get(scopeName);
-  }
-  /**
-   * Given a produced TM scope, return the language that token describes or null if unknown.
-   * e.g. source.html => html, source.css.embedded.html => css, punctuation.definition.tag.html => null
-   */
-  _scopeToLanguage(scope) {
-    return this._embeddedLanguagesMatcher.match(scope) || 0;
-  }
-  _toStandardTokenType(scopeName) {
-    const m = scopeName.match(_BasicScopeAttributesProvider.STANDARD_TOKEN_TYPE_REGEXP);
-    if (!m) {
-      return 8 /* NotSet */;
-    }
-    switch (m[1]) {
-      case "comment":
-        return 1 /* Comment */;
-      case "string":
-        return 2 /* String */;
-      case "regex":
-        return 3 /* RegEx */;
-      case "meta.embedded":
-        return 0 /* Other */;
-    }
-    throw new Error("Unexpected match for standard token type!");
-  }
-};
-_BasicScopeAttributesProvider._NULL_SCOPE_METADATA = new BasicScopeAttributes(0, 0);
-_BasicScopeAttributesProvider.STANDARD_TOKEN_TYPE_REGEXP = /\b(comment|string|regex|meta\.embedded)\b/;
-var BasicScopeAttributesProvider = _BasicScopeAttributesProvider;
-var ScopeMatcher = class {
-  constructor(values) {
-    if (values.length === 0) {
-      this.values = null;
-      this.scopesRegExp = null;
-    } else {
-      this.values = new Map(values);
-      const escapedScopes = values.map(
-        ([scopeName, value]) => escapeRegExpCharacters(scopeName)
-      );
-      escapedScopes.sort();
-      escapedScopes.reverse();
-      this.scopesRegExp = new RegExp(
-        `^((${escapedScopes.join(")|(")}))($|\\.)`,
-        ""
-      );
-    }
-  }
-  match(scope) {
-    if (!this.scopesRegExp) {
-      return void 0;
-    }
-    const m = scope.match(this.scopesRegExp);
-    if (!m) {
-      return void 0;
-    }
-    return this.values.get(m[1]);
-  }
-};
-
-// src/debug.ts
-({
-  InDebugMode: typeof process !== "undefined" && !!process.env["VSCODE_TEXTMATE_DEBUG"]
-});
-
-// src/grammar/tokenizeString.ts
-var TokenizeStringResult = class {
-  constructor(stack, stoppedEarly) {
-    this.stack = stack;
-    this.stoppedEarly = stoppedEarly;
-  }
-};
-function _tokenizeString(grammar, lineText, isFirstLine, linePos, stack, lineTokens, checkWhileConditions, timeLimit) {
-  const lineLength = lineText.content.length;
-  let STOP = false;
-  let anchorPosition = -1;
-  if (checkWhileConditions) {
-    const whileCheckResult = _checkWhileConditions(
-      grammar,
-      lineText,
-      isFirstLine,
-      linePos,
-      stack,
-      lineTokens
-    );
-    stack = whileCheckResult.stack;
-    linePos = whileCheckResult.linePos;
-    isFirstLine = whileCheckResult.isFirstLine;
-    anchorPosition = whileCheckResult.anchorPosition;
-  }
-  const startTime = Date.now();
-  while (!STOP) {
-    if (timeLimit !== 0) {
-      const elapsedTime = Date.now() - startTime;
-      if (elapsedTime > timeLimit) {
-        return new TokenizeStringResult(stack, true);
-      }
-    }
-    scanNext();
-  }
-  return new TokenizeStringResult(stack, false);
-  function scanNext() {
-    const r = matchRuleOrInjections(
-      grammar,
-      lineText,
-      isFirstLine,
-      linePos,
-      stack,
-      anchorPosition
-    );
-    if (!r) {
-      lineTokens.produce(stack, lineLength);
-      STOP = true;
-      return;
-    }
-    const captureIndices = r.captureIndices;
-    const matchedRuleId = r.matchedRuleId;
-    const hasAdvanced = captureIndices && captureIndices.length > 0 ? captureIndices[0].end > linePos : false;
-    if (matchedRuleId === endRuleId) {
-      const poppedRule = stack.getRule(grammar);
-      lineTokens.produce(stack, captureIndices[0].start);
-      stack = stack.withContentNameScopesList(stack.nameScopesList);
-      handleCaptures(
-        grammar,
-        lineText,
-        isFirstLine,
-        stack,
-        lineTokens,
-        poppedRule.endCaptures,
-        captureIndices
-      );
-      lineTokens.produce(stack, captureIndices[0].end);
-      const popped = stack;
-      stack = stack.parent;
-      anchorPosition = popped.getAnchorPos();
-      if (!hasAdvanced && popped.getEnterPos() === linePos) {
-        stack = popped;
-        lineTokens.produce(stack, lineLength);
-        STOP = true;
-        return;
-      }
-    } else {
-      const _rule = grammar.getRule(matchedRuleId);
-      lineTokens.produce(stack, captureIndices[0].start);
-      const beforePush = stack;
-      const scopeName = _rule.getName(lineText.content, captureIndices);
-      const nameScopesList = stack.contentNameScopesList.pushAttributed(
-        scopeName,
-        grammar
-      );
-      stack = stack.push(
-        matchedRuleId,
-        linePos,
-        anchorPosition,
-        captureIndices[0].end === lineLength,
-        null,
-        nameScopesList,
-        nameScopesList
-      );
-      if (_rule instanceof BeginEndRule) {
-        const pushedRule = _rule;
-        handleCaptures(
-          grammar,
-          lineText,
-          isFirstLine,
-          stack,
-          lineTokens,
-          pushedRule.beginCaptures,
-          captureIndices
-        );
-        lineTokens.produce(stack, captureIndices[0].end);
-        anchorPosition = captureIndices[0].end;
-        const contentName = pushedRule.getContentName(
-          lineText.content,
-          captureIndices
-        );
-        const contentNameScopesList = nameScopesList.pushAttributed(
-          contentName,
-          grammar
-        );
-        stack = stack.withContentNameScopesList(contentNameScopesList);
-        if (pushedRule.endHasBackReferences) {
-          stack = stack.withEndRule(
-            pushedRule.getEndWithResolvedBackReferences(
-              lineText.content,
-              captureIndices
-            )
-          );
-        }
-        if (!hasAdvanced && beforePush.hasSameRuleAs(stack)) {
-          stack = stack.pop();
-          lineTokens.produce(stack, lineLength);
-          STOP = true;
-          return;
-        }
-      } else if (_rule instanceof BeginWhileRule) {
-        const pushedRule = _rule;
-        handleCaptures(
-          grammar,
-          lineText,
-          isFirstLine,
-          stack,
-          lineTokens,
-          pushedRule.beginCaptures,
-          captureIndices
-        );
-        lineTokens.produce(stack, captureIndices[0].end);
-        anchorPosition = captureIndices[0].end;
-        const contentName = pushedRule.getContentName(
-          lineText.content,
-          captureIndices
-        );
-        const contentNameScopesList = nameScopesList.pushAttributed(
-          contentName,
-          grammar
-        );
-        stack = stack.withContentNameScopesList(contentNameScopesList);
-        if (pushedRule.whileHasBackReferences) {
-          stack = stack.withEndRule(
-            pushedRule.getWhileWithResolvedBackReferences(
-              lineText.content,
-              captureIndices
-            )
-          );
-        }
-        if (!hasAdvanced && beforePush.hasSameRuleAs(stack)) {
-          stack = stack.pop();
-          lineTokens.produce(stack, lineLength);
-          STOP = true;
-          return;
-        }
-      } else {
-        const matchingRule = _rule;
-        handleCaptures(
-          grammar,
-          lineText,
-          isFirstLine,
-          stack,
-          lineTokens,
-          matchingRule.captures,
-          captureIndices
-        );
-        lineTokens.produce(stack, captureIndices[0].end);
-        stack = stack.pop();
-        if (!hasAdvanced) {
-          stack = stack.safePop();
-          lineTokens.produce(stack, lineLength);
-          STOP = true;
-          return;
-        }
-      }
-    }
-    if (captureIndices[0].end > linePos) {
-      linePos = captureIndices[0].end;
-      isFirstLine = false;
-    }
-  }
-}
-function _checkWhileConditions(grammar, lineText, isFirstLine, linePos, stack, lineTokens) {
-  let anchorPosition = stack.beginRuleCapturedEOL ? 0 : -1;
-  const whileRules = [];
-  for (let node = stack; node; node = node.pop()) {
-    const nodeRule = node.getRule(grammar);
-    if (nodeRule instanceof BeginWhileRule) {
-      whileRules.push({
-        rule: nodeRule,
-        stack: node
-      });
-    }
-  }
-  for (let whileRule = whileRules.pop(); whileRule; whileRule = whileRules.pop()) {
-    const { ruleScanner, findOptions } = prepareRuleWhileSearch(whileRule.rule, grammar, whileRule.stack.endRule, isFirstLine, linePos === anchorPosition);
-    const r = ruleScanner.findNextMatchSync(lineText, linePos, findOptions);
-    if (r) {
-      const matchedRuleId = r.ruleId;
-      if (matchedRuleId !== whileRuleId) {
-        stack = whileRule.stack.pop();
-        break;
-      }
-      if (r.captureIndices && r.captureIndices.length) {
-        lineTokens.produce(whileRule.stack, r.captureIndices[0].start);
-        handleCaptures(grammar, 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 matchRuleOrInjections(grammar, lineText, isFirstLine, linePos, stack, anchorPosition) {
-  const matchResult = matchRule(grammar, lineText, isFirstLine, linePos, stack, anchorPosition);
-  const injections = grammar.getInjections();
-  if (injections.length === 0) {
-    return matchResult;
-  }
-  const injectionResult = matchInjections(injections, grammar, lineText, isFirstLine, linePos, stack, anchorPosition);
-  if (!injectionResult) {
-    return matchResult;
-  }
-  if (!matchResult) {
-    return injectionResult;
-  }
-  const matchResultScore = matchResult.captureIndices[0].start;
-  const injectionResultScore = injectionResult.captureIndices[0].start;
-  if (injectionResultScore < matchResultScore || injectionResult.priorityMatch && injectionResultScore === matchResultScore) {
-    return injectionResult;
-  }
-  return matchResult;
-}
-function matchRule(grammar, lineText, isFirstLine, linePos, stack, anchorPosition) {
-  const rule = stack.getRule(grammar);
-  const { ruleScanner, findOptions } = prepareRuleSearch(rule, grammar, stack.endRule, isFirstLine, linePos === anchorPosition);
-  const r = ruleScanner.findNextMatchSync(lineText, linePos, findOptions);
-  if (r) {
-    return {
-      captureIndices: r.captureIndices,
-      matchedRuleId: r.ruleId
-    };
-  }
-  return null;
-}
-function matchInjections(injections, grammar, lineText, isFirstLine, linePos, stack, anchorPosition) {
-  let bestMatchRating = Number.MAX_VALUE;
-  let bestMatchCaptureIndices = null;
-  let bestMatchRuleId;
-  let bestMatchResultPriority = 0;
-  const scopes = stack.contentNameScopesList.getScopeNames();
-  for (let i = 0, len = injections.length; i < len; i++) {
-    const injection = injections[i];
-    if (!injection.matcher(scopes)) {
-      continue;
-    }
-    const rule = grammar.getRule(injection.ruleId);
-    const { ruleScanner, findOptions } = prepareRuleSearch(rule, grammar, null, isFirstLine, linePos === anchorPosition);
-    const matchResult = ruleScanner.findNextMatchSync(lineText, linePos, findOptions);
-    if (!matchResult) {
-      continue;
-    }
-    const matchRating = matchResult.captureIndices[0].start;
-    if (matchRating >= bestMatchRating) {
-      continue;
-    }
-    bestMatchRating = matchRating;
-    bestMatchCaptureIndices = matchResult.captureIndices;
-    bestMatchRuleId = matchResult.ruleId;
-    bestMatchResultPriority = injection.priority;
-    if (bestMatchRating === linePos) {
-      break;
-    }
-  }
-  if (bestMatchCaptureIndices) {
-    return {
-      priorityMatch: bestMatchResultPriority === -1,
-      captureIndices: bestMatchCaptureIndices,
-      matchedRuleId: bestMatchRuleId
-    };
-  }
-  return null;
-}
-function prepareRuleSearch(rule, grammar, endRegexSource, allowA, allowG) {
-  const ruleScanner = rule.compileAG(grammar, endRegexSource, allowA, allowG);
-  return { ruleScanner, findOptions: 0 /* None */ };
-}
-function prepareRuleWhileSearch(rule, grammar, endRegexSource, allowA, allowG) {
-  const ruleScanner = rule.compileWhileAG(grammar, endRegexSource, allowA, allowG);
-  return { ruleScanner, findOptions: 0 /* None */ };
-}
-function handleCaptures(grammar, lineText, isFirstLine, stack, lineTokens, captures, captureIndices) {
-  if (captures.length === 0) {
-    return;
-  }
-  const lineTextContent = lineText.content;
-  const len = Math.min(captures.length, captureIndices.length);
-  const localStack = [];
-  const maxEnd = captureIndices[0].end;
-  for (let i = 0; i < len; i++) {
-    const captureRule = captures[i];
-    if (captureRule === null) {
-      continue;
-    }
-    const 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) {
-      const scopeName = captureRule.getName(lineTextContent, captureIndices);
-      const nameScopesList = stack.contentNameScopesList.pushAttributed(scopeName, grammar);
-      const contentName = captureRule.getContentName(lineTextContent, captureIndices);
-      const contentNameScopesList = nameScopesList.pushAttributed(contentName, grammar);
-      const stackClone = stack.push(captureRule.retokenizeCapturedWithRuleId, captureIndex.start, -1, false, null, nameScopesList, contentNameScopesList);
-      const onigSubStr = grammar.createOnigString(lineTextContent.substring(0, captureIndex.end));
-      _tokenizeString(
-        grammar,
-        onigSubStr,
-        isFirstLine && captureIndex.start === 0,
-        captureIndex.start,
-        stackClone,
-        lineTokens,
-        false,
-        /* no time limit */
-        0
-      );
-      disposeOnigString(onigSubStr);
-      continue;
-    }
-    const captureRuleScopeName = captureRule.getName(lineTextContent, captureIndices);
-    if (captureRuleScopeName !== null) {
-      const base = localStack.length > 0 ? localStack[localStack.length - 1].scopes : stack.contentNameScopesList;
-      const captureRuleScopesList = base.pushAttributed(captureRuleScopeName, grammar);
-      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();
-  }
-}
-var LocalStackElement = class {
-  constructor(scopes, endPos) {
-    this.scopes = scopes;
-    this.endPos = endPos;
-  }
-};
-
-// src/grammar/grammar.ts
-function createGrammar(scopeName, grammar, initialLanguage, embeddedLanguages, tokenTypes, balancedBracketSelectors, grammarRepository, onigLib) {
-  return new Grammar(
-    scopeName,
-    grammar,
-    initialLanguage,
-    embeddedLanguages,
-    tokenTypes,
-    balancedBracketSelectors,
-    grammarRepository,
-    onigLib
-  );
-}
-function collectInjections(result, selector, rule, ruleFactoryHelper, grammar) {
-  const matchers = createMatchers(selector, nameMatcher);
-  const ruleId = RuleFactory.getCompiledRuleId(rule, ruleFactoryHelper, grammar.repository);
-  for (const matcher of matchers) {
-    result.push({
-      debugSelector: selector,
-      matcher: matcher.matcher,
-      ruleId,
-      grammar,
-      priority: matcher.priority
-    });
-  }
-}
-function nameMatcher(identifers, scopes) {
-  if (scopes.length < identifers.length) {
-    return false;
-  }
-  let lastIndex = 0;
-  return identifers.every((identifier) => {
-    for (let i = lastIndex; i < scopes.length; i++) {
-      if (scopesAreMatching(scopes[i], identifier)) {
-        lastIndex = i + 1;
-        return true;
-      }
-    }
-    return false;
-  });
-}
-function scopesAreMatching(thisScopeName, scopeName) {
-  if (!thisScopeName) {
-    return false;
-  }
-  if (thisScopeName === scopeName) {
-    return true;
-  }
-  const len = scopeName.length;
-  return thisScopeName.length > len && thisScopeName.substr(0, len) === scopeName && thisScopeName[len] === ".";
-}
-var Grammar = class {
-  constructor(_rootScopeName, grammar, initialLanguage, embeddedLanguages, tokenTypes, balancedBracketSelectors, grammarRepository, _onigLib) {
-    this._rootScopeName = _rootScopeName;
-    this.balancedBracketSelectors = balancedBracketSelectors;
-    this._onigLib = _onigLib;
-    this._basicScopeAttributesProvider = new BasicScopeAttributesProvider(
-      initialLanguage,
-      embeddedLanguages
-    );
-    this._rootId = -1;
-    this._lastRuleId = 0;
-    this._ruleId2desc = [null];
-    this._includedGrammars = {};
-    this._grammarRepository = grammarRepository;
-    this._grammar = initGrammar(grammar, null);
-    this._injections = null;
-    this._tokenTypeMatchers = [];
-    if (tokenTypes) {
-      for (const selector of Object.keys(tokenTypes)) {
-        const matchers = createMatchers(selector, nameMatcher);
-        for (const matcher of matchers) {
-          this._tokenTypeMatchers.push({
-            matcher: matcher.matcher,
-            type: tokenTypes[selector]
-          });
-        }
-      }
-    }
-  }
-  get themeProvider() {
-    return this._grammarRepository;
-  }
-  dispose() {
-    for (const rule of this._ruleId2desc) {
-      if (rule) {
-        rule.dispose();
-      }
-    }
-  }
-  createOnigScanner(sources) {
-    return this._onigLib.createOnigScanner(sources);
-  }
-  createOnigString(sources) {
-    return this._onigLib.createOnigString(sources);
-  }
-  getMetadataForScope(scope) {
-    return this._basicScopeAttributesProvider.getBasicScopeAttributes(scope);
-  }
-  _collectInjections() {
-    const grammarRepository = {
-      lookup: (scopeName2) => {
-        if (scopeName2 === this._rootScopeName) {
-          return this._grammar;
-        }
-        return this.getExternalGrammar(scopeName2);
-      },
-      injections: (scopeName2) => {
-        return this._grammarRepository.injections(scopeName2);
-      }
-    };
-    const result = [];
-    const scopeName = this._rootScopeName;
-    const grammar = grammarRepository.lookup(scopeName);
-    if (grammar) {
-      const rawInjections = grammar.injections;
-      if (rawInjections) {
-        for (let expression in rawInjections) {
-          collectInjections(
-            result,
-            expression,
-            rawInjections[expression],
-            this,
-            grammar
-          );
-        }
-      }
-      const injectionScopeNames = this._grammarRepository.injections(scopeName);
-      if (injectionScopeNames) {
-        injectionScopeNames.forEach((injectionScopeName) => {
-          const injectionGrammar = this.getExternalGrammar(injectionScopeName);
-          if (injectionGrammar) {
-            const selector = injectionGrammar.injectionSelector;
-            if (selector) {
-              collectInjections(
-                result,
-                selector,
-                injectionGrammar,
-                this,
-                injectionGrammar
-              );
-            }
-          }
-        });
-      }
-    }
-    result.sort((i1, i2) => i1.priority - i2.priority);
-    return result;
-  }
-  getInjections() {
-    if (this._injections === null) {
-      this._injections = this._collectInjections();
-    }
-    return this._injections;
-  }
-  registerRule(factory) {
-    const id = ++this._lastRuleId;
-    const result = factory(ruleIdFromNumber(id));
-    this._ruleId2desc[id] = result;
-    return result;
-  }
-  getRule(ruleId) {
-    return this._ruleId2desc[ruleIdToNumber(ruleId)];
-  }
-  getExternalGrammar(scopeName, repository) {
-    if (this._includedGrammars[scopeName]) {
-      return this._includedGrammars[scopeName];
-    } else if (this._grammarRepository) {
-      const rawIncludedGrammar = this._grammarRepository.lookup(scopeName);
-      if (rawIncludedGrammar) {
-        this._includedGrammars[scopeName] = initGrammar(
-          rawIncludedGrammar,
-          repository && repository.$base
-        );
-        return this._includedGrammars[scopeName];
-      }
-    }
-    return void 0;
-  }
-  tokenizeLine(lineText, prevState, timeLimit = 0) {
-    const r = this._tokenize(lineText, prevState, false, timeLimit);
-    return {
-      tokens: r.lineTokens.getResult(r.ruleStack, r.lineLength),
-      ruleStack: r.ruleStack,
-      stoppedEarly: r.stoppedEarly
-    };
-  }
-  tokenizeLine2(lineText, prevState, timeLimit = 0) {
-    const r = this._tokenize(lineText, prevState, true, timeLimit);
-    return {
-      tokens: r.lineTokens.getBinaryResult(r.ruleStack, r.lineLength),
-      ruleStack: r.ruleStack,
-      stoppedEarly: r.stoppedEarly
-    };
-  }
-  _tokenize(lineText, prevState, emitBinaryTokens, timeLimit) {
-    if (this._rootId === -1) {
-      this._rootId = RuleFactory.getCompiledRuleId(
-        this._grammar.repository.$self,
-        this,
-        this._grammar.repository
-      );
-      this.getInjections();
-    }
-    let isFirstLine;
-    if (!prevState || prevState === StateStackImpl.NULL) {
-      isFirstLine = true;
-      const rawDefaultMetadata = this._basicScopeAttributesProvider.getDefaultAttributes();
-      const defaultStyle = this.themeProvider.getDefaults();
-      const defaultMetadata = EncodedTokenAttributes.set(
-        0,
-        rawDefaultMetadata.languageId,
-        rawDefaultMetadata.tokenType,
-        null,
-        defaultStyle.fontStyle,
-        defaultStyle.foregroundId,
-        defaultStyle.backgroundId
-      );
-      const rootScopeName = this.getRule(this._rootId).getName(
-        null,
-        null
-      );
-      let scopeList;
-      if (rootScopeName) {
-        scopeList = AttributedScopeStack.createRootAndLookUpScopeName(
-          rootScopeName,
-          defaultMetadata,
-          this
-        );
-      } else {
-        scopeList = AttributedScopeStack.createRoot(
-          "unknown",
-          defaultMetadata
-        );
-      }
-      prevState = new StateStackImpl(
-        null,
-        this._rootId,
-        -1,
-        -1,
-        false,
-        null,
-        scopeList,
-        scopeList
-      );
-    } else {
-      isFirstLine = false;
-      prevState.reset();
-    }
-    lineText = lineText + "\n";
-    const onigLineText = this.createOnigString(lineText);
-    const lineLength = onigLineText.content.length;
-    const lineTokens = new LineTokens(
-      emitBinaryTokens,
-      lineText,
-      this._tokenTypeMatchers,
-      this.balancedBracketSelectors
-    );
-    const r = _tokenizeString(
-      this,
-      onigLineText,
-      isFirstLine,
-      0,
-      prevState,
-      lineTokens,
-      true,
-      timeLimit
-    );
-    disposeOnigString(onigLineText);
-    return {
-      lineLength,
-      lineTokens,
-      ruleStack: r.stack,
-      stoppedEarly: r.stoppedEarly
-    };
-  }
-};
-function initGrammar(grammar, base) {
-  grammar = clone(grammar);
-  grammar.repository = grammar.repository || {};
-  grammar.repository.$self = {
-    $vscodeTextmateLocation: grammar.$vscodeTextmateLocation,
-    patterns: grammar.patterns,
-    name: grammar.scopeName
-  };
-  grammar.repository.$base = base || grammar.repository.$self;
-  return grammar;
-}
-var AttributedScopeStack = class _AttributedScopeStack {
-  /**
-   * Invariant:
-   * ```
-   * if (parent && !scopePath.extends(parent.scopePath)) {
-   * 	throw new Error();
-   * }
-   * ```
-   */
-  constructor(parent, scopePath, tokenAttributes) {
-    this.parent = parent;
-    this.scopePath = scopePath;
-    this.tokenAttributes = tokenAttributes;
-  }
-  static fromExtension(namesScopeList, contentNameScopesList) {
-    let current = namesScopeList;
-    let scopeNames = namesScopeList?.scopePath ?? null;
-    for (const frame of contentNameScopesList) {
-      scopeNames = ScopeStack.push(scopeNames, frame.scopeNames);
-      current = new _AttributedScopeStack(current, scopeNames, frame.encodedTokenAttributes);
-    }
-    return current;
-  }
-  static createRoot(scopeName, tokenAttributes) {
-    return new _AttributedScopeStack(null, new ScopeStack(null, scopeName), tokenAttributes);
-  }
-  static createRootAndLookUpScopeName(scopeName, tokenAttributes, grammar) {
-    const rawRootMetadata = grammar.getMetadataForScope(scopeName);
-    const scopePath = new ScopeStack(null, scopeName);
-    const rootStyle = grammar.themeProvider.themeMatch(scopePath);
-    const resolvedTokenAttributes = _AttributedScopeStack.mergeAttributes(
-      tokenAttributes,
-      rawRootMetadata,
-      rootStyle
-    );
-    return new _AttributedScopeStack(null, scopePath, resolvedTokenAttributes);
-  }
-  get scopeName() {
-    return this.scopePath.scopeName;
-  }
-  toString() {
-    return this.getScopeNames().join(" ");
-  }
-  equals(other) {
-    return _AttributedScopeStack.equals(this, other);
-  }
-  static equals(a, b) {
-    do {
-      if (a === b) {
-        return true;
-      }
-      if (!a && !b) {
-        return true;
-      }
-      if (!a || !b) {
-        return false;
-      }
-      if (a.scopeName !== b.scopeName || a.tokenAttributes !== b.tokenAttributes) {
-        return false;
-      }
-      a = a.parent;
-      b = b.parent;
-    } while (true);
-  }
-  static mergeAttributes(existingTokenAttributes, basicScopeAttributes, styleAttributes) {
-    let fontStyle = -1 /* NotSet */;
-    let foreground = 0;
-    let background = 0;
-    if (styleAttributes !== null) {
-      fontStyle = styleAttributes.fontStyle;
-      foreground = styleAttributes.foregroundId;
-      background = styleAttributes.backgroundId;
-    }
-    return EncodedTokenAttributes.set(
-      existingTokenAttributes,
-      basicScopeAttributes.languageId,
-      basicScopeAttributes.tokenType,
-      null,
-      fontStyle,
-      foreground,
-      background
-    );
-  }
-  pushAttributed(scopePath, grammar) {
-    if (scopePath === null) {
-      return this;
-    }
-    if (scopePath.indexOf(" ") === -1) {
-      return _AttributedScopeStack._pushAttributed(this, scopePath, grammar);
-    }
-    const scopes = scopePath.split(/ /g);
-    let result = this;
-    for (const scope of scopes) {
-      result = _AttributedScopeStack._pushAttributed(result, scope, grammar);
-    }
-    return result;
-  }
-  static _pushAttributed(target, scopeName, grammar) {
-    const rawMetadata = grammar.getMetadataForScope(scopeName);
-    const newPath = target.scopePath.push(scopeName);
-    const scopeThemeMatchResult = grammar.themeProvider.themeMatch(newPath);
-    const metadata = _AttributedScopeStack.mergeAttributes(
-      target.tokenAttributes,
-      rawMetadata,
-      scopeThemeMatchResult
-    );
-    return new _AttributedScopeStack(target, newPath, metadata);
-  }
-  getScopeNames() {
-    return this.scopePath.getSegments();
-  }
-  getExtensionIfDefined(base) {
-    const result = [];
-    let self = this;
-    while (self && self !== base) {
-      result.push({
-        encodedTokenAttributes: self.tokenAttributes,
-        scopeNames: self.scopePath.getExtensionIfDefined(self.parent?.scopePath ?? null)
-      });
-      self = self.parent;
-    }
-    return self === base ? result.reverse() : void 0;
-  }
-};
-var _StateStackImpl = class _StateStackImpl {
-  /**
-   * Invariant:
-   * ```
-   * if (contentNameScopesList !== nameScopesList && contentNameScopesList?.parent !== nameScopesList) {
-   * 	throw new Error();
-   * }
-   * if (this.parent && !nameScopesList.extends(this.parent.contentNameScopesList)) {
-   * 	throw new Error();
-   * }
-   * ```
-   */
-  constructor(parent, ruleId, enterPos, anchorPos, beginRuleCapturedEOL, endRule, nameScopesList, contentNameScopesList) {
-    this.parent = parent;
-    this.ruleId = ruleId;
-    this.beginRuleCapturedEOL = beginRuleCapturedEOL;
-    this.endRule = endRule;
-    this.nameScopesList = nameScopesList;
-    this.contentNameScopesList = contentNameScopesList;
-    this._stackElementBrand = void 0;
-    this.depth = this.parent ? this.parent.depth + 1 : 1;
-    this._enterPos = enterPos;
-    this._anchorPos = anchorPos;
-  }
-  equals(other) {
-    if (other === null) {
-      return false;
-    }
-    return _StateStackImpl._equals(this, other);
-  }
-  static _equals(a, b) {
-    if (a === b) {
-      return true;
-    }
-    if (!this._structuralEquals(a, b)) {
-      return false;
-    }
-    return AttributedScopeStack.equals(a.contentNameScopesList, b.contentNameScopesList);
-  }
-  /**
-   * A structural equals check. Does not take into account `scopes`.
-   */
-  static _structuralEquals(a, b) {
-    do {
-      if (a === b) {
-        return true;
-      }
-      if (!a && !b) {
-        return true;
-      }
-      if (!a || !b) {
-        return false;
-      }
-      if (a.depth !== b.depth || a.ruleId !== b.ruleId || a.endRule !== b.endRule) {
-        return false;
-      }
-      a = a.parent;
-      b = b.parent;
-    } while (true);
-  }
-  clone() {
-    return this;
-  }
-  static _reset(el) {
-    while (el) {
-      el._enterPos = -1;
-      el._anchorPos = -1;
-      el = el.parent;
-    }
-  }
-  reset() {
-    _StateStackImpl._reset(this);
-  }
-  pop() {
-    return this.parent;
-  }
-  safePop() {
-    if (this.parent) {
-      return this.parent;
-    }
-    return this;
-  }
-  push(ruleId, enterPos, anchorPos, beginRuleCapturedEOL, endRule, nameScopesList, contentNameScopesList) {
-    return new _StateStackImpl(
-      this,
-      ruleId,
-      enterPos,
-      anchorPos,
-      beginRuleCapturedEOL,
-      endRule,
-      nameScopesList,
-      contentNameScopesList
-    );
-  }
-  getEnterPos() {
-    return this._enterPos;
-  }
-  getAnchorPos() {
-    return this._anchorPos;
-  }
-  getRule(grammar) {
-    return grammar.getRule(this.ruleId);
-  }
-  toString() {
-    const r = [];
-    this._writeString(r, 0);
-    return "[" + r.join(",") + "]";
-  }
-  _writeString(res, outIndex) {
-    if (this.parent) {
-      outIndex = this.parent._writeString(res, outIndex);
-    }
-    res[outIndex++] = `(${this.ruleId}, ${this.nameScopesList?.toString()}, ${this.contentNameScopesList?.toString()})`;
-    return outIndex;
-  }
-  withContentNameScopesList(contentNameScopeStack) {
-    if (this.contentNameScopesList === contentNameScopeStack) {
-      return this;
-    }
-    return this.parent.push(
-      this.ruleId,
-      this._enterPos,
-      this._anchorPos,
-      this.beginRuleCapturedEOL,
-      this.endRule,
-      this.nameScopesList,
-      contentNameScopeStack
-    );
-  }
-  withEndRule(endRule) {
-    if (this.endRule === endRule) {
-      return this;
-    }
-    return new _StateStackImpl(
-      this.parent,
-      this.ruleId,
-      this._enterPos,
-      this._anchorPos,
-      this.beginRuleCapturedEOL,
-      endRule,
-      this.nameScopesList,
-      this.contentNameScopesList
-    );
-  }
-  // Used to warn of endless loops
-  hasSameRuleAs(other) {
-    let el = this;
-    while (el && el._enterPos === other._enterPos) {
-      if (el.ruleId === other.ruleId) {
-        return true;
-      }
-      el = el.parent;
-    }
-    return false;
-  }
-  toStateStackFrame() {
-    return {
-      ruleId: ruleIdToNumber(this.ruleId),
-      beginRuleCapturedEOL: this.beginRuleCapturedEOL,
-      endRule: this.endRule,
-      nameScopesList: this.nameScopesList?.getExtensionIfDefined(this.parent?.nameScopesList ?? null) ?? [],
-      contentNameScopesList: this.contentNameScopesList?.getExtensionIfDefined(this.nameScopesList) ?? []
-    };
-  }
-  static pushFrame(self, frame) {
-    const namesScopeList = AttributedScopeStack.fromExtension(self?.nameScopesList ?? null, frame.nameScopesList);
-    return new _StateStackImpl(
-      self,
-      ruleIdFromNumber(frame.ruleId),
-      frame.enterPos ?? -1,
-      frame.anchorPos ?? -1,
-      frame.beginRuleCapturedEOL,
-      frame.endRule,
-      namesScopeList,
-      AttributedScopeStack.fromExtension(namesScopeList, frame.contentNameScopesList)
-    );
-  }
-};
-// TODO remove me
-_StateStackImpl.NULL = new _StateStackImpl(
-  null,
-  0,
-  0,
-  0,
-  false,
-  null,
-  null,
-  null
-);
-var StateStackImpl = _StateStackImpl;
-var BalancedBracketSelectors = class {
-  constructor(balancedBracketScopes, unbalancedBracketScopes) {
-    this.allowAny = false;
-    this.balancedBracketScopes = balancedBracketScopes.flatMap(
-      (selector) => {
-        if (selector === "*") {
-          this.allowAny = true;
-          return [];
-        }
-        return createMatchers(selector, nameMatcher).map((m) => m.matcher);
-      }
-    );
-    this.unbalancedBracketScopes = unbalancedBracketScopes.flatMap(
-      (selector) => createMatchers(selector, nameMatcher).map((m) => m.matcher)
-    );
-  }
-  get matchesAlways() {
-    return this.allowAny && this.unbalancedBracketScopes.length === 0;
-  }
-  get matchesNever() {
-    return this.balancedBracketScopes.length === 0 && !this.allowAny;
-  }
-  match(scopes) {
-    for (const excluder of this.unbalancedBracketScopes) {
-      if (excluder(scopes)) {
-        return false;
-      }
-    }
-    for (const includer of this.balancedBracketScopes) {
-      if (includer(scopes)) {
-        return true;
-      }
-    }
-    return this.allowAny;
-  }
-};
-var LineTokens = class {
-  constructor(emitBinaryTokens, lineText, tokenTypeOverrides, balancedBracketSelectors) {
-    this.balancedBracketSelectors = balancedBracketSelectors;
-    this._emitBinaryTokens = emitBinaryTokens;
-    this._tokenTypeOverrides = tokenTypeOverrides;
-    {
-      this._lineText = null;
-    }
-    this._tokens = [];
-    this._binaryTokens = [];
-    this._lastTokenEndIndex = 0;
-  }
-  produce(stack, endIndex) {
-    this.produceFromScopes(stack.contentNameScopesList, endIndex);
-  }
-  produceFromScopes(scopesList, endIndex) {
-    if (this._lastTokenEndIndex >= endIndex) {
-      return;
-    }
-    if (this._emitBinaryTokens) {
-      let metadata = scopesList?.tokenAttributes ?? 0;
-      let containsBalancedBrackets = false;
-      if (this.balancedBracketSelectors?.matchesAlways) {
-        containsBalancedBrackets = true;
-      }
-      if (this._tokenTypeOverrides.length > 0 || this.balancedBracketSelectors && !this.balancedBracketSelectors.matchesAlways && !this.balancedBracketSelectors.matchesNever) {
-        const scopes2 = scopesList?.getScopeNames() ?? [];
-        for (const tokenType of this._tokenTypeOverrides) {
-          if (tokenType.matcher(scopes2)) {
-            metadata = EncodedTokenAttributes.set(
-              metadata,
-              0,
-              toOptionalTokenType(tokenType.type),
-              null,
-              -1 /* NotSet */,
-              0,
-              0
-            );
-          }
-        }
-        if (this.balancedBracketSelectors) {
-          containsBalancedBrackets = this.balancedBracketSelectors.match(scopes2);
-        }
-      }
-      if (containsBalancedBrackets) {
-        metadata = EncodedTokenAttributes.set(
-          metadata,
-          0,
-          8 /* NotSet */,
-          containsBalancedBrackets,
-          -1 /* NotSet */,
-          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;
-    }
-    const scopes = scopesList?.getScopeNames() ?? [];
-    this._tokens.push({
-      startIndex: this._lastTokenEndIndex,
-      endIndex,
-      // value: lineText.substring(lastTokenEndIndex, endIndex),
-      scopes
-    });
-    this._lastTokenEndIndex = endIndex;
-  }
-  getResult(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;
-  }
-  getBinaryResult(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;
-    }
-    const result = new Uint32Array(this._binaryTokens.length);
-    for (let i = 0, len = this._binaryTokens.length; i < len; i++) {
-      result[i] = this._binaryTokens[i];
-    }
-    return result;
-  }
-};
-
-// src/registry.ts
-var SyncRegistry = class {
-  constructor(theme, _onigLib) {
-    this._onigLib = _onigLib;
-    this._grammars = /* @__PURE__ */ new Map();
-    this._rawGrammars = /* @__PURE__ */ new Map();
-    this._injectionGrammars = /* @__PURE__ */ new Map();
-    this._theme = theme;
-  }
-  dispose() {
-    for (const grammar of this._grammars.values()) {
-      grammar.dispose();
-    }
-  }
-  setTheme(theme) {
-    this._theme = theme;
-  }
-  getColorMap() {
-    return this._theme.getColorMap();
-  }
-  /**
-   * Add `grammar` to registry and return a list of referenced scope names
-   */
-  addGrammar(grammar, injectionScopeNames) {
-    this._rawGrammars.set(grammar.scopeName, grammar);
-    if (injectionScopeNames) {
-      this._injectionGrammars.set(grammar.scopeName, injectionScopeNames);
-    }
-  }
-  /**
-   * Lookup a raw grammar.
-   */
-  lookup(scopeName) {
-    return this._rawGrammars.get(scopeName);
-  }
-  /**
-   * Returns the injections for the given grammar
-   */
-  injections(targetScope) {
-    return this._injectionGrammars.get(targetScope);
-  }
-  /**
-   * Get the default theme settings
-   */
-  getDefaults() {
-    return this._theme.getDefaults();
-  }
-  /**
-   * Match a scope in the theme.
-   */
-  themeMatch(scopePath) {
-    return this._theme.match(scopePath);
-  }
-  /**
-   * Lookup a grammar.
-   */
-  grammarForScopeName(scopeName, initialLanguage, embeddedLanguages, tokenTypes, balancedBracketSelectors) {
-    if (!this._grammars.has(scopeName)) {
-      let rawGrammar = this._rawGrammars.get(scopeName);
-      if (!rawGrammar) {
-        return null;
-      }
-      this._grammars.set(scopeName, createGrammar(
-        scopeName,
-        rawGrammar,
-        initialLanguage,
-        embeddedLanguages,
-        tokenTypes,
-        balancedBracketSelectors,
-        this,
-        this._onigLib
-      ));
-    }
-    return this._grammars.get(scopeName);
-  }
-};
-
-// src/main.ts
-var Registry$1 = class Registry {
-  constructor(options) {
-    this._options = options;
-    this._syncRegistry = new SyncRegistry(
-      Theme.createFromRawTheme(options.theme, options.colorMap),
-      options.onigLib
-    );
-    this._ensureGrammarCache = /* @__PURE__ */ new Map();
-  }
-  dispose() {
-    this._syncRegistry.dispose();
-  }
-  /**
-   * Change the theme. Once called, no previous `ruleStack` should be used anymore.
-   */
-  setTheme(theme, colorMap) {
-    this._syncRegistry.setTheme(Theme.createFromRawTheme(theme, colorMap));
-  }
-  /**
-   * Returns a lookup array for color ids.
-   */
-  getColorMap() {
-    return this._syncRegistry.getColorMap();
-  }
-  /**
-   * Load the grammar for `scopeName` and all referenced included grammars asynchronously.
-   * Please do not use language id 0.
-   */
-  loadGrammarWithEmbeddedLanguages(initialScopeName, initialLanguage, embeddedLanguages) {
-    return this.loadGrammarWithConfiguration(initialScopeName, initialLanguage, { embeddedLanguages });
-  }
-  /**
-   * Load the grammar for `scopeName` and all referenced included grammars asynchronously.
-   * Please do not use language id 0.
-   */
-  loadGrammarWithConfiguration(initialScopeName, initialLanguage, configuration) {
-    return this._loadGrammar(
-      initialScopeName,
-      initialLanguage,
-      configuration.embeddedLanguages,
-      configuration.tokenTypes,
-      new BalancedBracketSelectors(
-        configuration.balancedBracketSelectors || [],
-        configuration.unbalancedBracketSelectors || []
-      )
-    );
-  }
-  /**
-   * Load the grammar for `scopeName` and all referenced included grammars asynchronously.
-   */
-  loadGrammar(initialScopeName) {
-    return this._loadGrammar(initialScopeName, 0, null, null, null);
-  }
-  _loadGrammar(initialScopeName, initialLanguage, embeddedLanguages, tokenTypes, balancedBracketSelectors) {
-    const dependencyProcessor = new ScopeDependencyProcessor(this._syncRegistry, initialScopeName);
-    while (dependencyProcessor.Q.length > 0) {
-      dependencyProcessor.Q.map((request) => this._loadSingleGrammar(request.scopeName));
-      dependencyProcessor.processQueue();
-    }
-    return this._grammarForScopeName(
-      initialScopeName,
-      initialLanguage,
-      embeddedLanguages,
-      tokenTypes,
-      balancedBracketSelectors
-    );
-  }
-  _loadSingleGrammar(scopeName) {
-    if (!this._ensureGrammarCache.has(scopeName)) {
-      this._doLoadSingleGrammar(scopeName);
-      this._ensureGrammarCache.set(scopeName, true);
-    }
-  }
-  _doLoadSingleGrammar(scopeName) {
-    const grammar = this._options.loadGrammar(scopeName);
-    if (grammar) {
-      const injections = typeof this._options.getInjections === "function" ? this._options.getInjections(scopeName) : void 0;
-      this._syncRegistry.addGrammar(grammar, injections);
-    }
-  }
-  /**
-   * Adds a rawGrammar.
-   */
-  addGrammar(rawGrammar, injections = [], initialLanguage = 0, embeddedLanguages = null) {
-    this._syncRegistry.addGrammar(rawGrammar, injections);
-    return this._grammarForScopeName(rawGrammar.scopeName, initialLanguage, embeddedLanguages);
-  }
-  /**
-   * Get the grammar for `scopeName`. The grammar must first be created via `loadGrammar` or `addGrammar`.
-   */
-  _grammarForScopeName(scopeName, initialLanguage = 0, embeddedLanguages = null, tokenTypes = null, balancedBracketSelectors = null) {
-    return this._syncRegistry.grammarForScopeName(
-      scopeName,
-      initialLanguage,
-      embeddedLanguages,
-      tokenTypes,
-      balancedBracketSelectors
-    );
-  }
-};
-var INITIAL = StateStackImpl.NULL;
-
 /**
  * GrammarState is a special reference object that holds the state of a grammar.
  *
@@ -3445,110 +444,6 @@ function getGrammarStack(state) {
     return state._stack;
 }
 
-/**
- * Helpers to manage the "collapsed" metadata of an entire StackElement stack.
- * The following assumptions have been made:
- *  - languageId < 256 => needs 8 bits
- *  - unique color count < 512 => needs 9 bits
- *
- * The binary format is:
- * - -------------------------------------------
- *     3322 2222 2222 1111 1111 1100 0000 0000
- *     1098 7654 3210 9876 5432 1098 7654 3210
- * - -------------------------------------------
- *     xxxx xxxx xxxx xxxx xxxx xxxx xxxx xxxx
- *     bbbb bbbb bfff ffff ffFF FTTT LLLL LLLL
- * - -------------------------------------------
- *  - L = LanguageId (8 bits)
- *  - T = StandardTokenType (3 bits)
- *  - F = FontStyle (3 bits)
- *  - f = foreground color (9 bits)
- *  - b = background color (9 bits)
- */
-const MetadataConsts = {
-    LANGUAGEID_MASK: 0b00000000000000000000000011111111,
-    TOKEN_TYPE_MASK: 0b00000000000000000000001100000000,
-    BALANCED_BRACKETS_MASK: 0b00000000000000000000010000000000,
-    FONT_STYLE_MASK: 0b00000000000000000011100000000000,
-    FOREGROUND_MASK: 0b00000000011111111100000000000000,
-    BACKGROUND_MASK: 0b11111111100000000000000000000000,
-    LANGUAGEID_OFFSET: 0,
-    TOKEN_TYPE_OFFSET: 8,
-    BALANCED_BRACKETS_OFFSET: 10,
-    FONT_STYLE_OFFSET: 11,
-    FOREGROUND_OFFSET: 15,
-    BACKGROUND_OFFSET: 24,
-};
-class StackElementMetadata {
-    static toBinaryStr(metadata) {
-        let r = metadata.toString(2);
-        while (r.length < 32)
-            r = `0${r}`;
-        return r;
-    }
-    // public static printMetadata(metadata: number): void {
-    //   const languageId = StackElementMetadata.getLanguageId(metadata)
-    //   const tokenType = StackElementMetadata.getTokenType(metadata)
-    //   const fontStyle = StackElementMetadata.getFontStyle(metadata)
-    //   const foreground = StackElementMetadata.getForeground(metadata)
-    //   const background = StackElementMetadata.getBackground(metadata)
-    //   console.log({
-    //     languageId,
-    //     tokenType,
-    //     fontStyle,
-    //     foreground,
-    //     background,
-    //   })
-    // }
-    static getLanguageId(metadata) {
-        return (metadata & MetadataConsts.LANGUAGEID_MASK) >>> MetadataConsts.LANGUAGEID_OFFSET;
-    }
-    static getTokenType(metadata) {
-        return (metadata & MetadataConsts.TOKEN_TYPE_MASK) >>> MetadataConsts.TOKEN_TYPE_OFFSET;
-    }
-    static getFontStyle(metadata) {
-        return (metadata & MetadataConsts.FONT_STYLE_MASK) >>> MetadataConsts.FONT_STYLE_OFFSET;
-    }
-    static getForeground(metadata) {
-        return (metadata & MetadataConsts.FOREGROUND_MASK) >>> MetadataConsts.FOREGROUND_OFFSET;
-    }
-    static getBackground(metadata) {
-        return (metadata & MetadataConsts.BACKGROUND_MASK) >>> MetadataConsts.BACKGROUND_OFFSET;
-    }
-    static containsBalancedBrackets(metadata) {
-        return (metadata & MetadataConsts.BALANCED_BRACKETS_MASK) !== 0;
-    }
-    static set(metadata, languageId, tokenType, fontStyle, foreground, background) {
-        let _languageId = StackElementMetadata.getLanguageId(metadata);
-        let _tokenType = StackElementMetadata.getTokenType(metadata);
-        let _fontStyle = StackElementMetadata.getFontStyle(metadata);
-        let _foreground = StackElementMetadata.getForeground(metadata);
-        let _background = StackElementMetadata.getBackground(metadata);
-        const _containsBalancedBracketsBit = StackElementMetadata.containsBalancedBrackets(metadata)
-            ? 1
-            : 0;
-        if (languageId !== 0)
-            _languageId = languageId;
-        if (tokenType !== 0 /* TemporaryStandardTokenType.Other */) {
-            _tokenType
-                = tokenType === 8 /* TemporaryStandardTokenType.MetaEmbedded */ ? 0 /* StandardTokenType.Other */ : tokenType;
-        }
-        if (fontStyle !== FontStyle.NotSet)
-            _fontStyle = fontStyle;
-        if (foreground !== 0)
-            _foreground = foreground;
-        if (background !== 0)
-            _background = background;
-        return (((_languageId << MetadataConsts.LANGUAGEID_OFFSET)
-            | (_tokenType << MetadataConsts.TOKEN_TYPE_OFFSET)
-            | (_fontStyle << MetadataConsts.FONT_STYLE_OFFSET)
-            | (_containsBalancedBracketsBit << MetadataConsts.BALANCED_BRACKETS_OFFSET)
-            | (_foreground << MetadataConsts.FOREGROUND_OFFSET)
-            | (_background << MetadataConsts.BACKGROUND_OFFSET))
-            >>> 0);
-    }
-}
-
 // src/colors.ts
 var namedColors = [
   "black",
@@ -3858,7 +753,8 @@ function dimColor(color) {
     if (hexMatch) {
         if (hexMatch[3]) {
             // convert from #rrggbbaa to #rrggbb(aa/2)
-            const alpha = Math.round(Number.parseInt(hexMatch[3], 16) / 2)
+            const alpha = Math
+                .round(Number.parseInt(hexMatch[3], 16) / 2)
                 .toString(16)
                 .padStart(2, '0');
             return `#${hexMatch[1]}${hexMatch[2]}${alpha}`;
@@ -3869,7 +765,8 @@ function dimColor(color) {
         }
         else {
             // convert from #rgb to #rrggbb80
-            return `#${Array.from(hexMatch[1])
+            return `#${Array
+                .from(hexMatch[1])
                 .map(x => `${x}${x}`)
                 .join('')}80`;
         }
@@ -3966,8 +863,8 @@ function _tokenizeWithTheme(code, grammar, theme, colorMap, options) {
             if (startIndex === nextStartIndex)
                 continue;
             const metadata = result.tokens[2 * j + 1];
-            const color = applyColorReplacements(colorMap[StackElementMetadata.getForeground(metadata)], colorReplacements);
-            const fontStyle = StackElementMetadata.getFontStyle(metadata);
+            const color = applyColorReplacements(colorMap[EncodedTokenMetadata.getForeground(metadata)], colorReplacements);
+            const fontStyle = EncodedTokenMetadata.getFontStyle(metadata);
             const token = {
                 content: line.substring(startIndex, nextStartIndex),
                 offset: lineOffset + startIndex,
@@ -4070,7 +967,8 @@ function explainThemeScope(themeSettingsSelectors, scope, parentScopes) {
  * Get tokens with multiple themes
  */
 function codeToTokensWithThemes(internal, code, options) {
-    const themes = Object.entries(options.themes)
+    const themes = Object
+        .entries(options.themes)
         .filter(i => i[1])
         .map(i => ({ color: i[0], theme: i[1] }));
     const tokens = syncThemesTokenization(...themes.map(t => codeToTokensBase(internal, code, {
@@ -4157,7 +1055,8 @@ function codeToTokens(internal, code, options) {
     let rootStyle;
     if ('themes' in options) {
         const { defaultColor = 'light', cssVariablePrefix = '--shiki-', } = options;
-        const themes = Object.entries(options.themes)
+        const themes = Object
+            .entries(options.themes)
             .filter(i => i[1])
             .map(i => ({ color: i[0], theme: i[1] }))
             .sort((a, b) => a.color === defaultColor ? -1 : b.color === defaultColor ? 1 : 0);
@@ -8968,6 +5867,8 @@ class RegExpConversionError extends SyntaxError {
   }
 }
 
+const UNNECESSARY_ESCAPE_CHAR_CLASS = new Set("!?:=+$(){}_><# ");
+const UNNECESSARY_ESCAPE = new Set("-!:=_>< ");
 const TABLE_POSIX = {
   alnum: "0-9A-Za-z",
   alpha: "A-Za-z",
@@ -8984,13 +5885,23 @@ const TABLE_POSIX = {
   xdigit: "0-9A-Fa-f",
   word: "\\w"
 };
+const TABLE_SLASH_P = {
+  alnum: "0-9A-Za-z",
+  alpha: "A-Za-z",
+  alphabetic: "A-Za-z",
+  blank: "\\s",
+  greek: "\\p{Script=Greek}",
+  print: "\\p{L}\\p{N}\\p{P}\\p{S}\\p{Zs}",
+  word: "\\w"
+};
 const KNOWN_FLAGS = /* @__PURE__ */ new Set("gimsuyx");
 function syntaxLowering(input, options = {}) {
   const {
     preserveFlags = false,
     removePossessiveQuantifier = false,
     removeAtomicGroup = false,
-    convertHexDigitsShorthand = false
+    convertHexDigitsShorthand = false,
+    convertUnicodeCategory = false
   } = options;
   let output = "";
   const flags = /* @__PURE__ */ new Set();
@@ -9005,7 +5916,7 @@ function syntaxLowering(input, options = {}) {
         freeSpacingLocal.shift();
       }
       const head = stack[0];
-      const wsEscape = freeSpacingGlobal || freeSpacingLocal.length;
+      const freeSpacing = freeSpacingGlobal || freeSpacingLocal.length;
       if (char === "\\") {
         if (convertHexDigitsShorthand) {
           if (input[i + 1] === "h") {
@@ -9031,11 +5942,41 @@ function syntaxLowering(input, options = {}) {
             continue;
           }
         }
+        if (convertUnicodeCategory && input[i + 1] === "p" && input[i + 2] === "{") {
+          const end = input.indexOf("}", i + 3);
+          if (end === -1) {
+            throw new RegExpConversionError(
+              "Unmatched \\p{...}",
+              { pattern: input, converted: output, cursor: i }
+            );
+          }
+          const name = input.slice(i + 3, end);
+          const resolved = TABLE_SLASH_P[name.toLowerCase()];
+          if (resolved) {
+            if (head === "[") {
+              output += resolved;
+            } else {
+              output += `[${resolved}]`;
+            }
+            i = end + 1;
+            continue;
+          }
+        }
+        if (head === "[" && UNNECESSARY_ESCAPE_CHAR_CLASS.has(input[i + 1])) {
+          output += input[i + 1];
+          i += 2;
+          continue;
+        }
+        if (head !== "[" && UNNECESSARY_ESCAPE.has(input[i + 1])) {
+          output += input[i + 1];
+          i += 2;
+          continue;
+        }
         output += char + input[i + 1];
         i += 2;
         continue;
       }
-      if (char === "#" && wsEscape && input[i - 1].match(/\s/) && head !== "[") {
+      if (char === "#" && freeSpacing && input[i - 1].match(/\s/) && head !== "[") {
         for (let j = i + 1; j <= input.length; j++) {
           if (input[j] === "\n" || j === input.length) {
             i = j;
@@ -9174,7 +6115,7 @@ function syntaxLowering(input, options = {}) {
           continue;
         }
       }
-      if (!(wsEscape && head !== "[" && char.match(/\s/))) {
+      if (!(freeSpacing && head !== "[" && char.match(/\s/))) {
         output += char;
       }
       i += 1;
@@ -9214,7 +6155,9 @@ function construct(pattern, options = {}) {
   if (options.ignoreContiguousAnchors) {
     pattern = pattern.replace(/\\G/g, "");
   }
-  pattern = pattern.replace(/\\A/g, "^").replace(/\\x\{([^}]*)\}/g, (m, hex) => `\\u${hex.padStart(4, "0")}`).replace(/\(\?(-)?(\w+):/g, (_, neg, flagStr) => {
+  if (pattern.includes("\\p{"))
+    flagSet.add("u");
+  pattern = pattern.replace(/\\A/g, "^").replace(/\\Z/gi, "$").replace(/\\x\{([^}]*)\}/g, (m, hex) => `\\u${hex.padStart(4, "0")}`).replace(/\(\?(-)?(\w+):/g, (_, neg, flagStr) => {
     if (neg) {
       for (const flag of flagStr)
         flagSet.delete(flag);
@@ -9261,6 +6204,7 @@ function onigurumaToRegexp(pattern, options = {}) {
     removePossessiveQuantifier: true,
     removeAtomicGroup: true,
     convertHexDigitsShorthand: true,
+    convertUnicodeCategory: true,
     ...options
   });
   return construct(converted, {
@@ -9271,15 +6215,30 @@ function onigurumaToRegexp(pattern, options = {}) {
 }
 
 const MAX = 4294967295;
+/**
+ * The default RegExp constructor for JavaScript regex engine.
+ */
+function defaultJavaScriptRegexConstructor(pattern) {
+    return onigurumaToRegexp(pattern
+        .replace(/\|\\G(\||\))/g, '$1')
+        .replace(/(\(|\|)\\G\|/g, '$1')
+        // YAML specific handling; TODO: move to tm-grammars
+        .replaceAll('[^\\s[-?:,\\[\\]{}#&*!|>\'"%@`]]', '[^\\s\\-?:,\\[\\]{}#&*!|>\'"%@`]'), {
+        flags: 'dgm',
+        ignoreContiguousAnchors: true,
+    });
+}
 class JavaScriptScanner {
     patterns;
     cache;
     forgiving;
+    regexConstructor;
     regexps;
-    constructor(patterns, cache, forgiving) {
+    constructor(patterns, cache, forgiving, regexConstructor = defaultJavaScriptRegexConstructor) {
         this.patterns = patterns;
         this.cache = cache;
         this.forgiving = forgiving;
+        this.regexConstructor = regexConstructor;
         this.regexps = patterns.map((p) => {
             const cached = cache?.get(p);
             if (cached) {
@@ -9291,14 +6250,7 @@ class JavaScriptScanner {
                 throw cached;
             }
             try {
-                const regex = onigurumaToRegexp(p
-                    .replace(/\|\\G(\||\))/g, '$1')
-                    .replace(/(\(|\|)\\G\|/g, '$1')
-                    // YAML specific handling; TODO: move to tm-grammars
-                    .replaceAll('[^\\s[-?:,\\[\\]{}#&*!|>\'"%@`]]', '[^\\s\\-?:,\\[\\]{}#&*!|>\'"%@`]'), {
-                    flags: 'dgm',
-                    ignoreContiguousAnchors: true,
-                });
+                const regex = regexConstructor(p);
                 cache?.set(p, regex);
                 return regex;
             }
@@ -9382,7 +6334,7 @@ function createJavaScriptRegexEngine(options = {}) {
     const { forgiving = false, cache = new Map(), } = options;
     return {
         createScanner(patterns) {
-            return new JavaScriptScanner(patterns, cache, forgiving);
+            return new JavaScriptScanner(patterns, cache, forgiving, options.regexConstructor);
         },
         createString(s) {
             return {
@@ -9392,4 +6344,4 @@ function createJavaScriptRegexEngine(options = {}) {
     };
 }
 
-export { FontStyle, ShikiError, StackElementMetadata, addClassToHast, applyColorReplacements, codeToHast, codeToHtml, codeToTokens, codeToTokensBase, codeToTokensWithThemes, createHighlighterCore, createHighlighterCoreSync, createJavaScriptRegexEngine, createPositionConverter, createShikiInternal, createShikiInternalSync, createSingletonShorthands, createWasmOnigEngine, createdBundledHighlighter, getHighlighterCore, getShikiInternal, getSingletonHighlighterCore, getTokenStyleObject, toHtml as hastToHtml, isNoneTheme, isPlainLang, isSpecialLang, isSpecialTheme, loadWasm, makeSingletonHighlighter, makeSingletonHighlighterCore, normalizeGetter, normalizeTheme, resolveColorReplacements, setDefaultWasmLoader, splitLines, splitToken, splitTokens, stringifyTokenStyle, toArray, tokenizeAnsiWithTheme, tokenizeWithTheme, tokensToHast, transformerDecorations };
+export { FontStyle, ShikiError, addClassToHast, applyColorReplacements, codeToHast, codeToHtml, codeToTokens, codeToTokensBase, codeToTokensWithThemes, createHighlighterCore, createHighlighterCoreSync, createJavaScriptRegexEngine, createPositionConverter, createShikiInternal, createShikiInternalSync, createSingletonShorthands, createWasmOnigEngine, createdBundledHighlighter, defaultJavaScriptRegexConstructor, getHighlighterCore, getShikiInternal, getSingletonHighlighterCore, getTokenStyleObject, toHtml as hastToHtml, isNoneTheme, isPlainLang, isSpecialLang, isSpecialTheme, loadWasm, makeSingletonHighlighter, makeSingletonHighlighterCore, normalizeGetter, normalizeTheme, resolveColorReplacements, setDefaultWasmLoader, splitLines, splitToken, splitTokens, stringifyTokenStyle, toArray, tokenizeAnsiWithTheme, tokenizeWithTheme, tokensToHast, transformerDecorations };