{"mappings":"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","names":["clone","something","doClone","cloneArray","cloneObj","arr","r","i","len","obj","key","mergeObjects","target","sources","source","basename","path","idx","CAPTURING_REGEX_SOURCE","RegexSource","regexSource","captureSource","captureIndices","match","index","commandIndex","command","capture","result","strcmp","a","b","strArrCmp","len1","len2","res","isValidHexColor","hex","escapeRegExpCharacters","value","CachedFn","fn","Theme","_colorMap","_defaults","_root","colorMap","parseTheme","resolveParsedThemeRules","scopeName","scopePath","effectiveRule","v","_scopePathMatchesParentScopes","StyleAttributes","ScopeStack","_ScopeStack","parent","scopeNames","name","segments","item","other","base","parentScopes","scopePattern","scopeMustMatch","_matchesScope","fontStyle","foregroundId","backgroundId","settings","resultLen","entry","scopes","_scope","j","lenJ","foreground","background","scope","ParsedThemeRule","FontStyle","FontStyle2","parsedThemeRules","defaultFontStyle","defaultForeground","defaultBackground","incomingDefaults","ColorMap","defaults","root","ThemeTrieElement","ThemeTrieElementRule","rule","color","emptyParentScopes","_ThemeTrieElementRule","scopeDepth","_ThemeTrieElement","_mainRule","rulesWithParentScopes","_children","aParentIndex","bParentIndex","parentScopeLengthDiff","dotIndex","head","tail","rules","child","EncodedTokenMetadata","_EncodedTokenMetadata","encodedTokenAttributes","languageId","tokenType","containsBalancedBrackets","_languageId","_tokenType","_containsBalancedBracketsBit","_fontStyle","_foreground","_background","createMatchers","selector","matchesName","results","tokenizer","newTokenizer","token","priority","matcher","parseConjunction","parseOperand","expressionToNegate","matcherInput","expressionInParents","parseInnerExpression","isIdentifier","identifiers","matchers","matcher2","input","regex","match","res","FindOption","FindOption2","disposeOnigString","str","TopLevelRuleReference","scopeName","TopLevelRepositoryRuleReference","ruleName","ExternalReferenceCollector","reference","key","ScopeDependencyProcessor","repo","initialScopeName","q","deps","dep","collectReferencesOfReference","baseGrammarScopeName","result","selfGrammar","baseGrammar","collectExternalReferencesInTopLevelRule","collectExternalReferencesInTopLevelRepositoryRule","injections","injection","context","rule","collectExternalReferencesInRules","rules","patternRepository","mergeObjects","include","parseInclude","newContext","BaseReference","SelfReference","RelativeReference","TopLevelReference","TopLevelRepositoryReference","indexOfSharp","HAS_BACK_REFERENCES","BACK_REFERENCING_END","ruleIdSymbol","endRuleId","whileRuleId","Rule","$location","id","name","contentName","RegexSource","location","basename","lineText","captureIndices","CaptureRule","retokenizeCapturedWithRuleId","grammar","out","endRegexSource","allowA","allowG","MatchRule","match","captures","RegExpSource","RegExpSourceList","IncludeOnlyRule","patterns","pattern","BeginEndRule","begin","beginCaptures","end","endCaptures","applyEndPatternLast","BeginWhileRule","_while","whileCaptures","whileRuleId","RuleFactory","_RuleFactory","helper","desc","repository","mergeObjects","maximumCaptureId","captureId","numericCaptureId","i","len","ruleId","reference","parseInclude","localIncludedRule","externalGrammarName","externalGrammarInclude","externalGrammar","externalIncludedRule","rule","skipRule","_RegExpSource","regExpSource","lastPushedPos","output","hasAnchor","pos","nextCh","HAS_BACK_REFERENCES","newSource","capturedValues","capture","BACK_REFERENCING_END","g1","escapeRegExpCharacters","A0_G0_result","A0_G1_result","A1_G0_result","A1_G1_result","ch","item","index","onigLib","regExps","e","CompiledRule","rules","r","string","startPosition","options","result","BasicScopeAttributes","languageId","tokenType","BasicScopeAttributesProvider","_BasicScopeAttributesProvider","initialLanguageId","embeddedLanguages","ScopeMatcher","scopeName","CachedFn","standardTokenType","scope","m","values","escapedScopes","value","DebugFlags","UseOnigurumaFindOptions","TokenizeStringResult","stack","stoppedEarly","_tokenizeString","isFirstLine","linePos","lineTokens","checkWhileConditions","timeLimit","lineLength","STOP","anchorPosition","whileCheckResult","_checkWhileConditions","startTime","scanNext","matchRuleOrInjections","matchedRuleId","hasAdvanced","endRuleId","poppedRule","handleCaptures","popped","_rule","beforePush","nameScopesList","pushedRule","contentNameScopesList","whileRules","node","nodeRule","whileRule","ruleScanner","findOptions","prepareRuleWhileSearch","matchResult","matchRule","injections","injectionResult","matchInjections","matchResultScore","injectionResultScore","prepareRuleSearch","bestMatchRating","bestMatchCaptureIndices","bestMatchRuleId","bestMatchResultPriority","scopes","injection","matchRating","ruleScanner2","getFindOptions","lineTextContent","localStack","maxEnd","captureRule","captureIndex","stackClone","onigSubStr","disposeOnigString","captureRuleScopeName","captureRuleScopesList","LocalStackElement","endPos","createGrammar","initialLanguage","tokenTypes","balancedBracketSelectors","grammarRepository","Grammar","collectInjections","selector","ruleFactoryHelper","matchers","createMatchers","nameMatcher","matcher","identifers","lastIndex","identifier","scopesAreMatching","thisScopeName","_rootScopeName","_onigLib","initGrammar","sources","scopeName2","rawInjections","expression","injectionScopeNames","injectionScopeName","injectionGrammar","i1","i2","factory","rawIncludedGrammar","prevState","emitBinaryTokens","StateStackImpl","rawDefaultMetadata","defaultStyle","defaultMetadata","EncodedTokenMetadata","rootScopeName","scopeList","AttributedScopeStack","onigLineText","LineTokens","base","clone","_AttributedScopeStack","parent","scopePath","tokenAttributes","namesScopeList","current","scopeNames","frame","ScopeStack","rawRootMetadata","rootStyle","resolvedTokenAttributes","other","a","b","existingTokenAttributes","basicScopeAttributes","styleAttributes","fontStyle","foreground","background","target","rawMetadata","newPath","scopeThemeMatchResult","metadata","self","_StateStackImpl","enterPos","anchorPos","beginRuleCapturedEOL","endRule","el","res","outIndex","contentNameScopeStack","BalancedBracketSelectors","balancedBracketScopes","unbalancedBracketScopes","excluder","includer","tokenTypeOverrides","endIndex","scopesList","containsBalancedBrackets","scopes2","SyncRegistry","theme","targetScope","rawGrammar","Registry","Theme","colorMap","initialScopeName","configuration","dependencyProcessor","ScopeDependencyProcessor","request","INITIAL"],"sources":["../esm/npm/@shikijs/vscode-textmate@10.0.2/node_modules/@shikijs/vscode-textmate/dist/index.js"],"sourcesContent":["// src/utils.ts\nfunction clone(something) {\n  return doClone(something);\n}\nfunction doClone(something) {\n  if (Array.isArray(something)) {\n    return cloneArray(something);\n  }\n  if (something instanceof RegExp) {\n    return something;\n  }\n  if (typeof something === \"object\") {\n    return cloneObj(something);\n  }\n  return something;\n}\nfunction cloneArray(arr) {\n  let r = [];\n  for (let i = 0, len = arr.length; i \u003c len; i++) {\n    r[i] = doClone(arr[i]);\n  }\n  return r;\n}\nfunction cloneObj(obj) {\n  let r = {};\n  for (let key in obj) {\n    r[key] = doClone(obj[key]);\n  }\n  return r;\n}\nfunction mergeObjects(target, ...sources) {\n  sources.forEach((source) =\u003e {\n    for (let key in source) {\n      target[key] = source[key];\n    }\n  });\n  return target;\n}\nfunction basename(path) {\n  const idx = ~path.lastIndexOf(\"/\") || ~path.lastIndexOf(\"\\\\\");\n  if (idx === 0) {\n    return path;\n  } else if (~idx === path.length - 1) {\n    return basename(path.substring(0, path.length - 1));\n  } else {\n    return path.substr(~idx + 1);\n  }\n}\nvar CAPTURING_REGEX_SOURCE = /\\$(\\d+)|\\${(\\d+):\\/(downcase|upcase)}/g;\nvar RegexSource = class {\n  static hasCaptures(regexSource) {\n    if (regexSource === null) {\n      return false;\n    }\n    CAPTURING_REGEX_SOURCE.lastIndex = 0;\n    return CAPTURING_REGEX_SOURCE.test(regexSource);\n  }\n  static replaceCaptures(regexSource, captureSource, captureIndices) {\n    return regexSource.replace(CAPTURING_REGEX_SOURCE, (match, index, commandIndex, command) =\u003e {\n      let capture = captureIndices[parseInt(index || commandIndex, 10)];\n      if (capture) {\n        let result = captureSource.substring(capture.start, capture.end);\n        while (result[0] === \".\") {\n          result = result.substring(1);\n        }\n        switch (command) {\n          case \"downcase\":\n            return result.toLowerCase();\n          case \"upcase\":\n            return result.toUpperCase();\n          default:\n            return result;\n        }\n      } else {\n        return match;\n      }\n    });\n  }\n};\nfunction strcmp(a, b) {\n  if (a \u003c b) {\n    return -1;\n  }\n  if (a \u003e b) {\n    return 1;\n  }\n  return 0;\n}\nfunction strArrCmp(a, b) {\n  if (a === null \u0026\u0026 b === null) {\n    return 0;\n  }\n  if (!a) {\n    return -1;\n  }\n  if (!b) {\n    return 1;\n  }\n  let len1 = a.length;\n  let len2 = b.length;\n  if (len1 === len2) {\n    for (let i = 0; i \u003c len1; i++) {\n      let res = strcmp(a[i], b[i]);\n      if (res !== 0) {\n        return res;\n      }\n    }\n    return 0;\n  }\n  return len1 - len2;\n}\nfunction isValidHexColor(hex) {\n  if (/^#[0-9a-f]{6}$/i.test(hex)) {\n    return true;\n  }\n  if (/^#[0-9a-f]{8}$/i.test(hex)) {\n    return true;\n  }\n  if (/^#[0-9a-f]{3}$/i.test(hex)) {\n    return true;\n  }\n  if (/^#[0-9a-f]{4}$/i.test(hex)) {\n    return true;\n  }\n  return false;\n}\nfunction escapeRegExpCharacters(value) {\n  return value.replace(/[\\-\\\\\\{\\}\\*\\+\\?\\|\\^\\$\\.\\,\\[\\]\\(\\)\\#\\s]/g, \"\\\\$\u0026\");\n}\nvar CachedFn = class {\n  constructor(fn) {\n    this.fn = fn;\n  }\n  cache = /* @__PURE__ */ new Map();\n  get(key) {\n    if (this.cache.has(key)) {\n      return this.cache.get(key);\n    }\n    const value = this.fn(key);\n    this.cache.set(key, value);\n    return value;\n  }\n};\n\n// src/theme.ts\nvar Theme = class {\n  constructor(_colorMap, _defaults, _root) {\n    this._colorMap = _colorMap;\n    this._defaults = _defaults;\n    this._root = _root;\n  }\n  static createFromRawTheme(source, colorMap) {\n    return this.createFromParsedTheme(parseTheme(source), colorMap);\n  }\n  static createFromParsedTheme(source, colorMap) {\n    return resolveParsedThemeRules(source, colorMap);\n  }\n  _cachedMatchRoot = new CachedFn(\n    (scopeName) =\u003e this._root.match(scopeName)\n  );\n  getColorMap() {\n    return this._colorMap.getColorMap();\n  }\n  getDefaults() {\n    return this._defaults;\n  }\n  match(scopePath) {\n    if (scopePath === null) {\n      return this._defaults;\n    }\n    const scopeName = scopePath.scopeName;\n    const matchingTrieElements = this._cachedMatchRoot.get(scopeName);\n    const effectiveRule = matchingTrieElements.find(\n      (v) =\u003e _scopePathMatchesParentScopes(scopePath.parent, v.parentScopes)\n    );\n    if (!effectiveRule) {\n      return null;\n    }\n    return new StyleAttributes(\n      effectiveRule.fontStyle,\n      effectiveRule.foreground,\n      effectiveRule.background\n    );\n  }\n};\nvar ScopeStack = class _ScopeStack {\n  constructor(parent, scopeName) {\n    this.parent = parent;\n    this.scopeName = scopeName;\n  }\n  static push(path, scopeNames) {\n    for (const name of scopeNames) {\n      path = new _ScopeStack(path, name);\n    }\n    return path;\n  }\n  static from(...segments) {\n    let result = null;\n    for (let i = 0; i \u003c segments.length; i++) {\n      result = new _ScopeStack(result, segments[i]);\n    }\n    return result;\n  }\n  push(scopeName) {\n    return new _ScopeStack(this, scopeName);\n  }\n  getSegments() {\n    let item = this;\n    const result = [];\n    while (item) {\n      result.push(item.scopeName);\n      item = item.parent;\n    }\n    result.reverse();\n    return result;\n  }\n  toString() {\n    return this.getSegments().join(\" \");\n  }\n  extends(other) {\n    if (this === other) {\n      return true;\n    }\n    if (this.parent === null) {\n      return false;\n    }\n    return this.parent.extends(other);\n  }\n  getExtensionIfDefined(base) {\n    const result = [];\n    let item = this;\n    while (item \u0026\u0026 item !== base) {\n      result.push(item.scopeName);\n      item = item.parent;\n    }\n    return item === base ? result.reverse() : void 0;\n  }\n};\nfunction _scopePathMatchesParentScopes(scopePath, parentScopes) {\n  if (parentScopes.length === 0) {\n    return true;\n  }\n  for (let index = 0; index \u003c parentScopes.length; index++) {\n    let scopePattern = parentScopes[index];\n    let scopeMustMatch = false;\n    if (scopePattern === \"\u003e\") {\n      if (index === parentScopes.length - 1) {\n        return false;\n      }\n      scopePattern = parentScopes[++index];\n      scopeMustMatch = true;\n    }\n    while (scopePath) {\n      if (_matchesScope(scopePath.scopeName, scopePattern)) {\n        break;\n      }\n      if (scopeMustMatch) {\n        return false;\n      }\n      scopePath = scopePath.parent;\n    }\n    if (!scopePath) {\n      return false;\n    }\n    scopePath = scopePath.parent;\n  }\n  return true;\n}\nfunction _matchesScope(scopeName, scopePattern) {\n  return scopePattern === scopeName || scopeName.startsWith(scopePattern) \u0026\u0026 scopeName[scopePattern.length] === \".\";\n}\nvar StyleAttributes = class {\n  constructor(fontStyle, foregroundId, backgroundId) {\n    this.fontStyle = fontStyle;\n    this.foregroundId = foregroundId;\n    this.backgroundId = backgroundId;\n  }\n};\nfunction parseTheme(source) {\n  if (!source) {\n    return [];\n  }\n  if (!source.settings || !Array.isArray(source.settings)) {\n    return [];\n  }\n  let settings = source.settings;\n  let result = [], resultLen = 0;\n  for (let i = 0, len = settings.length; i \u003c len; i++) {\n    let entry = settings[i];\n    if (!entry.settings) {\n      continue;\n    }\n    let scopes;\n    if (typeof entry.scope === \"string\") {\n      let _scope = entry.scope;\n      _scope = _scope.replace(/^[,]+/, \"\");\n      _scope = _scope.replace(/[,]+$/, \"\");\n      scopes = _scope.split(\",\");\n    } else if (Array.isArray(entry.scope)) {\n      scopes = entry.scope;\n    } else {\n      scopes = [\"\"];\n    }\n    let fontStyle = -1 /* NotSet */;\n    if (typeof entry.settings.fontStyle === \"string\") {\n      fontStyle = 0 /* None */;\n      let segments = entry.settings.fontStyle.split(\" \");\n      for (let j = 0, lenJ = segments.length; j \u003c lenJ; j++) {\n        let segment = segments[j];\n        switch (segment) {\n          case \"italic\":\n            fontStyle = fontStyle | 1 /* Italic */;\n            break;\n          case \"bold\":\n            fontStyle = fontStyle | 2 /* Bold */;\n            break;\n          case \"underline\":\n            fontStyle = fontStyle | 4 /* Underline */;\n            break;\n          case \"strikethrough\":\n            fontStyle = fontStyle | 8 /* Strikethrough */;\n            break;\n        }\n      }\n    }\n    let foreground = null;\n    if (typeof entry.settings.foreground === \"string\" \u0026\u0026 isValidHexColor(entry.settings.foreground)) {\n      foreground = entry.settings.foreground;\n    }\n    let background = null;\n    if (typeof entry.settings.background === \"string\" \u0026\u0026 isValidHexColor(entry.settings.background)) {\n      background = entry.settings.background;\n    }\n    for (let j = 0, lenJ = scopes.length; j \u003c lenJ; j++) {\n      let _scope = scopes[j].trim();\n      let segments = _scope.split(\" \");\n      let scope = segments[segments.length - 1];\n      let parentScopes = null;\n      if (segments.length \u003e 1) {\n        parentScopes = segments.slice(0, segments.length - 1);\n        parentScopes.reverse();\n      }\n      result[resultLen++] = new ParsedThemeRule(\n        scope,\n        parentScopes,\n        i,\n        fontStyle,\n        foreground,\n        background\n      );\n    }\n  }\n  return result;\n}\nvar ParsedThemeRule = class {\n  constructor(scope, parentScopes, index, fontStyle, foreground, background) {\n    this.scope = scope;\n    this.parentScopes = parentScopes;\n    this.index = index;\n    this.fontStyle = fontStyle;\n    this.foreground = foreground;\n    this.background = background;\n  }\n};\nvar FontStyle = /* @__PURE__ */ ((FontStyle2) =\u003e {\n  FontStyle2[FontStyle2[\"NotSet\"] = -1] = \"NotSet\";\n  FontStyle2[FontStyle2[\"None\"] = 0] = \"None\";\n  FontStyle2[FontStyle2[\"Italic\"] = 1] = \"Italic\";\n  FontStyle2[FontStyle2[\"Bold\"] = 2] = \"Bold\";\n  FontStyle2[FontStyle2[\"Underline\"] = 4] = \"Underline\";\n  FontStyle2[FontStyle2[\"Strikethrough\"] = 8] = \"Strikethrough\";\n  return FontStyle2;\n})(FontStyle || {});\nfunction resolveParsedThemeRules(parsedThemeRules, _colorMap) {\n  parsedThemeRules.sort((a, b) =\u003e {\n    let r = strcmp(a.scope, b.scope);\n    if (r !== 0) {\n      return r;\n    }\n    r = strArrCmp(a.parentScopes, b.parentScopes);\n    if (r !== 0) {\n      return r;\n    }\n    return a.index - b.index;\n  });\n  let defaultFontStyle = 0 /* None */;\n  let defaultForeground = \"#000000\";\n  let defaultBackground = \"#ffffff\";\n  while (parsedThemeRules.length \u003e= 1 \u0026\u0026 parsedThemeRules[0].scope === \"\") {\n    let incomingDefaults = parsedThemeRules.shift();\n    if (incomingDefaults.fontStyle !== -1 /* NotSet */) {\n      defaultFontStyle = incomingDefaults.fontStyle;\n    }\n    if (incomingDefaults.foreground !== null) {\n      defaultForeground = incomingDefaults.foreground;\n    }\n    if (incomingDefaults.background !== null) {\n      defaultBackground = incomingDefaults.background;\n    }\n  }\n  let colorMap = new ColorMap(_colorMap);\n  let defaults = new StyleAttributes(defaultFontStyle, colorMap.getId(defaultForeground), colorMap.getId(defaultBackground));\n  let root = new ThemeTrieElement(new ThemeTrieElementRule(0, null, -1 /* NotSet */, 0, 0), []);\n  for (let i = 0, len = parsedThemeRules.length; i \u003c len; i++) {\n    let rule = parsedThemeRules[i];\n    root.insert(0, rule.scope, rule.parentScopes, rule.fontStyle, colorMap.getId(rule.foreground), colorMap.getId(rule.background));\n  }\n  return new Theme(colorMap, defaults, root);\n}\nvar ColorMap = class {\n  _isFrozen;\n  _lastColorId;\n  _id2color;\n  _color2id;\n  constructor(_colorMap) {\n    this._lastColorId = 0;\n    this._id2color = [];\n    this._color2id = /* @__PURE__ */ Object.create(null);\n    if (Array.isArray(_colorMap)) {\n      this._isFrozen = true;\n      for (let i = 0, len = _colorMap.length; i \u003c len; i++) {\n        this._color2id[_colorMap[i]] = i;\n        this._id2color[i] = _colorMap[i];\n      }\n    } else {\n      this._isFrozen = false;\n    }\n  }\n  getId(color) {\n    if (color === null) {\n      return 0;\n    }\n    color = color.toUpperCase();\n    let value = this._color2id[color];\n    if (value) {\n      return value;\n    }\n    if (this._isFrozen) {\n      throw new Error(`Missing color in color map - ${color}`);\n    }\n    value = ++this._lastColorId;\n    this._color2id[color] = value;\n    this._id2color[value] = color;\n    return value;\n  }\n  getColorMap() {\n    return this._id2color.slice(0);\n  }\n};\nvar emptyParentScopes = Object.freeze([]);\nvar ThemeTrieElementRule = class _ThemeTrieElementRule {\n  scopeDepth;\n  parentScopes;\n  fontStyle;\n  foreground;\n  background;\n  constructor(scopeDepth, parentScopes, fontStyle, foreground, background) {\n    this.scopeDepth = scopeDepth;\n    this.parentScopes = parentScopes || emptyParentScopes;\n    this.fontStyle = fontStyle;\n    this.foreground = foreground;\n    this.background = background;\n  }\n  clone() {\n    return new _ThemeTrieElementRule(this.scopeDepth, this.parentScopes, this.fontStyle, this.foreground, this.background);\n  }\n  static cloneArr(arr) {\n    let r = [];\n    for (let i = 0, len = arr.length; i \u003c len; i++) {\n      r[i] = arr[i].clone();\n    }\n    return r;\n  }\n  acceptOverwrite(scopeDepth, fontStyle, foreground, background) {\n    if (this.scopeDepth \u003e scopeDepth) {\n      console.log(\"how did this happen?\");\n    } else {\n      this.scopeDepth = scopeDepth;\n    }\n    if (fontStyle !== -1 /* NotSet */) {\n      this.fontStyle = fontStyle;\n    }\n    if (foreground !== 0) {\n      this.foreground = foreground;\n    }\n    if (background !== 0) {\n      this.background = background;\n    }\n  }\n};\nvar ThemeTrieElement = class _ThemeTrieElement {\n  constructor(_mainRule, rulesWithParentScopes = [], _children = {}) {\n    this._mainRule = _mainRule;\n    this._children = _children;\n    this._rulesWithParentScopes = rulesWithParentScopes;\n  }\n  _rulesWithParentScopes;\n  static _cmpBySpecificity(a, b) {\n    if (a.scopeDepth !== b.scopeDepth) {\n      return b.scopeDepth - a.scopeDepth;\n    }\n    let aParentIndex = 0;\n    let bParentIndex = 0;\n    while (true) {\n      if (a.parentScopes[aParentIndex] === \"\u003e\") {\n        aParentIndex++;\n      }\n      if (b.parentScopes[bParentIndex] === \"\u003e\") {\n        bParentIndex++;\n      }\n      if (aParentIndex \u003e= a.parentScopes.length || bParentIndex \u003e= b.parentScopes.length) {\n        break;\n      }\n      const parentScopeLengthDiff = b.parentScopes[bParentIndex].length - a.parentScopes[aParentIndex].length;\n      if (parentScopeLengthDiff !== 0) {\n        return parentScopeLengthDiff;\n      }\n      aParentIndex++;\n      bParentIndex++;\n    }\n    return b.parentScopes.length - a.parentScopes.length;\n  }\n  match(scope) {\n    if (scope !== \"\") {\n      let dotIndex = scope.indexOf(\".\");\n      let head;\n      let tail;\n      if (dotIndex === -1) {\n        head = scope;\n        tail = \"\";\n      } else {\n        head = scope.substring(0, dotIndex);\n        tail = scope.substring(dotIndex + 1);\n      }\n      if (this._children.hasOwnProperty(head)) {\n        return this._children[head].match(tail);\n      }\n    }\n    const rules = this._rulesWithParentScopes.concat(this._mainRule);\n    rules.sort(_ThemeTrieElement._cmpBySpecificity);\n    return rules;\n  }\n  insert(scopeDepth, scope, parentScopes, fontStyle, foreground, background) {\n    if (scope === \"\") {\n      this._doInsertHere(scopeDepth, parentScopes, fontStyle, foreground, background);\n      return;\n    }\n    let dotIndex = scope.indexOf(\".\");\n    let head;\n    let tail;\n    if (dotIndex === -1) {\n      head = scope;\n      tail = \"\";\n    } else {\n      head = scope.substring(0, dotIndex);\n      tail = scope.substring(dotIndex + 1);\n    }\n    let child;\n    if (this._children.hasOwnProperty(head)) {\n      child = this._children[head];\n    } else {\n      child = new _ThemeTrieElement(this._mainRule.clone(), ThemeTrieElementRule.cloneArr(this._rulesWithParentScopes));\n      this._children[head] = child;\n    }\n    child.insert(scopeDepth + 1, tail, parentScopes, fontStyle, foreground, background);\n  }\n  _doInsertHere(scopeDepth, parentScopes, fontStyle, foreground, background) {\n    if (parentScopes === null) {\n      this._mainRule.acceptOverwrite(scopeDepth, fontStyle, foreground, background);\n      return;\n    }\n    for (let i = 0, len = this._rulesWithParentScopes.length; i \u003c len; i++) {\n      let rule = this._rulesWithParentScopes[i];\n      if (strArrCmp(rule.parentScopes, parentScopes) === 0) {\n        rule.acceptOverwrite(scopeDepth, fontStyle, foreground, background);\n        return;\n      }\n    }\n    if (fontStyle === -1 /* NotSet */) {\n      fontStyle = this._mainRule.fontStyle;\n    }\n    if (foreground === 0) {\n      foreground = this._mainRule.foreground;\n    }\n    if (background === 0) {\n      background = this._mainRule.background;\n    }\n    this._rulesWithParentScopes.push(new ThemeTrieElementRule(scopeDepth, parentScopes, fontStyle, foreground, background));\n  }\n};\n\n// src/encodedTokenAttributes.ts\nvar EncodedTokenMetadata = class _EncodedTokenMetadata {\n  static toBinaryStr(encodedTokenAttributes) {\n    return encodedTokenAttributes.toString(2).padStart(32, \"0\");\n  }\n  static print(encodedTokenAttributes) {\n    const languageId = _EncodedTokenMetadata.getLanguageId(encodedTokenAttributes);\n    const tokenType = _EncodedTokenMetadata.getTokenType(encodedTokenAttributes);\n    const fontStyle = _EncodedTokenMetadata.getFontStyle(encodedTokenAttributes);\n    const foreground = _EncodedTokenMetadata.getForeground(encodedTokenAttributes);\n    const background = _EncodedTokenMetadata.getBackground(encodedTokenAttributes);\n    console.log({\n      languageId,\n      tokenType,\n      fontStyle,\n      foreground,\n      background\n    });\n  }\n  static getLanguageId(encodedTokenAttributes) {\n    return (encodedTokenAttributes \u0026 255 /* LANGUAGEID_MASK */) \u003e\u003e\u003e 0 /* LANGUAGEID_OFFSET */;\n  }\n  static getTokenType(encodedTokenAttributes) {\n    return (encodedTokenAttributes \u0026 768 /* TOKEN_TYPE_MASK */) \u003e\u003e\u003e 8 /* TOKEN_TYPE_OFFSET */;\n  }\n  static containsBalancedBrackets(encodedTokenAttributes) {\n    return (encodedTokenAttributes \u0026 1024 /* BALANCED_BRACKETS_MASK */) !== 0;\n  }\n  static getFontStyle(encodedTokenAttributes) {\n    return (encodedTokenAttributes \u0026 30720 /* FONT_STYLE_MASK */) \u003e\u003e\u003e 11 /* FONT_STYLE_OFFSET */;\n  }\n  static getForeground(encodedTokenAttributes) {\n    return (encodedTokenAttributes \u0026 16744448 /* FOREGROUND_MASK */) \u003e\u003e\u003e 15 /* FOREGROUND_OFFSET */;\n  }\n  static getBackground(encodedTokenAttributes) {\n    return (encodedTokenAttributes \u0026 4278190080 /* BACKGROUND_MASK */) \u003e\u003e\u003e 24 /* BACKGROUND_OFFSET */;\n  }\n  /**\n   * Updates the fields in `metadata`.\n   * A value of `0`, `NotSet` or `null` indicates that the corresponding field should be left as is.\n   */\n  static set(encodedTokenAttributes, languageId, tokenType, containsBalancedBrackets, fontStyle, foreground, background) {\n    let _languageId = _EncodedTokenMetadata.getLanguageId(encodedTokenAttributes);\n    let _tokenType = _EncodedTokenMetadata.getTokenType(encodedTokenAttributes);\n    let _containsBalancedBracketsBit = _EncodedTokenMetadata.containsBalancedBrackets(encodedTokenAttributes) ? 1 : 0;\n    let _fontStyle = _EncodedTokenMetadata.getFontStyle(encodedTokenAttributes);\n    let _foreground = _EncodedTokenMetadata.getForeground(encodedTokenAttributes);\n    let _background = _EncodedTokenMetadata.getBackground(encodedTokenAttributes);\n    if (languageId !== 0) {\n      _languageId = languageId;\n    }\n    if (tokenType !== 8 /* NotSet */) {\n      _tokenType = fromOptionalTokenType(tokenType);\n    }\n    if (containsBalancedBrackets !== null) {\n      _containsBalancedBracketsBit = containsBalancedBrackets ? 1 : 0;\n    }\n    if (fontStyle !== -1 /* NotSet */) {\n      _fontStyle = fontStyle;\n    }\n    if (foreground !== 0) {\n      _foreground = foreground;\n    }\n    if (background !== 0) {\n      _background = background;\n    }\n    return (_languageId \u003c\u003c 0 /* LANGUAGEID_OFFSET */ | _tokenType \u003c\u003c 8 /* TOKEN_TYPE_OFFSET */ | _containsBalancedBracketsBit \u003c\u003c 10 /* BALANCED_BRACKETS_OFFSET */ | _fontStyle \u003c\u003c 11 /* FONT_STYLE_OFFSET */ | _foreground \u003c\u003c 15 /* FOREGROUND_OFFSET */ | _background \u003c\u003c 24 /* BACKGROUND_OFFSET */) \u003e\u003e\u003e 0;\n  }\n};\nfunction toOptionalTokenType(standardType) {\n  return standardType;\n}\nfunction fromOptionalTokenType(standardType) {\n  return standardType;\n}\n\n// src/matcher.ts\nfunction createMatchers(selector, matchesName) {\n  const results = [];\n  const tokenizer = newTokenizer(selector);\n  let token = tokenizer.next();\n  while (token !== null) {\n    let priority = 0;\n    if (token.length === 2 \u0026\u0026 token.charAt(1) === \":\") {\n      switch (token.charAt(0)) {\n        case \"R\":\n          priority = 1;\n          break;\n        case \"L\":\n          priority = -1;\n          break;\n        default:\n          console.log(`Unknown priority ${token} in scope selector`);\n      }\n      token = tokenizer.next();\n    }\n    let matcher = parseConjunction();\n    results.push({ matcher, priority });\n    if (token !== \",\") {\n      break;\n    }\n    token = tokenizer.next();\n  }\n  return results;\n  function parseOperand() {\n    if (token === \"-\") {\n      token = tokenizer.next();\n      const expressionToNegate = parseOperand();\n      return (matcherInput) =\u003e !!expressionToNegate \u0026\u0026 !expressionToNegate(matcherInput);\n    }\n    if (token === \"(\") {\n      token = tokenizer.next();\n      const expressionInParents = parseInnerExpression();\n      if (token === \")\") {\n        token = tokenizer.next();\n      }\n      return expressionInParents;\n    }\n    if (isIdentifier(token)) {\n      const identifiers = [];\n      do {\n        identifiers.push(token);\n        token = tokenizer.next();\n      } while (isIdentifier(token));\n      return (matcherInput) =\u003e matchesName(identifiers, matcherInput);\n    }\n    return null;\n  }\n  function parseConjunction() {\n    const matchers = [];\n    let matcher = parseOperand();\n    while (matcher) {\n      matchers.push(matcher);\n      matcher = parseOperand();\n    }\n    return (matcherInput) =\u003e matchers.every((matcher2) =\u003e matcher2(matcherInput));\n  }\n  function parseInnerExpression() {\n    const matchers = [];\n    let matcher = parseConjunction();\n    while (matcher) {\n      matchers.push(matcher);\n      if (token === \"|\" || token === \",\") {\n        do {\n          token = tokenizer.next();\n        } while (token === \"|\" || token === \",\");\n      } else {\n        break;\n      }\n      matcher = parseConjunction();\n    }\n    return (matcherInput) =\u003e matchers.some((matcher2) =\u003e matcher2(matcherInput));\n  }\n}\nfunction isIdentifier(token) {\n  return !!token \u0026\u0026 !!token.match(/[\\w\\.:]+/);\n}\nfunction newTokenizer(input) {\n  let regex = /([LR]:|[\\w\\.:][\\w\\.:\\-]*|[\\,\\|\\-\\(\\)])/g;\n  let match = regex.exec(input);\n  return {\n    next: () =\u003e {\n      if (!match) {\n        return null;\n      }\n      const res = match[0];\n      match = regex.exec(input);\n      return res;\n    }\n  };\n}\n\n// src/onigLib.ts\nvar FindOption = /* @__PURE__ */ ((FindOption2) =\u003e {\n  FindOption2[FindOption2[\"None\"] = 0] = \"None\";\n  FindOption2[FindOption2[\"NotBeginString\"] = 1] = \"NotBeginString\";\n  FindOption2[FindOption2[\"NotEndString\"] = 2] = \"NotEndString\";\n  FindOption2[FindOption2[\"NotBeginPosition\"] = 4] = \"NotBeginPosition\";\n  FindOption2[FindOption2[\"DebugCall\"] = 8] = \"DebugCall\";\n  return FindOption2;\n})(FindOption || {});\nfunction disposeOnigString(str) {\n  if (typeof str.dispose === \"function\") {\n    str.dispose();\n  }\n}\n\n// src/grammar/grammarDependencies.ts\nvar TopLevelRuleReference = class {\n  constructor(scopeName) {\n    this.scopeName = scopeName;\n  }\n  toKey() {\n    return this.scopeName;\n  }\n};\nvar TopLevelRepositoryRuleReference = class {\n  constructor(scopeName, ruleName) {\n    this.scopeName = scopeName;\n    this.ruleName = ruleName;\n  }\n  toKey() {\n    return `${this.scopeName}#${this.ruleName}`;\n  }\n};\nvar ExternalReferenceCollector = class {\n  _references = [];\n  _seenReferenceKeys = /* @__PURE__ */ new Set();\n  get references() {\n    return this._references;\n  }\n  visitedRule = /* @__PURE__ */ new Set();\n  add(reference) {\n    const key = reference.toKey();\n    if (this._seenReferenceKeys.has(key)) {\n      return;\n    }\n    this._seenReferenceKeys.add(key);\n    this._references.push(reference);\n  }\n};\nvar ScopeDependencyProcessor = class {\n  constructor(repo, initialScopeName) {\n    this.repo = repo;\n    this.initialScopeName = initialScopeName;\n    this.seenFullScopeRequests.add(this.initialScopeName);\n    this.Q = [new TopLevelRuleReference(this.initialScopeName)];\n  }\n  seenFullScopeRequests = /* @__PURE__ */ new Set();\n  seenPartialScopeRequests = /* @__PURE__ */ new Set();\n  Q;\n  processQueue() {\n    const q = this.Q;\n    this.Q = [];\n    const deps = new ExternalReferenceCollector();\n    for (const dep of q) {\n      collectReferencesOfReference(dep, this.initialScopeName, this.repo, deps);\n    }\n    for (const dep of deps.references) {\n      if (dep instanceof TopLevelRuleReference) {\n        if (this.seenFullScopeRequests.has(dep.scopeName)) {\n          continue;\n        }\n        this.seenFullScopeRequests.add(dep.scopeName);\n        this.Q.push(dep);\n      } else {\n        if (this.seenFullScopeRequests.has(dep.scopeName)) {\n          continue;\n        }\n        if (this.seenPartialScopeRequests.has(dep.toKey())) {\n          continue;\n        }\n        this.seenPartialScopeRequests.add(dep.toKey());\n        this.Q.push(dep);\n      }\n    }\n  }\n};\nfunction collectReferencesOfReference(reference, baseGrammarScopeName, repo, result) {\n  const selfGrammar = repo.lookup(reference.scopeName);\n  if (!selfGrammar) {\n    if (reference.scopeName === baseGrammarScopeName) {\n      throw new Error(`No grammar provided for \u003c${baseGrammarScopeName}\u003e`);\n    }\n    return;\n  }\n  const baseGrammar = repo.lookup(baseGrammarScopeName);\n  if (reference instanceof TopLevelRuleReference) {\n    collectExternalReferencesInTopLevelRule({ baseGrammar, selfGrammar }, result);\n  } else {\n    collectExternalReferencesInTopLevelRepositoryRule(\n      reference.ruleName,\n      { baseGrammar, selfGrammar, repository: selfGrammar.repository },\n      result\n    );\n  }\n  const injections = repo.injections(reference.scopeName);\n  if (injections) {\n    for (const injection of injections) {\n      result.add(new TopLevelRuleReference(injection));\n    }\n  }\n}\nfunction collectExternalReferencesInTopLevelRepositoryRule(ruleName, context, result) {\n  if (context.repository \u0026\u0026 context.repository[ruleName]) {\n    const rule = context.repository[ruleName];\n    collectExternalReferencesInRules([rule], context, result);\n  }\n}\nfunction collectExternalReferencesInTopLevelRule(context, result) {\n  if (context.selfGrammar.patterns \u0026\u0026 Array.isArray(context.selfGrammar.patterns)) {\n    collectExternalReferencesInRules(\n      context.selfGrammar.patterns,\n      { ...context, repository: context.selfGrammar.repository },\n      result\n    );\n  }\n  if (context.selfGrammar.injections) {\n    collectExternalReferencesInRules(\n      Object.values(context.selfGrammar.injections),\n      { ...context, repository: context.selfGrammar.repository },\n      result\n    );\n  }\n}\nfunction collectExternalReferencesInRules(rules, context, result) {\n  for (const rule of rules) {\n    if (result.visitedRule.has(rule)) {\n      continue;\n    }\n    result.visitedRule.add(rule);\n    const patternRepository = rule.repository ? mergeObjects({}, context.repository, rule.repository) : context.repository;\n    if (Array.isArray(rule.patterns)) {\n      collectExternalReferencesInRules(rule.patterns, { ...context, repository: patternRepository }, result);\n    }\n    const include = rule.include;\n    if (!include) {\n      continue;\n    }\n    const reference = parseInclude(include);\n    switch (reference.kind) {\n      case 0 /* Base */:\n        collectExternalReferencesInTopLevelRule({ ...context, selfGrammar: context.baseGrammar }, result);\n        break;\n      case 1 /* Self */:\n        collectExternalReferencesInTopLevelRule(context, result);\n        break;\n      case 2 /* RelativeReference */:\n        collectExternalReferencesInTopLevelRepositoryRule(reference.ruleName, { ...context, repository: patternRepository }, result);\n        break;\n      case 3 /* TopLevelReference */:\n      case 4 /* TopLevelRepositoryReference */:\n        const selfGrammar = reference.scopeName === context.selfGrammar.scopeName ? context.selfGrammar : reference.scopeName === context.baseGrammar.scopeName ? context.baseGrammar : void 0;\n        if (selfGrammar) {\n          const newContext = { baseGrammar: context.baseGrammar, selfGrammar, repository: patternRepository };\n          if (reference.kind === 4 /* TopLevelRepositoryReference */) {\n            collectExternalReferencesInTopLevelRepositoryRule(reference.ruleName, newContext, result);\n          } else {\n            collectExternalReferencesInTopLevelRule(newContext, result);\n          }\n        } else {\n          if (reference.kind === 4 /* TopLevelRepositoryReference */) {\n            result.add(new TopLevelRepositoryRuleReference(reference.scopeName, reference.ruleName));\n          } else {\n            result.add(new TopLevelRuleReference(reference.scopeName));\n          }\n        }\n        break;\n    }\n  }\n}\nvar BaseReference = class {\n  kind = 0 /* Base */;\n};\nvar SelfReference = class {\n  kind = 1 /* Self */;\n};\nvar RelativeReference = class {\n  constructor(ruleName) {\n    this.ruleName = ruleName;\n  }\n  kind = 2 /* RelativeReference */;\n};\nvar TopLevelReference = class {\n  constructor(scopeName) {\n    this.scopeName = scopeName;\n  }\n  kind = 3 /* TopLevelReference */;\n};\nvar TopLevelRepositoryReference = class {\n  constructor(scopeName, ruleName) {\n    this.scopeName = scopeName;\n    this.ruleName = ruleName;\n  }\n  kind = 4 /* TopLevelRepositoryReference */;\n};\nfunction parseInclude(include) {\n  if (include === \"$base\") {\n    return new BaseReference();\n  } else if (include === \"$self\") {\n    return new SelfReference();\n  }\n  const indexOfSharp = include.indexOf(\"#\");\n  if (indexOfSharp === -1) {\n    return new TopLevelReference(include);\n  } else if (indexOfSharp === 0) {\n    return new RelativeReference(include.substring(1));\n  } else {\n    const scopeName = include.substring(0, indexOfSharp);\n    const ruleName = include.substring(indexOfSharp + 1);\n    return new TopLevelRepositoryReference(scopeName, ruleName);\n  }\n}\n\n// src/rule.ts\nvar HAS_BACK_REFERENCES = /\\\\(\\d+)/;\nvar BACK_REFERENCING_END = /\\\\(\\d+)/g;\nvar ruleIdSymbol = Symbol(\"RuleId\");\nvar endRuleId = -1;\nvar whileRuleId = -2;\nfunction ruleIdFromNumber(id) {\n  return id;\n}\nfunction ruleIdToNumber(id) {\n  return id;\n}\nvar Rule = class {\n  $location;\n  id;\n  _nameIsCapturing;\n  _name;\n  _contentNameIsCapturing;\n  _contentName;\n  constructor($location, id, name, contentName) {\n    this.$location = $location;\n    this.id = id;\n    this._name = name || null;\n    this._nameIsCapturing = RegexSource.hasCaptures(this._name);\n    this._contentName = contentName || null;\n    this._contentNameIsCapturing = RegexSource.hasCaptures(this._contentName);\n  }\n  get debugName() {\n    const location = this.$location ? `${basename(this.$location.filename)}:${this.$location.line}` : \"unknown\";\n    return `${this.constructor.name}#${this.id} @ ${location}`;\n  }\n  getName(lineText, captureIndices) {\n    if (!this._nameIsCapturing || this._name === null || lineText === null || captureIndices === null) {\n      return this._name;\n    }\n    return RegexSource.replaceCaptures(this._name, lineText, captureIndices);\n  }\n  getContentName(lineText, captureIndices) {\n    if (!this._contentNameIsCapturing || this._contentName === null) {\n      return this._contentName;\n    }\n    return RegexSource.replaceCaptures(this._contentName, lineText, captureIndices);\n  }\n};\nvar CaptureRule = class extends Rule {\n  retokenizeCapturedWithRuleId;\n  constructor($location, id, name, contentName, retokenizeCapturedWithRuleId) {\n    super($location, id, name, contentName);\n    this.retokenizeCapturedWithRuleId = retokenizeCapturedWithRuleId;\n  }\n  dispose() {\n  }\n  collectPatterns(grammar, out) {\n    throw new Error(\"Not supported!\");\n  }\n  compile(grammar, endRegexSource) {\n    throw new Error(\"Not supported!\");\n  }\n  compileAG(grammar, endRegexSource, allowA, allowG) {\n    throw new Error(\"Not supported!\");\n  }\n};\nvar MatchRule = class extends Rule {\n  _match;\n  captures;\n  _cachedCompiledPatterns;\n  constructor($location, id, name, match, captures) {\n    super($location, id, name, null);\n    this._match = new RegExpSource(match, this.id);\n    this.captures = captures;\n    this._cachedCompiledPatterns = null;\n  }\n  dispose() {\n    if (this._cachedCompiledPatterns) {\n      this._cachedCompiledPatterns.dispose();\n      this._cachedCompiledPatterns = null;\n    }\n  }\n  get debugMatchRegExp() {\n    return `${this._match.source}`;\n  }\n  collectPatterns(grammar, out) {\n    out.push(this._match);\n  }\n  compile(grammar, endRegexSource) {\n    return this._getCachedCompiledPatterns(grammar).compile(grammar);\n  }\n  compileAG(grammar, endRegexSource, allowA, allowG) {\n    return this._getCachedCompiledPatterns(grammar).compileAG(grammar, allowA, allowG);\n  }\n  _getCachedCompiledPatterns(grammar) {\n    if (!this._cachedCompiledPatterns) {\n      this._cachedCompiledPatterns = new RegExpSourceList();\n      this.collectPatterns(grammar, this._cachedCompiledPatterns);\n    }\n    return this._cachedCompiledPatterns;\n  }\n};\nvar IncludeOnlyRule = class extends Rule {\n  hasMissingPatterns;\n  patterns;\n  _cachedCompiledPatterns;\n  constructor($location, id, name, contentName, patterns) {\n    super($location, id, name, contentName);\n    this.patterns = patterns.patterns;\n    this.hasMissingPatterns = patterns.hasMissingPatterns;\n    this._cachedCompiledPatterns = null;\n  }\n  dispose() {\n    if (this._cachedCompiledPatterns) {\n      this._cachedCompiledPatterns.dispose();\n      this._cachedCompiledPatterns = null;\n    }\n  }\n  collectPatterns(grammar, out) {\n    for (const pattern of this.patterns) {\n      const rule = grammar.getRule(pattern);\n      rule.collectPatterns(grammar, out);\n    }\n  }\n  compile(grammar, endRegexSource) {\n    return this._getCachedCompiledPatterns(grammar).compile(grammar);\n  }\n  compileAG(grammar, endRegexSource, allowA, allowG) {\n    return this._getCachedCompiledPatterns(grammar).compileAG(grammar, allowA, allowG);\n  }\n  _getCachedCompiledPatterns(grammar) {\n    if (!this._cachedCompiledPatterns) {\n      this._cachedCompiledPatterns = new RegExpSourceList();\n      this.collectPatterns(grammar, this._cachedCompiledPatterns);\n    }\n    return this._cachedCompiledPatterns;\n  }\n};\nvar BeginEndRule = class extends Rule {\n  _begin;\n  beginCaptures;\n  _end;\n  endHasBackReferences;\n  endCaptures;\n  applyEndPatternLast;\n  hasMissingPatterns;\n  patterns;\n  _cachedCompiledPatterns;\n  constructor($location, id, name, contentName, begin, beginCaptures, end, endCaptures, applyEndPatternLast, patterns) {\n    super($location, id, name, contentName);\n    this._begin = new RegExpSource(begin, this.id);\n    this.beginCaptures = beginCaptures;\n    this._end = new RegExpSource(end ? end : \"\\uFFFF\", -1);\n    this.endHasBackReferences = this._end.hasBackReferences;\n    this.endCaptures = endCaptures;\n    this.applyEndPatternLast = applyEndPatternLast || false;\n    this.patterns = patterns.patterns;\n    this.hasMissingPatterns = patterns.hasMissingPatterns;\n    this._cachedCompiledPatterns = null;\n  }\n  dispose() {\n    if (this._cachedCompiledPatterns) {\n      this._cachedCompiledPatterns.dispose();\n      this._cachedCompiledPatterns = null;\n    }\n  }\n  get debugBeginRegExp() {\n    return `${this._begin.source}`;\n  }\n  get debugEndRegExp() {\n    return `${this._end.source}`;\n  }\n  getEndWithResolvedBackReferences(lineText, captureIndices) {\n    return this._end.resolveBackReferences(lineText, captureIndices);\n  }\n  collectPatterns(grammar, out) {\n    out.push(this._begin);\n  }\n  compile(grammar, endRegexSource) {\n    return this._getCachedCompiledPatterns(grammar, endRegexSource).compile(grammar);\n  }\n  compileAG(grammar, endRegexSource, allowA, allowG) {\n    return this._getCachedCompiledPatterns(grammar, endRegexSource).compileAG(grammar, allowA, allowG);\n  }\n  _getCachedCompiledPatterns(grammar, endRegexSource) {\n    if (!this._cachedCompiledPatterns) {\n      this._cachedCompiledPatterns = new RegExpSourceList();\n      for (const pattern of this.patterns) {\n        const rule = grammar.getRule(pattern);\n        rule.collectPatterns(grammar, this._cachedCompiledPatterns);\n      }\n      if (this.applyEndPatternLast) {\n        this._cachedCompiledPatterns.push(this._end.hasBackReferences ? this._end.clone() : this._end);\n      } else {\n        this._cachedCompiledPatterns.unshift(this._end.hasBackReferences ? this._end.clone() : this._end);\n      }\n    }\n    if (this._end.hasBackReferences) {\n      if (this.applyEndPatternLast) {\n        this._cachedCompiledPatterns.setSource(this._cachedCompiledPatterns.length() - 1, endRegexSource);\n      } else {\n        this._cachedCompiledPatterns.setSource(0, endRegexSource);\n      }\n    }\n    return this._cachedCompiledPatterns;\n  }\n};\nvar BeginWhileRule = class extends Rule {\n  _begin;\n  beginCaptures;\n  whileCaptures;\n  _while;\n  whileHasBackReferences;\n  hasMissingPatterns;\n  patterns;\n  _cachedCompiledPatterns;\n  _cachedCompiledWhilePatterns;\n  constructor($location, id, name, contentName, begin, beginCaptures, _while, whileCaptures, patterns) {\n    super($location, id, name, contentName);\n    this._begin = new RegExpSource(begin, this.id);\n    this.beginCaptures = beginCaptures;\n    this.whileCaptures = whileCaptures;\n    this._while = new RegExpSource(_while, whileRuleId);\n    this.whileHasBackReferences = this._while.hasBackReferences;\n    this.patterns = patterns.patterns;\n    this.hasMissingPatterns = patterns.hasMissingPatterns;\n    this._cachedCompiledPatterns = null;\n    this._cachedCompiledWhilePatterns = null;\n  }\n  dispose() {\n    if (this._cachedCompiledPatterns) {\n      this._cachedCompiledPatterns.dispose();\n      this._cachedCompiledPatterns = null;\n    }\n    if (this._cachedCompiledWhilePatterns) {\n      this._cachedCompiledWhilePatterns.dispose();\n      this._cachedCompiledWhilePatterns = null;\n    }\n  }\n  get debugBeginRegExp() {\n    return `${this._begin.source}`;\n  }\n  get debugWhileRegExp() {\n    return `${this._while.source}`;\n  }\n  getWhileWithResolvedBackReferences(lineText, captureIndices) {\n    return this._while.resolveBackReferences(lineText, captureIndices);\n  }\n  collectPatterns(grammar, out) {\n    out.push(this._begin);\n  }\n  compile(grammar, endRegexSource) {\n    return this._getCachedCompiledPatterns(grammar).compile(grammar);\n  }\n  compileAG(grammar, endRegexSource, allowA, allowG) {\n    return this._getCachedCompiledPatterns(grammar).compileAG(grammar, allowA, allowG);\n  }\n  _getCachedCompiledPatterns(grammar) {\n    if (!this._cachedCompiledPatterns) {\n      this._cachedCompiledPatterns = new RegExpSourceList();\n      for (const pattern of this.patterns) {\n        const rule = grammar.getRule(pattern);\n        rule.collectPatterns(grammar, this._cachedCompiledPatterns);\n      }\n    }\n    return this._cachedCompiledPatterns;\n  }\n  compileWhile(grammar, endRegexSource) {\n    return this._getCachedCompiledWhilePatterns(grammar, endRegexSource).compile(grammar);\n  }\n  compileWhileAG(grammar, endRegexSource, allowA, allowG) {\n    return this._getCachedCompiledWhilePatterns(grammar, endRegexSource).compileAG(grammar, allowA, allowG);\n  }\n  _getCachedCompiledWhilePatterns(grammar, endRegexSource) {\n    if (!this._cachedCompiledWhilePatterns) {\n      this._cachedCompiledWhilePatterns = new RegExpSourceList();\n      this._cachedCompiledWhilePatterns.push(this._while.hasBackReferences ? this._while.clone() : this._while);\n    }\n    if (this._while.hasBackReferences) {\n      this._cachedCompiledWhilePatterns.setSource(0, endRegexSource ? endRegexSource : \"\\uFFFF\");\n    }\n    return this._cachedCompiledWhilePatterns;\n  }\n};\nvar RuleFactory = class _RuleFactory {\n  static createCaptureRule(helper, $location, name, contentName, retokenizeCapturedWithRuleId) {\n    return helper.registerRule((id) =\u003e {\n      return new CaptureRule($location, id, name, contentName, retokenizeCapturedWithRuleId);\n    });\n  }\n  static getCompiledRuleId(desc, helper, repository) {\n    if (!desc.id) {\n      helper.registerRule((id) =\u003e {\n        desc.id = id;\n        if (desc.match) {\n          return new MatchRule(\n            desc.$vscodeTextmateLocation,\n            desc.id,\n            desc.name,\n            desc.match,\n            _RuleFactory._compileCaptures(desc.captures, helper, repository)\n          );\n        }\n        if (typeof desc.begin === \"undefined\") {\n          if (desc.repository) {\n            repository = mergeObjects({}, repository, desc.repository);\n          }\n          let patterns = desc.patterns;\n          if (typeof patterns === \"undefined\" \u0026\u0026 desc.include) {\n            patterns = [{ include: desc.include }];\n          }\n          return new IncludeOnlyRule(\n            desc.$vscodeTextmateLocation,\n            desc.id,\n            desc.name,\n            desc.contentName,\n            _RuleFactory._compilePatterns(patterns, helper, repository)\n          );\n        }\n        if (desc.while) {\n          return new BeginWhileRule(\n            desc.$vscodeTextmateLocation,\n            desc.id,\n            desc.name,\n            desc.contentName,\n            desc.begin,\n            _RuleFactory._compileCaptures(desc.beginCaptures || desc.captures, helper, repository),\n            desc.while,\n            _RuleFactory._compileCaptures(desc.whileCaptures || desc.captures, helper, repository),\n            _RuleFactory._compilePatterns(desc.patterns, helper, repository)\n          );\n        }\n        return new BeginEndRule(\n          desc.$vscodeTextmateLocation,\n          desc.id,\n          desc.name,\n          desc.contentName,\n          desc.begin,\n          _RuleFactory._compileCaptures(desc.beginCaptures || desc.captures, helper, repository),\n          desc.end,\n          _RuleFactory._compileCaptures(desc.endCaptures || desc.captures, helper, repository),\n          desc.applyEndPatternLast,\n          _RuleFactory._compilePatterns(desc.patterns, helper, repository)\n        );\n      });\n    }\n    return desc.id;\n  }\n  static _compileCaptures(captures, helper, repository) {\n    let r = [];\n    if (captures) {\n      let maximumCaptureId = 0;\n      for (const captureId in captures) {\n        if (captureId === \"$vscodeTextmateLocation\") {\n          continue;\n        }\n        const numericCaptureId = parseInt(captureId, 10);\n        if (numericCaptureId \u003e maximumCaptureId) {\n          maximumCaptureId = numericCaptureId;\n        }\n      }\n      for (let i = 0; i \u003c= maximumCaptureId; i++) {\n        r[i] = null;\n      }\n      for (const captureId in captures) {\n        if (captureId === \"$vscodeTextmateLocation\") {\n          continue;\n        }\n        const numericCaptureId = parseInt(captureId, 10);\n        let retokenizeCapturedWithRuleId = 0;\n        if (captures[captureId].patterns) {\n          retokenizeCapturedWithRuleId = _RuleFactory.getCompiledRuleId(captures[captureId], helper, repository);\n        }\n        r[numericCaptureId] = _RuleFactory.createCaptureRule(helper, captures[captureId].$vscodeTextmateLocation, captures[captureId].name, captures[captureId].contentName, retokenizeCapturedWithRuleId);\n      }\n    }\n    return r;\n  }\n  static _compilePatterns(patterns, helper, repository) {\n    let r = [];\n    if (patterns) {\n      for (let i = 0, len = patterns.length; i \u003c len; i++) {\n        const pattern = patterns[i];\n        let ruleId = -1;\n        if (pattern.include) {\n          const reference = parseInclude(pattern.include);\n          switch (reference.kind) {\n            case 0 /* Base */:\n            case 1 /* Self */:\n              ruleId = _RuleFactory.getCompiledRuleId(repository[pattern.include], helper, repository);\n              break;\n            case 2 /* RelativeReference */:\n              let localIncludedRule = repository[reference.ruleName];\n              if (localIncludedRule) {\n                ruleId = _RuleFactory.getCompiledRuleId(localIncludedRule, helper, repository);\n              } else {\n              }\n              break;\n            case 3 /* TopLevelReference */:\n            case 4 /* TopLevelRepositoryReference */:\n              const externalGrammarName = reference.scopeName;\n              const externalGrammarInclude = reference.kind === 4 /* TopLevelRepositoryReference */ ? reference.ruleName : null;\n              const externalGrammar = helper.getExternalGrammar(externalGrammarName, repository);\n              if (externalGrammar) {\n                if (externalGrammarInclude) {\n                  let externalIncludedRule = externalGrammar.repository[externalGrammarInclude];\n                  if (externalIncludedRule) {\n                    ruleId = _RuleFactory.getCompiledRuleId(externalIncludedRule, helper, externalGrammar.repository);\n                  } else {\n                  }\n                } else {\n                  ruleId = _RuleFactory.getCompiledRuleId(externalGrammar.repository.$self, helper, externalGrammar.repository);\n                }\n              } else {\n              }\n              break;\n          }\n        } else {\n          ruleId = _RuleFactory.getCompiledRuleId(pattern, helper, repository);\n        }\n        if (ruleId !== -1) {\n          const rule = helper.getRule(ruleId);\n          let skipRule = false;\n          if (rule instanceof IncludeOnlyRule || rule instanceof BeginEndRule || rule instanceof BeginWhileRule) {\n            if (rule.hasMissingPatterns \u0026\u0026 rule.patterns.length === 0) {\n              skipRule = true;\n            }\n          }\n          if (skipRule) {\n            continue;\n          }\n          r.push(ruleId);\n        }\n      }\n    }\n    return {\n      patterns: r,\n      hasMissingPatterns: (patterns ? patterns.length : 0) !== r.length\n    };\n  }\n};\nvar RegExpSource = class _RegExpSource {\n  source;\n  ruleId;\n  hasAnchor;\n  hasBackReferences;\n  _anchorCache;\n  constructor(regExpSource, ruleId) {\n    if (regExpSource \u0026\u0026 typeof regExpSource === \"string\") {\n      const len = regExpSource.length;\n      let lastPushedPos = 0;\n      let output = [];\n      let hasAnchor = false;\n      for (let pos = 0; pos \u003c len; pos++) {\n        const ch = regExpSource.charAt(pos);\n        if (ch === \"\\\\\") {\n          if (pos + 1 \u003c len) {\n            const nextCh = regExpSource.charAt(pos + 1);\n            if (nextCh === \"z\") {\n              output.push(regExpSource.substring(lastPushedPos, pos));\n              output.push(\"$(?!\\\\n)(?\u003c!\\\\n)\");\n              lastPushedPos = pos + 2;\n            } else if (nextCh === \"A\" || nextCh === \"G\") {\n              hasAnchor = true;\n            }\n            pos++;\n          }\n        }\n      }\n      this.hasAnchor = hasAnchor;\n      if (lastPushedPos === 0) {\n        this.source = regExpSource;\n      } else {\n        output.push(regExpSource.substring(lastPushedPos, len));\n        this.source = output.join(\"\");\n      }\n    } else {\n      this.hasAnchor = false;\n      this.source = regExpSource;\n    }\n    if (this.hasAnchor) {\n      this._anchorCache = this._buildAnchorCache();\n    } else {\n      this._anchorCache = null;\n    }\n    this.ruleId = ruleId;\n    if (typeof this.source === \"string\") {\n      this.hasBackReferences = HAS_BACK_REFERENCES.test(this.source);\n    } else {\n      this.hasBackReferences = false;\n    }\n  }\n  clone() {\n    return new _RegExpSource(this.source, this.ruleId);\n  }\n  setSource(newSource) {\n    if (this.source === newSource) {\n      return;\n    }\n    this.source = newSource;\n    if (this.hasAnchor) {\n      this._anchorCache = this._buildAnchorCache();\n    }\n  }\n  resolveBackReferences(lineText, captureIndices) {\n    if (typeof this.source !== \"string\") {\n      throw new Error(\"This method should only be called if the source is a string\");\n    }\n    let capturedValues = captureIndices.map((capture) =\u003e {\n      return lineText.substring(capture.start, capture.end);\n    });\n    BACK_REFERENCING_END.lastIndex = 0;\n    return this.source.replace(BACK_REFERENCING_END, (match, g1) =\u003e {\n      return escapeRegExpCharacters(capturedValues[parseInt(g1, 10)] || \"\");\n    });\n  }\n  _buildAnchorCache() {\n    if (typeof this.source !== \"string\") {\n      throw new Error(\"This method should only be called if the source is a string\");\n    }\n    let A0_G0_result = [];\n    let A0_G1_result = [];\n    let A1_G0_result = [];\n    let A1_G1_result = [];\n    let pos, len, ch, nextCh;\n    for (pos = 0, len = this.source.length; pos \u003c len; pos++) {\n      ch = this.source.charAt(pos);\n      A0_G0_result[pos] = ch;\n      A0_G1_result[pos] = ch;\n      A1_G0_result[pos] = ch;\n      A1_G1_result[pos] = ch;\n      if (ch === \"\\\\\") {\n        if (pos + 1 \u003c len) {\n          nextCh = this.source.charAt(pos + 1);\n          if (nextCh === \"A\") {\n            A0_G0_result[pos + 1] = \"\\uFFFF\";\n            A0_G1_result[pos + 1] = \"\\uFFFF\";\n            A1_G0_result[pos + 1] = \"A\";\n            A1_G1_result[pos + 1] = \"A\";\n          } else if (nextCh === \"G\") {\n            A0_G0_result[pos + 1] = \"\\uFFFF\";\n            A0_G1_result[pos + 1] = \"G\";\n            A1_G0_result[pos + 1] = \"\\uFFFF\";\n            A1_G1_result[pos + 1] = \"G\";\n          } else {\n            A0_G0_result[pos + 1] = nextCh;\n            A0_G1_result[pos + 1] = nextCh;\n            A1_G0_result[pos + 1] = nextCh;\n            A1_G1_result[pos + 1] = nextCh;\n          }\n          pos++;\n        }\n      }\n    }\n    return {\n      A0_G0: A0_G0_result.join(\"\"),\n      A0_G1: A0_G1_result.join(\"\"),\n      A1_G0: A1_G0_result.join(\"\"),\n      A1_G1: A1_G1_result.join(\"\")\n    };\n  }\n  resolveAnchors(allowA, allowG) {\n    if (!this.hasAnchor || !this._anchorCache || typeof this.source !== \"string\") {\n      return this.source;\n    }\n    if (allowA) {\n      if (allowG) {\n        return this._anchorCache.A1_G1;\n      } else {\n        return this._anchorCache.A1_G0;\n      }\n    } else {\n      if (allowG) {\n        return this._anchorCache.A0_G1;\n      } else {\n        return this._anchorCache.A0_G0;\n      }\n    }\n  }\n};\nvar RegExpSourceList = class {\n  _items;\n  _hasAnchors;\n  _cached;\n  _anchorCache;\n  constructor() {\n    this._items = [];\n    this._hasAnchors = false;\n    this._cached = null;\n    this._anchorCache = {\n      A0_G0: null,\n      A0_G1: null,\n      A1_G0: null,\n      A1_G1: null\n    };\n  }\n  dispose() {\n    this._disposeCaches();\n  }\n  _disposeCaches() {\n    if (this._cached) {\n      this._cached.dispose();\n      this._cached = null;\n    }\n    if (this._anchorCache.A0_G0) {\n      this._anchorCache.A0_G0.dispose();\n      this._anchorCache.A0_G0 = null;\n    }\n    if (this._anchorCache.A0_G1) {\n      this._anchorCache.A0_G1.dispose();\n      this._anchorCache.A0_G1 = null;\n    }\n    if (this._anchorCache.A1_G0) {\n      this._anchorCache.A1_G0.dispose();\n      this._anchorCache.A1_G0 = null;\n    }\n    if (this._anchorCache.A1_G1) {\n      this._anchorCache.A1_G1.dispose();\n      this._anchorCache.A1_G1 = null;\n    }\n  }\n  push(item) {\n    this._items.push(item);\n    this._hasAnchors = this._hasAnchors || item.hasAnchor;\n  }\n  unshift(item) {\n    this._items.unshift(item);\n    this._hasAnchors = this._hasAnchors || item.hasAnchor;\n  }\n  length() {\n    return this._items.length;\n  }\n  setSource(index, newSource) {\n    if (this._items[index].source !== newSource) {\n      this._disposeCaches();\n      this._items[index].setSource(newSource);\n    }\n  }\n  compile(onigLib) {\n    if (!this._cached) {\n      let regExps = this._items.map((e) =\u003e e.source);\n      this._cached = new CompiledRule(onigLib, regExps, this._items.map((e) =\u003e e.ruleId));\n    }\n    return this._cached;\n  }\n  compileAG(onigLib, allowA, allowG) {\n    if (!this._hasAnchors) {\n      return this.compile(onigLib);\n    } else {\n      if (allowA) {\n        if (allowG) {\n          if (!this._anchorCache.A1_G1) {\n            this._anchorCache.A1_G1 = this._resolveAnchors(onigLib, allowA, allowG);\n          }\n          return this._anchorCache.A1_G1;\n        } else {\n          if (!this._anchorCache.A1_G0) {\n            this._anchorCache.A1_G0 = this._resolveAnchors(onigLib, allowA, allowG);\n          }\n          return this._anchorCache.A1_G0;\n        }\n      } else {\n        if (allowG) {\n          if (!this._anchorCache.A0_G1) {\n            this._anchorCache.A0_G1 = this._resolveAnchors(onigLib, allowA, allowG);\n          }\n          return this._anchorCache.A0_G1;\n        } else {\n          if (!this._anchorCache.A0_G0) {\n            this._anchorCache.A0_G0 = this._resolveAnchors(onigLib, allowA, allowG);\n          }\n          return this._anchorCache.A0_G0;\n        }\n      }\n    }\n  }\n  _resolveAnchors(onigLib, allowA, allowG) {\n    let regExps = this._items.map((e) =\u003e e.resolveAnchors(allowA, allowG));\n    return new CompiledRule(onigLib, regExps, this._items.map((e) =\u003e e.ruleId));\n  }\n};\nvar CompiledRule = class {\n  constructor(onigLib, regExps, rules) {\n    this.regExps = regExps;\n    this.rules = rules;\n    this.scanner = onigLib.createOnigScanner(regExps);\n  }\n  scanner;\n  dispose() {\n    if (typeof this.scanner.dispose === \"function\") {\n      this.scanner.dispose();\n    }\n  }\n  toString() {\n    const r = [];\n    for (let i = 0, len = this.rules.length; i \u003c len; i++) {\n      r.push(\"   - \" + this.rules[i] + \": \" + this.regExps[i]);\n    }\n    return r.join(\"\\n\");\n  }\n  findNextMatchSync(string, startPosition, options) {\n    const result = this.scanner.findNextMatchSync(string, startPosition, options);\n    if (!result) {\n      return null;\n    }\n    return {\n      ruleId: this.rules[result.index],\n      captureIndices: result.captureIndices\n    };\n  }\n};\n\n// src/grammar/basicScopesAttributeProvider.ts\nvar BasicScopeAttributes = class {\n  constructor(languageId, tokenType) {\n    this.languageId = languageId;\n    this.tokenType = tokenType;\n  }\n};\nvar BasicScopeAttributesProvider = class _BasicScopeAttributesProvider {\n  _defaultAttributes;\n  _embeddedLanguagesMatcher;\n  constructor(initialLanguageId, embeddedLanguages) {\n    this._defaultAttributes = new BasicScopeAttributes(initialLanguageId, 8 /* NotSet */);\n    this._embeddedLanguagesMatcher = new ScopeMatcher(Object.entries(embeddedLanguages || {}));\n  }\n  getDefaultAttributes() {\n    return this._defaultAttributes;\n  }\n  getBasicScopeAttributes(scopeName) {\n    if (scopeName === null) {\n      return _BasicScopeAttributesProvider._NULL_SCOPE_METADATA;\n    }\n    return this._getBasicScopeAttributes.get(scopeName);\n  }\n  static _NULL_SCOPE_METADATA = new BasicScopeAttributes(0, 0);\n  _getBasicScopeAttributes = new CachedFn((scopeName) =\u003e {\n    const languageId = this._scopeToLanguage(scopeName);\n    const standardTokenType = this._toStandardTokenType(scopeName);\n    return new BasicScopeAttributes(languageId, standardTokenType);\n  });\n  /**\n   * Given a produced TM scope, return the language that token describes or null if unknown.\n   * e.g. source.html =\u003e html, source.css.embedded.html =\u003e css, punctuation.definition.tag.html =\u003e null\n   */\n  _scopeToLanguage(scope) {\n    return this._embeddedLanguagesMatcher.match(scope) || 0;\n  }\n  _toStandardTokenType(scopeName) {\n    const m = scopeName.match(_BasicScopeAttributesProvider.STANDARD_TOKEN_TYPE_REGEXP);\n    if (!m) {\n      return 8 /* NotSet */;\n    }\n    switch (m[1]) {\n      case \"comment\":\n        return 1 /* Comment */;\n      case \"string\":\n        return 2 /* String */;\n      case \"regex\":\n        return 3 /* RegEx */;\n      case \"meta.embedded\":\n        return 0 /* Other */;\n    }\n    throw new Error(\"Unexpected match for standard token type!\");\n  }\n  static STANDARD_TOKEN_TYPE_REGEXP = /\\b(comment|string|regex|meta\\.embedded)\\b/;\n};\nvar ScopeMatcher = class {\n  values;\n  scopesRegExp;\n  constructor(values) {\n    if (values.length === 0) {\n      this.values = null;\n      this.scopesRegExp = null;\n    } else {\n      this.values = new Map(values);\n      const escapedScopes = values.map(\n        ([scopeName, value]) =\u003e escapeRegExpCharacters(scopeName)\n      );\n      escapedScopes.sort();\n      escapedScopes.reverse();\n      this.scopesRegExp = new RegExp(\n        `^((${escapedScopes.join(\")|(\")}))($|\\\\.)`,\n        \"\"\n      );\n    }\n  }\n  match(scope) {\n    if (!this.scopesRegExp) {\n      return void 0;\n    }\n    const m = scope.match(this.scopesRegExp);\n    if (!m) {\n      return void 0;\n    }\n    return this.values.get(m[1]);\n  }\n};\n\n// src/debug.ts\nvar DebugFlags = {\n  InDebugMode: typeof process !== \"undefined\" \u0026\u0026 !!process.env[\"VSCODE_TEXTMATE_DEBUG\"]\n};\nvar UseOnigurumaFindOptions = false;\n\n// src/grammar/tokenizeString.ts\nvar TokenizeStringResult = class {\n  constructor(stack, stoppedEarly) {\n    this.stack = stack;\n    this.stoppedEarly = stoppedEarly;\n  }\n};\nfunction _tokenizeString(grammar, lineText, isFirstLine, linePos, stack, lineTokens, checkWhileConditions, timeLimit) {\n  const lineLength = lineText.content.length;\n  let STOP = false;\n  let anchorPosition = -1;\n  if (checkWhileConditions) {\n    const whileCheckResult = _checkWhileConditions(\n      grammar,\n      lineText,\n      isFirstLine,\n      linePos,\n      stack,\n      lineTokens\n    );\n    stack = whileCheckResult.stack;\n    linePos = whileCheckResult.linePos;\n    isFirstLine = whileCheckResult.isFirstLine;\n    anchorPosition = whileCheckResult.anchorPosition;\n  }\n  const startTime = Date.now();\n  while (!STOP) {\n    if (timeLimit !== 0) {\n      const elapsedTime = Date.now() - startTime;\n      if (elapsedTime \u003e timeLimit) {\n        return new TokenizeStringResult(stack, true);\n      }\n    }\n    scanNext();\n  }\n  return new TokenizeStringResult(stack, false);\n  function scanNext() {\n    if (false) {\n      console.log(\"\");\n      console.log(\n        `@@scanNext ${linePos}: |${lineText.content.substr(linePos).replace(/\\n$/, \"\\\\n\")}|`\n      );\n    }\n    const r = matchRuleOrInjections(\n      grammar,\n      lineText,\n      isFirstLine,\n      linePos,\n      stack,\n      anchorPosition\n    );\n    if (!r) {\n      lineTokens.produce(stack, lineLength);\n      STOP = true;\n      return;\n    }\n    const captureIndices = r.captureIndices;\n    const matchedRuleId = r.matchedRuleId;\n    const hasAdvanced = captureIndices \u0026\u0026 captureIndices.length \u003e 0 ? captureIndices[0].end \u003e linePos : false;\n    if (matchedRuleId === endRuleId) {\n      const poppedRule = stack.getRule(grammar);\n      if (false) {\n        console.log(\n          \"  popping \" + poppedRule.debugName + \" - \" + poppedRule.debugEndRegExp\n        );\n      }\n      lineTokens.produce(stack, captureIndices[0].start);\n      stack = stack.withContentNameScopesList(stack.nameScopesList);\n      handleCaptures(\n        grammar,\n        lineText,\n        isFirstLine,\n        stack,\n        lineTokens,\n        poppedRule.endCaptures,\n        captureIndices\n      );\n      lineTokens.produce(stack, captureIndices[0].end);\n      const popped = stack;\n      stack = stack.parent;\n      anchorPosition = popped.getAnchorPos();\n      if (!hasAdvanced \u0026\u0026 popped.getEnterPos() === linePos) {\n        if (false) {\n          console.error(\n            \"[1] - Grammar is in an endless loop - Grammar pushed \u0026 popped a rule without advancing\"\n          );\n        }\n        stack = popped;\n        lineTokens.produce(stack, lineLength);\n        STOP = true;\n        return;\n      }\n    } else {\n      const _rule = grammar.getRule(matchedRuleId);\n      lineTokens.produce(stack, captureIndices[0].start);\n      const beforePush = stack;\n      const scopeName = _rule.getName(lineText.content, captureIndices);\n      const nameScopesList = stack.contentNameScopesList.pushAttributed(\n        scopeName,\n        grammar\n      );\n      stack = stack.push(\n        matchedRuleId,\n        linePos,\n        anchorPosition,\n        captureIndices[0].end === lineLength,\n        null,\n        nameScopesList,\n        nameScopesList\n      );\n      if (_rule instanceof BeginEndRule) {\n        const pushedRule = _rule;\n        if (false) {\n          console.log(\n            \"  pushing \" + pushedRule.debugName + \" - \" + pushedRule.debugBeginRegExp\n          );\n        }\n        handleCaptures(\n          grammar,\n          lineText,\n          isFirstLine,\n          stack,\n          lineTokens,\n          pushedRule.beginCaptures,\n          captureIndices\n        );\n        lineTokens.produce(stack, captureIndices[0].end);\n        anchorPosition = captureIndices[0].end;\n        const contentName = pushedRule.getContentName(\n          lineText.content,\n          captureIndices\n        );\n        const contentNameScopesList = nameScopesList.pushAttributed(\n          contentName,\n          grammar\n        );\n        stack = stack.withContentNameScopesList(contentNameScopesList);\n        if (pushedRule.endHasBackReferences) {\n          stack = stack.withEndRule(\n            pushedRule.getEndWithResolvedBackReferences(\n              lineText.content,\n              captureIndices\n            )\n          );\n        }\n        if (!hasAdvanced \u0026\u0026 beforePush.hasSameRuleAs(stack)) {\n          if (false) {\n            console.error(\n              \"[2] - Grammar is in an endless loop - Grammar pushed the same rule without advancing\"\n            );\n          }\n          stack = stack.pop();\n          lineTokens.produce(stack, lineLength);\n          STOP = true;\n          return;\n        }\n      } else if (_rule instanceof BeginWhileRule) {\n        const pushedRule = _rule;\n        if (false) {\n          console.log(\"  pushing \" + pushedRule.debugName);\n        }\n        handleCaptures(\n          grammar,\n          lineText,\n          isFirstLine,\n          stack,\n          lineTokens,\n          pushedRule.beginCaptures,\n          captureIndices\n        );\n        lineTokens.produce(stack, captureIndices[0].end);\n        anchorPosition = captureIndices[0].end;\n        const contentName = pushedRule.getContentName(\n          lineText.content,\n          captureIndices\n        );\n        const contentNameScopesList = nameScopesList.pushAttributed(\n          contentName,\n          grammar\n        );\n        stack = stack.withContentNameScopesList(contentNameScopesList);\n        if (pushedRule.whileHasBackReferences) {\n          stack = stack.withEndRule(\n            pushedRule.getWhileWithResolvedBackReferences(\n              lineText.content,\n              captureIndices\n            )\n          );\n        }\n        if (!hasAdvanced \u0026\u0026 beforePush.hasSameRuleAs(stack)) {\n          if (false) {\n            console.error(\n              \"[3] - Grammar is in an endless loop - Grammar pushed the same rule without advancing\"\n            );\n          }\n          stack = stack.pop();\n          lineTokens.produce(stack, lineLength);\n          STOP = true;\n          return;\n        }\n      } else {\n        const matchingRule = _rule;\n        if (false) {\n          console.log(\n            \"  matched \" + matchingRule.debugName + \" - \" + matchingRule.debugMatchRegExp\n          );\n        }\n        handleCaptures(\n          grammar,\n          lineText,\n          isFirstLine,\n          stack,\n          lineTokens,\n          matchingRule.captures,\n          captureIndices\n        );\n        lineTokens.produce(stack, captureIndices[0].end);\n        stack = stack.pop();\n        if (!hasAdvanced) {\n          if (false) {\n            console.error(\n              \"[4] - Grammar is in an endless loop - Grammar is not advancing, nor is it pushing/popping\"\n            );\n          }\n          stack = stack.safePop();\n          lineTokens.produce(stack, lineLength);\n          STOP = true;\n          return;\n        }\n      }\n    }\n    if (captureIndices[0].end \u003e linePos) {\n      linePos = captureIndices[0].end;\n      isFirstLine = false;\n    }\n  }\n}\nfunction _checkWhileConditions(grammar, lineText, isFirstLine, linePos, stack, lineTokens) {\n  let anchorPosition = stack.beginRuleCapturedEOL ? 0 : -1;\n  const whileRules = [];\n  for (let node = stack; node; node = node.pop()) {\n    const nodeRule = node.getRule(grammar);\n    if (nodeRule instanceof BeginWhileRule) {\n      whileRules.push({\n        rule: nodeRule,\n        stack: node\n      });\n    }\n  }\n  for (let whileRule = whileRules.pop(); whileRule; whileRule = whileRules.pop()) {\n    const { ruleScanner, findOptions } = prepareRuleWhileSearch(whileRule.rule, grammar, whileRule.stack.endRule, isFirstLine, linePos === anchorPosition);\n    const r = ruleScanner.findNextMatchSync(lineText, linePos, findOptions);\n    if (false) {\n      console.log(\"  scanning for while rule\");\n      console.log(ruleScanner.toString());\n    }\n    if (r) {\n      const matchedRuleId = r.ruleId;\n      if (matchedRuleId !== whileRuleId) {\n        stack = whileRule.stack.pop();\n        break;\n      }\n      if (r.captureIndices \u0026\u0026 r.captureIndices.length) {\n        lineTokens.produce(whileRule.stack, r.captureIndices[0].start);\n        handleCaptures(grammar, lineText, isFirstLine, whileRule.stack, lineTokens, whileRule.rule.whileCaptures, r.captureIndices);\n        lineTokens.produce(whileRule.stack, r.captureIndices[0].end);\n        anchorPosition = r.captureIndices[0].end;\n        if (r.captureIndices[0].end \u003e linePos) {\n          linePos = r.captureIndices[0].end;\n          isFirstLine = false;\n        }\n      }\n    } else {\n      if (false) {\n        console.log(\"  popping \" + whileRule.rule.debugName + \" - \" + whileRule.rule.debugWhileRegExp);\n      }\n      stack = whileRule.stack.pop();\n      break;\n    }\n  }\n  return { stack, linePos, anchorPosition, isFirstLine };\n}\nfunction matchRuleOrInjections(grammar, lineText, isFirstLine, linePos, stack, anchorPosition) {\n  const matchResult = matchRule(grammar, lineText, isFirstLine, linePos, stack, anchorPosition);\n  const injections = grammar.getInjections();\n  if (injections.length === 0) {\n    return matchResult;\n  }\n  const injectionResult = matchInjections(injections, grammar, lineText, isFirstLine, linePos, stack, anchorPosition);\n  if (!injectionResult) {\n    return matchResult;\n  }\n  if (!matchResult) {\n    return injectionResult;\n  }\n  const matchResultScore = matchResult.captureIndices[0].start;\n  const injectionResultScore = injectionResult.captureIndices[0].start;\n  if (injectionResultScore \u003c matchResultScore || injectionResult.priorityMatch \u0026\u0026 injectionResultScore === matchResultScore) {\n    return injectionResult;\n  }\n  return matchResult;\n}\nfunction matchRule(grammar, lineText, isFirstLine, linePos, stack, anchorPosition) {\n  const rule = stack.getRule(grammar);\n  const { ruleScanner, findOptions } = prepareRuleSearch(rule, grammar, stack.endRule, isFirstLine, linePos === anchorPosition);\n  const r = ruleScanner.findNextMatchSync(lineText, linePos, findOptions);\n  if (r) {\n    return {\n      captureIndices: r.captureIndices,\n      matchedRuleId: r.ruleId\n    };\n  }\n  return null;\n}\nfunction matchInjections(injections, grammar, lineText, isFirstLine, linePos, stack, anchorPosition) {\n  let bestMatchRating = Number.MAX_VALUE;\n  let bestMatchCaptureIndices = null;\n  let bestMatchRuleId;\n  let bestMatchResultPriority = 0;\n  const scopes = stack.contentNameScopesList.getScopeNames();\n  for (let i = 0, len = injections.length; i \u003c len; i++) {\n    const injection = injections[i];\n    if (!injection.matcher(scopes)) {\n      continue;\n    }\n    const rule = grammar.getRule(injection.ruleId);\n    const { ruleScanner, findOptions } = prepareRuleSearch(rule, grammar, null, isFirstLine, linePos === anchorPosition);\n    const matchResult = ruleScanner.findNextMatchSync(lineText, linePos, findOptions);\n    if (!matchResult) {\n      continue;\n    }\n    if (false) {\n      console.log(`  matched injection: ${injection.debugSelector}`);\n      console.log(ruleScanner.toString());\n    }\n    const matchRating = matchResult.captureIndices[0].start;\n    if (matchRating \u003e= bestMatchRating) {\n      continue;\n    }\n    bestMatchRating = matchRating;\n    bestMatchCaptureIndices = matchResult.captureIndices;\n    bestMatchRuleId = matchResult.ruleId;\n    bestMatchResultPriority = injection.priority;\n    if (bestMatchRating === linePos) {\n      break;\n    }\n  }\n  if (bestMatchCaptureIndices) {\n    return {\n      priorityMatch: bestMatchResultPriority === -1,\n      captureIndices: bestMatchCaptureIndices,\n      matchedRuleId: bestMatchRuleId\n    };\n  }\n  return null;\n}\nfunction prepareRuleSearch(rule, grammar, endRegexSource, allowA, allowG) {\n  if (UseOnigurumaFindOptions) {\n    const ruleScanner2 = rule.compile(grammar, endRegexSource);\n    const findOptions = getFindOptions(allowA, allowG);\n    return { ruleScanner: ruleScanner2, findOptions };\n  }\n  const ruleScanner = rule.compileAG(grammar, endRegexSource, allowA, allowG);\n  return { ruleScanner, findOptions: 0 /* None */ };\n}\nfunction prepareRuleWhileSearch(rule, grammar, endRegexSource, allowA, allowG) {\n  if (UseOnigurumaFindOptions) {\n    const ruleScanner2 = rule.compileWhile(grammar, endRegexSource);\n    const findOptions = getFindOptions(allowA, allowG);\n    return { ruleScanner: ruleScanner2, findOptions };\n  }\n  const ruleScanner = rule.compileWhileAG(grammar, endRegexSource, allowA, allowG);\n  return { ruleScanner, findOptions: 0 /* None */ };\n}\nfunction getFindOptions(allowA, allowG) {\n  let options = 0 /* None */;\n  if (!allowA) {\n    options |= 1 /* NotBeginString */;\n  }\n  if (!allowG) {\n    options |= 4 /* NotBeginPosition */;\n  }\n  return options;\n}\nfunction handleCaptures(grammar, lineText, isFirstLine, stack, lineTokens, captures, captureIndices) {\n  if (captures.length === 0) {\n    return;\n  }\n  const lineTextContent = lineText.content;\n  const len = Math.min(captures.length, captureIndices.length);\n  const localStack = [];\n  const maxEnd = captureIndices[0].end;\n  for (let i = 0; i \u003c len; i++) {\n    const captureRule = captures[i];\n    if (captureRule === null) {\n      continue;\n    }\n    const captureIndex = captureIndices[i];\n    if (captureIndex.length === 0) {\n      continue;\n    }\n    if (captureIndex.start \u003e maxEnd) {\n      break;\n    }\n    while (localStack.length \u003e 0 \u0026\u0026 localStack[localStack.length - 1].endPos \u003c= captureIndex.start) {\n      lineTokens.produceFromScopes(localStack[localStack.length - 1].scopes, localStack[localStack.length - 1].endPos);\n      localStack.pop();\n    }\n    if (localStack.length \u003e 0) {\n      lineTokens.produceFromScopes(localStack[localStack.length - 1].scopes, captureIndex.start);\n    } else {\n      lineTokens.produce(stack, captureIndex.start);\n    }\n    if (captureRule.retokenizeCapturedWithRuleId) {\n      const scopeName = captureRule.getName(lineTextContent, captureIndices);\n      const nameScopesList = stack.contentNameScopesList.pushAttributed(scopeName, grammar);\n      const contentName = captureRule.getContentName(lineTextContent, captureIndices);\n      const contentNameScopesList = nameScopesList.pushAttributed(contentName, grammar);\n      const stackClone = stack.push(captureRule.retokenizeCapturedWithRuleId, captureIndex.start, -1, false, null, nameScopesList, contentNameScopesList);\n      const onigSubStr = grammar.createOnigString(lineTextContent.substring(0, captureIndex.end));\n      _tokenizeString(\n        grammar,\n        onigSubStr,\n        isFirstLine \u0026\u0026 captureIndex.start === 0,\n        captureIndex.start,\n        stackClone,\n        lineTokens,\n        false,\n        /* no time limit */\n        0\n      );\n      disposeOnigString(onigSubStr);\n      continue;\n    }\n    const captureRuleScopeName = captureRule.getName(lineTextContent, captureIndices);\n    if (captureRuleScopeName !== null) {\n      const base = localStack.length \u003e 0 ? localStack[localStack.length - 1].scopes : stack.contentNameScopesList;\n      const captureRuleScopesList = base.pushAttributed(captureRuleScopeName, grammar);\n      localStack.push(new LocalStackElement(captureRuleScopesList, captureIndex.end));\n    }\n  }\n  while (localStack.length \u003e 0) {\n    lineTokens.produceFromScopes(localStack[localStack.length - 1].scopes, localStack[localStack.length - 1].endPos);\n    localStack.pop();\n  }\n}\nvar LocalStackElement = class {\n  scopes;\n  endPos;\n  constructor(scopes, endPos) {\n    this.scopes = scopes;\n    this.endPos = endPos;\n  }\n};\n\n// src/grammar/grammar.ts\nfunction createGrammar(scopeName, grammar, initialLanguage, embeddedLanguages, tokenTypes, balancedBracketSelectors, grammarRepository, onigLib) {\n  return new Grammar(\n    scopeName,\n    grammar,\n    initialLanguage,\n    embeddedLanguages,\n    tokenTypes,\n    balancedBracketSelectors,\n    grammarRepository,\n    onigLib\n  );\n}\nfunction collectInjections(result, selector, rule, ruleFactoryHelper, grammar) {\n  const matchers = createMatchers(selector, nameMatcher);\n  const ruleId = RuleFactory.getCompiledRuleId(rule, ruleFactoryHelper, grammar.repository);\n  for (const matcher of matchers) {\n    result.push({\n      debugSelector: selector,\n      matcher: matcher.matcher,\n      ruleId,\n      grammar,\n      priority: matcher.priority\n    });\n  }\n}\nfunction nameMatcher(identifers, scopes) {\n  if (scopes.length \u003c identifers.length) {\n    return false;\n  }\n  let lastIndex = 0;\n  return identifers.every((identifier) =\u003e {\n    for (let i = lastIndex; i \u003c scopes.length; i++) {\n      if (scopesAreMatching(scopes[i], identifier)) {\n        lastIndex = i + 1;\n        return true;\n      }\n    }\n    return false;\n  });\n}\nfunction scopesAreMatching(thisScopeName, scopeName) {\n  if (!thisScopeName) {\n    return false;\n  }\n  if (thisScopeName === scopeName) {\n    return true;\n  }\n  const len = scopeName.length;\n  return thisScopeName.length \u003e len \u0026\u0026 thisScopeName.substr(0, len) === scopeName \u0026\u0026 thisScopeName[len] === \".\";\n}\nvar Grammar = class {\n  constructor(_rootScopeName, grammar, initialLanguage, embeddedLanguages, tokenTypes, balancedBracketSelectors, grammarRepository, _onigLib) {\n    this._rootScopeName = _rootScopeName;\n    this.balancedBracketSelectors = balancedBracketSelectors;\n    this._onigLib = _onigLib;\n    this._basicScopeAttributesProvider = new BasicScopeAttributesProvider(\n      initialLanguage,\n      embeddedLanguages\n    );\n    this._rootId = -1;\n    this._lastRuleId = 0;\n    this._ruleId2desc = [null];\n    this._includedGrammars = {};\n    this._grammarRepository = grammarRepository;\n    this._grammar = initGrammar(grammar, null);\n    this._injections = null;\n    this._tokenTypeMatchers = [];\n    if (tokenTypes) {\n      for (const selector of Object.keys(tokenTypes)) {\n        const matchers = createMatchers(selector, nameMatcher);\n        for (const matcher of matchers) {\n          this._tokenTypeMatchers.push({\n            matcher: matcher.matcher,\n            type: tokenTypes[selector]\n          });\n        }\n      }\n    }\n  }\n  _rootId;\n  _lastRuleId;\n  _ruleId2desc;\n  _includedGrammars;\n  _grammarRepository;\n  _grammar;\n  _injections;\n  _basicScopeAttributesProvider;\n  _tokenTypeMatchers;\n  get themeProvider() {\n    return this._grammarRepository;\n  }\n  dispose() {\n    for (const rule of this._ruleId2desc) {\n      if (rule) {\n        rule.dispose();\n      }\n    }\n  }\n  createOnigScanner(sources) {\n    return this._onigLib.createOnigScanner(sources);\n  }\n  createOnigString(sources) {\n    return this._onigLib.createOnigString(sources);\n  }\n  getMetadataForScope(scope) {\n    return this._basicScopeAttributesProvider.getBasicScopeAttributes(scope);\n  }\n  _collectInjections() {\n    const grammarRepository = {\n      lookup: (scopeName2) =\u003e {\n        if (scopeName2 === this._rootScopeName) {\n          return this._grammar;\n        }\n        return this.getExternalGrammar(scopeName2);\n      },\n      injections: (scopeName2) =\u003e {\n        return this._grammarRepository.injections(scopeName2);\n      }\n    };\n    const result = [];\n    const scopeName = this._rootScopeName;\n    const grammar = grammarRepository.lookup(scopeName);\n    if (grammar) {\n      const rawInjections = grammar.injections;\n      if (rawInjections) {\n        for (let expression in rawInjections) {\n          collectInjections(\n            result,\n            expression,\n            rawInjections[expression],\n            this,\n            grammar\n          );\n        }\n      }\n      const injectionScopeNames = this._grammarRepository.injections(scopeName);\n      if (injectionScopeNames) {\n        injectionScopeNames.forEach((injectionScopeName) =\u003e {\n          const injectionGrammar = this.getExternalGrammar(injectionScopeName);\n          if (injectionGrammar) {\n            const selector = injectionGrammar.injectionSelector;\n            if (selector) {\n              collectInjections(\n                result,\n                selector,\n                injectionGrammar,\n                this,\n                injectionGrammar\n              );\n            }\n          }\n        });\n      }\n    }\n    result.sort((i1, i2) =\u003e i1.priority - i2.priority);\n    return result;\n  }\n  getInjections() {\n    if (this._injections === null) {\n      this._injections = this._collectInjections();\n    }\n    return this._injections;\n  }\n  registerRule(factory) {\n    const id = ++this._lastRuleId;\n    const result = factory(ruleIdFromNumber(id));\n    this._ruleId2desc[id] = result;\n    return result;\n  }\n  getRule(ruleId) {\n    return this._ruleId2desc[ruleIdToNumber(ruleId)];\n  }\n  getExternalGrammar(scopeName, repository) {\n    if (this._includedGrammars[scopeName]) {\n      return this._includedGrammars[scopeName];\n    } else if (this._grammarRepository) {\n      const rawIncludedGrammar = this._grammarRepository.lookup(scopeName);\n      if (rawIncludedGrammar) {\n        this._includedGrammars[scopeName] = initGrammar(\n          rawIncludedGrammar,\n          repository \u0026\u0026 repository.$base\n        );\n        return this._includedGrammars[scopeName];\n      }\n    }\n    return void 0;\n  }\n  tokenizeLine(lineText, prevState, timeLimit = 0) {\n    const r = this._tokenize(lineText, prevState, false, timeLimit);\n    return {\n      tokens: r.lineTokens.getResult(r.ruleStack, r.lineLength),\n      ruleStack: r.ruleStack,\n      stoppedEarly: r.stoppedEarly\n    };\n  }\n  tokenizeLine2(lineText, prevState, timeLimit = 0) {\n    const r = this._tokenize(lineText, prevState, true, timeLimit);\n    return {\n      tokens: r.lineTokens.getBinaryResult(r.ruleStack, r.lineLength),\n      ruleStack: r.ruleStack,\n      stoppedEarly: r.stoppedEarly\n    };\n  }\n  _tokenize(lineText, prevState, emitBinaryTokens, timeLimit) {\n    if (this._rootId === -1) {\n      this._rootId = RuleFactory.getCompiledRuleId(\n        this._grammar.repository.$self,\n        this,\n        this._grammar.repository\n      );\n      this.getInjections();\n    }\n    let isFirstLine;\n    if (!prevState || prevState === StateStackImpl.NULL) {\n      isFirstLine = true;\n      const rawDefaultMetadata = this._basicScopeAttributesProvider.getDefaultAttributes();\n      const defaultStyle = this.themeProvider.getDefaults();\n      const defaultMetadata = EncodedTokenMetadata.set(\n        0,\n        rawDefaultMetadata.languageId,\n        rawDefaultMetadata.tokenType,\n        null,\n        defaultStyle.fontStyle,\n        defaultStyle.foregroundId,\n        defaultStyle.backgroundId\n      );\n      const rootScopeName = this.getRule(this._rootId).getName(\n        null,\n        null\n      );\n      let scopeList;\n      if (rootScopeName) {\n        scopeList = AttributedScopeStack.createRootAndLookUpScopeName(\n          rootScopeName,\n          defaultMetadata,\n          this\n        );\n      } else {\n        scopeList = AttributedScopeStack.createRoot(\n          \"unknown\",\n          defaultMetadata\n        );\n      }\n      prevState = new StateStackImpl(\n        null,\n        this._rootId,\n        -1,\n        -1,\n        false,\n        null,\n        scopeList,\n        scopeList\n      );\n    } else {\n      isFirstLine = false;\n      prevState.reset();\n    }\n    lineText = lineText + \"\\n\";\n    const onigLineText = this.createOnigString(lineText);\n    const lineLength = onigLineText.content.length;\n    const lineTokens = new LineTokens(\n      emitBinaryTokens,\n      lineText,\n      this._tokenTypeMatchers,\n      this.balancedBracketSelectors\n    );\n    const r = _tokenizeString(\n      this,\n      onigLineText,\n      isFirstLine,\n      0,\n      prevState,\n      lineTokens,\n      true,\n      timeLimit\n    );\n    disposeOnigString(onigLineText);\n    return {\n      lineLength,\n      lineTokens,\n      ruleStack: r.stack,\n      stoppedEarly: r.stoppedEarly\n    };\n  }\n};\nfunction initGrammar(grammar, base) {\n  grammar = clone(grammar);\n  grammar.repository = grammar.repository || {};\n  grammar.repository.$self = {\n    $vscodeTextmateLocation: grammar.$vscodeTextmateLocation,\n    patterns: grammar.patterns,\n    name: grammar.scopeName\n  };\n  grammar.repository.$base = base || grammar.repository.$self;\n  return grammar;\n}\nvar AttributedScopeStack = class _AttributedScopeStack {\n  /**\n   * Invariant:\n   * ```\n   * if (parent \u0026\u0026 !scopePath.extends(parent.scopePath)) {\n   * \tthrow new Error();\n   * }\n   * ```\n   */\n  constructor(parent, scopePath, tokenAttributes) {\n    this.parent = parent;\n    this.scopePath = scopePath;\n    this.tokenAttributes = tokenAttributes;\n  }\n  static fromExtension(namesScopeList, contentNameScopesList) {\n    let current = namesScopeList;\n    let scopeNames = namesScopeList?.scopePath ?? null;\n    for (const frame of contentNameScopesList) {\n      scopeNames = ScopeStack.push(scopeNames, frame.scopeNames);\n      current = new _AttributedScopeStack(current, scopeNames, frame.encodedTokenAttributes);\n    }\n    return current;\n  }\n  static createRoot(scopeName, tokenAttributes) {\n    return new _AttributedScopeStack(null, new ScopeStack(null, scopeName), tokenAttributes);\n  }\n  static createRootAndLookUpScopeName(scopeName, tokenAttributes, grammar) {\n    const rawRootMetadata = grammar.getMetadataForScope(scopeName);\n    const scopePath = new ScopeStack(null, scopeName);\n    const rootStyle = grammar.themeProvider.themeMatch(scopePath);\n    const resolvedTokenAttributes = _AttributedScopeStack.mergeAttributes(\n      tokenAttributes,\n      rawRootMetadata,\n      rootStyle\n    );\n    return new _AttributedScopeStack(null, scopePath, resolvedTokenAttributes);\n  }\n  get scopeName() {\n    return this.scopePath.scopeName;\n  }\n  toString() {\n    return this.getScopeNames().join(\" \");\n  }\n  equals(other) {\n    return _AttributedScopeStack.equals(this, other);\n  }\n  static equals(a, b) {\n    do {\n      if (a === b) {\n        return true;\n      }\n      if (!a \u0026\u0026 !b) {\n        return true;\n      }\n      if (!a || !b) {\n        return false;\n      }\n      if (a.scopeName !== b.scopeName || a.tokenAttributes !== b.tokenAttributes) {\n        return false;\n      }\n      a = a.parent;\n      b = b.parent;\n    } while (true);\n  }\n  static mergeAttributes(existingTokenAttributes, basicScopeAttributes, styleAttributes) {\n    let fontStyle = -1 /* NotSet */;\n    let foreground = 0;\n    let background = 0;\n    if (styleAttributes !== null) {\n      fontStyle = styleAttributes.fontStyle;\n      foreground = styleAttributes.foregroundId;\n      background = styleAttributes.backgroundId;\n    }\n    return EncodedTokenMetadata.set(\n      existingTokenAttributes,\n      basicScopeAttributes.languageId,\n      basicScopeAttributes.tokenType,\n      null,\n      fontStyle,\n      foreground,\n      background\n    );\n  }\n  pushAttributed(scopePath, grammar) {\n    if (scopePath === null) {\n      return this;\n    }\n    if (scopePath.indexOf(\" \") === -1) {\n      return _AttributedScopeStack._pushAttributed(this, scopePath, grammar);\n    }\n    const scopes = scopePath.split(/ /g);\n    let result = this;\n    for (const scope of scopes) {\n      result = _AttributedScopeStack._pushAttributed(result, scope, grammar);\n    }\n    return result;\n  }\n  static _pushAttributed(target, scopeName, grammar) {\n    const rawMetadata = grammar.getMetadataForScope(scopeName);\n    const newPath = target.scopePath.push(scopeName);\n    const scopeThemeMatchResult = grammar.themeProvider.themeMatch(newPath);\n    const metadata = _AttributedScopeStack.mergeAttributes(\n      target.tokenAttributes,\n      rawMetadata,\n      scopeThemeMatchResult\n    );\n    return new _AttributedScopeStack(target, newPath, metadata);\n  }\n  getScopeNames() {\n    return this.scopePath.getSegments();\n  }\n  getExtensionIfDefined(base) {\n    const result = [];\n    let self = this;\n    while (self \u0026\u0026 self !== base) {\n      result.push({\n        encodedTokenAttributes: self.tokenAttributes,\n        scopeNames: self.scopePath.getExtensionIfDefined(self.parent?.scopePath ?? null)\n      });\n      self = self.parent;\n    }\n    return self === base ? result.reverse() : void 0;\n  }\n};\nvar StateStackImpl = class _StateStackImpl {\n  /**\n   * Invariant:\n   * ```\n   * if (contentNameScopesList !== nameScopesList \u0026\u0026 contentNameScopesList?.parent !== nameScopesList) {\n   * \tthrow new Error();\n   * }\n   * if (this.parent \u0026\u0026 !nameScopesList.extends(this.parent.contentNameScopesList)) {\n   * \tthrow new Error();\n   * }\n   * ```\n   */\n  constructor(parent, ruleId, enterPos, anchorPos, beginRuleCapturedEOL, endRule, nameScopesList, contentNameScopesList) {\n    this.parent = parent;\n    this.ruleId = ruleId;\n    this.beginRuleCapturedEOL = beginRuleCapturedEOL;\n    this.endRule = endRule;\n    this.nameScopesList = nameScopesList;\n    this.contentNameScopesList = contentNameScopesList;\n    this.depth = this.parent ? this.parent.depth + 1 : 1;\n    this._enterPos = enterPos;\n    this._anchorPos = anchorPos;\n  }\n  _stackElementBrand = void 0;\n  // TODO remove me\n  static NULL = new _StateStackImpl(\n    null,\n    0,\n    0,\n    0,\n    false,\n    null,\n    null,\n    null\n  );\n  /**\n   * The position on the current line where this state was pushed.\n   * This is relevant only while tokenizing a line, to detect endless loops.\n   * Its value is meaningless across lines.\n   */\n  _enterPos;\n  /**\n   * The captured anchor position when this stack element was pushed.\n   * This is relevant only while tokenizing a line, to restore the anchor position when popping.\n   * Its value is meaningless across lines.\n   */\n  _anchorPos;\n  /**\n   * The depth of the stack.\n   */\n  depth;\n  equals(other) {\n    if (other === null) {\n      return false;\n    }\n    return _StateStackImpl._equals(this, other);\n  }\n  static _equals(a, b) {\n    if (a === b) {\n      return true;\n    }\n    if (!this._structuralEquals(a, b)) {\n      return false;\n    }\n    return AttributedScopeStack.equals(a.contentNameScopesList, b.contentNameScopesList);\n  }\n  /**\n   * A structural equals check. Does not take into account `scopes`.\n   */\n  static _structuralEquals(a, b) {\n    do {\n      if (a === b) {\n        return true;\n      }\n      if (!a \u0026\u0026 !b) {\n        return true;\n      }\n      if (!a || !b) {\n        return false;\n      }\n      if (a.depth !== b.depth || a.ruleId !== b.ruleId || a.endRule !== b.endRule) {\n        return false;\n      }\n      a = a.parent;\n      b = b.parent;\n    } while (true);\n  }\n  clone() {\n    return this;\n  }\n  static _reset(el) {\n    while (el) {\n      el._enterPos = -1;\n      el._anchorPos = -1;\n      el = el.parent;\n    }\n  }\n  reset() {\n    _StateStackImpl._reset(this);\n  }\n  pop() {\n    return this.parent;\n  }\n  safePop() {\n    if (this.parent) {\n      return this.parent;\n    }\n    return this;\n  }\n  push(ruleId, enterPos, anchorPos, beginRuleCapturedEOL, endRule, nameScopesList, contentNameScopesList) {\n    return new _StateStackImpl(\n      this,\n      ruleId,\n      enterPos,\n      anchorPos,\n      beginRuleCapturedEOL,\n      endRule,\n      nameScopesList,\n      contentNameScopesList\n    );\n  }\n  getEnterPos() {\n    return this._enterPos;\n  }\n  getAnchorPos() {\n    return this._anchorPos;\n  }\n  getRule(grammar) {\n    return grammar.getRule(this.ruleId);\n  }\n  toString() {\n    const r = [];\n    this._writeString(r, 0);\n    return \"[\" + r.join(\",\") + \"]\";\n  }\n  _writeString(res, outIndex) {\n    if (this.parent) {\n      outIndex = this.parent._writeString(res, outIndex);\n    }\n    res[outIndex++] = `(${this.ruleId}, ${this.nameScopesList?.toString()}, ${this.contentNameScopesList?.toString()})`;\n    return outIndex;\n  }\n  withContentNameScopesList(contentNameScopeStack) {\n    if (this.contentNameScopesList === contentNameScopeStack) {\n      return this;\n    }\n    return this.parent.push(\n      this.ruleId,\n      this._enterPos,\n      this._anchorPos,\n      this.beginRuleCapturedEOL,\n      this.endRule,\n      this.nameScopesList,\n      contentNameScopeStack\n    );\n  }\n  withEndRule(endRule) {\n    if (this.endRule === endRule) {\n      return this;\n    }\n    return new _StateStackImpl(\n      this.parent,\n      this.ruleId,\n      this._enterPos,\n      this._anchorPos,\n      this.beginRuleCapturedEOL,\n      endRule,\n      this.nameScopesList,\n      this.contentNameScopesList\n    );\n  }\n  // Used to warn of endless loops\n  hasSameRuleAs(other) {\n    let el = this;\n    while (el \u0026\u0026 el._enterPos === other._enterPos) {\n      if (el.ruleId === other.ruleId) {\n        return true;\n      }\n      el = el.parent;\n    }\n    return false;\n  }\n  toStateStackFrame() {\n    return {\n      ruleId: ruleIdToNumber(this.ruleId),\n      beginRuleCapturedEOL: this.beginRuleCapturedEOL,\n      endRule: this.endRule,\n      nameScopesList: this.nameScopesList?.getExtensionIfDefined(this.parent?.nameScopesList ?? null) ?? [],\n      contentNameScopesList: this.contentNameScopesList?.getExtensionIfDefined(this.nameScopesList) ?? []\n    };\n  }\n  static pushFrame(self, frame) {\n    const namesScopeList = AttributedScopeStack.fromExtension(self?.nameScopesList ?? null, frame.nameScopesList);\n    return new _StateStackImpl(\n      self,\n      ruleIdFromNumber(frame.ruleId),\n      frame.enterPos ?? -1,\n      frame.anchorPos ?? -1,\n      frame.beginRuleCapturedEOL,\n      frame.endRule,\n      namesScopeList,\n      AttributedScopeStack.fromExtension(namesScopeList, frame.contentNameScopesList)\n    );\n  }\n};\nvar BalancedBracketSelectors = class {\n  balancedBracketScopes;\n  unbalancedBracketScopes;\n  allowAny = false;\n  constructor(balancedBracketScopes, unbalancedBracketScopes) {\n    this.balancedBracketScopes = balancedBracketScopes.flatMap(\n      (selector) =\u003e {\n        if (selector === \"*\") {\n          this.allowAny = true;\n          return [];\n        }\n        return createMatchers(selector, nameMatcher).map((m) =\u003e m.matcher);\n      }\n    );\n    this.unbalancedBracketScopes = unbalancedBracketScopes.flatMap(\n      (selector) =\u003e createMatchers(selector, nameMatcher).map((m) =\u003e m.matcher)\n    );\n  }\n  get matchesAlways() {\n    return this.allowAny \u0026\u0026 this.unbalancedBracketScopes.length === 0;\n  }\n  get matchesNever() {\n    return this.balancedBracketScopes.length === 0 \u0026\u0026 !this.allowAny;\n  }\n  match(scopes) {\n    for (const excluder of this.unbalancedBracketScopes) {\n      if (excluder(scopes)) {\n        return false;\n      }\n    }\n    for (const includer of this.balancedBracketScopes) {\n      if (includer(scopes)) {\n        return true;\n      }\n    }\n    return this.allowAny;\n  }\n};\nvar LineTokens = class {\n  constructor(emitBinaryTokens, lineText, tokenTypeOverrides, balancedBracketSelectors) {\n    this.balancedBracketSelectors = balancedBracketSelectors;\n    this._emitBinaryTokens = emitBinaryTokens;\n    this._tokenTypeOverrides = tokenTypeOverrides;\n    if (false) {\n      this._lineText = lineText;\n    } else {\n      this._lineText = null;\n    }\n    this._tokens = [];\n    this._binaryTokens = [];\n    this._lastTokenEndIndex = 0;\n  }\n  _emitBinaryTokens;\n  /**\n   * defined only if `false`.\n   */\n  _lineText;\n  /**\n   * used only if `_emitBinaryTokens` is false.\n   */\n  _tokens;\n  /**\n   * used only if `_emitBinaryTokens` is true.\n   */\n  _binaryTokens;\n  _lastTokenEndIndex;\n  _tokenTypeOverrides;\n  produce(stack, endIndex) {\n    this.produceFromScopes(stack.contentNameScopesList, endIndex);\n  }\n  produceFromScopes(scopesList, endIndex) {\n    if (this._lastTokenEndIndex \u003e= endIndex) {\n      return;\n    }\n    if (this._emitBinaryTokens) {\n      let metadata = scopesList?.tokenAttributes ?? 0;\n      let containsBalancedBrackets = false;\n      if (this.balancedBracketSelectors?.matchesAlways) {\n        containsBalancedBrackets = true;\n      }\n      if (this._tokenTypeOverrides.length \u003e 0 || this.balancedBracketSelectors \u0026\u0026 !this.balancedBracketSelectors.matchesAlways \u0026\u0026 !this.balancedBracketSelectors.matchesNever) {\n        const scopes2 = scopesList?.getScopeNames() ?? [];\n        for (const tokenType of this._tokenTypeOverrides) {\n          if (tokenType.matcher(scopes2)) {\n            metadata = EncodedTokenMetadata.set(\n              metadata,\n              0,\n              toOptionalTokenType(tokenType.type),\n              null,\n              -1 /* NotSet */,\n              0,\n              0\n            );\n          }\n        }\n        if (this.balancedBracketSelectors) {\n          containsBalancedBrackets = this.balancedBracketSelectors.match(scopes2);\n        }\n      }\n      if (containsBalancedBrackets) {\n        metadata = EncodedTokenMetadata.set(\n          metadata,\n          0,\n          8 /* NotSet */,\n          containsBalancedBrackets,\n          -1 /* NotSet */,\n          0,\n          0\n        );\n      }\n      if (this._binaryTokens.length \u003e 0 \u0026\u0026 this._binaryTokens[this._binaryTokens.length - 1] === metadata) {\n        this._lastTokenEndIndex = endIndex;\n        return;\n      }\n      this._binaryTokens.push(this._lastTokenEndIndex);\n      this._binaryTokens.push(metadata);\n      this._lastTokenEndIndex = endIndex;\n      return;\n    }\n    const scopes = scopesList?.getScopeNames() ?? [];\n    this._tokens.push({\n      startIndex: this._lastTokenEndIndex,\n      endIndex,\n      // value: lineText.substring(lastTokenEndIndex, endIndex),\n      scopes\n    });\n    this._lastTokenEndIndex = endIndex;\n  }\n  getResult(stack, lineLength) {\n    if (this._tokens.length \u003e 0 \u0026\u0026 this._tokens[this._tokens.length - 1].startIndex === lineLength - 1) {\n      this._tokens.pop();\n    }\n    if (this._tokens.length === 0) {\n      this._lastTokenEndIndex = -1;\n      this.produce(stack, lineLength);\n      this._tokens[this._tokens.length - 1].startIndex = 0;\n    }\n    return this._tokens;\n  }\n  getBinaryResult(stack, lineLength) {\n    if (this._binaryTokens.length \u003e 0 \u0026\u0026 this._binaryTokens[this._binaryTokens.length - 2] === lineLength - 1) {\n      this._binaryTokens.pop();\n      this._binaryTokens.pop();\n    }\n    if (this._binaryTokens.length === 0) {\n      this._lastTokenEndIndex = -1;\n      this.produce(stack, lineLength);\n      this._binaryTokens[this._binaryTokens.length - 2] = 0;\n    }\n    const result = new Uint32Array(this._binaryTokens.length);\n    for (let i = 0, len = this._binaryTokens.length; i \u003c len; i++) {\n      result[i] = this._binaryTokens[i];\n    }\n    return result;\n  }\n};\n\n// src/registry.ts\nvar SyncRegistry = class {\n  constructor(theme, _onigLib) {\n    this._onigLib = _onigLib;\n    this._theme = theme;\n  }\n  _grammars = /* @__PURE__ */ new Map();\n  _rawGrammars = /* @__PURE__ */ new Map();\n  _injectionGrammars = /* @__PURE__ */ new Map();\n  _theme;\n  dispose() {\n    for (const grammar of this._grammars.values()) {\n      grammar.dispose();\n    }\n  }\n  setTheme(theme) {\n    this._theme = theme;\n  }\n  getColorMap() {\n    return this._theme.getColorMap();\n  }\n  /**\n   * Add `grammar` to registry and return a list of referenced scope names\n   */\n  addGrammar(grammar, injectionScopeNames) {\n    this._rawGrammars.set(grammar.scopeName, grammar);\n    if (injectionScopeNames) {\n      this._injectionGrammars.set(grammar.scopeName, injectionScopeNames);\n    }\n  }\n  /**\n   * Lookup a raw grammar.\n   */\n  lookup(scopeName) {\n    return this._rawGrammars.get(scopeName);\n  }\n  /**\n   * Returns the injections for the given grammar\n   */\n  injections(targetScope) {\n    return this._injectionGrammars.get(targetScope);\n  }\n  /**\n   * Get the default theme settings\n   */\n  getDefaults() {\n    return this._theme.getDefaults();\n  }\n  /**\n   * Match a scope in the theme.\n   */\n  themeMatch(scopePath) {\n    return this._theme.match(scopePath);\n  }\n  /**\n   * Lookup a grammar.\n   */\n  grammarForScopeName(scopeName, initialLanguage, embeddedLanguages, tokenTypes, balancedBracketSelectors) {\n    if (!this._grammars.has(scopeName)) {\n      let rawGrammar = this._rawGrammars.get(scopeName);\n      if (!rawGrammar) {\n        return null;\n      }\n      this._grammars.set(scopeName, createGrammar(\n        scopeName,\n        rawGrammar,\n        initialLanguage,\n        embeddedLanguages,\n        tokenTypes,\n        balancedBracketSelectors,\n        this,\n        this._onigLib\n      ));\n    }\n    return this._grammars.get(scopeName);\n  }\n};\n\n// src/index.ts\nvar Registry = class {\n  _options;\n  _syncRegistry;\n  _ensureGrammarCache;\n  constructor(options) {\n    this._options = options;\n    this._syncRegistry = new SyncRegistry(\n      Theme.createFromRawTheme(options.theme, options.colorMap),\n      options.onigLib\n    );\n    this._ensureGrammarCache = /* @__PURE__ */ new Map();\n  }\n  dispose() {\n    this._syncRegistry.dispose();\n  }\n  /**\n   * Change the theme. Once called, no previous `ruleStack` should be used anymore.\n   */\n  setTheme(theme, colorMap) {\n    this._syncRegistry.setTheme(Theme.createFromRawTheme(theme, colorMap));\n  }\n  /**\n   * Returns a lookup array for color ids.\n   */\n  getColorMap() {\n    return this._syncRegistry.getColorMap();\n  }\n  /**\n   * Load the grammar for `scopeName` and all referenced included grammars asynchronously.\n   * Please do not use language id 0.\n   */\n  loadGrammarWithEmbeddedLanguages(initialScopeName, initialLanguage, embeddedLanguages) {\n    return this.loadGrammarWithConfiguration(initialScopeName, initialLanguage, { embeddedLanguages });\n  }\n  /**\n   * Load the grammar for `scopeName` and all referenced included grammars asynchronously.\n   * Please do not use language id 0.\n   */\n  loadGrammarWithConfiguration(initialScopeName, initialLanguage, configuration) {\n    return this._loadGrammar(\n      initialScopeName,\n      initialLanguage,\n      configuration.embeddedLanguages,\n      configuration.tokenTypes,\n      new BalancedBracketSelectors(\n        configuration.balancedBracketSelectors || [],\n        configuration.unbalancedBracketSelectors || []\n      )\n    );\n  }\n  /**\n   * Load the grammar for `scopeName` and all referenced included grammars asynchronously.\n   */\n  loadGrammar(initialScopeName) {\n    return this._loadGrammar(initialScopeName, 0, null, null, null);\n  }\n  _loadGrammar(initialScopeName, initialLanguage, embeddedLanguages, tokenTypes, balancedBracketSelectors) {\n    const dependencyProcessor = new ScopeDependencyProcessor(this._syncRegistry, initialScopeName);\n    while (dependencyProcessor.Q.length \u003e 0) {\n      dependencyProcessor.Q.map((request) =\u003e this._loadSingleGrammar(request.scopeName));\n      dependencyProcessor.processQueue();\n    }\n    return this._grammarForScopeName(\n      initialScopeName,\n      initialLanguage,\n      embeddedLanguages,\n      tokenTypes,\n      balancedBracketSelectors\n    );\n  }\n  _loadSingleGrammar(scopeName) {\n    if (!this._ensureGrammarCache.has(scopeName)) {\n      this._doLoadSingleGrammar(scopeName);\n      this._ensureGrammarCache.set(scopeName, true);\n    }\n  }\n  _doLoadSingleGrammar(scopeName) {\n    const grammar = this._options.loadGrammar(scopeName);\n    if (grammar) {\n      const injections = typeof this._options.getInjections === \"function\" ? this._options.getInjections(scopeName) : void 0;\n      this._syncRegistry.addGrammar(grammar, injections);\n    }\n  }\n  /**\n   * Adds a rawGrammar.\n   */\n  addGrammar(rawGrammar, injections = [], initialLanguage = 0, embeddedLanguages = null) {\n    this._syncRegistry.addGrammar(rawGrammar, injections);\n    return this._grammarForScopeName(rawGrammar.scopeName, initialLanguage, embeddedLanguages);\n  }\n  /**\n   * Get the grammar for `scopeName`. The grammar must first be created via `loadGrammar` or `addGrammar`.\n   */\n  _grammarForScopeName(scopeName, initialLanguage = 0, embeddedLanguages = null, tokenTypes = null, balancedBracketSelectors = null) {\n    return this._syncRegistry.grammarForScopeName(\n      scopeName,\n      initialLanguage,\n      embeddedLanguages,\n      tokenTypes,\n      balancedBracketSelectors\n    );\n  }\n};\nvar INITIAL = StateStackImpl.NULL;\nexport {\n  EncodedTokenMetadata,\n  FindOption,\n  FontStyle,\n  INITIAL,\n  Registry,\n  Theme,\n  disposeOnigString\n};\n"],"version":3}