@vibecheck-ai/mcp 24.0.0 → 24.0.2

package/dist/index.js

@@ -515,12 +515,12 @@ var require_to_regex_range = __commonJS({
         }
         return `(?:${result})`;
       }
-      let isPadded = hasPadding(min2) || hasPadding(max2);
+      let isPadded2 = hasPadding(min2) || hasPadding(max2);
       let state = { min: min2, max: max2, a, b };
       let positives = [];
       let negatives = [];
-      if (isPadded) {
-        state.isPadded = isPadded;
+      if (isPadded2) {
+        state.isPadded = isPadded2;
         state.maxLen = String(state.max).length;
       }
       if (a < 0) {
@@ -811,21 +811,21 @@ var require_fill_range = __commonJS({
       }
       let parts2 = { negatives: [], positives: [] };
       let push = (num) => parts2[num < 0 ? "negatives" : "positives"].push(Math.abs(num));
-      let range = [];
+      let range2 = [];
       let index2 = 0;
       while (descending ? a >= b : a <= b) {
         if (options.toRegex === true && step > 1) {
           push(a);
         } else {
-          range.push(pad(format(a, index2), maxLen, toNumber));
+          range2.push(pad(format(a, index2), maxLen, toNumber));
         }
         a = descending ? a - step : a + step;
         index2++;
       }
       if (options.toRegex === true) {
-        return step > 1 ? toSequence(parts2, options, maxLen) : toRegex(range, null, { wrap: false, ...options });
+        return step > 1 ? toSequence(parts2, options, maxLen) : toRegex(range2, null, { wrap: false, ...options });
       }
-      return range;
+      return range2;
     };
     var fillLetters = (start2, end, step = 1, options = {}) => {
       if (!isNumber(start2) && start2.length > 1 || !isNumber(end) && end.length > 1) {
@@ -840,17 +840,17 @@ var require_fill_range = __commonJS({
       if (options.toRegex && step === 1) {
         return toRange(min2, max2, false, options);
       }
-      let range = [];
+      let range2 = [];
       let index2 = 0;
       while (descending ? a >= b : a <= b) {
-        range.push(format(a, index2));
+        range2.push(format(a, index2));
         a = descending ? a - step : a + step;
         index2++;
       }
       if (options.toRegex === true) {
-        return toRegex(range, null, { wrap: false, options });
+        return toRegex(range2, null, { wrap: false, options });
       }
-      return range;
+      return range2;
     };
     var fill = (start2, end, step, options = {}) => {
       if (end == null && isValidValue(start2)) {
@@ -915,9 +915,9 @@ var require_compile = __commonJS({
         }
         if (node.nodes && node.ranges > 0) {
           const args2 = utils.reduce(node.nodes);
-          const range = fill(...args2, { ...options, wrap: false, toRegex: true, strictZeros: true });
-          if (range.length !== 0) {
-            return args2.length > 1 && range.length > 1 ? `(${range})` : range;
+          const range2 = fill(...args2, { ...options, wrap: false, toRegex: true, strictZeros: true });
+          if (range2.length !== 0) {
+            return args2.length > 1 && range2.length > 1 ? `(${range2})` : range2;
           }
         }
         if (node.nodes) {
@@ -985,11 +985,11 @@ var require_expand = __commonJS({
           if (utils.exceedsLimit(...args2, options.step, rangeLimit)) {
             throw new RangeError("expanded array length exceeds range limit. Use options.rangeLimit to increase or disable the limit.");
           }
-          let range = fill(...args2, options);
-          if (range.length === 0) {
-            range = stringify(node, options);
+          let range2 = fill(...args2, options);
+          if (range2.length === 0) {
+            range2 = stringify(node, options);
           }
-          q.push(append(q.pop(), range));
+          q.push(append(q.pop(), range2));
           node.nodes = [];
           return;
         }
@@ -2418,17 +2418,17 @@ var require_parse2 = __commonJS({
           let output = ")";
           if (brace.dots === true) {
             const arr = tokens.slice();
-            const range = [];
+            const range2 = [];
             for (let i2 = arr.length - 1; i2 >= 0; i2--) {
               tokens.pop();
               if (arr[i2].type === "brace") {
                 break;
               }
               if (arr[i2].type !== "dots") {
-                range.unshift(arr[i2].value);
+                range2.unshift(arr[i2].value);
               }
             }
-            output = expandRange(range, opts);
+            output = expandRange(range2, opts);
             state.backtrack = true;
           }
           if (brace.comma !== true && brace.dots !== true) {
@@ -12744,9 +12744,9 @@ ${lanes.join("\n")}
         static tryParse(text) {
           const sets = parseRange(text);
           if (sets) {
-            const range = new _VersionRange("");
-            range._alternatives = sets;
-            return range;
+            const range2 = new _VersionRange("");
+            range2._alternatives = sets;
+            return range2;
           }
           return void 0;
         }
@@ -12769,15 +12769,15 @@ ${lanes.join("\n")}
       var rangeRegExp = /^([~^<>=]|<=|>=)?\s*([a-z0-9-+.*]+)$/i;
       function parseRange(text) {
         const alternatives = [];
-        for (let range of text.trim().split(logicalOrRegExp)) {
-          if (!range) continue;
+        for (let range2 of text.trim().split(logicalOrRegExp)) {
+          if (!range2) continue;
           const comparators = [];
-          range = range.trim();
-          const match2 = hyphenRegExp.exec(range);
+          range2 = range2.trim();
+          const match2 = hyphenRegExp.exec(range2);
           if (match2) {
             if (!parseHyphen(match2[1], match2[2], comparators)) return void 0;
           } else {
-            for (const simple of range.split(whitespaceRegExp)) {
+            for (const simple of range2.split(whitespaceRegExp)) {
               const match22 = rangeRegExp.exec(simple.trim());
               if (!match22 || !parseComparator(match22[1], match22[2], comparators)) return void 0;
             }
@@ -22946,17 +22946,17 @@ ${lanes.join("\n")}
       function textSpanContainsPosition(span, position) {
         return position >= span.start && position < textSpanEnd(span);
       }
-      function textRangeContainsPositionInclusive(range, position) {
-        return position >= range.pos && position <= range.end;
+      function textRangeContainsPositionInclusive(range2, position) {
+        return position >= range2.pos && position <= range2.end;
       }
       function textSpanContainsTextSpan(span, other) {
         return other.start >= span.start && textSpanEnd(other) <= textSpanEnd(span);
       }
-      function textSpanContainsTextRange(span, range) {
-        return range.pos >= span.start && range.end <= textSpanEnd(span);
+      function textSpanContainsTextRange(span, range2) {
+        return range2.pos >= span.start && range2.end <= textSpanEnd(span);
       }
-      function textRangeContainsTextSpan(range, span) {
-        return span.start >= range.pos && textSpanEnd(span) <= range.end;
+      function textRangeContainsTextSpan(range2, span) {
+        return span.start >= range2.pos && textSpanEnd(span) <= range2.end;
       }
       function textSpanOverlapsWith(span, other) {
         return textSpanOverlap(span, other) !== void 0;
@@ -22979,8 +22979,8 @@ ${lanes.join("\n")}
       function textSpanIntersectsWithPosition(span, position) {
         return position <= textSpanEnd(span) && position >= span.start;
       }
-      function textRangeIntersectsWithTextSpan(range, span) {
-        return textSpanIntersectsWith(span, range.pos, range.end - range.pos);
+      function textRangeIntersectsWithTextSpan(range2, span) {
+        return textSpanIntersectsWith(span, range2.pos, range2.end - range2.pos);
       }
       function textSpanIntersection(span1, span2) {
         const start2 = Math.max(span1.start, span2.start);
@@ -23019,11 +23019,11 @@ ${lanes.join("\n")}
       function createTextSpanFromBounds(start2, end) {
         return createTextSpan(start2, end - start2);
       }
-      function textChangeRangeNewSpan(range) {
-        return createTextSpan(range.span.start, range.newLength);
+      function textChangeRangeNewSpan(range2) {
+        return createTextSpan(range2.span.start, range2.newLength);
       }
-      function textChangeRangeIsUnchanged(range) {
-        return textSpanIsEmpty(range.span) && range.newLength === 0;
+      function textChangeRangeIsUnchanged(range2) {
+        return textSpanIsEmpty(range2.span) && range2.newLength === 0;
       }
       function createTextChangeRange(span, newLength) {
         if (newLength < 0) {
@@ -24456,8 +24456,8 @@ ${lanes.join("\n")}
         const type = isJSDocParameterTag(node) ? node.typeExpression && node.typeExpression.type : node.type;
         return node.dotDotDotToken !== void 0 || !!type && type.kind === 319;
       }
-      function hasInternalAnnotation(range, sourceFile) {
-        const comment = sourceFile.text.substring(range.pos, range.end);
+      function hasInternalAnnotation(range2, sourceFile) {
+        const comment = sourceFile.text.substring(range2.pos, range2.end);
         return comment.includes("@internal");
       }
       function isInternalDeclaration(node, sourceFile) {
@@ -24491,8 +24491,8 @@ ${lanes.join("\n")}
           return some(commentRanges) && hasInternalAnnotation(last(commentRanges), sourceFile);
         }
         const leadingCommentRanges = parseTreeNode && getLeadingCommentRangesOfNode(parseTreeNode, sourceFile);
-        return !!forEach(leadingCommentRanges, (range) => {
-          return hasInternalAnnotation(range, sourceFile);
+        return !!forEach(leadingCommentRanges, (range2) => {
+          return hasInternalAnnotation(range2, sourceFile);
         });
       }
       var resolvingEmptyArray = [];
@@ -24959,8 +24959,8 @@ ${lanes.join("\n")}
       function getTextOfNode(node, includeTrivia = false) {
         return getSourceTextOfNodeFromSourceFile(getSourceFileOfNode(node), node, includeTrivia);
       }
-      function getPos(range) {
-        return range.pos;
+      function getPos(range2) {
+        return range2.pos;
       }
       function indexOfNode(nodeArray, node) {
         return binarySearch(nodeArray, node, getPos, compareValues);
@@ -25892,11 +25892,11 @@ ${lanes.join("\n")}
           next: diagnostic.next
         } : diagnostic.messageText;
       }
-      function createDiagnosticForRange(sourceFile, range, message) {
+      function createDiagnosticForRange(sourceFile, range2, message) {
         return {
           file: sourceFile,
-          start: range.pos,
-          length: range.end - range.pos,
+          start: range2.pos,
+          length: range2.end - range2.pos,
           code: message.code,
           category: message.category,
           messageText: message.message
@@ -28025,8 +28025,8 @@ ${lanes.join("\n")}
         const kind = node.kind;
         return kind === 177 || kind === 219 || kind === 263 || kind === 220 || kind === 175 || kind === 178 || kind === 179 || kind === 268 || kind === 308;
       }
-      function nodeIsSynthesized(range) {
-        return positionIsSynthesized(range.pos) || positionIsSynthesized(range.end);
+      function nodeIsSynthesized(range2) {
+        return positionIsSynthesized(range2.pos) || positionIsSynthesized(range2.end);
       }
       var Associativity = /* @__PURE__ */ ((Associativity2) => {
         Associativity2[Associativity2["Left"] = 0] = "Left";
@@ -29519,11 +29519,11 @@ ${lanes.join("\n")}
         Debug.assert(end >= pos || end === -1);
         return { pos, end };
       }
-      function moveRangeEnd(range, end) {
-        return createRange(range.pos, end);
+      function moveRangeEnd(range2, end) {
+        return createRange(range2.pos, end);
       }
-      function moveRangePos(range, pos) {
-        return createRange(pos, range.end);
+      function moveRangePos(range2, pos) {
+        return createRange(pos, range2.end);
       }
       function moveRangePastDecorators(node) {
         const lastDecorator = canHaveModifiers(node) ? findLast(node.modifiers, isDecorator) : void 0;
@@ -29539,8 +29539,8 @@ ${lanes.join("\n")}
       function createTokenRange(pos, token) {
         return createRange(pos, pos + tokenToString(token).length);
       }
-      function rangeIsOnSingleLine(range, sourceFile) {
-        return rangeStartIsOnSameLineAsRangeEnd(range, range, sourceFile);
+      function rangeIsOnSingleLine(range2, sourceFile) {
+        return rangeStartIsOnSameLineAsRangeEnd(range2, range2, sourceFile);
       }
       function rangeStartPositionsAreOnSameLine(range1, range2, sourceFile) {
         return positionsAreOnSameLine(
@@ -29591,10 +29591,10 @@ ${lanes.join("\n")}
       function positionsAreOnSameLine(pos1, pos2, sourceFile) {
         return getLinesBetweenPositions(sourceFile, pos1, pos2) === 0;
       }
-      function getStartPositionOfRange(range, sourceFile, includeComments) {
-        return positionIsSynthesized(range.pos) ? -1 : skipTrivia(
+      function getStartPositionOfRange(range2, sourceFile, includeComments) {
+        return positionIsSynthesized(range2.pos) ? -1 : skipTrivia(
           sourceFile.text,
-          range.pos,
+          range2.pos,
           /*stopAfterLineBreak*/
           false,
           includeComments
@@ -29624,8 +29624,8 @@ ${lanes.join("\n")}
       function rangeContainsRange(r1, r2) {
         return startEndContainsRange(r1.pos, r1.end, r2);
       }
-      function startEndContainsRange(start2, end, range) {
-        return start2 <= range.pos && end >= range.end;
+      function startEndContainsRange(start2, end, range2) {
+        return start2 <= range2.pos && end >= range2.end;
       }
       function getPreviousNonWhitespacePosition(pos, stopPos = 0, sourceFile) {
         while (pos-- > stopPos) {
@@ -31476,19 +31476,19 @@ ${lanes.join("\n")}
         }
         return true;
       }
-      function setTextRangePos(range, pos) {
-        range.pos = pos;
-        return range;
+      function setTextRangePos(range2, pos) {
+        range2.pos = pos;
+        return range2;
       }
-      function setTextRangeEnd(range, end) {
-        range.end = end;
-        return range;
+      function setTextRangeEnd(range2, end) {
+        range2.end = end;
+        return range2;
       }
-      function setTextRangePosEnd(range, pos, end) {
-        return setTextRangeEnd(setTextRangePos(range, pos), end);
+      function setTextRangePosEnd(range2, pos, end) {
+        return setTextRangeEnd(setTextRangePos(range2, pos), end);
       }
-      function setTextRangePosWidth(range, pos, width) {
-        return setTextRangePosEnd(range, pos, pos + width);
+      function setTextRangePosWidth(range2, pos, width) {
+        return setTextRangePosEnd(range2, pos, pos + width);
       }
       function setNodeFlags(node, newFlags) {
         if (node) {
@@ -38743,18 +38743,18 @@ ${lanes.join("\n")}
         var _a2;
         return ((_a2 = node.emitNode) == null ? void 0 : _a2.sourceMapRange) ?? node;
       }
-      function setSourceMapRange(node, range) {
-        getOrCreateEmitNode(node).sourceMapRange = range;
+      function setSourceMapRange(node, range2) {
+        getOrCreateEmitNode(node).sourceMapRange = range2;
         return node;
       }
       function getTokenSourceMapRange(node, token) {
         var _a2, _b;
         return (_b = (_a2 = node.emitNode) == null ? void 0 : _a2.tokenSourceMapRanges) == null ? void 0 : _b[token];
       }
-      function setTokenSourceMapRange(node, token, range) {
+      function setTokenSourceMapRange(node, token, range2) {
         const emitNode = getOrCreateEmitNode(node);
         const tokenSourceMapRanges = emitNode.tokenSourceMapRanges ?? (emitNode.tokenSourceMapRanges = []);
-        tokenSourceMapRanges[token] = range;
+        tokenSourceMapRanges[token] = range2;
         return node;
       }
       function getStartsOnNewLine(node) {
@@ -38769,8 +38769,8 @@ ${lanes.join("\n")}
         var _a2;
         return ((_a2 = node.emitNode) == null ? void 0 : _a2.commentRange) ?? node;
       }
-      function setCommentRange(node, range) {
-        getOrCreateEmitNode(node).commentRange = range;
+      function setCommentRange(node, range2) {
+        getOrCreateEmitNode(node).commentRange = range2;
         return node;
       }
       function getSyntheticLeadingComments(node) {
@@ -41817,8 +41817,8 @@ ${lanes.join("\n")}
         }
         return false;
       }
-      function setTextRange(range, location) {
-        return location ? setTextRangePosEnd(range, location.pos, location.end) : range;
+      function setTextRange(range2, location) {
+        return location ? setTextRangePosEnd(range2, location.pos, location.end) : range2;
       }
       function canHaveModifiers(node) {
         const kind = node.kind;
@@ -43642,8 +43642,8 @@ ${lanes.join("\n")}
         function parseErrorAt(start2, end, message, ...args2) {
           return parseErrorAtPosition(start2, end - start2, message, ...args2);
         }
-        function parseErrorAtRange(range, message, ...args2) {
-          parseErrorAt(range.pos, range.end, message, ...args2);
+        function parseErrorAtRange(range2, message, ...args2) {
+          parseErrorAt(range2.pos, range2.end, message, ...args2);
         }
         function scanError(message, length2, arg0) {
           parseErrorAtPosition(scanner2.getTokenEnd(), length2, message, arg0);
@@ -50988,18 +50988,18 @@ ${lanes.join("\n")}
           let commentDirectives;
           let addedNewlyScannedDirectives = false;
           for (const directive of oldDirectives) {
-            const { range, type } = directive;
-            if (range.end < changeStart) {
+            const { range: range2, type } = directive;
+            if (range2.end < changeStart) {
               commentDirectives = append(commentDirectives, directive);
-            } else if (range.pos > changeRangeOldEnd) {
+            } else if (range2.pos > changeRangeOldEnd) {
               addNewlyScannedDirectives();
               const updatedDirective = {
-                range: { pos: range.pos + delta, end: range.end + delta },
+                range: { pos: range2.pos + delta, end: range2.end + delta },
                 type
               };
               commentDirectives = append(commentDirectives, updatedDirective);
               if (aggressiveChecks) {
-                Debug.assert(oldText.substring(range.pos, range.end) === newText.substring(updatedDirective.range.pos, updatedDirective.range.end));
+                Debug.assert(oldText.substring(range2.pos, range2.end) === newText.substring(updatedDirective.range.pos, updatedDirective.range.end));
               }
             }
           }
@@ -51331,9 +51331,9 @@ ${lanes.join("\n")}
       }
       function processCommentPragmas(context, sourceText) {
         const pragmas = [];
-        for (const range of getLeadingCommentRanges(sourceText, 0) || emptyArray) {
-          const comment = sourceText.substring(range.pos, range.end);
-          extractPragmas(pragmas, range, comment);
+        for (const range2 of getLeadingCommentRanges(sourceText, 0) || emptyArray) {
+          const comment = sourceText.substring(range2.pos, range2.end);
+          extractPragmas(pragmas, range2, comment);
         }
         context.pragmas = /* @__PURE__ */ new Map();
         for (const pragma of pragmas) {
@@ -51435,8 +51435,8 @@ ${lanes.join("\n")}
       }
       var tripleSlashXMLCommentStartRegEx = /^\/\/\/\s*<(\S+)\s.*?\/>/m;
       var singleLinePragmaRegEx = /^\/\/\/?\s*@([^\s:]+)((?:[^\S\r\n]|:).*)?$/m;
-      function extractPragmas(pragmas, range, text) {
-        const tripleSlash = range.kind === 2 && tripleSlashXMLCommentStartRegEx.exec(text);
+      function extractPragmas(pragmas, range2, text) {
+        const tripleSlash = range2.kind === 2 && tripleSlashXMLCommentStartRegEx.exec(text);
         if (tripleSlash) {
           const name2 = tripleSlash[1].toLowerCase();
           const pragma = commentPragmas[name2];
@@ -51453,7 +51453,7 @@ ${lanes.join("\n")}
               } else if (matchResult) {
                 const value = matchResult[2] || matchResult[3];
                 if (arg.captureSpan) {
-                  const startPos = range.pos + matchResult.index + matchResult[1].length + 1;
+                  const startPos = range2.pos + matchResult.index + matchResult[1].length + 1;
                   argument[arg.name] = {
                     value,
                     pos: startPos,
@@ -51464,25 +51464,25 @@ ${lanes.join("\n")}
                 }
               }
             }
-            pragmas.push({ name: name2, args: { arguments: argument, range } });
+            pragmas.push({ name: name2, args: { arguments: argument, range: range2 } });
           } else {
-            pragmas.push({ name: name2, args: { arguments: {}, range } });
+            pragmas.push({ name: name2, args: { arguments: {}, range: range2 } });
           }
           return;
         }
-        const singleLine = range.kind === 2 && singleLinePragmaRegEx.exec(text);
+        const singleLine = range2.kind === 2 && singleLinePragmaRegEx.exec(text);
         if (singleLine) {
-          return addPragmaForMatch(pragmas, range, 2, singleLine);
+          return addPragmaForMatch(pragmas, range2, 2, singleLine);
         }
-        if (range.kind === 3) {
+        if (range2.kind === 3) {
           const multiLinePragmaRegEx = /@(\S+)(\s+(?:\S.*)?)?$/gm;
           let multiLineMatch;
           while (multiLineMatch = multiLinePragmaRegEx.exec(text)) {
-            addPragmaForMatch(pragmas, range, 4, multiLineMatch);
+            addPragmaForMatch(pragmas, range2, 4, multiLineMatch);
           }
         }
       }
-      function addPragmaForMatch(pragmas, range, kind, match2) {
+      function addPragmaForMatch(pragmas, range2, kind, match2) {
         if (!match2) return;
         const name2 = match2[1].toLowerCase();
         const pragma = commentPragmas[name2];
@@ -51492,7 +51492,7 @@ ${lanes.join("\n")}
         const args2 = match2[2];
         const argument = getNamedPragmaArguments(pragma, args2);
         if (argument === "fail") return;
-        pragmas.push({ name: name2, args: { arguments: argument, range } });
+        pragmas.push({ name: name2, args: { arguments: argument, range: range2 } });
         return;
       }
       function getNamedPragmaArguments(pragma, text) {
@@ -57358,9 +57358,9 @@ ${lanes.join("\n")}
       function isApplicableVersionedTypesKey(conditions, key) {
         if (!conditions.includes("types")) return false;
         if (!startsWith(key, "types@")) return false;
-        const range = VersionRange.tryParse(key.substring("types@".length));
-        if (!range) return false;
-        return range.test(version3);
+        const range2 = VersionRange.tryParse(key.substring("types@".length));
+        if (!range2) return false;
+        return range2.test(version3);
       }
       function loadModuleFromNearestNodeModulesDirectory(extensions, moduleName, directory, state, cache, redirectedReference) {
         return loadModuleFromNearestNodeModulesDirectoryWorker(
@@ -59793,8 +59793,8 @@ ${lanes.join("\n")}
         function errorOrSuggestionOnRange(isError, startNode2, endNode2, message) {
           addErrorOrSuggestionDiagnostic(isError, { pos: getTokenPosOfNode(startNode2, file), end: endNode2.end }, message);
         }
-        function addErrorOrSuggestionDiagnostic(isError, range, message) {
-          const diag2 = createFileDiagnostic(file, range.pos, range.end - range.pos, message);
+        function addErrorOrSuggestionDiagnostic(isError, range2, message) {
+          const diag2 = createFileDiagnostic(file, range2.pos, range2.end - range2.pos, message);
           if (isError) {
             file.bindDiagnostics.push(diag2);
           } else {
@@ -67155,8 +67155,8 @@ ${lanes.join("\n")}
                 );
               }
             },
-            markNodeReuse(context, range, location) {
-              return setTextRange2(context, range, location);
+            markNodeReuse(context, range2, location) {
+              return setTextRange2(context, range2, location);
             },
             trackExistingEntityName(context, node) {
               return trackExistingEntityName(node, context);
@@ -67376,25 +67376,25 @@ ${lanes.join("\n")}
             const mappedType = instantiateType(type, context.mapper);
             return noMappedTypes && mappedType !== type ? void 0 : mappedType;
           }
-          function setTextRange2(context, range, location) {
-            if (!nodeIsSynthesized(range) || !(range.flags & 16) || !context.enclosingFile || context.enclosingFile !== getSourceFileOfNode(getOriginalNode(range))) {
-              range = factory.cloneNode(range);
+          function setTextRange2(context, range2, location) {
+            if (!nodeIsSynthesized(range2) || !(range2.flags & 16) || !context.enclosingFile || context.enclosingFile !== getSourceFileOfNode(getOriginalNode(range2))) {
+              range2 = factory.cloneNode(range2);
             }
-            if (range === location) return range;
+            if (range2 === location) return range2;
             if (!location) {
-              return range;
+              return range2;
             }
-            let original = range.original;
+            let original = range2.original;
             while (original && original !== location) {
               original = original.original;
             }
             if (!original) {
-              setOriginalNode(range, location);
+              setOriginalNode(range2, location);
             }
             if (context.enclosingFile && context.enclosingFile === getSourceFileOfNode(getOriginalNode(location))) {
-              return setTextRange(range, location);
+              return setTextRange(range2, location);
             }
-            return range;
+            return range2;
           }
           function symbolToNode(symbol, context, meaning) {
             if (context.internalFlags & 1) {
@@ -68808,7 +68808,7 @@ ${lanes.join("\n")}
               propertyTypeNode
             );
             typeElements.push(preserveCommentsOn(propertySignature, propertySymbol.valueDeclaration));
-            function preserveCommentsOn(node, range) {
+            function preserveCommentsOn(node, range2) {
               var _a22;
               const jsdocPropertyTag = (_a22 = propertySymbol.declarations) == null ? void 0 : _a22.find(
                 (d) => d.kind === 349
@@ -68819,15 +68819,15 @@ ${lanes.join("\n")}
                 if (commentText) {
                   setSyntheticLeadingComments(node, [{ kind: 3, text: "*\n * " + commentText.replace(/\n/g, "\n * ") + "\n ", pos: -1, end: -1, hasTrailingNewLine: true }]);
                 }
-              } else if (range) {
-                setCommentRange2(context, node, range);
+              } else if (range2) {
+                setCommentRange2(context, node, range2);
               }
               return node;
             }
           }
-          function setCommentRange2(context, node, range) {
-            if (context.enclosingFile && context.enclosingFile === getSourceFileOfNode(range)) {
-              return setCommentRange(node, range);
+          function setCommentRange2(context, node, range2) {
+            if (context.enclosingFile && context.enclosingFile === getSourceFileOfNode(range2)) {
+              return setCommentRange(node, range2);
             }
             return node;
           }
@@ -101681,10 +101681,10 @@ ${lanes.join("\n")}
             if (parent2.kind !== 196 && parent2.typeParameters.every(isTypeParameterUnused)) {
               if (tryAddToSet(seenParentsWithEveryUnused, parent2)) {
                 const sourceFile = getSourceFileOfNode(parent2);
-                const range = isJSDocTemplateTag(parent2) ? rangeOfNode(parent2) : rangeOfTypeParameters(sourceFile, parent2.typeParameters);
+                const range2 = isJSDocTemplateTag(parent2) ? rangeOfNode(parent2) : rangeOfTypeParameters(sourceFile, parent2.typeParameters);
                 const only = parent2.typeParameters.length === 1;
                 const messageAndArg = only ? [Diagnostics._0_is_declared_but_its_value_is_never_read, name2] : [Diagnostics.All_type_parameters_are_unused];
-                addDiagnostic(typeParameter, 1, createFileDiagnostic(sourceFile, range.pos, range.end - range.pos, ...messageAndArg));
+                addDiagnostic(typeParameter, 1, createFileDiagnostic(sourceFile, range2.pos, range2.end - range2.pos, ...messageAndArg));
               }
             } else {
               addDiagnostic(typeParameter, 1, createDiagnosticForNode(typeParameter, Diagnostics._0_is_declared_but_its_value_is_never_read, name2));
@@ -109202,10 +109202,10 @@ ${lanes.join("\n")}
         }
         function checkGrammarConstructorTypeParameters(node) {
           const jsdocTypeParameters = isInJSFile(node) ? getJSDocTypeParameterDeclarations(node) : void 0;
-          const range = node.typeParameters || jsdocTypeParameters && firstOrUndefined(jsdocTypeParameters);
-          if (range) {
-            const pos = range.pos === range.end ? range.pos : skipTrivia(getSourceFileOfNode(node).text, range.pos);
-            return grammarErrorAtPos(node, pos, range.end - pos, Diagnostics.Type_parameters_cannot_appear_on_a_constructor_declaration);
+          const range2 = node.typeParameters || jsdocTypeParameters && firstOrUndefined(jsdocTypeParameters);
+          if (range2) {
+            const pos = range2.pos === range2.end ? range2.pos : skipTrivia(getSourceFileOfNode(node).text, range2.pos);
+            return grammarErrorAtPos(node, pos, range2.end - pos, Diagnostics.Type_parameters_cannot_appear_on_a_constructor_declaration);
           }
         }
         function checkGrammarConstructorTypeAnnotation(node) {
@@ -142394,8 +142394,8 @@ ${lanes.join("\n")}
             pos
           );
         }
-        function emitDetachedCommentsAndUpdateCommentsInfo(range) {
-          const currentDetachedCommentInfo = currentSourceFile && emitDetachedComments(currentSourceFile.text, getCurrentLineMap(), writer, emitComment, range, newLine, commentsDisabled);
+        function emitDetachedCommentsAndUpdateCommentsInfo(range2) {
+          const currentDetachedCommentInfo = currentSourceFile && emitDetachedComments(currentSourceFile.text, getCurrentLineMap(), writer, emitComment, range2, newLine, commentsDisabled);
           if (currentDetachedCommentInfo) {
             if (detachedCommentsInfo) {
               detachedCommentsInfo.push(currentDetachedCommentInfo);
@@ -142475,14 +142475,14 @@ ${lanes.join("\n")}
           }
           const emitNode = node && node.emitNode;
           const emitFlags = emitNode && emitNode.flags || 0;
-          const range = emitNode && emitNode.tokenSourceMapRanges && emitNode.tokenSourceMapRanges[token];
-          const source = range && range.source || sourceMapSource;
-          tokenPos = skipSourceTrivia(source, range ? range.pos : tokenPos);
+          const range2 = emitNode && emitNode.tokenSourceMapRanges && emitNode.tokenSourceMapRanges[token];
+          const source = range2 && range2.source || sourceMapSource;
+          tokenPos = skipSourceTrivia(source, range2 ? range2.pos : tokenPos);
           if ((emitFlags & 256) === 0 && tokenPos >= 0) {
             emitSourcePos(source, tokenPos);
           }
           tokenPos = emitCallback(token, writer2, tokenPos);
-          if (range) tokenPos = range.end;
+          if (range2) tokenPos = range2.end;
           if ((emitFlags & 512) === 0 && tokenPos >= 0) {
             emitSourcePos(source, tokenPos);
           }
@@ -154806,8 +154806,8 @@ ${lanes.join("\n")}
             return tryReuseExistingTypeNode(context, existing);
           }
         };
-        function reuseNode(context, node, range = node) {
-          return node === void 0 ? void 0 : resolver.markNodeReuse(context, node.flags & 16 ? node : factory.cloneNode(node), range ?? node);
+        function reuseNode(context, node, range2 = node) {
+          return node === void 0 ? void 0 : resolver.markNodeReuse(context, node.flags & 16 ? node : factory.cloneNode(node), range2 ?? node);
         }
         function tryReuseExistingTypeNode(context, existing) {
           const { finalizeBoundary, startRecoveryScope, hadError, markError } = resolver.createRecoveryBoundary(context);
@@ -157087,8 +157087,8 @@ ${lanes.join("\n")}
       function rangeContainsPositionExclusive(r, pos) {
         return r.pos < pos && pos < r.end;
       }
-      function rangeContainsStartEnd(range, start2, end) {
-        return range.pos <= start2 && range.end >= end;
+      function rangeContainsStartEnd(range2, start2, end) {
+        return range2.pos <= start2 && range2.end >= end;
       }
       function rangeOverlapsWithStartEnd(r1, start2, end) {
         return startEndOverlapsWithStartEnd(r1.pos, r1.end, start2, end);
@@ -158021,13 +158021,13 @@ ${lanes.join("\n")}
         );
       }
       function isInReferenceCommentWorker(sourceFile, position, shouldBeReference) {
-        const range = isInComment(
+        const range2 = isInComment(
           sourceFile,
           position,
           /*tokenAtPosition*/
           void 0
         );
-        return !!range && shouldBeReference === tripleSlashDirectivePrefixRegex.test(sourceFile.text.substring(range.pos, range.end));
+        return !!range2 && shouldBeReference === tripleSlashDirectivePrefixRegex.test(sourceFile.text.substring(range2.pos, range2.end));
       }
       function getReplacementSpanForContextToken(contextToken, position) {
         if (!contextToken) return void 0;
@@ -158053,8 +158053,8 @@ ${lanes.join("\n")}
       function createTextRangeFromNode(node, sourceFile) {
         return createRange(node.getStart(sourceFile), node.end);
       }
-      function createTextSpanFromRange(range) {
-        return createTextSpanFromBounds(range.pos, range.end);
+      function createTextSpanFromRange(range2) {
+        return createTextSpanFromBounds(range2.pos, range2.end);
       }
       function createTextRangeFromSpan(span) {
         return createRange(span.start, span.start + span.length);
@@ -164628,9 +164628,9 @@ interface Symbol {
       function getRangeToExtract(context, considerEmptySpans = true) {
         const { file, startPosition } = context;
         const isJS = isSourceFileJS(file);
-        const range = createTextRangeFromSpan(getRefactorContextSpan(context));
-        const isCursorRequest = range.pos === range.end && considerEmptySpans;
-        const firstType = getFirstTypeAt(file, startPosition, range, isCursorRequest);
+        const range2 = createTextRangeFromSpan(getRefactorContextSpan(context));
+        const isCursorRequest = range2.pos === range2.end && considerEmptySpans;
+        const firstType = getFirstTypeAt(file, startPosition, range2, isCursorRequest);
         if (!firstType || !isTypeNode(firstType)) return { info: { error: getLocaleSpecificMessage(Diagnostics.Selection_is_not_a_valid_type_node) }, affectedTextRange: void 0 };
         const checker = context.program.getTypeChecker();
         const enclosingNode = getEnclosingNode(firstType, isJS);
@@ -164638,11 +164638,11 @@ interface Symbol {
         const expandedFirstType = getExpandedSelectionNode(firstType, enclosingNode);
         if (!isTypeNode(expandedFirstType)) return { info: { error: getLocaleSpecificMessage(Diagnostics.Selection_is_not_a_valid_type_node) }, affectedTextRange: void 0 };
         const typeList = [];
-        if ((isUnionTypeNode(expandedFirstType.parent) || isIntersectionTypeNode(expandedFirstType.parent)) && range.end > firstType.end) {
+        if ((isUnionTypeNode(expandedFirstType.parent) || isIntersectionTypeNode(expandedFirstType.parent)) && range2.end > firstType.end) {
           addRange(
             typeList,
             expandedFirstType.parent.types.filter((type) => {
-              return nodeOverlapsWithStartEnd(type, file, range.pos, range.end);
+              return nodeOverlapsWithStartEnd(type, file, range2.pos, range2.end);
             })
           );
         }
@@ -164652,15 +164652,15 @@ interface Symbol {
         const typeElements = flattenTypeLiteralNodeReference(checker, selection);
         return { info: { isJS, selection, enclosingNode, typeParameters, typeElements }, affectedTextRange };
       }
-      function getFirstTypeAt(file, startPosition, range, isCursorRequest) {
+      function getFirstTypeAt(file, startPosition, range2, isCursorRequest) {
         const currentNodes = [
           () => getTokenAtPosition(file, startPosition),
           () => getTouchingToken(file, startPosition, () => true)
         ];
         for (const f of currentNodes) {
           const current = f();
-          const overlappingRange = nodeOverlapsWithStartEnd(current, file, range.pos, range.end);
-          const firstType = findAncestor(current, (node) => node.parent && isTypeNode(node) && !rangeContainsSkipTrivia(range, node.parent, file) && (isCursorRequest || overlappingRange));
+          const overlappingRange = nodeOverlapsWithStartEnd(current, file, range2.pos, range2.end);
+          const firstType = findAncestor(current, (node) => node.parent && isTypeNode(node) && !rangeContainsSkipTrivia(range2, node.parent, file) && (isCursorRequest || overlappingRange));
           if (firstType) {
             return firstType;
           }
@@ -165428,17 +165428,17 @@ interface Symbol {
       }
       function getRangeToMove(context) {
         const { file } = context;
-        const range = createTextRangeFromSpan(getRefactorContextSpan(context));
+        const range2 = createTextRangeFromSpan(getRefactorContextSpan(context));
         const { statements } = file;
-        let startNodeIndex = findIndex(statements, (s) => s.end > range.pos);
+        let startNodeIndex = findIndex(statements, (s) => s.end > range2.pos);
         if (startNodeIndex === -1) return void 0;
         const startStatement = statements[startNodeIndex];
         const overloadRangeToMove = getOverloadRangeToMove(file, startStatement);
         if (overloadRangeToMove) {
           startNodeIndex = overloadRangeToMove.start;
         }
-        let endNodeIndex = findIndex(statements, (s) => s.end >= range.end, startNodeIndex);
-        if (endNodeIndex !== -1 && range.end <= statements[endNodeIndex].getStart()) {
+        let endNodeIndex = findIndex(statements, (s) => s.end >= range2.end, startNodeIndex);
+        if (endNodeIndex !== -1 && range2.end <= statements[endNodeIndex].getStart()) {
           endNodeIndex--;
         }
         const endingOverloadRangeToMove = getOverloadRangeToMove(file, statements[endNodeIndex]);
@@ -168048,9 +168048,9 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       function isScope(node) {
         return isArrowFunction(node) ? isFunctionBody(node.body) : isFunctionLikeDeclaration(node) || isSourceFile(node) || isModuleBlock(node) || isClassLike(node);
       }
-      function collectEnclosingScopes(range) {
-        let current = isReadonlyArray(range.range) ? first(range.range) : range.range;
-        if (range.facts & 8 && !(range.facts & 16)) {
+      function collectEnclosingScopes(range2) {
+        let current = isReadonlyArray(range2.range) ? first(range2.range) : range2.range;
+        if (range2.facts & 8 && !(range2.facts & 16)) {
           const containingClass = getContainingClass(current);
           if (containingClass) {
             const containingFunction = findAncestor(current, isFunctionLikeDeclaration);
@@ -168164,7 +168164,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       function getDescriptionForModuleLikeDeclaration(scope) {
         return scope.kind === 269 ? `namespace '${scope.parent.name.getText()}'` : scope.externalModuleIndicator ? 0 : 1;
       }
-      function extractFunctionInScope(node, scope, { usages: usagesInScope, typeParameterUsages, substitutions }, exposedVariableDeclarations, range, context) {
+      function extractFunctionInScope(node, scope, { usages: usagesInScope, typeParameterUsages, substitutions }, exposedVariableDeclarations, range2, context) {
         const checker = context.program.getTypeChecker();
         const scriptTarget = getEmitScriptTarget(context.program.getCompilerOptions());
         const importAdder = ts_codefix_exports.createImportAdder(context.file, context.program, context.preferences, context.host);
@@ -168227,22 +168227,22 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             /* AllowUnresolvedNames */
           );
         }
-        const { body: body2, returnValueProperty } = transformFunctionBody(node, exposedVariableDeclarations, writes, substitutions, !!(range.facts & 1));
+        const { body: body2, returnValueProperty } = transformFunctionBody(node, exposedVariableDeclarations, writes, substitutions, !!(range2.facts & 1));
         suppressLeadingAndTrailingTrivia(body2);
         let newFunction;
-        const callThis = !!(range.facts & 16);
+        const callThis = !!(range2.facts & 16);
         if (isClassLike(scope)) {
           const modifiers = isJS ? [] : [factory.createModifier(
             123
             /* PrivateKeyword */
           )];
-          if (range.facts & 32) {
+          if (range2.facts & 32) {
             modifiers.push(factory.createModifier(
               126
               /* StaticKeyword */
             ));
           }
-          if (range.facts & 4) {
+          if (range2.facts & 4) {
             modifiers.push(factory.createModifier(
               134
               /* AsyncKeyword */
@@ -168250,7 +168250,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           }
           newFunction = factory.createMethodDeclaration(
             modifiers.length ? modifiers : void 0,
-            range.facts & 2 ? factory.createToken(
+            range2.facts & 2 ? factory.createToken(
               42
               /* AsteriskToken */
             ) : void 0,
@@ -168275,7 +168275,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
                 /*questionToken*/
                 void 0,
                 checker.typeToTypeNode(
-                  checker.getTypeAtLocation(range.thisNode),
+                  checker.getTypeAtLocation(range2.thisNode),
                   scope,
                   1,
                   8
@@ -168287,11 +168287,11 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             );
           }
           newFunction = factory.createFunctionDeclaration(
-            range.facts & 4 ? [factory.createToken(
+            range2.facts & 4 ? [factory.createToken(
               134
               /* AsyncKeyword */
             )] : void 0,
-            range.facts & 2 ? factory.createToken(
+            range2.facts & 2 ? factory.createToken(
               42
               /* AsteriskToken */
             ) : void 0,
@@ -168303,7 +168303,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           );
         }
         const changeTracker = ts_textChanges_exports.ChangeTracker.fromContext(context);
-        const minInsertionPos = (isReadonlyArray(range.range) ? last(range.range) : range.range).end;
+        const minInsertionPos = (isReadonlyArray(range2.range) ? last(range2.range) : range2.range).end;
         const nodeToInsertBefore = getNodeToInsertFunctionBefore(minInsertionPos, scope);
         if (nodeToInsertBefore) {
           changeTracker.insertNodeBefore(
@@ -168318,7 +168318,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         }
         importAdder.writeFixes(changeTracker);
         const newNodes = [];
-        const called = getCalledExpression(scope, range, functionNameText);
+        const called = getCalledExpression(scope, range2, functionNameText);
         if (callThis) {
           callArguments.unshift(factory.createIdentifier("this"));
         }
@@ -168331,13 +168331,13 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           // Note that no attempt is made to take advantage of type argument inference
           callArguments
         );
-        if (range.facts & 2) {
+        if (range2.facts & 2) {
           call = factory.createYieldExpression(factory.createToken(
             42
             /* AsteriskToken */
           ), call);
         }
-        if (range.facts & 4) {
+        if (range2.facts & 4) {
           call = factory.createAwaitExpression(call);
         }
         if (isInJSXContent(node)) {
@@ -168349,7 +168349,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         }
         if (exposedVariableDeclarations.length && !writes) {
           Debug.assert(!returnValueProperty, "Expected no returnValueProperty");
-          Debug.assert(!(range.facts & 1), "Expected RangeFacts.HasReturn flag to be unset");
+          Debug.assert(!(range2.facts & 1), "Expected RangeFacts.HasReturn flag to be unset");
           if (exposedVariableDeclarations.length === 1) {
             const variableDeclaration = exposedVariableDeclarations[0];
             newNodes.push(factory.createVariableStatement(
@@ -168472,7 +168472,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           if (assignments.length === 1) {
             Debug.assert(!returnValueProperty, "Shouldn't have returnValueProperty here");
             newNodes.push(factory.createExpressionStatement(factory.createAssignment(assignments[0].name, call)));
-            if (range.facts & 1) {
+            if (range2.facts & 1) {
               newNodes.push(factory.createReturnStatement());
             }
           } else {
@@ -168482,21 +168482,21 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             }
           }
         } else {
-          if (range.facts & 1) {
+          if (range2.facts & 1) {
             newNodes.push(factory.createReturnStatement(call));
-          } else if (isReadonlyArray(range.range)) {
+          } else if (isReadonlyArray(range2.range)) {
             newNodes.push(factory.createExpressionStatement(call));
           } else {
             newNodes.push(call);
           }
         }
-        if (isReadonlyArray(range.range)) {
-          changeTracker.replaceNodeRangeWithNodes(context.file, first(range.range), last(range.range), newNodes);
+        if (isReadonlyArray(range2.range)) {
+          changeTracker.replaceNodeRangeWithNodes(context.file, first(range2.range), last(range2.range), newNodes);
         } else {
-          changeTracker.replaceNodeWithNodes(context.file, range.range, newNodes);
+          changeTracker.replaceNodeWithNodes(context.file, range2.range, newNodes);
         }
         const edits = changeTracker.getChanges();
-        const renameRange = isReadonlyArray(range.range) ? first(range.range) : range.range;
+        const renameRange = isReadonlyArray(range2.range) ? first(range2.range) : range2.range;
         const renameFilename = renameRange.getSourceFile().fileName;
         const renameLocation = getRenameLocation(
           edits,
@@ -168766,10 +168766,10 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           type2.symbol ? type2.symbol.getName() : ""
         ) || compareValues(type1.id, type2.id);
       }
-      function getCalledExpression(scope, range, functionNameText) {
+      function getCalledExpression(scope, range2, functionNameText) {
         const functionReference = factory.createIdentifier(functionNameText);
         if (isClassLike(scope)) {
-          const lhs = range.facts & 32 ? factory.createIdentifier(scope.name.text) : factory.createThis();
+          const lhs = range2.facts & 32 ? factory.createIdentifier(scope.name.text) : factory.createThis();
           return factory.createPropertyAccessExpression(lhs, functionReference);
         } else {
           return functionReference;
@@ -170972,7 +170972,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         }
         function getNodesForRanges(file, ranges) {
           const nodes = [];
-          const spans = normalizeSpans(ranges.map((range) => createTextSpanFromRange(range)));
+          const spans = normalizeSpans(ranges.map((range2) => createTextSpanFromRange(range2)));
           for (const span of spans) {
             const nodesForSpan = getNodesForSpan(file, span);
             if (!nodesForSpan) {
@@ -171760,8 +171760,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         }
         function getSpanOfEnclosingComment(fileName, position, onlyMultiLine) {
           const sourceFile = syntaxTreeCache.getCurrentSourceFile(fileName);
-          const range = ts_formatting_exports.getRangeOfEnclosingComment(sourceFile, position);
-          return range && (!onlyMultiLine || range.kind === 3) ? createTextSpanFromRange(range) : void 0;
+          const range2 = ts_formatting_exports.getRangeOfEnclosingComment(sourceFile, position);
+          return range2 && (!onlyMultiLine || range2.kind === 3) ? createTextSpanFromRange(range2) : void 0;
         }
         function getTodoComments(fileName, descriptors) {
           synchronizeHostData();
@@ -172905,13 +172905,13 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           const target = isTaggedTemplateExpression(node) ? node.tag : isJsxOpeningLikeElement(node) ? node.tagName : isAccessExpression(node) ? node : isClassStaticBlockDeclaration(node) ? node : node.expression;
           const declaration = resolveCallHierarchyDeclaration(program, target);
           if (declaration) {
-            const range = createTextRangeFromNode(target, node.getSourceFile());
+            const range2 = createTextRangeFromNode(target, node.getSourceFile());
             if (isArray(declaration)) {
               for (const decl of declaration) {
-                callSites.push({ declaration: decl, range });
+                callSites.push({ declaration: decl, range: range2 });
               }
             } else {
-              callSites.push({ declaration, range });
+              callSites.push({ declaration, range: range2 });
             }
           }
         }
@@ -186320,23 +186320,23 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         let modifiers = 0;
         let decorators;
         let contextMod;
-        const range = { pos: position, end: position };
+        const range2 = { pos: position, end: position };
         if (isPropertyDeclaration(contextToken.parent) && (contextMod = isModifierLike2(contextToken))) {
           if (contextToken.parent.modifiers) {
             modifiers |= modifiersToFlags(contextToken.parent.modifiers) & 98303;
             decorators = contextToken.parent.modifiers.filter(isDecorator) || [];
-            range.pos = Math.min(...contextToken.parent.modifiers.map((n) => n.getStart(sourceFile)));
+            range2.pos = Math.min(...contextToken.parent.modifiers.map((n) => n.getStart(sourceFile)));
           }
           const contextModifierFlag = modifierToFlag(contextMod);
           if (!(modifiers & contextModifierFlag)) {
             modifiers |= contextModifierFlag;
-            range.pos = Math.min(range.pos, contextToken.getStart(sourceFile));
+            range2.pos = Math.min(range2.pos, contextToken.getStart(sourceFile));
           }
           if (contextToken.parent.name !== contextToken) {
-            range.end = contextToken.parent.name.getStart(sourceFile);
+            range2.end = contextToken.parent.name.getStart(sourceFile);
           }
         }
-        return { modifiers, decorators, range: range.pos < range.end ? range : void 0 };
+        return { modifiers, decorators, range: range2.pos < range2.end ? range2 : void 0 };
       }
       function isModifierLike2(node) {
         if (isModifier(node)) {
@@ -190216,11 +190216,11 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         const compilerOptions = program.getCompilerOptions();
         const token = getTokenAtPosition(sourceFile, position);
         const commentRanges = getLeadingCommentRanges(sourceFile.text, token.pos);
-        const range = commentRanges && find(commentRanges, (commentRange) => position >= commentRange.pos && position <= commentRange.end);
-        if (!range) {
+        const range2 = commentRanges && find(commentRanges, (commentRange) => position >= commentRange.pos && position <= commentRange.end);
+        if (!range2) {
           return void 0;
         }
-        const text = sourceFile.text.slice(range.pos, position);
+        const text = sourceFile.text.slice(range2.pos, position);
         const match2 = tripleSlashDirectiveFragmentRegex.exec(text);
         if (!match2) {
           return void 0;
@@ -190238,7 +190238,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           true,
           sourceFile.path
         ) : kind === "types" ? getCompletionEntriesFromTypings(program, host, moduleSpecifierResolutionHost, scriptPath, getFragmentDirectory(toComplete), getExtensionOptions(compilerOptions, 1, sourceFile)) : Debug.fail();
-        return addReplacementSpans(toComplete, range.pos + prefix.length, arrayFrom(names.values()));
+        return addReplacementSpans(toComplete, range2.pos + prefix.length, arrayFrom(names.values()));
       }
       function getCompletionEntriesFromTypings(program, host, moduleSpecifierResolutionHost, scriptPath, fragmentDirectory, extensionOptions, result = createNameAndKindSet()) {
         const options = program.getCompilerOptions();
@@ -191626,11 +191626,11 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
               }
               return nodeEntry(reference.literal);
             } else if (reference.kind === "implicit") {
-              const range = reference.literal.text !== externalHelpersModuleNameText && forEachChildRecursively(
+              const range2 = reference.literal.text !== externalHelpersModuleNameText && forEachChildRecursively(
                 reference.referencingFile,
                 (n) => !(n.transformFlags & 2) ? "skip" : isJsxElement(n) || isJsxSelfClosingElement(n) || isJsxFragment(n) ? n : void 0
               ) || reference.referencingFile.statements[0] || reference.referencingFile;
-              return nodeEntry(range);
+              return nodeEntry(range2);
             } else {
               return {
                 kind: 0,
@@ -193686,7 +193686,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
             return false;
           }
           const regex = leadingParameterNameCommentRegexFactory(name2);
-          return some(ranges, (range) => regex.test(sourceFileText.substring(range.pos, range.end)));
+          return some(ranges, (range2) => regex.test(sourceFileText.substring(range2.pos, range2.end)));
         }
         function isHintableLiteral(node) {
           switch (node.kind) {
@@ -195515,14 +195515,14 @@ ${content}
       function getOrganizeImportsUnicodeStringComparer(ignoreCase, preferences) {
         const resolvedLocale = getOrganizeImportsLocale(preferences);
         const caseFirst = preferences.organizeImportsCaseFirst ?? false;
-        const numeric = preferences.organizeImportsNumericCollation ?? false;
+        const numeric2 = preferences.organizeImportsNumericCollation ?? false;
         const accents = preferences.organizeImportsAccentCollation ?? true;
         const sensitivity = ignoreCase ? accents ? "accent" : "base" : accents ? "variant" : "case";
         const collator = new Intl.Collator(resolvedLocale, {
           usage: "sort",
           caseFirst: caseFirst || "false",
           sensitivity,
-          numeric
+          numeric: numeric2
         });
         return collator.compare;
       }
@@ -198117,8 +198117,8 @@ ${content}
             });
           }
         }
-        deleteRange(sourceFile, range) {
-          this.changes.push({ kind: 0, sourceFile, range });
+        deleteRange(sourceFile, range2) {
+          this.changes.push({ kind: 0, sourceFile, range: range2 });
         }
         delete(sourceFile, node) {
           this.deletedNodes.push({ sourceFile, node });
@@ -198165,8 +198165,8 @@ ${content}
           const endPosition = afterEndNode === void 0 ? sourceFile.text.length : getAdjustedStartPosition(sourceFile, afterEndNode, options);
           this.deleteRange(sourceFile, { pos: startPosition, end: endPosition });
         }
-        replaceRange(sourceFile, range, newNode, options = {}) {
-          this.changes.push({ kind: 1, sourceFile, range, options, node: newNode });
+        replaceRange(sourceFile, range2, newNode, options = {}) {
+          this.changes.push({ kind: 1, sourceFile, range: range2, options, node: newNode });
         }
         replaceNode(sourceFile, oldNode, newNode, options = useNonAdjustedPositions) {
           this.replaceRange(sourceFile, getAdjustedRange(sourceFile, oldNode, oldNode, options), newNode, options);
@@ -198174,8 +198174,8 @@ ${content}
         replaceNodeRange(sourceFile, startNode2, endNode2, newNode, options = useNonAdjustedPositions) {
           this.replaceRange(sourceFile, getAdjustedRange(sourceFile, startNode2, endNode2, options), newNode, options);
         }
-        replaceRangeWithNodes(sourceFile, range, newNodes, options = {}) {
-          this.changes.push({ kind: 2, sourceFile, range, options, nodes: newNodes });
+        replaceRangeWithNodes(sourceFile, range2, newNodes, options = {}) {
+          this.changes.push({ kind: 2, sourceFile, range: range2, options, nodes: newNodes });
         }
         replaceNodeWithNodes(sourceFile, oldNode, newNodes, options = useNonAdjustedPositions) {
           this.replaceRangeWithNodes(sourceFile, getAdjustedRange(sourceFile, oldNode, oldNode, options), newNodes, options);
@@ -198308,8 +198308,8 @@ ${content}
         filterJSDocTags(sourceFile, parent2, predicate) {
           this.replaceJSDocComment(sourceFile, parent2, filter2(flatMapToMutable(parent2.jsDoc, (j) => j.tags), predicate));
         }
-        replaceRangeWithText(sourceFile, range, text) {
-          this.changes.push({ kind: 3, sourceFile, range, text });
+        replaceRangeWithText(sourceFile, range2, text) {
+          this.changes.push({ kind: 3, sourceFile, range: range2, text });
         }
         insertText(sourceFile, pos, text) {
           this.replaceRangeWithText(sourceFile, createRange(pos), text);
@@ -199115,28 +199115,28 @@ ${options.prefix}` : "\n" : options.prefix
         if (!ranges) return position;
         let lastComment;
         let firstNodeLine;
-        for (const range of ranges) {
-          if (range.kind === 3) {
-            if (isPinnedComment(text, range.pos)) {
-              lastComment = { range, pinnedOrTripleSlash: true };
+        for (const range2 of ranges) {
+          if (range2.kind === 3) {
+            if (isPinnedComment(text, range2.pos)) {
+              lastComment = { range: range2, pinnedOrTripleSlash: true };
               continue;
             }
-          } else if (isRecognizedTripleSlashComment(text, range.pos, range.end)) {
-            lastComment = { range, pinnedOrTripleSlash: true };
+          } else if (isRecognizedTripleSlashComment(text, range2.pos, range2.end)) {
+            lastComment = { range: range2, pinnedOrTripleSlash: true };
             continue;
           }
           if (lastComment) {
             if (lastComment.pinnedOrTripleSlash) break;
-            const commentLine = sourceFile.getLineAndCharacterOfPosition(range.pos).line;
+            const commentLine = sourceFile.getLineAndCharacterOfPosition(range2.pos).line;
             const lastCommentEndLine = sourceFile.getLineAndCharacterOfPosition(lastComment.range.end).line;
             if (commentLine >= lastCommentEndLine + 2) break;
           }
           if (sourceFile.statements.length) {
             if (firstNodeLine === void 0) firstNodeLine = sourceFile.getLineAndCharacterOfPosition(sourceFile.statements[0].getStart()).line;
-            const commentEndLine = sourceFile.getLineAndCharacterOfPosition(range.end).line;
+            const commentEndLine = sourceFile.getLineAndCharacterOfPosition(range2.end).line;
             if (firstNodeLine < commentEndLine + 2) break;
           }
-          lastComment = { range, pinnedOrTripleSlash: false };
+          lastComment = { range: range2, pinnedOrTripleSlash: false };
         }
         if (lastComment) {
           position = lastComment.range.end;
@@ -201761,10 +201761,10 @@ ${options.prefix}` : "\n" : options.prefix
         }
         return false;
       }
-      function findEnclosingNode(range, sourceFile) {
+      function findEnclosingNode(range2, sourceFile) {
         return find2(sourceFile);
         function find2(n) {
-          const candidate = forEachChild(n, (c) => startEndContainsRange(c.getStart(sourceFile), c.end, range) && c);
+          const candidate = forEachChild(n, (c) => startEndContainsRange(c.getStart(sourceFile), c.end, range2) && c);
           if (candidate) {
             const result = find2(candidate);
             if (result) {
@@ -201834,9 +201834,9 @@ ${options.prefix}` : "\n" : options.prefix
         return 0;
       }
       function formatNodeGivenIndentation(node, sourceFileLike, languageVariant, initialIndentation, delta, formatContext) {
-        const range = { pos: node.pos, end: node.end };
-        return getFormattingScanner(sourceFileLike.text, languageVariant, range.pos, range.end, (scanner2) => formatSpanWorker(
-          range,
+        const range2 = { pos: node.pos, end: node.end };
+        return getFormattingScanner(sourceFileLike.text, languageVariant, range2.pos, range2.end, (scanner2) => formatSpanWorker(
+          range2,
           node,
           initialIndentation,
           delta,
@@ -201952,8 +201952,8 @@ ${options.prefix}` : "\n" : options.prefix
           }
         }
         return edits;
-        function tryComputeIndentationForListItem(startPos, endPos, parentStartLine, range, inheritedIndentation) {
-          if (rangeOverlapsWithStartEnd(range, startPos, endPos) || rangeContainsStartEnd(range, startPos, endPos)) {
+        function tryComputeIndentationForListItem(startPos, endPos, parentStartLine, range2, inheritedIndentation) {
+          if (rangeOverlapsWithStartEnd(range2, startPos, endPos) || rangeContainsStartEnd(range2, startPos, endPos)) {
             if (inheritedIndentation !== -1) {
               return inheritedIndentation;
             }
@@ -202342,19 +202342,19 @@ ${options.prefix}` : "\n" : options.prefix
             }
           }
         }
-        function processRange(range, rangeStart, parent2, contextNode, dynamicIndentation) {
-          const rangeHasError = rangeContainsError(range);
+        function processRange(range2, rangeStart, parent2, contextNode, dynamicIndentation) {
+          const rangeHasError = rangeContainsError(range2);
           let lineAction = 0;
           if (!rangeHasError) {
             if (!previousRange) {
               const originalStart = sourceFile.getLineAndCharacterOfPosition(originalRange.pos);
               trimTrailingWhitespacesForLines(originalStart.line, rangeStart.line);
             } else {
-              lineAction = processPair(range, rangeStart.line, parent2, previousRange, previousRangeStartLine, previousParent, contextNode, dynamicIndentation);
+              lineAction = processPair(range2, rangeStart.line, parent2, previousRange, previousRangeStartLine, previousParent, contextNode, dynamicIndentation);
             }
           }
-          previousRange = range;
-          previousRangeTriviaEnd = range.end;
+          previousRange = range2;
+          previousRangeTriviaEnd = range2.end;
           previousParent = parent2;
           previousRangeStartLine = rangeStart.line;
           return lineAction;
@@ -202475,11 +202475,11 @@ ${options.prefix}` : "\n" : options.prefix
             }
           }
         }
-        function trimTrailingWhitespacesForLines(line1, line2, range) {
+        function trimTrailingWhitespacesForLines(line1, line2, range2) {
           for (let line = line1; line < line2; line++) {
             const lineStartPosition = getStartPositionOfLine(line, sourceFile);
             const lineEndPosition = getEndLinePosition(line, sourceFile);
-            if (range && (isComment(range.kind) || isStringOrRegularExpressionOrTemplateLiteral(range.kind)) && range.pos <= lineEndPosition && range.end > lineEndPosition) {
+            if (range2 && (isComment(range2.kind) || isStringOrRegularExpressionOrTemplateLiteral(range2.kind)) && range2.pos <= lineEndPosition && range2.end > lineEndPosition) {
               continue;
             }
             const whitespaceStart = getTrailingWhitespaceStartPosition(lineStartPosition, lineEndPosition);
@@ -202584,7 +202584,7 @@ ${options.prefix}` : "\n" : options.prefix
         const trailingRangesOfPreviousToken = precedingToken && getTrailingCommentRanges(sourceFile.text, precedingToken.end);
         const leadingCommentRangesOfNextToken = getLeadingCommentRangesOfNode(tokenAtPosition, sourceFile);
         const commentRanges = concatenate(trailingRangesOfPreviousToken, leadingCommentRangesOfNextToken);
-        return commentRanges && find(commentRanges, (range) => rangeContainsPositionExclusive(range, position) || // The end marker of a single-line comment does not include the newline character.
+        return commentRanges && find(commentRanges, (range2) => rangeContainsPositionExclusive(range2, position) || // The end marker of a single-line comment does not include the newline character.
         // With caret at `^`, in the following case, we are inside a comment (^ denotes the cursor position):
         //
         //    // asdf   ^\n
@@ -202597,7 +202597,7 @@ ${options.prefix}` : "\n" : options.prefix
         //
         // Internally, we represent the end of the comment at the newline and closing '/', respectively.
         //
-        position === range.end && (range.kind === 2 || position === sourceFile.getFullWidth()));
+        position === range2.end && (range2.kind === 2 || position === sourceFile.getFullWidth()));
       }
       function getOpenTokenForList(node, list) {
         switch (node.kind) {
@@ -203220,10 +203220,10 @@ ${options.prefix}` : "\n" : options.prefix
           ) && !(isNextChild && child && isControlFlowEndingStatement(child.kind, parent2));
         }
         SmartIndenter2.shouldIndentChildNode = shouldIndentChildNode;
-        function rangeIsOnOneLine(sourceFile, range) {
-          const rangeStart = skipTrivia(sourceFile.text, range.pos);
+        function rangeIsOnOneLine(sourceFile, range2) {
+          const rangeStart = skipTrivia(sourceFile.text, range2.pos);
           const startLine = sourceFile.getLineAndCharacterOfPosition(rangeStart).line;
-          const endLine = sourceFile.getLineAndCharacterOfPosition(range.end).line;
+          const endLine = sourceFile.getLineAndCharacterOfPosition(range2.end).line;
           return startLine === endLine;
         }
       })(SmartIndenter || (SmartIndenter = {}));
@@ -203233,16 +203233,16 @@ ${options.prefix}` : "\n" : options.prefix
       });
       function preparePasteEdits(sourceFile, copiedFromRange, checker) {
         let shouldProvidePasteEdits = false;
-        copiedFromRange.forEach((range) => {
+        copiedFromRange.forEach((range2) => {
           const enclosingNode = findAncestor(
-            getTokenAtPosition(sourceFile, range.pos),
-            (ancestorNode) => rangeContainsRange(ancestorNode, range)
+            getTokenAtPosition(sourceFile, range2.pos),
+            (ancestorNode) => rangeContainsRange(ancestorNode, range2)
           );
           if (!enclosingNode) return;
           forEachChild(enclosingNode, function checkNameResolution(node) {
             var _a2;
             if (shouldProvidePasteEdits) return;
-            if (isIdentifier(node) && rangeContainsPosition(range, node.getStart(sourceFile))) {
+            if (isIdentifier(node) && rangeContainsPosition(range2, node.getStart(sourceFile))) {
               const resolvedSymbol = checker.resolveName(
                 node.text,
                 node,
@@ -203322,15 +203322,15 @@ ${options.prefix}` : "\n" : options.prefix
               const textToBePasted = actualPastedText ?? pastedText[i2];
               const startPos = location.pos + offset;
               const endPos = startPos + textToBePasted.length;
-              const range = { pos: startPos, end: endPos };
+              const range2 = { pos: startPos, end: endPos };
               offset += textToBePasted.length - oldTextLength;
               const enclosingNode = findAncestor(
-                getTokenAtPosition(context.sourceFile, range.pos),
-                (ancestorNode) => rangeContainsRange(ancestorNode, range)
+                getTokenAtPosition(context.sourceFile, range2.pos),
+                (ancestorNode) => rangeContainsRange(ancestorNode, range2)
               );
               if (!enclosingNode) return;
               forEachChild(enclosingNode, function importUnresolvedIdentifiers(node) {
-                const isImportCandidate = isIdentifier(node) && rangeContainsPosition(range, node.getStart(updatedFile)) && !(updatedProgram == null ? void 0 : updatedProgram.getTypeChecker().resolveName(
+                const isImportCandidate = isIdentifier(node) && rangeContainsPosition(range2, node.getStart(updatedFile)) && !(updatedProgram == null ? void 0 : updatedProgram.getTypeChecker().resolveName(
                   node.text,
                   node,
                   -1,
@@ -203362,9 +203362,9 @@ ${options.prefix}` : "\n" : options.prefix
           );
         });
       }
-      function getUsageInfoRangeForPasteEdits({ file: sourceFile, range }) {
-        const pos = range[0].pos;
-        const end = range[range.length - 1].end;
+      function getUsageInfoRangeForPasteEdits({ file: sourceFile, range: range2 }) {
+        const pos = range2[0].pos;
+        const end = range2[range2.length - 1].end;
         const startToken = getTokenAtPosition(sourceFile, pos);
         const endToken = findTokenOnLeftOfPosition(sourceFile, pos) ?? getTokenAtPosition(sourceFile, end);
         return {
@@ -215579,7 +215579,7 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
               return next.immediate("regionSemanticCheck", () => {
                 const scriptInfo = this.projectService.getScriptInfoForNormalizedPath(fileName);
                 if (scriptInfo) {
-                  this.regionSemanticCheck(fileName, project, ranges.map((range) => this.getRange({ file: fileName, ...range }, scriptInfo)));
+                  this.regionSemanticCheck(fileName, project, ranges.map((range2) => this.getRange({ file: fileName, ...range2 }, scriptInfo)));
                 }
                 if (this.changeSeq !== seq) {
                   return;
@@ -218587,215 +218587,6 @@ Additional information: BADCLIENT: Bad error code, ${badCode} not found in range
   }
 });
 
-// ../../node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/index.js
-var require_balanced_match = __commonJS({
-  "../../node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/index.js"(exports2, module2) {
-    "use strict";
-    module2.exports = balanced;
-    function balanced(a, b, str) {
-      if (a instanceof RegExp) a = maybeMatch(a, str);
-      if (b instanceof RegExp) b = maybeMatch(b, str);
-      var r = range(a, b, str);
-      return r && {
-        start: r[0],
-        end: r[1],
-        pre: str.slice(0, r[0]),
-        body: str.slice(r[0] + a.length, r[1]),
-        post: str.slice(r[1] + b.length)
-      };
-    }
-    function maybeMatch(reg, str) {
-      var m = str.match(reg);
-      return m ? m[0] : null;
-    }
-    balanced.range = range;
-    function range(a, b, str) {
-      var begs, beg, left, right, result;
-      var ai = str.indexOf(a);
-      var bi = str.indexOf(b, ai + 1);
-      var i2 = ai;
-      if (ai >= 0 && bi > 0) {
-        if (a === b) {
-          return [ai, bi];
-        }
-        begs = [];
-        left = str.length;
-        while (i2 >= 0 && !result) {
-          if (i2 == ai) {
-            begs.push(i2);
-            ai = str.indexOf(a, i2 + 1);
-          } else if (begs.length == 1) {
-            result = [begs.pop(), bi];
-          } else {
-            beg = begs.pop();
-            if (beg < left) {
-              left = beg;
-              right = bi;
-            }
-            bi = str.indexOf(b, i2 + 1);
-          }
-          i2 = ai < bi && ai >= 0 ? ai : bi;
-        }
-        if (begs.length) {
-          result = [left, right];
-        }
-      }
-      return result;
-    }
-  }
-});
-
-// ../../node_modules/.pnpm/brace-expansion@2.0.2/node_modules/brace-expansion/index.js
-var require_brace_expansion = __commonJS({
-  "../../node_modules/.pnpm/brace-expansion@2.0.2/node_modules/brace-expansion/index.js"(exports2, module2) {
-    "use strict";
-    var balanced = require_balanced_match();
-    module2.exports = expandTop;
-    var escSlash = "\0SLASH" + Math.random() + "\0";
-    var escOpen = "\0OPEN" + Math.random() + "\0";
-    var escClose = "\0CLOSE" + Math.random() + "\0";
-    var escComma = "\0COMMA" + Math.random() + "\0";
-    var escPeriod = "\0PERIOD" + Math.random() + "\0";
-    function numeric(str) {
-      return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
-    }
-    function escapeBraces(str) {
-      return str.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
-    }
-    function unescapeBraces(str) {
-      return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
-    }
-    function parseCommaParts(str) {
-      if (!str)
-        return [""];
-      var parts2 = [];
-      var m = balanced("{", "}", str);
-      if (!m)
-        return str.split(",");
-      var pre = m.pre;
-      var body2 = m.body;
-      var post2 = m.post;
-      var p = pre.split(",");
-      p[p.length - 1] += "{" + body2 + "}";
-      var postParts = parseCommaParts(post2);
-      if (post2.length) {
-        p[p.length - 1] += postParts.shift();
-        p.push.apply(p, postParts);
-      }
-      parts2.push.apply(parts2, p);
-      return parts2;
-    }
-    function expandTop(str) {
-      if (!str)
-        return [];
-      if (str.substr(0, 2) === "{}") {
-        str = "\\{\\}" + str.substr(2);
-      }
-      return expand2(escapeBraces(str), true).map(unescapeBraces);
-    }
-    function embrace(str) {
-      return "{" + str + "}";
-    }
-    function isPadded(el) {
-      return /^-?0\d/.test(el);
-    }
-    function lte(i2, y) {
-      return i2 <= y;
-    }
-    function gte(i2, y) {
-      return i2 >= y;
-    }
-    function expand2(str, isTop) {
-      var expansions = [];
-      var m = balanced("{", "}", str);
-      if (!m) return [str];
-      var pre = m.pre;
-      var post2 = m.post.length ? expand2(m.post, false) : [""];
-      if (/\$$/.test(m.pre)) {
-        for (var k = 0; k < post2.length; k++) {
-          var expansion = pre + "{" + m.body + "}" + post2[k];
-          expansions.push(expansion);
-        }
-      } else {
-        var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
-        var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
-        var isSequence = isNumericSequence || isAlphaSequence;
-        var isOptions = m.body.indexOf(",") >= 0;
-        if (!isSequence && !isOptions) {
-          if (m.post.match(/,(?!,).*\}/)) {
-            str = m.pre + "{" + m.body + escClose + m.post;
-            return expand2(str);
-          }
-          return [str];
-        }
-        var n;
-        if (isSequence) {
-          n = m.body.split(/\.\./);
-        } else {
-          n = parseCommaParts(m.body);
-          if (n.length === 1) {
-            n = expand2(n[0], false).map(embrace);
-            if (n.length === 1) {
-              return post2.map(function(p) {
-                return m.pre + n[0] + p;
-              });
-            }
-          }
-        }
-        var N;
-        if (isSequence) {
-          var x = numeric(n[0]);
-          var y = numeric(n[1]);
-          var width = Math.max(n[0].length, n[1].length);
-          var incr = n.length == 3 ? Math.abs(numeric(n[2])) : 1;
-          var test = lte;
-          var reverse = y < x;
-          if (reverse) {
-            incr *= -1;
-            test = gte;
-          }
-          var pad = n.some(isPadded);
-          N = [];
-          for (var i2 = x; test(i2, y); i2 += incr) {
-            var c;
-            if (isAlphaSequence) {
-              c = String.fromCharCode(i2);
-              if (c === "\\")
-                c = "";
-            } else {
-              c = String(i2);
-              if (pad) {
-                var need = width - c.length;
-                if (need > 0) {
-                  var z = new Array(need + 1).join("0");
-                  if (i2 < 0)
-                    c = "-" + z + c.slice(1);
-                  else
-                    c = z + c;
-                }
-              }
-            }
-            N.push(c);
-          }
-        } else {
-          N = [];
-          for (var j = 0; j < n.length; j++) {
-            N.push.apply(N, expand2(n[j], false));
-          }
-        }
-        for (var j = 0; j < N.length; j++) {
-          for (var k = 0; k < post2.length; k++) {
-            var expansion = pre + N[j] + post2[k];
-            if (!isTop || isSequence || expansion)
-              expansions.push(expansion);
-          }
-        }
-      }
-      return expansions;
-    }
-  }
-});
-
 // ../context-evolution/dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
@@ -222984,13 +222775,13 @@ ${indentData}`);
       }
     }
     function xrange(n, exception) {
-      let range = [];
+      let range2 = [];
       for (let i2 = 0; i2 < n; i2++) {
         if (i2 !== exception) {
-          range.push(i2);
+          range2.push(i2);
         }
       }
-      return range;
+      return range2;
     }
     function dependenciesOneRow(error, matrix2, index2, thresholdValue = 1e-9, thresholdError = 1e-9) {
       if (error > thresholdError) {
@@ -224018,7 +223809,7 @@ var require_ignore = __commonJS({
     };
     var REGEX_REGEXP_RANGE = /([0-z])-([0-z])/g;
     var RETURN_FALSE = () => false;
-    var sanitizeRange = (range) => range.replace(
+    var sanitizeRange = (range2) => range2.replace(
       REGEX_REGEXP_RANGE,
       (match2, from, to) => from.charCodeAt(0) <= to.charCodeAt(0) ? match2 : EMPTY
     );
@@ -224154,7 +223945,7 @@ var require_ignore = __commonJS({
         // > can be used to match one of the characters in a range.
         // `\` is escaped by step 3
         /(\\)?\[([^\]/]*?)(\\*)($|\])/g,
-        (match2, leadEscape, range, endEscape, close) => leadEscape === ESCAPE ? `\\[${range}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range)}${endEscape}]` : "[]" : "[]"
+        (match2, leadEscape, range2, endEscape, close) => leadEscape === ESCAPE ? `\\[${range2}${cleanRangeBackSlash(endEscape)}${close}` : close === "]" ? endEscape.length % 2 === 0 ? `[${sanitizeRange(range2)}${endEscape}]` : "[]" : "[]"
       ],
       // ending
       [
@@ -227745,13 +227536,13 @@ var require_parse_options = __commonJS({
 var require_identifiers = __commonJS({
   "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/internal/identifiers.js"(exports2, module2) {
     "use strict";
-    var numeric = /^[0-9]+$/;
+    var numeric2 = /^[0-9]+$/;
     var compareIdentifiers = (a, b) => {
       if (typeof a === "number" && typeof b === "number") {
         return a === b ? 0 : a < b ? -1 : 1;
       }
-      const anum = numeric.test(a);
-      const bnum = numeric.test(b);
+      const anum = numeric2.test(a);
+      const bnum = numeric2.test(b);
       if (anum && bnum) {
         a = +a;
         b = +b;
@@ -228128,8 +227919,8 @@ var require_gte = __commonJS({
   "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/gte.js"(exports2, module2) {
     "use strict";
     var compare = require_compare();
-    var gte = (a, b, loose) => compare(a, b, loose) >= 0;
-    module2.exports = gte;
+    var gte2 = (a, b, loose) => compare(a, b, loose) >= 0;
+    module2.exports = gte2;
   }
 });
 
@@ -228216,8 +228007,8 @@ var require_lte = __commonJS({
   "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/lte.js"(exports2, module2) {
     "use strict";
     var compare = require_compare();
-    var lte = (a, b, loose) => compare(a, b, loose) <= 0;
-    module2.exports = lte;
+    var lte2 = (a, b, loose) => compare(a, b, loose) <= 0;
+    module2.exports = lte2;
   }
 });
 
@@ -228228,9 +228019,9 @@ var require_cmp = __commonJS({
     var eq = require_eq();
     var neq = require_neq();
     var gt = require_gt();
-    var gte = require_gte();
+    var gte2 = require_gte();
     var lt = require_lt();
-    var lte = require_lte();
+    var lte2 = require_lte();
     var cmp = (a, op, b, loose) => {
       switch (op) {
         case "===":
@@ -228258,11 +228049,11 @@ var require_cmp = __commonJS({
         case ">":
           return gt(a, b, loose);
         case ">=":
-          return gte(a, b, loose);
+          return gte2(a, b, loose);
         case "<":
           return lt(a, b, loose);
         case "<=":
-          return lte(a, b, loose);
+          return lte2(a, b, loose);
         default:
           throw new TypeError(`Invalid operator: ${op}`);
       }
@@ -228390,25 +228181,25 @@ var require_range = __commonJS({
     "use strict";
     var SPACE_CHARACTERS = /\s+/g;
     var Range = class _Range {
-      constructor(range, options) {
+      constructor(range2, options) {
         options = parseOptions(options);
-        if (range instanceof _Range) {
-          if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
-            return range;
+        if (range2 instanceof _Range) {
+          if (range2.loose === !!options.loose && range2.includePrerelease === !!options.includePrerelease) {
+            return range2;
           } else {
-            return new _Range(range.raw, options);
+            return new _Range(range2.raw, options);
           }
         }
-        if (range instanceof Comparator) {
-          this.raw = range.value;
-          this.set = [[range]];
+        if (range2 instanceof Comparator) {
+          this.raw = range2.value;
+          this.set = [[range2]];
           this.formatted = void 0;
           return this;
         }
         this.options = options;
         this.loose = !!options.loose;
         this.includePrerelease = !!options.includePrerelease;
-        this.raw = range.trim().replace(SPACE_CHARACTERS, " ");
+        this.raw = range2.trim().replace(SPACE_CHARACTERS, " ");
         this.set = this.raw.split("||").map((r) => this.parseRange(r.trim())).filter((c) => c.length);
         if (!this.set.length) {
           throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
@@ -228453,24 +228244,24 @@ var require_range = __commonJS({
       toString() {
         return this.range;
       }
-      parseRange(range) {
+      parseRange(range2) {
         const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
-        const memoKey = memoOpts + ":" + range;
+        const memoKey = memoOpts + ":" + range2;
         const cached = cache.get(memoKey);
         if (cached) {
           return cached;
         }
         const loose = this.options.loose;
         const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
-        range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
-        debug("hyphen replace", range);
-        range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
-        debug("comparator trim", range);
-        range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
-        debug("tilde trim", range);
-        range = range.replace(re[t.CARETTRIM], caretTrimReplace);
-        debug("caret trim", range);
-        let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
+        range2 = range2.replace(hr, hyphenReplace(this.options.includePrerelease));
+        debug("hyphen replace", range2);
+        range2 = range2.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
+        debug("comparator trim", range2);
+        range2 = range2.replace(re[t.TILDETRIM], tildeTrimReplace);
+        debug("tilde trim", range2);
+        range2 = range2.replace(re[t.CARETTRIM], caretTrimReplace);
+        debug("caret trim", range2);
+        let rangeList = range2.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
         if (loose) {
           rangeList = rangeList.filter((comp) => {
             debug("loose invalid filter", comp, this.options);
@@ -228493,12 +228284,12 @@ var require_range = __commonJS({
         cache.set(memoKey, result);
         return result;
       }
-      intersects(range, options) {
-        if (!(range instanceof _Range)) {
+      intersects(range2, options) {
+        if (!(range2 instanceof _Range)) {
           throw new TypeError("a Range is required");
         }
         return this.set.some((thisComparators) => {
-          return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => {
+          return isSatisfiable(thisComparators, options) && range2.set.some((rangeComparators) => {
             return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
               return rangeComparators.every((rangeComparator) => {
                 return thisComparator.intersects(rangeComparator, options);
@@ -228766,13 +228557,13 @@ var require_satisfies = __commonJS({
   "../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/satisfies.js"(exports2, module2) {
     "use strict";
     var Range = require_range();
-    var satisfies = (version3, range, options) => {
+    var satisfies = (version3, range2, options) => {
       try {
-        range = new Range(range, options);
+        range2 = new Range(range2, options);
       } catch (er) {
         return false;
       }
-      return range.test(version3);
+      return range2.test(version3);
     };
     module2.exports = satisfies;
   }
@@ -235747,7 +235538,7 @@ var init_transformers_node = __esm({
             }
             return program;
           }
-          function range(start2, stop2, step = 1) {
+          function range2(start2, stop2, step = 1) {
             if (stop2 === void 0) {
               stop2 = start2;
               start2 = 0;
@@ -236292,7 +236083,7 @@ var init_transformers_node = __esm({
             env3.set("raise_exception", (args2) => {
               throw new Error(args2);
             });
-            env3.set("range", range);
+            env3.set("range", range2);
             env3.set("strftime_now", strftime_now);
             env3.set("True", true);
             env3.set("False", false);
@@ -276048,8 +275839,8 @@ async function semanticIdentifierSearch(options) {
   ];
   for (let i2 = 0; i2 < top.length; i2++) {
     const item = top[i2];
-    const range = formatLineRange3(item.doc.line, item.doc.endLine);
-    lines.push(`${i2 + 1}. ${item.doc.kind} ${item.doc.name} - ${item.doc.path} (${range})`);
+    const range2 = formatLineRange3(item.doc.line, item.doc.endLine);
+    lines.push(`${i2 + 1}. ${item.doc.kind} ${item.doc.name} - ${item.doc.path} (${range2})`);
     lines.push(`   Score: ${Math.round(item.score * 1e3) / 10}% | Semantic: ${Math.round(item.semanticScore * 1e3) / 10}% | Keyword: ${Math.round(item.keywordScore * 1e3) / 10}%`);
     lines.push(`   Signature: ${item.doc.signature}`);
     if (item.doc.parentName) lines.push(`   Parent: ${item.doc.parentName}`);
@@ -278000,10 +277791,220 @@ async function buildCodeGraph(opts) {
 import * as path3 from "path";
 import * as path22 from "path";
 
-// ../../node_modules/.pnpm/minimatch@9.0.9/node_modules/minimatch/dist/esm/index.js
-var import_brace_expansion = __toESM(require_brace_expansion(), 1);
+// ../../node_modules/.pnpm/balanced-match@4.0.4/node_modules/balanced-match/dist/esm/index.js
+var balanced = (a, b, str) => {
+  const ma = a instanceof RegExp ? maybeMatch(a, str) : a;
+  const mb = b instanceof RegExp ? maybeMatch(b, str) : b;
+  const r = ma !== null && mb != null && range(ma, mb, str);
+  return r && {
+    start: r[0],
+    end: r[1],
+    pre: str.slice(0, r[0]),
+    body: str.slice(r[0] + ma.length, r[1]),
+    post: str.slice(r[1] + mb.length)
+  };
+};
+var maybeMatch = (reg, str) => {
+  const m = str.match(reg);
+  return m ? m[0] : null;
+};
+var range = (a, b, str) => {
+  let begs, beg, left, right = void 0, result;
+  let ai = str.indexOf(a);
+  let bi = str.indexOf(b, ai + 1);
+  let i2 = ai;
+  if (ai >= 0 && bi > 0) {
+    if (a === b) {
+      return [ai, bi];
+    }
+    begs = [];
+    left = str.length;
+    while (i2 >= 0 && !result) {
+      if (i2 === ai) {
+        begs.push(i2);
+        ai = str.indexOf(a, i2 + 1);
+      } else if (begs.length === 1) {
+        const r = begs.pop();
+        if (r !== void 0)
+          result = [r, bi];
+      } else {
+        beg = begs.pop();
+        if (beg !== void 0 && beg < left) {
+          left = beg;
+          right = bi;
+        }
+        bi = str.indexOf(b, i2 + 1);
+      }
+      i2 = ai < bi && ai >= 0 ? ai : bi;
+    }
+    if (begs.length && right !== void 0) {
+      result = [left, right];
+    }
+  }
+  return result;
+};
+
+// ../../node_modules/.pnpm/brace-expansion@5.0.4/node_modules/brace-expansion/dist/esm/index.js
+var escSlash = "\0SLASH" + Math.random() + "\0";
+var escOpen = "\0OPEN" + Math.random() + "\0";
+var escClose = "\0CLOSE" + Math.random() + "\0";
+var escComma = "\0COMMA" + Math.random() + "\0";
+var escPeriod = "\0PERIOD" + Math.random() + "\0";
+var escSlashPattern = new RegExp(escSlash, "g");
+var escOpenPattern = new RegExp(escOpen, "g");
+var escClosePattern = new RegExp(escClose, "g");
+var escCommaPattern = new RegExp(escComma, "g");
+var escPeriodPattern = new RegExp(escPeriod, "g");
+var slashPattern = /\\\\/g;
+var openPattern = /\\{/g;
+var closePattern = /\\}/g;
+var commaPattern = /\\,/g;
+var periodPattern = /\\\./g;
+var EXPANSION_MAX = 1e5;
+function numeric(str) {
+  return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
+}
+function escapeBraces(str) {
+  return str.replace(slashPattern, escSlash).replace(openPattern, escOpen).replace(closePattern, escClose).replace(commaPattern, escComma).replace(periodPattern, escPeriod);
+}
+function unescapeBraces(str) {
+  return str.replace(escSlashPattern, "\\").replace(escOpenPattern, "{").replace(escClosePattern, "}").replace(escCommaPattern, ",").replace(escPeriodPattern, ".");
+}
+function parseCommaParts(str) {
+  if (!str) {
+    return [""];
+  }
+  const parts2 = [];
+  const m = balanced("{", "}", str);
+  if (!m) {
+    return str.split(",");
+  }
+  const { pre, body: body2, post: post2 } = m;
+  const p = pre.split(",");
+  p[p.length - 1] += "{" + body2 + "}";
+  const postParts = parseCommaParts(post2);
+  if (post2.length) {
+    ;
+    p[p.length - 1] += postParts.shift();
+    p.push.apply(p, postParts);
+  }
+  parts2.push.apply(parts2, p);
+  return parts2;
+}
+function expand(str, options = {}) {
+  if (!str) {
+    return [];
+  }
+  const { max: max2 = EXPANSION_MAX } = options;
+  if (str.slice(0, 2) === "{}") {
+    str = "\\{\\}" + str.slice(2);
+  }
+  return expand_(escapeBraces(str), max2, true).map(unescapeBraces);
+}
+function embrace(str) {
+  return "{" + str + "}";
+}
+function isPadded(el) {
+  return /^-?0\d/.test(el);
+}
+function lte(i2, y) {
+  return i2 <= y;
+}
+function gte(i2, y) {
+  return i2 >= y;
+}
+function expand_(str, max2, isTop) {
+  const expansions = [];
+  const m = balanced("{", "}", str);
+  if (!m)
+    return [str];
+  const pre = m.pre;
+  const post2 = m.post.length ? expand_(m.post, max2, false) : [""];
+  if (/\$$/.test(m.pre)) {
+    for (let k = 0; k < post2.length && k < max2; k++) {
+      const expansion = pre + "{" + m.body + "}" + post2[k];
+      expansions.push(expansion);
+    }
+  } else {
+    const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+    const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+    const isSequence = isNumericSequence || isAlphaSequence;
+    const isOptions = m.body.indexOf(",") >= 0;
+    if (!isSequence && !isOptions) {
+      if (m.post.match(/,(?!,).*\}/)) {
+        str = m.pre + "{" + m.body + escClose + m.post;
+        return expand_(str, max2, true);
+      }
+      return [str];
+    }
+    let n;
+    if (isSequence) {
+      n = m.body.split(/\.\./);
+    } else {
+      n = parseCommaParts(m.body);
+      if (n.length === 1 && n[0] !== void 0) {
+        n = expand_(n[0], max2, false).map(embrace);
+        if (n.length === 1) {
+          return post2.map((p) => m.pre + n[0] + p);
+        }
+      }
+    }
+    let N;
+    if (isSequence && n[0] !== void 0 && n[1] !== void 0) {
+      const x = numeric(n[0]);
+      const y = numeric(n[1]);
+      const width = Math.max(n[0].length, n[1].length);
+      let incr = n.length === 3 && n[2] !== void 0 ? Math.abs(numeric(n[2])) : 1;
+      let test = lte;
+      const reverse = y < x;
+      if (reverse) {
+        incr *= -1;
+        test = gte;
+      }
+      const pad = n.some(isPadded);
+      N = [];
+      for (let i2 = x; test(i2, y); i2 += incr) {
+        let c;
+        if (isAlphaSequence) {
+          c = String.fromCharCode(i2);
+          if (c === "\\") {
+            c = "";
+          }
+        } else {
+          c = String(i2);
+          if (pad) {
+            const need = width - c.length;
+            if (need > 0) {
+              const z = new Array(need + 1).join("0");
+              if (i2 < 0) {
+                c = "-" + z + c.slice(1);
+              } else {
+                c = z + c;
+              }
+            }
+          }
+        }
+        N.push(c);
+      }
+    } else {
+      N = [];
+      for (let j = 0; j < n.length; j++) {
+        N.push.apply(N, expand_(n[j], max2, false));
+      }
+    }
+    for (let j = 0; j < N.length; j++) {
+      for (let k = 0; k < post2.length && expansions.length < max2; k++) {
+        const expansion = pre + N[j] + post2[k];
+        if (!isTop || isSequence || expansion) {
+          expansions.push(expansion);
+        }
+      }
+    }
+  }
+  return expansions;
+}
 
-// ../../node_modules/.pnpm/minimatch@9.0.9/node_modules/minimatch/dist/esm/assert-valid-pattern.js
+// ../../node_modules/.pnpm/minimatch@10.2.4/node_modules/minimatch/dist/esm/assert-valid-pattern.js
 var MAX_PATTERN_LENGTH = 1024 * 64;
 var assertValidPattern = (pattern) => {
   if (typeof pattern !== "string") {
@@ -278014,7 +278015,7 @@ var assertValidPattern = (pattern) => {
   }
 };
 
-// ../../node_modules/.pnpm/minimatch@9.0.9/node_modules/minimatch/dist/esm/brace-expressions.js
+// ../../node_modules/.pnpm/minimatch@10.2.4/node_modules/minimatch/dist/esm/brace-expressions.js
 var posixClasses = {
   "[:alnum:]": ["\\p{L}\\p{Nl}\\p{Nd}", true],
   "[:alpha:]": ["\\p{L}\\p{Nl}", true],
@@ -278123,12 +278124,15 @@ var parseClass = (glob, position) => {
   return [comb, uflag, endPos - pos, true];
 };
 
-// ../../node_modules/.pnpm/minimatch@9.0.9/node_modules/minimatch/dist/esm/unescape.js
-var unescape = (s, { windowsPathsNoEscape = false } = {}) => {
-  return windowsPathsNoEscape ? s.replace(/\[([^\/\\])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^\/\\])\]/g, "$1$2").replace(/\\([^\/])/g, "$1");
+// ../../node_modules/.pnpm/minimatch@10.2.4/node_modules/minimatch/dist/esm/unescape.js
+var unescape = (s, { windowsPathsNoEscape = false, magicalBraces = true } = {}) => {
+  if (magicalBraces) {
+    return windowsPathsNoEscape ? s.replace(/\[([^\/\\])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^\/\\])\]/g, "$1$2").replace(/\\([^\/])/g, "$1");
+  }
+  return windowsPathsNoEscape ? s.replace(/\[([^\/\\{}])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^\/\\{}])\]/g, "$1$2").replace(/\\([^\/{}])/g, "$1");
 };
 
-// ../../node_modules/.pnpm/minimatch@9.0.9/node_modules/minimatch/dist/esm/ast.js
+// ../../node_modules/.pnpm/minimatch@10.2.4/node_modules/minimatch/dist/esm/ast.js
 var _a;
 var types = /* @__PURE__ */ new Set(["!", "?", "+", "*", "@"]);
 var isExtglobType = (c) => types.has(c);
@@ -278154,9 +278158,30 @@ var adoptionAnyMap = /* @__PURE__ */ new Map([
 ]);
 var usurpMap = /* @__PURE__ */ new Map([
   ["!", /* @__PURE__ */ new Map([["!", "@"]])],
-  ["?", /* @__PURE__ */ new Map([["*", "*"], ["+", "*"]])],
-  ["@", /* @__PURE__ */ new Map([["!", "!"], ["?", "?"], ["@", "@"], ["*", "*"], ["+", "+"]])],
-  ["+", /* @__PURE__ */ new Map([["?", "*"], ["*", "*"]])]
+  [
+    "?",
+    /* @__PURE__ */ new Map([
+      ["*", "*"],
+      ["+", "*"]
+    ])
+  ],
+  [
+    "@",
+    /* @__PURE__ */ new Map([
+      ["!", "!"],
+      ["?", "?"],
+      ["@", "@"],
+      ["*", "*"],
+      ["+", "+"]
+    ])
+  ],
+  [
+    "+",
+    /* @__PURE__ */ new Map([
+      ["?", "*"],
+      ["*", "*"]
+    ])
+  ]
 ]);
 var startNoTraversal = "(?!(?:^|/)\\.\\.?(?:$|/))";
 var startNoDot = "(?!\\.)";
@@ -278167,6 +278192,7 @@ var regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
 var qmark = "[^/]";
 var star = qmark + "*?";
 var starNoEmpty = qmark + "+?";
+var ID = 0;
 var AST = class {
   type;
   #root;
@@ -278182,6 +278208,22 @@ var AST = class {
   // set to true if it's an extglob with no children
   // (which really means one child of '')
   #emptyExt = false;
+  id = ++ID;
+  get depth() {
+    return (this.#parent?.depth ?? -1) + 1;
+  }
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
+    return {
+      "@@type": "AST",
+      id: this.id,
+      type: this.type,
+      root: this.#root.id,
+      parent: this.#parent?.id,
+      depth: this.depth,
+      partsLength: this.#parts.length,
+      parts: this.#parts
+    };
+  }
   constructor(type, parent, options = {}) {
     this.type = type;
     if (type)
@@ -278378,7 +278420,7 @@ var AST = class {
         acc += c;
         continue;
       }
-      const doRecurse = isExtglobType(c) && str.charAt(i2) === "(" && /* c8 ignore start - the maxDepth is sufficient here */
+      const doRecurse = !opt.noext && isExtglobType(c) && str.charAt(i2) === "(" && /* c8 ignore start - the maxDepth is sufficient here */
       (extDepth <= maxDepth || ast && ast.#canAdoptType(c));
       if (doRecurse) {
         const depthAdd = ast && ast.#canAdoptType(c) ? 0 : 1;
@@ -278466,44 +278508,14 @@ var AST = class {
       return false;
     this.#parts = gc.#parts;
     for (const p of this.#parts) {
-      if (typeof p === "object")
+      if (typeof p === "object") {
         p.#parent = this;
+      }
     }
     this.type = nt;
     this.#toString = void 0;
     this.#emptyExt = false;
   }
-  #flatten() {
-    if (!isExtglobAST(this)) {
-      for (const p of this.#parts) {
-        if (typeof p === "object")
-          p.#flatten();
-      }
-    } else {
-      let iterations = 0;
-      let done = false;
-      do {
-        done = true;
-        for (let i2 = 0; i2 < this.#parts.length; i2++) {
-          const c = this.#parts[i2];
-          if (typeof c === "object") {
-            c.#flatten();
-            if (this.#canAdopt(c)) {
-              done = false;
-              this.#adopt(c, i2);
-            } else if (this.#canAdoptWithSpace(c)) {
-              done = false;
-              this.#adoptWithSpace(c, i2);
-            } else if (this.#canUsurp(c)) {
-              done = false;
-              this.#usurp(c);
-            }
-          }
-        }
-      } while (!done && ++iterations < 10);
-    }
-    this.#toString = void 0;
-  }
   static fromGlob(pattern, options = {}) {
     const ast = new _a(null, void 0, options);
     _a.#parseAST(pattern, ast, 0, options, 0);
@@ -278605,7 +278617,7 @@ var AST = class {
       this.#fillNegs();
     }
     if (!isExtglobAST(this)) {
-      const noEmpty = this.isStart() && this.isEnd();
+      const noEmpty = this.isStart() && this.isEnd() && !this.#parts.some((s) => typeof s !== "string");
       const src = this.#parts.map((p) => {
         const [re, _, hasMagic, uflag] = typeof p === "string" ? _a.#parseGlob(p, this.#hasMagic, noEmpty) : p.toRegExpSource(allowDot);
         this.#hasMagic = this.#hasMagic || hasMagic;
@@ -278676,6 +278688,38 @@ var AST = class {
       this.#uflag
     ];
   }
+  #flatten() {
+    if (!isExtglobAST(this)) {
+      for (const p of this.#parts) {
+        if (typeof p === "object") {
+          p.#flatten();
+        }
+      }
+    } else {
+      let iterations = 0;
+      let done = false;
+      do {
+        done = true;
+        for (let i2 = 0; i2 < this.#parts.length; i2++) {
+          const c = this.#parts[i2];
+          if (typeof c === "object") {
+            c.#flatten();
+            if (this.#canAdopt(c)) {
+              done = false;
+              this.#adopt(c, i2);
+            } else if (this.#canAdoptWithSpace(c)) {
+              done = false;
+              this.#adoptWithSpace(c, i2);
+            } else if (this.#canUsurp(c)) {
+              done = false;
+              this.#usurp(c);
+            }
+          }
+        }
+      } while (!done && ++iterations < 10);
+    }
+    this.#toString = void 0;
+  }
   #partsToRegExp(dot) {
     return this.#parts.map((p) => {
       if (typeof p === "string") {
@@ -278696,9 +278740,18 @@ var AST = class {
       if (escaping) {
         escaping = false;
         re += (reSpecials.has(c) ? "\\" : "") + c;
-        inStar = false;
         continue;
       }
+      if (c === "*") {
+        if (inStar)
+          continue;
+        inStar = true;
+        re += noEmpty && /^[*]+$/.test(glob) ? starNoEmpty : star;
+        hasMagic = true;
+        continue;
+      } else {
+        inStar = false;
+      }
       if (c === "\\") {
         if (i2 === glob.length - 1) {
           re += "\\\\";
@@ -278714,20 +278767,9 @@ var AST = class {
           uflag = uflag || needUflag;
           i2 += consumed2 - 1;
           hasMagic = hasMagic || magic;
-          inStar = false;
           continue;
         }
       }
-      if (c === "*") {
-        if (inStar)
-          continue;
-        inStar = true;
-        re += noEmpty && /^[*]+$/.test(glob) ? starNoEmpty : star;
-        hasMagic = true;
-        continue;
-      } else {
-        inStar = false;
-      }
       if (c === "?") {
         re += qmark;
         hasMagic = true;
@@ -278740,12 +278782,15 @@ var AST = class {
 };
 _a = AST;
 
-// ../../node_modules/.pnpm/minimatch@9.0.9/node_modules/minimatch/dist/esm/escape.js
-var escape = (s, { windowsPathsNoEscape = false } = {}) => {
+// ../../node_modules/.pnpm/minimatch@10.2.4/node_modules/minimatch/dist/esm/escape.js
+var escape = (s, { windowsPathsNoEscape = false, magicalBraces = false } = {}) => {
+  if (magicalBraces) {
+    return windowsPathsNoEscape ? s.replace(/[?*()[\]{}]/g, "[$&]") : s.replace(/[?*()[\]\\{}]/g, "\\$&");
+  }
   return windowsPathsNoEscape ? s.replace(/[?*()[\]]/g, "[$&]") : s.replace(/[?*()[\]\\]/g, "\\$&");
 };
 
-// ../../node_modules/.pnpm/minimatch@9.0.9/node_modules/minimatch/dist/esm/index.js
+// ../../node_modules/.pnpm/minimatch@10.2.4/node_modules/minimatch/dist/esm/index.js
 var minimatch = (p, pattern, options = {}) => {
   assertValidPattern(pattern);
   if (!options.nocomment && pattern.charAt(0) === "#") {
@@ -278861,7 +278906,7 @@ var braceExpand = (pattern, options = {}) => {
   if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
     return [pattern];
   }
-  return (0, import_brace_expansion.default)(pattern);
+  return expand(pattern, { max: options.braceExpandMax });
 };
 minimatch.braceExpand = braceExpand;
 var makeRe = (pattern, options = {}) => new Minimatch(pattern, options).makeRe();
@@ -278904,7 +278949,8 @@ var Minimatch = class {
     this.pattern = pattern;
     this.platform = options.platform || defaultPlatform;
     this.isWindows = this.platform === "win32";
-    this.windowsPathsNoEscape = !!options.windowsPathsNoEscape || options.allowWindowsEscape === false;
+    const awe = "allowWindowsEscape";
+    this.windowsPathsNoEscape = !!options.windowsPathsNoEscape || options[awe] === false;
     if (this.windowsPathsNoEscape) {
       this.pattern = this.pattern.replace(/\\/g, "/");
     }
@@ -278961,7 +279007,10 @@ var Minimatch = class {
         const isUNC = s[0] === "" && s[1] === "" && (s[2] === "?" || !globMagic.test(s[2])) && !globMagic.test(s[3]);
         const isDrive = /^[a-z]:/i.test(s[0]);
         if (isUNC) {
-          return [...s.slice(0, 4), ...s.slice(4).map((ss) => this.parse(ss))];
+          return [
+            ...s.slice(0, 4),
+            ...s.slice(4).map((ss) => this.parse(ss))
+          ];
         } else if (isDrive) {
           return [s[0], ...s.slice(1).map((ss) => this.parse(ss))];
         }
@@ -279277,9 +279326,11 @@ var Minimatch = class {
     ];
     if (head.length) {
       const fileHead = file.slice(fileIndex, fileIndex + head.length);
-      if (!this.#matchOne(fileHead, head, partial, 0, 0))
+      if (!this.#matchOne(fileHead, head, partial, 0, 0)) {
         return false;
+      }
       fileIndex += head.length;
+      patternIndex += head.length;
     }
     let fileTailMatch = 0;
     if (tail.length) {
@@ -279293,8 +279344,9 @@ var Minimatch = class {
           return false;
         }
         tailStart--;
-        if (!this.#matchOne(file, tail, partial, tailStart, 0))
+        if (!this.#matchOne(file, tail, partial, tailStart, 0)) {
           return false;
+        }
         fileTailMatch = tail.length + 1;
       }
     }
@@ -279330,6 +279382,8 @@ var Minimatch = class {
     }
     return !!this.#matchGlobStarBodySections(file, bodySegments, fileIndex, 0, partial, 0, !!fileTailMatch);
   }
+  // return false for "nope, not matching"
+  // return null for "not matching, cannot keep trying"
   #matchGlobStarBodySections(file, bodySegments, fileIndex, bodyIndex, partial, globStarDepth, sawTail) {
     const bs = bodySegments[bodyIndex];
     if (!bs) {
@@ -279347,8 +279401,9 @@ var Minimatch = class {
       const m = this.#matchOne(file.slice(0, fileIndex + body2.length), body2, partial, fileIndex, 0);
       if (m && globStarDepth < this.maxGlobstarRecursion) {
         const sub = this.#matchGlobStarBodySections(file, bodySegments, fileIndex + body2.length, bodyIndex + 1, partial, globStarDepth + 1, sawTail);
-        if (sub !== false)
+        if (sub !== false) {
           return sub;
+        }
       }
       const f = file[fileIndex];
       if (f === "." || f === ".." || !this.options.dot && f.startsWith(".")) {
@@ -279368,8 +279423,9 @@ var Minimatch = class {
       let p = pattern[pi];
       let f = file[fi];
       this.debug(pattern, p, f);
-      if (p === false || p === GLOBSTAR)
+      if (p === false || p === GLOBSTAR) {
         return false;
+      }
       let hit;
       if (typeof p === "string") {
         hit = f === p;
@@ -279452,16 +279508,27 @@ var Minimatch = class {
             pp[i2] = twoStar;
           }
         } else if (next === void 0) {
-          pp[i2 - 1] = prev + "(?:\\/|" + twoStar + ")?";
+          pp[i2 - 1] = prev + "(?:\\/|\\/" + twoStar + ")?";
         } else if (next !== GLOBSTAR) {
           pp[i2 - 1] = prev + "(?:\\/|\\/" + twoStar + "\\/)" + next;
           pp[i2 + 1] = GLOBSTAR;
         }
       });
-      return pp.filter((p) => p !== GLOBSTAR).join("/");
+      const filtered = pp.filter((p) => p !== GLOBSTAR);
+      if (this.partial && filtered.length >= 1) {
+        const prefixes = [];
+        for (let i2 = 1; i2 <= filtered.length; i2++) {
+          prefixes.push(filtered.slice(0, i2).join("/"));
+        }
+        return "(?:" + prefixes.join("|") + ")";
+      }
+      return filtered.join("/");
     }).join("|");
     const [open, close] = set.length > 1 ? ["(?:", ")"] : ["", ""];
     re = "^" + open + re + close + "$";
+    if (this.partial) {
+      re = "^(?:\\/|" + open + re.slice(1, -1) + close + ")$";
+    }
     if (this.negate)
       re = "^(?!" + re + ").+$";
     try {
@@ -282996,7 +283063,7 @@ var ContextEngine = class {
 // src/server.ts
 init_dist();
 
-// ../subscriptions/dist/chunk-ZZ2NRRC2.js
+// ../subscriptions/dist/chunk-WJ5IOQVB.js
 var PLAN_IDS = ["free", "pro", "team", "enterprise"];
 var PLAN_RANK = Object.fromEntries(
   PLAN_IDS.map((id, index2) => [id, index2])
@@ -283087,8 +283154,8 @@ var PLAN_DEFINITIONS = {
   pro: {
     displayName: "Pro",
     tagline: "Full verification for you and your team \u2014 fix, prove, and gate AI-generated code.",
-    monthlyPriceUsd: 9.99,
-    priceLabel: "$9.99/mo",
+    monthlyPriceUsd: 19,
+    priceLabel: "$19/mo",
     billingInterval: "month",
     badgeToken: "tier-pro",
     highlights: [
@@ -283107,8 +283174,8 @@ var PLAN_DEFINITIONS = {
   team: {
     displayName: "Team",
     tagline: "Verification-first building at scale.",
-    monthlyPriceUsd: 29.99,
-    priceLabel: "$29.99/mo",
+    monthlyPriceUsd: 19,
+    priceLabel: "$19/mo",
     billingInterval: "month",
     badgeToken: "tier-team",
     highlights: [
@@ -283131,8 +283198,8 @@ var PLAN_DEFINITIONS = {
   enterprise: {
     displayName: "Enterprise",
     tagline: "Teams, compliance, and scale.",
-    monthlyPriceUsd: 59.99,
-    priceLabel: "$59.99/mo",
+    monthlyPriceUsd: 19,
+    priceLabel: "$19/mo",
     billingInterval: "month",
     badgeToken: "tier-enterprise",
     highlights: [
@@ -283273,6 +283340,8 @@ var PLAN_QUOTAS = {
     islSpecsPerMonth: 0,
     atlasViewsPerMonth: Infinity,
     // wikicode/atlas is free per product spec
+    guidedRoutesPerDay: 5,
+    guidedFollowUpsPerRoute: 5,
     proofHistoryEntries: 0
   },
   pro: {
@@ -283300,6 +283369,8 @@ var PLAN_QUOTAS = {
     contextEngineRulesPerMonth: Infinity,
     islSpecsPerMonth: Infinity,
     atlasViewsPerMonth: Infinity,
+    guidedRoutesPerDay: Infinity,
+    guidedFollowUpsPerRoute: Infinity,
     proofHistoryEntries: Infinity
   },
   team: {
@@ -283326,6 +283397,8 @@ var PLAN_QUOTAS = {
     contextEngineRulesPerMonth: Infinity,
     islSpecsPerMonth: Infinity,
     atlasViewsPerMonth: Infinity,
+    guidedRoutesPerDay: Infinity,
+    guidedFollowUpsPerRoute: Infinity,
     proofHistoryEntries: Infinity
   },
   enterprise: {
@@ -283352,6 +283425,8 @@ var PLAN_QUOTAS = {
     contextEngineRulesPerMonth: Infinity,
     islSpecsPerMonth: Infinity,
     atlasViewsPerMonth: Infinity,
+    guidedRoutesPerDay: Infinity,
+    guidedFollowUpsPerRoute: Infinity,
     proofHistoryEntries: Infinity
   }
 };
@@ -283757,12 +283832,18 @@ var FEATURE_REGISTRY = {
     requiredPlan: "free",
     category: "analysis"
   },
-  /** CLI `vibecheck roast` — stylized scan output (free tier). */
+  /** CLI `vibecheck roast` — stylized scan output (free for everyone; no login on CLI). */
   Roast: {
     entitlement: ENTITLEMENTS.SCAN_BASIC,
     title: "Roast",
     subtitle: "Scan findings with editorial voice",
-    benefits: ["Same engines as scan", "Shareable output", "CLI and IDE entry points"],
+    benefits: [
+      "Same engines as scan",
+      "No VibeCheck login required (CLI)",
+      "Does not consume daily scan quota",
+      "Shareable output",
+      "CLI, MCP, and IDE panel"
+    ],
     requiredPlan: "free",
     category: "analysis"
   },
@@ -283850,6 +283931,20 @@ var FEATURE_REGISTRY = {
     requiredPlan: "free",
     category: "analysis"
   },
+  /**
+   * LLM-powered guided routes (intent → stops). Free tier: taste limit from `PLAN_QUOTAS.free.guidedRoutesPerDay`;
+   * Pro+ unlimited. Use getAccessMode + getLimitForFeature — not canAccessFeature alone.
+   */
+  "Guided Route": {
+    entitlement: ENTITLEMENTS.WIKICODE_VIEW,
+    title: "Guided Route (LLM)",
+    subtitle: "Intent-driven tour with AI-ordered stops",
+    benefits: ["Hybrid search + call graph context", "Next/prev stops", "Follow-up Q&A on each stop"],
+    requiredPlan: "pro",
+    category: "analysis",
+    freeTasteLimit: "guidedRoute",
+    upgradeMessage: "You have used today\u2019s free guided routes. Upgrade to Pro for unlimited LLM routes and follow-ups."
+  },
   "Proof History": {
     entitlement: ENTITLEMENTS.PROOF_VIEW,
     title: "Proof History",
@@ -284095,7 +284190,8 @@ var VALID_FEATURE_LIMIT_KEYS = /* @__PURE__ */ new Set([
   "islSpec",
   "atlas",
   "proofHistory",
-  "autoFix"
+  "autoFix",
+  "guidedRoute"
 ]);
 function validateFeatureRegistry() {
   const errs = [];
@@ -284169,6 +284265,8 @@ var FEATURE_NAMES = {
   REVIEW_WORKFLOWS: "Review Workflows",
   FLOW_WORKFLOWS: "Flow Workflows",
   WIKICODE_ATLAS: "WikiCode Atlas",
+  /** LLM guided routes — use getAccessMode for free taste vs Pro unlimited */
+  GUIDED_ROUTE: "Guided Route",
   SHIP_SCORE: "Ship Score",
   ISL_STUDIO: "ISL Studio",
   // ── Pro features ────────────────────────────────────────────────────────
@@ -285147,7 +285245,7 @@ function createScanIdempotencyKey(prefix) {
 // src/mcp-scan-meter-client.ts
 var MCP_SCAN_METER_CLIENT = {
   type: "mcp",
-  version: "24.0.0"
+  version: "24.0.2"
 };
 
 // src/server.ts
@@ -285438,7 +285536,7 @@ async function handleCallToolRequest(request, runtimeOverrides = {}) {
 ${validation.errors.join("\n")}`
     );
   }
-  const BILLABLE_ENGINE_TOOLS = /* @__PURE__ */ new Set(["vibecheck_scan", "vibecheck_roast", "vibecheck_score"]);
+  const BILLABLE_ENGINE_TOOLS = /* @__PURE__ */ new Set(["vibecheck_scan", "vibecheck_score"]);
   if (BILLABLE_ENGINE_TOOLS.has(name2)) {
     const token = process.env.VIBECHECK_TOKEN?.trim();
     if (token && !shouldSkipServerScanMetering() && !isUnlimitedDailyScansPlan(userPlan)) {
@@ -285567,16 +285665,6 @@ ${validation.errors.join("\n")}`
           MCP_TOOL_TIMEOUT_MS,
           "vibecheck_roast"
         );
-        const roastRec = await recordMcpBillableUsage("mcp-roast");
-        if (!roastRec.ok) {
-          return buildErrorResponse(
-            JSON.stringify({
-              code: "SCAN_RECORD_FAILED",
-              message: "Roast completed locally but scan usage could not be recorded.",
-              detail: roastRec.message
-            })
-          );
-        }
         return {
           content: [{ type: "text", text: output }]
         };