token-goat 2.6.32 → 2.6.34

package/dist/{token-goat-hook-chunk-DHW6SRHR.mjs → token-goat-hook-chunk-CNLMPHXT.mjs}

@@ -2,17 +2,13 @@ import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
 import {
   registerReset
-} from "./token-goat-hook-chunk-J2ZK2FYW.mjs";
-import {
-  init_define_import_meta_env
-} from "./token-goat-hook-chunk-K33JMLL7.mjs";
+} from "./token-goat-hook-chunk-BUOCULAM.mjs";
 
 // src/version.ts
-init_define_import_meta_env();
 import { createRequire } from "node:module";
 function resolveVersion() {
   if (true) {
-    return "2.6.32";
+    return "2.6.34";
   }
   const require2 = createRequire(import.meta.url);
   const pkg = require2("../package.json");
@@ -21,7 +17,6 @@ function resolveVersion() {
 var VERSION = resolveVersion();
 
 // src/constants.ts
-init_define_import_meta_env();
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
@@ -137,7 +132,6 @@ var ENV_KEYS = {
 var SYMBOL_BODY_CHAR_CAP = 128 * 1024;
 
 // src/bridges/registry.ts
-init_define_import_meta_env();
 var KNOWN_HARNESS_NAMES = /* @__PURE__ */ new Set([
   "claudecode",
   "codex",
@@ -149,6 +143,7 @@ var KNOWN_HARNESS_NAMES = /* @__PURE__ */ new Set([
   "copilot_cli",
   "grok",
   "qwen",
+  "kimi",
   "generic"
 ]);
 function detectHarness() {
@@ -199,7 +194,6 @@ function resetHarnessCache() {
 registerReset(resetHarnessCache);
 
 // src/paths.ts
-init_define_import_meta_env();
 import * as fs2 from "node:fs";
 import * as path2 from "node:path";
 var WSL_PATH_RE = /^\/mnt\/([a-zA-Z])\/(.*)$/s;
@@ -294,9 +288,20 @@ function safeJoin(base, ...parts) {
   }
   return path2.join(base, ...parts);
 }
+function displaySafeText(text) {
+  return text.replace(new RegExp("[\\u0000-\\u001f\\u007f-\\u009f\\u2028\\u2029]|\\p{Cf}", "gu"), (ch) => {
+    if (ch === "\n") return "\\n";
+    if (ch === "\r") return "\\r";
+    if (ch === "	") return "\\t";
+    const code = ch.codePointAt(0) ?? 0;
+    return code <= 255 ? "\\x" + code.toString(16).padStart(2, "0") : "\\u" + code.toString(16).padStart(4, "0");
+  });
+}
+function displaySafePath(p) {
+  return displaySafeText(p);
+}
 
 // src/util.ts
-init_define_import_meta_env();
 import { spawn, spawnSync } from "node:child_process";
 import { chmodSync as chmodSync2, closeSync, copyFileSync, existsSync, mkdirSync as mkdirSync2, openSync, readdirSync, readFileSync, renameSync, statSync as statSync2, unlinkSync, writeFileSync, writeSync } from "node:fs";
 import * as path3 from "node:path";
@@ -732,6 +737,11 @@ function countNoun(count, singular, plural = `${singular}s`) {
 function excludeTestsHiddenNote(count) {
   return `${count} in test ${count === 1 ? "file" : "files"} hidden by --exclude-tests`;
 }
+function countContentLines(content) {
+  if (content === "") return 0;
+  const n = content.split("\n").length;
+  return content.endsWith("\n") ? n - 1 : n;
+}
 function escapeRegExp(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
@@ -908,9 +918,74 @@ function packageNameDistance(a, b, cap = 3) {
 function suggestPackageNames(query, names) {
   return [...new Set(names)].map((n) => ({ n, d: packageNameDistance(query.toLowerCase(), n.toLowerCase()) })).filter((x) => x.d <= 3).sort((a, b) => a.d - b.d).slice(0, 5).map((x) => x.n);
 }
+function detectSourceEncoding(buf) {
+  if (buf.length >= 4) {
+    if (buf[0] === 255 && buf[1] === 254 && buf[2] === 0 && buf[3] === 0) return "utf32le";
+    if (buf[0] === 0 && buf[1] === 0 && buf[2] === 254 && buf[3] === 255) return "utf32be";
+  }
+  if (buf.length >= 2) {
+    if (buf[0] === 255 && buf[1] === 254) return "utf16le";
+    if (buf[0] === 254 && buf[1] === 255) return "utf16be";
+  }
+  if (buf.length >= 3 && buf[0] === 239 && buf[1] === 187 && buf[2] === 191) return "utf8-bom";
+  return "utf8";
+}
+function decodeSource(buf) {
+  switch (detectSourceEncoding(buf)) {
+    case "utf32le":
+      return decodeUtf32(buf.subarray(4), true);
+    case "utf32be":
+      return decodeUtf32(buf.subarray(4), false);
+    case "utf16le":
+      return buf.subarray(2).toString("utf16le");
+    case "utf16be":
+      return swap16(buf.subarray(2)).toString("utf16le");
+    case "utf8-bom":
+      return buf.subarray(3).toString("utf8");
+    default:
+      return buf.toString("utf8");
+  }
+}
+function encodeSource(text, encoding) {
+  switch (encoding) {
+    case "utf32le":
+      return Buffer.concat([Buffer.from([255, 254, 0, 0]), encodeUtf32(text, true)]);
+    case "utf32be":
+      return Buffer.concat([Buffer.from([0, 0, 254, 255]), encodeUtf32(text, false)]);
+    case "utf16le":
+      return Buffer.concat([Buffer.from([255, 254]), Buffer.from(text, "utf16le")]);
+    case "utf16be":
+      return Buffer.concat([Buffer.from([254, 255]), swap16(Buffer.from(text, "utf16le"))]);
+    case "utf8-bom":
+      return Buffer.concat([Buffer.from([239, 187, 191]), Buffer.from(text, "utf8")]);
+    default:
+      return Buffer.from(text, "utf8");
+  }
+}
+function swap16(buf) {
+  const out = Buffer.from(buf);
+  return out.subarray(0, out.length - out.length % 2).swap16();
+}
+function decodeUtf32(buf, littleEndian) {
+  const points = [];
+  for (let i = 0; i + 4 <= buf.length; i += 4) {
+    const cp = littleEndian ? buf.readUInt32LE(i) : buf.readUInt32BE(i);
+    points.push(cp > 1114111 || cp >= 55296 && cp <= 57343 ? 65533 : cp);
+  }
+  return String.fromCodePoint(...points);
+}
+function encodeUtf32(text, littleEndian) {
+  const points = [...text];
+  const out = Buffer.alloc(points.length * 4);
+  points.forEach((ch, i) => {
+    const cp = ch.codePointAt(0) ?? 65533;
+    if (littleEndian) out.writeUInt32LE(cp, i * 4);
+    else out.writeUInt32BE(cp, i * 4);
+  });
+  return out;
+}
 
 // src/fingerprint.ts
-init_define_import_meta_env();
 import { createHash } from "node:crypto";
 import * as fs3 from "node:fs";
 function fingerprintContent(content) {
@@ -930,9 +1005,15 @@ function fingerprintFile(filePath) {
   }
   return fingerprintContent(data);
 }
+function fileIsAbsent(filePath) {
+  try {
+    return fs3.statSync(filePath, { throwIfNoEntry: false }) === void 0;
+  } catch {
+    return false;
+  }
+}
 
 // src/project.ts
-init_define_import_meta_env();
 import * as fs4 from "node:fs";
 import * as os2 from "node:os";
 import * as path4 from "node:path";
@@ -1146,24 +1227,10 @@ function isInsideRoot(target, root) {
 }
 
 // src/config.ts
-init_define_import_meta_env();
 import * as fs5 from "node:fs";
 import * as path5 from "node:path";
 
-// node_modules/smol-toml/dist/index.js
-init_define_import_meta_env();
-
-// node_modules/smol-toml/dist/parse.js
-init_define_import_meta_env();
-
-// node_modules/smol-toml/dist/struct.js
-init_define_import_meta_env();
-
-// node_modules/smol-toml/dist/primitive.js
-init_define_import_meta_env();
-
 // node_modules/smol-toml/dist/date.js
-init_define_import_meta_env();
 var DATE_TIME_RE = /^(\d{4}-\d{2}-\d{2})?[T ]?(?:(\d{2}):\d{2}(?::\d{2}(?:\.\d+)?)?)?(Z|[-+]\d{2}:\d{2})?$/i;
 var TomlDate = class _TomlDate extends Date {
   #hasDate = false;
@@ -1256,7 +1323,6 @@ var TomlDate = class _TomlDate extends Date {
 };
 
 // node_modules/smol-toml/dist/error.js
-init_define_import_meta_env();
 function getLineColFromPtr(string, ptr) {
   let lines = string.slice(0, ptr).split(/\r\n|\n|\r/g);
   return [lines.length, lines.pop().length + 1];
@@ -1296,57 +1362,111 @@ ${codeblock}`, options);
   }
 };
 
+// node_modules/smol-toml/dist/util.js
+function indexOfNewline(str, start = 0) {
+  let idx = str.indexOf("\n", start);
+  if (str.charCodeAt(idx - 1) === 13)
+    idx--;
+  return idx;
+}
+function skipComment(ctx) {
+  for (; ctx.p < ctx.s.length; ctx.p++) {
+    let c = ctx.s.charCodeAt(ctx.p);
+    if (c === 10)
+      break;
+    if (c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10) {
+      ctx.p++;
+      break;
+    }
+    if (c < 32 && c !== 9 || c === 127) {
+      throw new TomlError("control characters are not allowed in comments", {
+        toml: ctx.s,
+        ptr: ctx.p
+      });
+    }
+  }
+}
+function skipVoid(ctx, banNewLines, banComments) {
+  let c;
+  while (1) {
+    while ((c = ctx.s.charCodeAt(ctx.p)) === 32 || c === 9 || !banNewLines && (c === 10 || c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10))
+      ctx.p++;
+    if (banComments || c !== 35)
+      break;
+    skipComment(ctx);
+  }
+}
+function skipUntil(ctx, sep, end) {
+  let ptr = ctx.p;
+  if (!end) {
+    ptr = indexOfNewline(ctx.s, ptr);
+    ctx.p = ptr < 0 ? ctx.s.length : ptr;
+    return;
+  }
+  for (; ctx.p < ctx.s.length; ctx.p++) {
+    let c = ctx.s.charCodeAt(ctx.p);
+    if (c === 35) {
+      skipComment(ctx);
+    } else if (c === end || c === sep) {
+      return;
+    }
+  }
+  throw new TomlError("cannot find end of structure", {
+    toml: ctx.s,
+    ptr
+  });
+}
+
 // node_modules/smol-toml/dist/primitive.js
 var INT_REGEX = /^((0x[0-9a-fA-F](_?[0-9a-fA-F])*)|(([+-]|0[ob])?\d(_?\d)*))$/;
 var FLOAT_REGEX = /^[+-]?\d(_?\d)*(\.\d(_?\d)*)?([eE][+-]?\d(_?\d)*)?$/;
 var LEADING_ZERO = /^[+-]?0[0-9_]/;
-function parseString(str, ptr) {
-  let c = str[ptr++];
+function parseString(ctx) {
+  let start = ctx.p;
+  let c = ctx.s.charCodeAt(ctx.p++);
   let first = c;
-  let isLiteral = c === "'";
-  let isMultiline = c === str[ptr] && c === str[ptr + 1];
+  let isLiteral = c === 39;
+  let isMultiline = c === ctx.s.charCodeAt(ctx.p) && c === ctx.s.charCodeAt(ctx.p + 1);
   if (isMultiline) {
-    if (str[ptr += 2] === "\n")
-      ptr++;
-    else if (str[ptr] === "\r" && str[ptr + 1] === "\n")
-      ptr += 2;
+    if ((c = ctx.s.charCodeAt(ctx.p += 2)) === 10)
+      ctx.p++;
+    else if (c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)
+      ctx.p += 2;
   }
   let parsed = "";
-  let sliceStart = ptr;
+  let sliceStart = ctx.p;
   let state = 0;
-  for (let i = ptr; i < str.length; i++) {
-    c = str[i];
-    if (isMultiline && (c === "\n" || c === "\r" && str[i + 1] === "\n")) {
+  for (; ctx.p < ctx.s.length; ctx.p++) {
+    c = ctx.s.charCodeAt(ctx.p);
+    if (isMultiline && (c === 10 || c === 13 && ctx.s.charCodeAt(ctx.p + 1) === 10)) {
       state = state && 3;
-    } else if (c < " " && c !== "	" || c === "\x7F") {
+    } else if (c < 32 && c !== 9 || c === 127) {
       throw new TomlError("control characters are not allowed in strings", {
-        toml: str,
-        ptr: i
+        toml: ctx.s,
+        ptr: ctx.p
       });
-    } else if ((!state || state === 3) && c === first && (!isMultiline || str[i + 1] === first && str[i + 2] === first)) {
+    } else if ((!state || state === 3) && c === first && (!isMultiline || ctx.s.charCodeAt(ctx.p + 1) === first && ctx.s.charCodeAt(ctx.p + 2) === first)) {
       if (isMultiline) {
-        if (str[i + 3] === first)
-          i++;
-        if (str[i + 3] === first)
-          i++;
+        if (ctx.s.charCodeAt(ctx.p + 3) === first)
+          ctx.p++;
+        if (ctx.s.charCodeAt(ctx.p + 3) === first)
+          ctx.p++;
       }
-      return [
-        // If we're in a newline escape still, then there's nothing to add.
-        // Also try to avoid concat if there's nothing to add to parsed, or nothing has been added to parsed.
-        state ? parsed : parsed + str.slice(sliceStart, i),
-        i + (isMultiline ? 3 : 1)
-      ];
+      if (!state)
+        parsed += ctx.s.slice(sliceStart, ctx.p);
+      ctx.p += isMultiline ? 3 : 1;
+      return parsed;
     } else if (!state) {
-      if (!isLiteral && c === "\\") {
-        parsed += str.slice(sliceStart, sliceStart = i);
+      if (!isLiteral && c === 92) {
+        parsed += ctx.s.slice(sliceStart, sliceStart = ctx.p);
         state = 1;
       }
     } else if (state === 1) {
-      if (c === "x" || c === "u" || c === "U") {
+      if (c === 120 || c === 117 || c === 85) {
         let value = 0;
-        let len = c === "x" ? 2 : c === "u" ? 4 : 8;
-        for (let j = 0; j < len; j++, i++) {
-          let hex = str.charCodeAt(i + 1);
+        let len = c === 120 ? 2 : c === 117 ? 4 : 8;
+        for (let j = 0; j < len; j++, ctx.p++) {
+          let hex = ctx.s.charCodeAt(ctx.p + 1);
           let digit = (
             /* 0-9 */
             hex >= 48 && hex <= 57 ? hex - 48 : (
@@ -1358,57 +1478,68 @@ function parseString(str, ptr) {
             )
           );
           if (digit < 0)
-            throw new TomlError("invalid non-hex character in unicode escape", { toml: str, ptr: i + 1 });
+            throw new TomlError("invalid non-hex character in unicode escape", { toml: ctx.s, ptr: ctx.p + 1 });
           value = value << 4 | digit;
         }
         if (value < 0 || value > 1114111 || value >= 55296 && value <= 57343) {
-          throw new TomlError("invalid unicode escape", { toml: str, ptr: i });
+          throw new TomlError("invalid unicode escape", { toml: ctx.s, ptr: ctx.p });
         }
         parsed += String.fromCodePoint(value);
-        sliceStart = i + 1;
+        sliceStart = ctx.p + 1;
         state = 0;
-      } else if (c === " " || c === "	") {
+      } else if (c === 32 || c === 9) {
         state = 2;
       } else {
-        if (c === "b")
+        if (c === 98)
           parsed += "\b";
-        else if (c === "t")
+        else if (c === 116)
           parsed += "	";
-        else if (c === "n")
+        else if (c === 110)
           parsed += "\n";
-        else if (c === "f")
+        else if (c === 102)
           parsed += "\f";
-        else if (c === "r")
+        else if (c === 114)
           parsed += "\r";
-        else if (c === "e")
+        else if (c === 101)
           parsed += "\x1B";
-        else if (c === '"')
+        else if (c === 34)
           parsed += '"';
-        else if (c === "\\")
+        else if (c === 92)
           parsed += "\\";
         else
-          throw new TomlError("unrecognized escape sequence", { toml: str, ptr: i });
-        sliceStart = i + 1;
+          throw new TomlError("unrecognized escape sequence", { toml: ctx.s, ptr: ctx.p });
+        sliceStart = ctx.p + 1;
         state = 0;
       }
-    } else if (c !== " " && c !== "	") {
+    } else if (c !== 32 && c !== 9) {
       if (state === 2) {
         throw new TomlError("invalid escape: only line-ending whitespace may be escaped", {
-          toml: str,
+          toml: ctx.s,
           ptr: sliceStart
         });
       }
-      state = !isLiteral && c === "\\" ? 1 : 0;
-      sliceStart = i;
+      state = !isLiteral && c === 92 ? 1 : 0;
+      sliceStart = ctx.p;
     }
   }
-  throw new TomlError("unfinished string", { toml: str, ptr });
+  throw new TomlError("unfinished string", { toml: ctx.s, ptr: start });
 }
-function parseValue(value, toml, ptr, integersAsBigInt) {
-  if (value === "true")
-    return true;
-  if (value === "false")
-    return false;
+function sliceAndTrimEndOf(ctx, start, end) {
+  let value = ctx.s.slice(start, end);
+  let commentIdx = value.indexOf("#");
+  if (commentIdx > 0) {
+    skipComment({ s: value, p: commentIdx, d: 0 });
+    value = value.slice(0, commentIdx);
+  }
+  return value.trimEnd();
+}
+function parseValue(ctx, integersAsBigInt, end) {
+  let ptr = ctx.p;
+  let err = { toml: ctx.s, ptr };
+  skipUntil(ctx, 44, end);
+  let value = sliceAndTrimEndOf(ctx, ptr, ctx.p);
+  if (!value)
+    throw new TomlError("incomplete declaration: value expected", err);
   if (value === "-inf")
     return -Infinity;
   if (value === "inf" || value === "+inf")
@@ -1420,25 +1551,16 @@ function parseValue(value, toml, ptr, integersAsBigInt) {
   let isInt = INT_REGEX.test(value);
   if (isInt || FLOAT_REGEX.test(value)) {
     if (LEADING_ZERO.test(value)) {
-      throw new TomlError("leading zeroes are not allowed", {
-        toml,
-        ptr
-      });
+      throw new TomlError("leading zeroes are not allowed", err);
     }
     value = value.replace(/_/g, "");
     let numeric = +value;
     if (isNaN(numeric)) {
-      throw new TomlError("invalid number", {
-        toml,
-        ptr
-      });
+      throw new TomlError("invalid number", err);
     }
     if (isInt) {
       if ((isInt = !Number.isSafeInteger(numeric)) && !integersAsBigInt) {
-        throw new TomlError("integer value cannot be represented losslessly", {
-          toml,
-          ptr
-        });
+        throw new TomlError("integer value cannot be represented losslessly", err);
       }
       if (isInt || integersAsBigInt === true)
         numeric = BigInt(value);
@@ -1446,281 +1568,184 @@ function parseValue(value, toml, ptr, integersAsBigInt) {
     return numeric;
   }
   const date = new TomlDate(value);
-  if (!date.isValid()) {
-    throw new TomlError("invalid value", {
-      toml,
-      ptr
-    });
-  }
+  if (!date.isValid())
+    throw new TomlError("invalid value", err);
   return date;
 }
 
 // node_modules/smol-toml/dist/extract.js
-init_define_import_meta_env();
-
-// node_modules/smol-toml/dist/util.js
-init_define_import_meta_env();
-function indexOfNewline(str, start = 0, end = str.length) {
-  let idx = str.indexOf("\n", start);
-  if (str[idx - 1] === "\r")
-    idx--;
-  return idx <= end ? idx : -1;
-}
-function skipComment(str, ptr) {
-  for (let i = ptr; i < str.length; i++) {
-    let c = str[i];
-    if (c === "\n")
-      return i;
-    if (c === "\r" && str[i + 1] === "\n")
-      return i + 1;
-    if (c < " " && c !== "	" || c === "\x7F") {
-      throw new TomlError("control characters are not allowed in comments", {
-        toml: str,
+function extractValue(ctx, end, integersAsBigInt) {
+  let ptr = ctx.p;
+  let c = ctx.s.charCodeAt(ptr);
+  if (c === 91 || c === 123) {
+    if (!ctx.d--) {
+      throw new TomlError("document contains excessively nested structures. aborting.", {
+        toml: ctx.s,
         ptr
       });
     }
+    let value = c === 91 ? parseArray(ctx, integersAsBigInt) : parseInlineTable(ctx, integersAsBigInt);
+    ctx.d++;
+    return value;
   }
-  return str.length;
-}
-function skipVoid(str, ptr, banNewLines, banComments) {
-  let c;
-  while (1) {
-    while ((c = str[ptr]) === " " || c === "	" || !banNewLines && (c === "\n" || c === "\r" && str[ptr + 1] === "\n"))
-      ptr++;
-    if (banComments || c !== "#")
-      break;
-    ptr = skipComment(str, ptr);
-  }
-  return ptr;
-}
-function skipUntil(str, ptr, sep, end, banNewLines = false) {
-  if (!end) {
-    ptr = indexOfNewline(str, ptr);
-    return ptr < 0 ? str.length : ptr;
-  }
-  for (let i = ptr; i < str.length; i++) {
-    let c = str[i];
-    if (c === "#") {
-      i = indexOfNewline(str, i);
-    } else if (c === sep) {
-      return i + 1;
-    } else if (c === end || banNewLines && (c === "\n" || c === "\r" && str[i + 1] === "\n")) {
-      return i;
-    }
-  }
-  throw new TomlError("cannot find end of structure", {
-    toml: str,
-    ptr
-  });
-}
-
-// node_modules/smol-toml/dist/extract.js
-function sliceAndTrimEndOf(str, startPtr, endPtr) {
-  let value = str.slice(startPtr, endPtr);
-  let commentIdx = value.indexOf("#");
-  if (commentIdx > -1) {
-    skipComment(str, commentIdx);
-    value = value.slice(0, commentIdx);
+  if (c === 34 || c === 39) {
+    return parseString(ctx);
   }
-  return [value.trimEnd(), commentIdx];
-}
-function extractValue(str, ptr, end, depth, integersAsBigInt) {
-  if (depth === 0) {
-    throw new TomlError("document contains excessively nested structures. aborting.", {
-      toml: str,
-      ptr
-    });
-  }
-  let c = str[ptr];
-  if (c === "[" || c === "{") {
-    let [value, endPtr2] = c === "[" ? parseArray(str, ptr, depth, integersAsBigInt) : parseInlineTable(str, ptr, depth, integersAsBigInt);
-    if (end) {
-      endPtr2 = skipVoid(str, endPtr2);
-      if (str[endPtr2] === ",")
-        endPtr2++;
-      else if (str[endPtr2] !== end) {
-        throw new TomlError("expected comma or end of structure", {
-          toml: str,
-          ptr: endPtr2
-        });
-      }
-    }
-    return [value, endPtr2];
-  }
-  if (c === '"' || c === "'") {
-    let [parsed, endPtr2] = parseString(str, ptr);
-    if (end) {
-      endPtr2 = skipVoid(str, endPtr2);
-      if (str[endPtr2] && str[endPtr2] !== "," && str[endPtr2] !== end && str[endPtr2] !== "\n" && str[endPtr2] !== "\r") {
-        throw new TomlError("unexpected character encountered", {
-          toml: str,
-          ptr: endPtr2
-        });
-      }
-      if (str[endPtr2] === ",")
-        endPtr2++;
-    }
-    return [parsed, endPtr2];
-  }
-  let endPtr = skipUntil(str, ptr, ",", end);
-  let slice = sliceAndTrimEndOf(str, ptr, endPtr - (str[endPtr - 1] === "," ? 1 : 0));
-  if (!slice[0]) {
-    throw new TomlError("incomplete key-value declaration: no value specified", {
-      toml: str,
-      ptr
-    });
+  if (c === 116) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 114 || ctx.s.charCodeAt(++ctx.p) !== 117 || ctx.s.charCodeAt(++ctx.p) !== 101)
+      throw new TomlError("invalid value", { toml: ctx.s, ptr });
+    ctx.p++;
+    return true;
   }
-  if (end && slice[1] > -1) {
-    endPtr = skipVoid(str, ptr + slice[1]);
-    if (str[endPtr] === ",")
-      endPtr++;
+  if (c === 102) {
+    if (ctx.s.charCodeAt(++ctx.p) !== 97 || ctx.s.charCodeAt(++ctx.p) !== 108 || ctx.s.charCodeAt(++ctx.p) !== 115 || ctx.s.charCodeAt(++ctx.p) !== 101)
+      throw new TomlError("invalid value", { toml: ctx.s, ptr });
+    ctx.p++;
+    return false;
   }
-  return [
-    parseValue(slice[0], str, ptr, integersAsBigInt),
-    endPtr
-  ];
+  return parseValue(ctx, integersAsBigInt, end);
 }
 
 // node_modules/smol-toml/dist/struct.js
 var KEY_PART_RE = /^[a-zA-Z0-9-_]+[ \t]*$/;
-function parseKey(str, ptr, end = "=") {
-  let dot = ptr - 1;
+function parseKey(ctx, end = "=") {
+  let start = ctx.p;
+  let dot = start - 1;
   let parsed = [];
-  let endPtr = str.indexOf(end, ptr);
+  let endPtr = ctx.s.indexOf(end, start);
   if (endPtr < 0) {
     throw new TomlError("incomplete key-value: cannot find end of key", {
-      toml: str,
-      ptr
+      toml: ctx.s,
+      ptr: start
     });
   }
   do {
-    let c = str[ptr = ++dot];
-    if (c !== " " && c !== "	") {
-      if (c === '"' || c === "'") {
-        if (c === str[ptr + 1] && c === str[ptr + 2]) {
+    let c = ctx.s.charCodeAt(ctx.p = ++dot);
+    if (c !== 32 && c !== 9) {
+      if (c === 34 || c === 39) {
+        if (c === ctx.s.charCodeAt(ctx.p + 1) && c === ctx.s.charCodeAt(ctx.p + 2)) {
           throw new TomlError("multiline strings are not allowed in keys", {
-            toml: str,
-            ptr
+            toml: ctx.s,
+            ptr: ctx.p
           });
         }
-        let [part, eos] = parseString(str, ptr);
-        dot = str.indexOf(".", eos);
-        let strEnd = str.slice(eos, dot < 0 || dot > endPtr ? endPtr : dot);
+        let part = parseString(ctx);
+        dot = ctx.s.indexOf(".", ctx.p);
+        let strEnd = ctx.s.slice(ctx.p, dot < 0 || dot > endPtr ? endPtr : dot);
         let newLine = indexOfNewline(strEnd);
         if (newLine > -1) {
           throw new TomlError("newlines are not allowed in keys", {
-            toml: str,
-            ptr: ptr + dot + newLine
+            toml: ctx.s,
+            ptr: newLine
           });
         }
         if (strEnd.trimStart()) {
           throw new TomlError("found extra tokens after the string part", {
-            toml: str,
-            ptr: eos
+            toml: ctx.s,
+            ptr: ctx.p
           });
         }
-        if (endPtr < eos) {
-          endPtr = str.indexOf(end, eos);
+        if (endPtr < ctx.p) {
+          endPtr = ctx.s.indexOf(end, ctx.p);
           if (endPtr < 0) {
             throw new TomlError("incomplete key-value: cannot find end of key", {
-              toml: str,
-              ptr
+              toml: ctx.s,
+              ptr: start
             });
           }
         }
         parsed.push(part);
       } else {
-        dot = str.indexOf(".", ptr);
-        let part = str.slice(ptr, dot < 0 || dot > endPtr ? endPtr : dot);
+        dot = ctx.s.indexOf(".", ctx.p);
+        let part = ctx.s.slice(ctx.p, dot < 0 || dot > endPtr ? endPtr : dot);
         if (!KEY_PART_RE.test(part)) {
           throw new TomlError("only letter, numbers, dashes and underscores are allowed in keys", {
-            toml: str,
-            ptr
+            toml: ctx.s,
+            ptr: ctx.p
           });
         }
         parsed.push(part.trimEnd());
       }
     }
   } while (dot + 1 && dot < endPtr);
-  return [parsed, skipVoid(str, endPtr + 1, true, true)];
+  ctx.p = endPtr + 1;
+  skipVoid(ctx, true, true);
+  return parsed;
 }
-function parseInlineTable(str, ptr, depth, integersAsBigInt) {
+function parseInlineTable(ctx, integersAsBigInt) {
   let res = {};
   let seen = /* @__PURE__ */ new Set();
   let c;
-  ptr++;
-  while ((c = str[ptr++]) !== "}" && c) {
-    if (c === ",") {
-      throw new TomlError("expected value, found comma", {
-        toml: str,
-        ptr: ptr - 1
-      });
-    } else if (c === "#")
-      ptr = skipComment(str, ptr);
-    else if (c !== " " && c !== "	" && c !== "\n" && c !== "\r") {
-      let k;
-      let t = res;
-      let hasOwn = false;
-      let [key, keyEndPtr] = parseKey(str, ptr - 1);
-      for (let i = 0; i < key.length; i++) {
-        if (i)
-          t = hasOwn ? t[k] : t[k] = {};
-        k = key[i];
-        if ((hasOwn = Object.hasOwn(t, k)) && (typeof t[k] !== "object" || seen.has(t[k]))) {
-          throw new TomlError("trying to redefine an already defined value", {
-            toml: str,
-            ptr
-          });
-        }
-        if (!hasOwn && k === "__proto__") {
-          Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
-        }
-      }
-      if (hasOwn) {
+  ctx.p++;
+  while (ctx.p < ctx.s.length) {
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p)) === 125) {
+      ctx.p++;
+      return res;
+    }
+    let k;
+    let t = res;
+    let hasOwn = false;
+    let p = ctx.p;
+    let key = parseKey(ctx);
+    for (let i = 0; i < key.length; i++) {
+      if (i)
+        t = hasOwn ? t[k] : t[k] = {};
+      k = key[i];
+      if ((hasOwn = Object.hasOwn(t, k)) && (typeof t[k] !== "object" || seen.has(t[k]))) {
         throw new TomlError("trying to redefine an already defined value", {
-          toml: str,
-          ptr
+          toml: ctx.s,
+          ptr: p
         });
       }
-      let [value, valueEndPtr] = extractValue(str, keyEndPtr, "}", depth - 1, integersAsBigInt);
-      seen.add(value);
-      t[k] = value;
-      ptr = valueEndPtr;
+      if (!hasOwn && k === "__proto__") {
+        Object.defineProperty(t, k, { enumerable: true, configurable: true, writable: true });
+      }
+    }
+    if (hasOwn) {
+      throw new TomlError("trying to redefine an already defined value", {
+        toml: ctx.s,
+        ptr: ctx.p
+      });
+    }
+    let value = extractValue(ctx, 125, integersAsBigInt);
+    seen.add(t[k] = value);
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p++)) === 125) {
+      return res;
+    }
+    if (c !== 44) {
+      throw new TomlError("expected comma or end of structure", { toml: ctx.s, ptr: ctx.p - 1 });
     }
   }
-  if (!c) {
-    throw new TomlError("unfinished table encountered", {
-      toml: str,
-      ptr
-    });
-  }
-  return [res, ptr];
+  throw new TomlError("unfinished table encountered", {
+    toml: ctx.s,
+    ptr: ctx.p
+  });
 }
-function parseArray(str, ptr, depth, integersAsBigInt) {
+function parseArray(ctx, integersAsBigInt) {
   let res = [];
   let c;
-  ptr++;
-  while ((c = str[ptr++]) !== "]" && c) {
-    if (c === ",") {
-      throw new TomlError("expected value, found comma", {
-        toml: str,
-        ptr: ptr - 1
-      });
-    } else if (c === "#")
-      ptr = skipComment(str, ptr);
-    else if (c !== " " && c !== "	" && c !== "\n" && c !== "\r") {
-      let e = extractValue(str, ptr - 1, "]", depth - 1, integersAsBigInt);
-      res.push(e[0]);
-      ptr = e[1];
-    }
-  }
-  if (!c) {
-    throw new TomlError("unfinished array encountered", {
-      toml: str,
-      ptr
-    });
+  ctx.p++;
+  while (ctx.p < ctx.s.length) {
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p)) === 93) {
+      ctx.p++;
+      return res;
+    }
+    res.push(extractValue(ctx, 93, integersAsBigInt));
+    skipVoid(ctx);
+    if ((c = ctx.s.charCodeAt(ctx.p++)) === 93) {
+      return res;
+    }
+    if (c !== 44) {
+      throw new TomlError("expected comma or end of structure", { toml: ctx.s, ptr: ctx.p - 1 });
+    }
   }
-  return [res, ptr];
+  throw new TomlError("unfinished array encountered", {
+    toml: ctx.s,
+    ptr: ctx.p
+  });
 }
 
 // node_modules/smol-toml/dist/parse.js
@@ -1784,25 +1809,29 @@ function peekTable(key, table, meta, type) {
   return [k, t, state.c];
 }
 function parse(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
+  let ctx = { s: toml, p: 0, d: maxDepth };
   let res = {};
   let meta = {};
+  let tmp;
   let tbl = res;
   let m = meta;
-  for (let ptr = skipVoid(toml, 0); ptr < toml.length; ) {
-    if (toml[ptr] === "[") {
-      let isTableArray = toml[++ptr] === "[";
-      let k = parseKey(toml, ptr += +isTableArray, "]");
+  skipVoid(ctx);
+  while (ctx.p < toml.length) {
+    if (toml.charCodeAt(ctx.p) === 91) {
+      let isTableArray = toml.charCodeAt(++ctx.p) === 91;
+      tmp = ctx.p += +isTableArray;
+      let k = parseKey(ctx, "]");
       if (isTableArray) {
-        if (toml[k[1] - 1] !== "]") {
+        if (toml.charCodeAt(ctx.p - 1) !== 93) {
           throw new TomlError("expected end of table declaration", {
             toml,
-            ptr: k[1] - 1
+            ptr: ctx.p - 1
           });
         }
-        k[1]++;
+        ctx.p++;
       }
       let p = peekTable(
-        k[0],
+        k,
         res,
         meta,
         isTableArray ? 2 : 1
@@ -1811,16 +1840,16 @@ function parse(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
       if (!p) {
         throw new TomlError("trying to redefine an already defined table or value", {
           toml,
-          ptr
+          ptr: tmp
         });
       }
       m = p[2];
       tbl = p[1];
-      ptr = k[1];
     } else {
-      let k = parseKey(toml, ptr);
+      tmp = ctx.p;
+      let k = parseKey(ctx);
       let p = peekTable(
-        k[0],
+        k,
         tbl,
         m,
         0
@@ -1829,35 +1858,36 @@ function parse(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
       if (!p) {
         throw new TomlError("trying to redefine an already defined table or value", {
           toml,
-          ptr
+          ptr: tmp
         });
       }
-      let v = extractValue(toml, k[1], void 0, maxDepth, integersAsBigInt);
-      p[1][p[0]] = v[0];
-      ptr = v[1];
+      p[1][p[0]] = extractValue(ctx, void 0, integersAsBigInt);
     }
-    ptr = skipVoid(toml, ptr, true);
-    if (toml[ptr] && toml[ptr] !== "\n" && toml[ptr] !== "\r") {
+    skipVoid(ctx, true);
+    if (ctx.p < toml.length && (tmp = toml.charCodeAt(ctx.p)) !== 10 && tmp !== 13) {
       throw new TomlError("each key-value declaration must be followed by an end-of-line", {
         toml,
-        ptr
+        ptr: ctx.p
       });
     }
-    ptr = skipVoid(toml, ptr);
+    skipVoid(ctx);
   }
   return res;
 }
 
 // node_modules/smol-toml/dist/stringify.js
-init_define_import_meta_env();
 var BARE_KEY = /^[a-z0-9-_]+$/i;
 function extendedTypeOf(obj) {
   let type = typeof obj;
   if (type === "object") {
     if (Array.isArray(obj))
       return "array";
-    if (obj instanceof Date)
+    if (typeof obj?.getUTCDate === "function" && obj instanceof Date)
       return "date";
+    if (globalThis.Temporal && // check for the 'since' property as an early bailout that avoids running all 5 instanceof checks
+    typeof obj?.since === "function" && (obj instanceof Temporal.Instant || obj instanceof Temporal.PlainDate || obj instanceof Temporal.PlainDateTime || obj instanceof Temporal.PlainTime || obj instanceof Temporal.ZonedDateTime)) {
+      return "temporal";
+    }
   }
   return type;
 }
@@ -1871,38 +1901,42 @@ function isArrayOfTables(obj) {
 function formatString(s) {
   return JSON.stringify(s).replace(/\x7f/g, "\\u007f");
 }
+function stringifyTemporal(temporal) {
+  return temporal.toString({
+    calendarName: "never",
+    timeZoneName: "never"
+  });
+}
 function stringifyValue(val, type, depth, numberAsFloat) {
   if (depth === 0) {
     throw new Error("Could not stringify the object: maximum object depth exceeded");
   }
-  if (type === "number") {
-    if (isNaN(val))
-      return "nan";
-    if (val === Infinity)
-      return "inf";
-    if (val === -Infinity)
-      return "-inf";
-    if (Number.isInteger(val) && (numberAsFloat || !Number.isSafeInteger(val)))
-      return val.toFixed(1);
-    return val.toString();
-  }
-  if (type === "bigint" || type === "boolean") {
-    return val.toString();
-  }
-  if (type === "string") {
-    return formatString(val);
-  }
-  if (type === "date") {
-    if (isNaN(val.getTime())) {
-      throw new TypeError("cannot serialize invalid date");
-    }
-    return val.toISOString();
-  }
-  if (type === "object") {
-    return stringifyInlineTable(val, depth, numberAsFloat);
-  }
-  if (type === "array") {
-    return stringifyArray(val, depth, numberAsFloat);
+  switch (type) {
+    // @ts-expect-error -- intentional fallthrough case
+    case "number":
+      if (isNaN(val))
+        return "nan";
+      if (val === Infinity)
+        return "inf";
+      if (val === -Infinity)
+        return "-inf";
+      if (Number.isInteger(val) && (numberAsFloat || !Number.isSafeInteger(val)))
+        return val.toFixed(1);
+    case "bigint":
+    case "boolean":
+      return val.toString();
+    case "string":
+      return formatString(val);
+    case "date":
+      if (isNaN(val.getTime()))
+        throw new TypeError("cannot serialize invalid date");
+      return val.toISOString();
+    case "object":
+      return stringifyInlineTable(val, depth, numberAsFloat);
+    case "array":
+      return stringifyArray(val, depth, numberAsFloat);
+    case "temporal":
+      return stringifyTemporal(val);
   }
 }
 function stringifyInlineTable(obj, depth, numberAsFloat) {
@@ -1991,7 +2025,6 @@ function stringify(obj, { maxDepth = 1e3, numbersAsFloat = false } = {}) {
 }
 
 // src/env.ts
-init_define_import_meta_env();
 var FALSY_ENV_VALUES = /* @__PURE__ */ new Set(["0", "false", "no", "off"]);
 var TRUTHY_ENV_VALUES = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
 function envStr(key, defaultVal) {
@@ -3235,11 +3268,1055 @@ function saveConfig(config) {
   _cached2 = null;
 }
 
+// src/parser_types.ts
+import * as path6 from "node:path";
+var EXTENSION_LANGUAGE = /* @__PURE__ */ new Map([
+  [".py", "python"],
+  [".pyi", "python"],
+  [".ts", "typescript"],
+  [".tsx", "typescript"],
+  [".mts", "typescript"],
+  [".cts", "typescript"],
+  [".js", "javascript"],
+  [".jsx", "javascript"],
+  [".mjs", "javascript"],
+  [".cjs", "javascript"],
+  [".rs", "rust"],
+  [".go", "go"],
+  [".c", "c"],
+  [".h", "c"],
+  [".cpp", "cpp"],
+  [".cc", "cpp"],
+  [".cxx", "cpp"],
+  [".hpp", "cpp"],
+  [".hxx", "cpp"],
+  [".rb", "ruby"],
+  [".ruby", "ruby"],
+  // Rake task files (lib/tasks/foo.rake) are plain Ruby syntax (`task :foo do ... end`),
+  // parsed identically by the ruby tree-sitter grammar. Without this entry a `.rake` file
+  // fell through to 'unknown' and indexed zero symbols despite the grammar handling its
+  // content exactly like any other .rb file -- the same has-extractor-but-no-extension gap
+  // previously fixed for `.mk` (Makefile fragments).
+  [".rake", "ruby"],
+  [".java", "java"],
+  [".sh", "bash"],
+  [".bash", "bash"],
+  [".md", "markdown"],
+  [".markdown", "markdown"],
+  // MDX heading syntax is plain ATX and works with the existing markdown extractor as-is,
+  // unlike .rst which genuinely needs an underline-style heading parser this extractor doesn't
+  // implement (left as 'unknown' deliberately).
+  [".mdx", "markdown"],
+  [".toml", "toml"],
+  [".json", "json"],
+  [".yaml", "yaml"],
+  [".yml", "yaml"],
+  [".css", "css"],
+  [".scss", "css"],
+  [".sass", "css"],
+  [".less", "css"],
+  [".cs", "csharp"],
+  [".php", "php"],
+  [".html", "html"],
+  [".htm", "html"],
+  [".liquid", "liquid"],
+  [".kt", "kotlin"],
+  [".kts", "kotlin"],
+  [".swift", "swift"],
+  [".scala", "scala"],
+  [".sc", "scala"],
+  [".lua", "lua"],
+  [".ex", "elixir"],
+  [".exs", "elixir"],
+  [".dart", "dart"],
+  [".zig", "zig"],
+  [".r", "r"],
+  [".graphql", "graphql"],
+  [".gql", "graphql"],
+  [".sql", "sql"],
+  [".ini", "ini"],
+  [".cfg", "ini"],
+  [".conf", "ini"],
+  [".proto", "proto"],
+  // `.mk` is the idiomatic extension for included Makefile fragments (config.mk, rules.mk,
+  // common.mk); their syntax is identical to a bare `Makefile`, which FILENAME_LANGUAGE already
+  // maps. Without this entry a `.mk` fragment fell through to 'unknown' and was indexed with zero
+  // symbols despite extractMakefile handling its content fine -- the same has-extractor-but-no-
+  // extension gap previously seen for other adapters. (importsExtensionFor already treats bare
+  // Makefile basenames as `.mk` for the imports command, so extractImports' `.mk` branch was
+  // reachable while symbol indexing was not.)
+  [".mk", "makefile"],
+  [".tf", "terraform"],
+  [".tfvars", "terraform"],
+  [".hcl", "terraform"],
+  [".ps1", "powershell"],
+  [".psm1", "powershell"],
+  [".env", "env_file"],
+  [".cls", "apex"],
+  [".trigger", "apex"],
+  [".cmp", "salesforce_markup"],
+  [".app", "salesforce_markup"],
+  [".evt", "salesforce_markup"],
+  [".intf", "salesforce_markup"],
+  [".design", "salesforce_markup"],
+  [".auradoc", "salesforce_markup"],
+  [".tokens", "salesforce_markup"],
+  [".page", "salesforce_markup"],
+  [".component", "salesforce_markup"],
+  [".email", "salesforce_markup"],
+  [".vue", "vue"],
+  [".svelte", "svelte"],
+  [".astro", "astro"],
+  [".ipynb", "ipynb"]
+]);
+var FILENAME_LANGUAGE = /* @__PURE__ */ new Map([
+  ["dockerfile", "dockerfile"],
+  ["makefile", "makefile"],
+  ["gnumakefile", "makefile"],
+  ["bsdmakefile", "makefile"],
+  ["cargo.toml", "toml"],
+  ["pyproject.toml", "toml"],
+  ["package.json", "json"],
+  ["tsconfig.json", "json"],
+  [".envrc", "env_file"],
+  // Gemfile and Rakefile are plain Ruby syntax with no extension -- the dominant, idiomatic
+  // dependency-manifest and task-runner files in virtually every real Ruby project (analogous to
+  // package.json for Node or a bare Makefile). Without these entries both fell through to
+  // 'unknown' and indexed zero symbols despite the ruby tree-sitter grammar handling their
+  // content exactly like any other .rb file -- the same has-extractor-but-no-dispatch-entry gap
+  // already fixed for bare `Makefile` / `.mk` fragments above.
+  ["gemfile", "ruby"],
+  ["rakefile", "ruby"],
+  // Vagrantfile, Guardfile, Podfile, Capfile, Fastfile: same idiomatic extensionless-Ruby-DSL
+  // pattern as Gemfile/Rakefile above -- `Vagrant.configure(...) do ... end`, Guard's `guard
+  // 'rspec' do ... end`, CocoaPods' `Pod::Spec.new do |s| ... end`, Capistrano's `set :application`,
+  // and fastlane's `lane :build do ... end` are all plain Ruby, parsed identically by the ruby
+  // tree-sitter grammar. Without these entries each fell through to 'unknown' and indexed zero
+  // symbols despite the grammar handling their content exactly like any other .rb file.
+  ["vagrantfile", "ruby"],
+  ["guardfile", "ruby"],
+  ["podfile", "ruby"],
+  ["capfile", "ruby"],
+  ["fastfile", "ruby"],
+  // Brewfile: Homebrew Bundle's dependency manifest (`brew "wget"`, `cask "..."`, `tap "..."`)
+  // is ordinary Ruby method-call syntax, evaluated by Homebrew's own Ruby DSL -- the extensionless
+  // macOS-dev-environment analogue of Gemfile/package.json, and near-universal in dotfiles repos
+  // that use `brew bundle dump`/`brew bundle install`. Same has-extractor-but-no-dispatch-entry
+  // gap as the other extensionless Ruby DSL files above: without this entry it fell through to
+  // 'unknown' and indexed zero symbols despite the ruby tree-sitter grammar handling its content
+  // exactly like any other .rb file.
+  ["brewfile", "ruby"]
+]);
+var DOTENV_VARIANT_RE = /^\.env(\..+)?$/;
+function detectLanguage(filePath) {
+  const base = path6.basename(filePath).toLowerCase();
+  if (DOTENV_VARIANT_RE.test(base)) return "env_file";
+  const byName = FILENAME_LANGUAGE.get(base);
+  if (byName !== void 0) return byName;
+  if (base.endsWith("-meta.xml")) {
+    return "salesforce_metadata";
+  }
+  const ext = path6.extname(base).toLowerCase();
+  return EXTENSION_LANGUAGE.get(ext) ?? "unknown";
+}
+var UNSUPPORTED_LANGUAGE_EXTENSIONS = /* @__PURE__ */ new Map([]);
+function unsupportedLanguageName(filePath) {
+  const ext = path6.extname(filePath).toLowerCase();
+  return UNSUPPORTED_LANGUAGE_EXTENSIONS.get(ext);
+}
+
+// src/doc_comment.ts
+function precedingDocComment(lines, lineStart, style) {
+  const aboveIdx = lineStart - 2;
+  if (aboveIdx < 0 || aboveIdx >= lines.length) return "";
+  const aboveLine = lines[aboveIdx];
+  if (aboveLine === void 0) return "";
+  const aboveTrimmed = aboveLine.trim();
+  if (style === "hash") {
+    if (!aboveTrimmed.startsWith("#")) return "";
+    const collected = [];
+    let i = aboveIdx;
+    while (i >= 0) {
+      const line = lines[i];
+      if (line === void 0) break;
+      const trimmed = line.trim();
+      if (!trimmed.startsWith("#")) break;
+      collected.unshift(trimmed.replace(/^#+\s?/, ""));
+      i--;
+    }
+    return collected.join("\n").trim();
+  }
+  if (aboveTrimmed.endsWith("*/")) {
+    let blockStart = aboveIdx;
+    while (blockStart >= 0) {
+      const l = lines[blockStart];
+      if (l === void 0) break;
+      if (l.trim().startsWith("/*")) break;
+      blockStart--;
+    }
+    if (blockStart < 0) return "";
+    const opener = lines[blockStart];
+    if (opener === void 0 || !opener.trim().startsWith("/*")) return "";
+    const region = lines.slice(blockStart, aboveIdx + 1);
+    const joined = region.join("\n").trimEnd();
+    if (joined.indexOf("*/") !== joined.length - 2) return "";
+    return region.map(
+      (l) => l.trim().replace(/^\/\*+/, "").replace(/\*+\/$/, "").replace(/^\*\s?/, "").trim()
+    ).filter((l) => l !== "").join("\n");
+  }
+  if (aboveTrimmed.startsWith("//")) {
+    const collected = [];
+    let i = aboveIdx;
+    while (i >= 0) {
+      const line = lines[i];
+      if (line === void 0) break;
+      const trimmed = line.trim();
+      if (!trimmed.startsWith("//")) break;
+      collected.unshift(trimmed.replace(/^\/\/[/!]?\s?/, ""));
+      i--;
+    }
+    return collected.join("\n").trim();
+  }
+  return "";
+}
+
+// src/languages/common.ts
+function buildLineIndex(text) {
+  const idx = [0];
+  for (let i = 0; i < text.length; i++) {
+    if (text[i] === "\n") idx.push(i + 1);
+  }
+  return idx;
+}
+function offsetToLine(lineIndex, offset) {
+  let lo = 0;
+  let hi = lineIndex.length - 1;
+  while (lo < hi) {
+    const mid = lo + hi + 1 >> 1;
+    const lineStart = lineIndex[mid];
+    if (lineStart === void 0 || lineStart > offset) {
+      hi = mid - 1;
+    } else {
+      lo = mid;
+    }
+  }
+  return lo + 1;
+}
+function stripCstyleComments(text, lineCommentRe) {
+  const lines = text.split("\n");
+  let inComment = false;
+  const outLines = [];
+  for (const line of lines) {
+    const { code, inComment: nextInComment } = stripBlockCommentSpan(line, inComment);
+    outLines.push(code);
+    inComment = nextInComment;
+  }
+  let out = outLines.join("\n");
+  if (lineCommentRe !== void 0) {
+    out = out.replace(lineCommentRe, (m) => " ".repeat(m.length));
+  }
+  return out;
+}
+function stripXmlComments(text) {
+  const lines = text.split("\n");
+  let inComment = false;
+  const outLines = [];
+  for (const line of lines) {
+    let result = "";
+    let j = 0;
+    while (j < line.length) {
+      if (!inComment) {
+        const open = line.indexOf("<!--", j);
+        if (open === -1) {
+          result += line.slice(j);
+          break;
+        }
+        result += line.slice(j, open);
+        const close = line.indexOf("-->", open + 4);
+        if (close === -1) {
+          result += " ".repeat(line.length - open);
+          inComment = true;
+          break;
+        }
+        result += " ".repeat(close + 3 - open);
+        j = close + 3;
+        inComment = false;
+      } else {
+        const close = line.indexOf("-->", j);
+        if (close === -1) {
+          result += " ".repeat(line.length - j);
+          break;
+        }
+        result += " ".repeat(close + 3 - j);
+        j = close + 3;
+        inComment = false;
+      }
+    }
+    outLines.push(result);
+  }
+  return outLines.join("\n");
+}
+function scanQuotedStringEnd(content, start) {
+  const quote = content[start];
+  const n = content.length;
+  let j = start + 1;
+  while (j < n) {
+    if (content[j] === "\\" && j + 1 < n) {
+      j += 2;
+      continue;
+    }
+    if (content[j] === quote) {
+      j++;
+      break;
+    }
+    if (quote !== "`" && content[j] === "\n") {
+      j++;
+      break;
+    }
+    j++;
+  }
+  return j;
+}
+function stripJsComments(content) {
+  let out = "";
+  let i = 0;
+  const n = content.length;
+  while (i < n) {
+    const ch = content[i];
+    if (ch === "/" && content[i + 1] === "/") {
+      let j = i;
+      while (j < n && content[j] !== "\n") j++;
+      out += " ".repeat(j - i);
+      i = j;
+      continue;
+    }
+    if (ch === "/" && content[i + 1] === "*") {
+      let j = i + 2;
+      while (j < n && !(content[j] === "*" && content[j + 1] === "/")) j++;
+      const end = j < n ? j + 2 : n;
+      out += content.slice(i, end).replace(/[^\n]/g, " ");
+      i = end;
+      continue;
+    }
+    if (ch === '"' || ch === "'" || ch === "`") {
+      const j = scanQuotedStringEnd(content, i);
+      out += content.slice(i, j);
+      i = j;
+      continue;
+    }
+    out += ch;
+    i++;
+  }
+  return out;
+}
+function stripHashComments(text) {
+  return text.split("\n").map((line) => {
+    for (let i = 0; i < line.length; i++) {
+      if (line[i] === "#" && !isInsideStringLiteral(line, i)) {
+        return line.slice(0, i) + " ".repeat(line.length - i);
+      }
+    }
+    return line;
+  }).join("\n");
+}
+var HTML_COMMENT_RE = /<!--[\s\S]*?-->/g;
+var HTML_SCRIPT_BODY_RE = /(<script\b[^>]*>)([\s\S]*?)(<\/script\s*>)/gi;
+var HTML_CDATA_RE = /<!\[CDATA\[[\s\S]*?\]\]>/g;
+var LIQUID_COMMENT_RE = /{%-?\s*comment\s*-?%}[\s\S]*?{%-?\s*endcomment\s*-?%}/gi;
+function maskHtmlNoise(text) {
+  let out = text.replace(
+    HTML_SCRIPT_BODY_RE,
+    (_m, open, body, close) => open + body.replace(/[^\n]/g, " ") + close
+  );
+  out = out.replace(HTML_COMMENT_RE, (m) => m.replace(/[^\n]/g, " "));
+  out = out.replace(LIQUID_COMMENT_RE, (m) => m.replace(/[^\n]/g, " "));
+  out = out.replace(HTML_CDATA_RE, (m) => m.replace(/[^\n]/g, " "));
+  return out;
+}
+var HTML_HEADING_RE = /<h([1-6])[^>]*>(.*?)<\/h\1>/gis;
+var HTML_HEADING_TAG_STRIP_RE = /<[^>]+>/g;
+function findHtmlHeadingMatches(content) {
+  const masked = maskHtmlNoise(content);
+  const matches = [];
+  for (const m of masked.matchAll(HTML_HEADING_RE)) {
+    const level = parseInt(m[1] ?? "1", 10);
+    const raw = m[2] ?? "";
+    const heading = raw.replace(HTML_HEADING_TAG_STRIP_RE, "").trim();
+    matches.push({ level, heading, offset: m.index ?? 0, tag: m[0] ?? "" });
+  }
+  return matches;
+}
+function isInsideStringLiteral(line, index, from = 0) {
+  let openQuote = null;
+  let i = from;
+  while (i < index) {
+    const ch = line[i];
+    if (openQuote !== null && ch === "\\" && i + 1 < line.length) {
+      i += 2;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      if (openQuote === null) {
+        openQuote = ch;
+      } else if (openQuote === ch) {
+        openQuote = null;
+      }
+    }
+    i++;
+  }
+  return openQuote !== null;
+}
+function stripBlockCommentSpan(line, inComment) {
+  let code = "";
+  let j = 0;
+  let comment = inComment;
+  while (j < line.length) {
+    if (!comment) {
+      const lineCommentIdx = lineCommentStartIndex(line, ["//"], j);
+      let open = line.indexOf("/*", j);
+      while (open !== -1 && (isInsideStringLiteral(line, open, j) || lineCommentIdx !== -1 && open >= lineCommentIdx)) {
+        open = line.indexOf("/*", open + 1);
+      }
+      if (open === -1) {
+        code += line.slice(j);
+        break;
+      }
+      code += line.slice(j, open);
+      const close = line.indexOf("*/", open + 2);
+      if (close === -1) {
+        code += " ".repeat(line.length - open);
+        comment = true;
+        break;
+      }
+      code += " ".repeat(close + 2 - open);
+      j = close + 2;
+      comment = false;
+    } else {
+      const close = line.indexOf("*/", j);
+      if (close === -1) {
+        code += " ".repeat(line.length - j);
+        break;
+      }
+      code += " ".repeat(close + 2 - j);
+      j = close + 2;
+      comment = false;
+    }
+  }
+  return { code, inComment: comment };
+}
+function stripNestedBlockCommentSpan(line, depth) {
+  let code = "";
+  let j = 0;
+  let d = depth;
+  while (j < line.length) {
+    if (d === 0) {
+      const lineCommentIdx = lineCommentStartIndex(line, ["//"], j);
+      let open = line.indexOf("/*", j);
+      while (open !== -1 && (isInsideStringLiteral(line, open, j) || lineCommentIdx !== -1 && open >= lineCommentIdx)) {
+        open = line.indexOf("/*", open + 1);
+      }
+      if (open === -1) {
+        code += line.slice(j);
+        break;
+      }
+      code += line.slice(j, open);
+      code += "  ";
+      j = open + 2;
+      d = 1;
+    } else {
+      const open = line.indexOf("/*", j);
+      const close = line.indexOf("*/", j);
+      if (close === -1 && open === -1) {
+        code += " ".repeat(line.length - j);
+        break;
+      }
+      const next = close === -1 ? open : open === -1 ? close : Math.min(open, close);
+      code += " ".repeat(next + 2 - j);
+      d = Math.max(0, d + (next === open ? 1 : -1));
+      j = next + 2;
+    }
+  }
+  return { code, depth: d };
+}
+function stripLineComment(line, markers = ["//"]) {
+  const cutIdx = lineCommentStartIndex(line, markers);
+  return cutIdx === -1 ? line : line.slice(0, cutIdx);
+}
+function lineCommentStartIndex(line, markers, from = 0) {
+  let cutIdx = -1;
+  for (const marker of markers) {
+    let idx = line.indexOf(marker, from);
+    while (idx !== -1 && isInsideStringLiteral(line, idx, from)) {
+      idx = line.indexOf(marker, idx + 1);
+    }
+    if (idx !== -1 && (cutIdx === -1 || idx < cutIdx)) cutIdx = idx;
+  }
+  return cutIdx;
+}
+function stripStringLiterals(line) {
+  let out = "";
+  let i = 0;
+  const stack = [];
+  while (i < line.length) {
+    const ch = line[i];
+    if (ch === "\n") {
+      out += ch;
+      i++;
+      stack.length = 0;
+      continue;
+    }
+    const top = stack[stack.length - 1];
+    if (top === void 0) {
+      if (ch === '"' || ch === "'") {
+        const bareBraceHole = ch === '"' && i > 0 && line[i - 1] === "$";
+        stack.push({ kind: "string", quote: ch, bareBraceHole });
+        out += ch;
+        i++;
+        continue;
+      }
+      out += ch;
+      i++;
+      continue;
+    }
+    if (top.kind === "hole") {
+      if (ch === '"' || ch === "'") {
+        const bareBraceHole = ch === '"' && i > 0 && line[i - 1] === "$";
+        stack.push({ kind: "string", quote: ch, bareBraceHole });
+        out += ch;
+        i++;
+        continue;
+      }
+      if (ch === "{") {
+        top.depth++;
+        out += ch;
+        i++;
+        continue;
+      }
+      if (ch === "}") {
+        if (top.depth > 0) {
+          top.depth--;
+        } else {
+          stack.pop();
+        }
+        out += ch;
+        i++;
+        continue;
+      }
+      out += ch;
+      i++;
+      continue;
+    }
+    if (ch === "\\" && i + 1 < line.length) {
+      out += "  ";
+      i += 2;
+      continue;
+    }
+    if (ch === top.quote) {
+      stack.pop();
+      out += ch;
+      i++;
+      continue;
+    }
+    if (top.quote === '"') {
+      if (top.bareBraceHole && ch === "{") {
+        if (line[i + 1] === "{") {
+          out += "  ";
+          i += 2;
+          continue;
+        }
+        stack.push({ kind: "hole", depth: 0 });
+        out += ch;
+        i++;
+        continue;
+      }
+      if (!top.bareBraceHole && ch === "$" && line[i + 1] === "{") {
+        stack.push({ kind: "hole", depth: 0 });
+        out += line.slice(i, i + 2);
+        i += 2;
+        continue;
+      }
+      if (!top.bareBraceHole && ch === "{" && line[i + 1] === "$") {
+        stack.push({ kind: "hole", depth: 0 });
+        out += ch;
+        i++;
+        continue;
+      }
+    }
+    out += " ";
+    i++;
+  }
+  return out;
+}
+function findMultilineCloser(line, from, state) {
+  switch (state.kind) {
+    case "heredoc":
+    case "nowdoc": {
+      const re = new RegExp(`^[ \\t]*${escapeRegExp(state.identifier)}\\b`);
+      const m = re.exec(line);
+      return m ? { maskEnd: m[0].length } : null;
+    }
+    case "tripleSingleQuote": {
+      const m = /'{3,}/.exec(line.slice(from));
+      return m === null ? null : { maskEnd: from + m.index + m[0].length };
+    }
+    case "tripleQuote": {
+      const n = state.identifier !== "" ? parseInt(state.identifier, 10) : 3;
+      const re = new RegExp(`"{${n},}`);
+      const m = re.exec(line.slice(from));
+      return m === null ? null : { maskEnd: from + m.index + m[0].length };
+    }
+    case "verbatim": {
+      if (!state.interpolated) {
+        let j2 = from;
+        while (j2 < line.length) {
+          if (line[j2] === '"') {
+            if (line[j2 + 1] === '"') {
+              j2 += 2;
+              continue;
+            }
+            return { maskEnd: j2 + 1 };
+          }
+          j2++;
+        }
+        return null;
+      }
+      let j = from;
+      let holeDepth = 0;
+      let nestedQuote = null;
+      while (j < line.length) {
+        const c = line[j];
+        if (nestedQuote !== null) {
+          if (c === "\\" && j + 1 < line.length) {
+            j += 2;
+            continue;
+          }
+          if (c === nestedQuote) {
+            nestedQuote = null;
+          }
+          j++;
+          continue;
+        }
+        if (holeDepth > 0) {
+          if (c === '"' || c === "'") {
+            nestedQuote = c;
+            j++;
+            continue;
+          }
+          if (c === "{") holeDepth++;
+          else if (c === "}") holeDepth--;
+          j++;
+          continue;
+        }
+        if (c === "{") {
+          holeDepth = 1;
+          j++;
+          continue;
+        }
+        if (c === '"') {
+          if (line[j + 1] === '"') {
+            j += 2;
+            continue;
+          }
+          return { maskEnd: j + 1 };
+        }
+        j++;
+      }
+      return null;
+    }
+    case "psHereDouble":
+      return line.startsWith('"@', from) ? { maskEnd: from + 2 } : null;
+    case "psHereSingle":
+      return line.startsWith("'@", from) ? { maskEnd: from + 2 } : null;
+    default:
+      return null;
+  }
+}
+var MULTILINE_OPENER_COMMENT_MARKERS = {
+  php: ["//", "#"],
+  kotlin: ["//"],
+  csharp: ["//"],
+  powershell: ["#"],
+  swift: ["//"],
+  elixir: ["#"]
+};
+var MULTILINE_OPENER_BLOCK_COMMENT_LANGS = /* @__PURE__ */ new Set(["php", "kotlin", "csharp", "swift"]);
+function isInsideSameLineBlockComment(line, idx, from = 0) {
+  let comment = false;
+  let j = from;
+  while (j < idx) {
+    if (!comment) {
+      const open = line.indexOf("/*", j);
+      if (open === -1 || open >= idx) return false;
+      if (isInsideStringLiteral(line, open, from)) {
+        j = open + 2;
+        continue;
+      }
+      comment = true;
+      j = open + 2;
+    } else {
+      const close = line.indexOf("*/", j);
+      if (close === -1 || close >= idx) return true;
+      comment = false;
+      j = close + 2;
+    }
+  }
+  return comment;
+}
+function findMultilineOpener(line, from, lang) {
+  const commentIdx = lineCommentStartIndex(line, MULTILINE_OPENER_COMMENT_MARKERS[lang], from);
+  const isCommented = (idx) => commentIdx !== -1 && idx >= commentIdx || MULTILINE_OPENER_BLOCK_COMMENT_LANGS.has(lang) && isInsideSameLineBlockComment(line, idx, from);
+  if (lang === "php") {
+    const re = /<<<\s*(['"]?)([A-Za-z_]\w*)\1/g;
+    re.lastIndex = from;
+    const m = re.exec(line);
+    if (!m || isInsideStringLiteral(line, m.index, from) || isCommented(m.index)) return null;
+    const identifier = m[2] ?? "";
+    const kind = m[1] === "'" ? "nowdoc" : "heredoc";
+    return { openStart: m.index, closesSameLine: null, state: { kind, identifier } };
+  }
+  if (lang === "kotlin") {
+    const idx = line.indexOf('"""', from);
+    if (idx === -1 || isInsideStringLiteral(line, idx, from) || isCommented(idx)) return null;
+    const closeIdx = line.indexOf('"""', idx + 3);
+    if (closeIdx !== -1) {
+      return { openStart: idx, closesSameLine: closeIdx + 3, state: { kind: "tripleQuote", identifier: "3" } };
+    }
+    return { openStart: idx, closesSameLine: null, state: { kind: "tripleQuote", identifier: "3" } };
+  }
+  if (lang === "swift") {
+    const idx = line.indexOf('"""', from);
+    if (idx === -1 || isInsideStringLiteral(line, idx, from) || isCommented(idx)) return null;
+    const closeIdx = line.indexOf('"""', idx + 3);
+    if (closeIdx !== -1) {
+      return { openStart: idx, closesSameLine: closeIdx + 3, state: { kind: "tripleQuote", identifier: "3" } };
+    }
+    return { openStart: idx, closesSameLine: null, state: { kind: "tripleQuote", identifier: "3" } };
+  }
+  if (lang === "elixir") {
+    const candidates = [];
+    const dq = line.indexOf('"""', from);
+    if (dq !== -1) candidates.push([dq, "tripleQuote", '"""']);
+    const sq = line.indexOf("'''", from);
+    if (sq !== -1) candidates.push([sq, "tripleSingleQuote", "'''"]);
+    candidates.sort((a, b) => a[0] - b[0]);
+    const first = candidates[0];
+    if (first === void 0) return null;
+    const [idx, kind, delim] = first;
+    if (isInsideStringLiteral(line, idx, from) || isCommented(idx)) return null;
+    const closeIdx = line.indexOf(delim, idx + 3);
+    const state = { kind, identifier: "3" };
+    if (closeIdx !== -1) return { openStart: idx, closesSameLine: closeIdx + 3, state };
+    return { openStart: idx, closesSameLine: null, state };
+  }
+  if (lang === "csharp") {
+    const tripleRe = /"{3,}/g;
+    tripleRe.lastIndex = from;
+    const tripleM = tripleRe.exec(line);
+    let tripleIdx = tripleM ? tripleM.index : -1;
+    const tripleLen = tripleM ? tripleM[0].length : 0;
+    if (tripleIdx !== -1 && (isInsideStringLiteral(line, tripleIdx, from) || isCommented(tripleIdx))) tripleIdx = -1;
+    const verbRe = /\$?@\$?"/g;
+    verbRe.lastIndex = from;
+    const verbM = verbRe.exec(line);
+    let verbIdx = verbM ? verbM.index : -1;
+    if (verbIdx !== -1 && isCommented(verbIdx)) verbIdx = -1;
+    if (verbIdx !== -1 && isInsideStringLiteral(line, verbIdx, from)) verbIdx = -1;
+    if (tripleIdx === -1 && verbIdx === -1) return null;
+    const useTriple = tripleIdx !== -1 && (verbIdx === -1 || tripleIdx < verbIdx);
+    if (useTriple) {
+      const closeRe = new RegExp(`"{${tripleLen},}`);
+      const closeM = closeRe.exec(line.slice(tripleIdx + tripleLen));
+      if (closeM !== null) {
+        const closeIdx = tripleIdx + tripleLen + closeM.index;
+        return { openStart: tripleIdx, closesSameLine: closeIdx + closeM[0].length, state: { kind: "tripleQuote", identifier: String(tripleLen) } };
+      }
+      return { openStart: tripleIdx, closesSameLine: null, state: { kind: "tripleQuote", identifier: String(tripleLen) } };
+    }
+    const quoteIdx = verbIdx + (verbM?.[0].length ?? 1) - 1;
+    const interpolated = (verbM?.[0] ?? "").includes("$");
+    const closer = findMultilineCloser(line, quoteIdx + 1, { kind: "verbatim", identifier: "", interpolated });
+    if (closer !== null) {
+      return { openStart: verbIdx, closesSameLine: closer.maskEnd, state: { kind: "verbatim", identifier: "", interpolated } };
+    }
+    return { openStart: verbIdx, closesSameLine: null, state: { kind: "verbatim", identifier: "", interpolated } };
+  }
+  if (lang === "powershell") {
+    const re = /@("|')\s*$/;
+    const tail = line.slice(from);
+    const m = re.exec(tail);
+    if (!m) return null;
+    const openStart = from + m.index;
+    if (isCommented(openStart)) return null;
+    if (isInsideStringLiteral(line, openStart, from)) return null;
+    const kind = m[1] === '"' ? "psHereDouble" : "psHereSingle";
+    return { openStart, closesSameLine: null, state: { kind, identifier: "" } };
+  }
+  return null;
+}
+function stripMultilineStringSpan(line, state, lang) {
+  let code = "";
+  let i = 0;
+  let cur = state;
+  while (i < line.length) {
+    if (cur !== null) {
+      const closed = findMultilineCloser(line, i, cur);
+      if (closed === null) {
+        code += " ".repeat(line.length - i);
+        i = line.length;
+        continue;
+      }
+      code += " ".repeat(closed.maskEnd - i);
+      i = closed.maskEnd;
+      cur = null;
+      continue;
+    }
+    const opened = findMultilineOpener(line, i, lang);
+    if (opened === null) {
+      code += line.slice(i);
+      break;
+    }
+    code += line.slice(i, opened.openStart);
+    if (opened.closesSameLine !== null) {
+      code += " ".repeat(opened.closesSameLine - opened.openStart);
+      i = opened.closesSameLine;
+      cur = null;
+    } else {
+      code += " ".repeat(line.length - opened.openStart);
+      i = line.length;
+      cur = opened.state;
+    }
+  }
+  return { code, state: cur };
+}
+function makeSpanSymbol(filePath, name, kind, span, parent = "", lines, style) {
+  return {
+    filePath,
+    name,
+    kind,
+    lineStart: span.startLine,
+    lineEnd: span.endLine,
+    body: span.body,
+    docstring: lines !== void 0 && style !== void 0 ? precedingDocComment(lines, span.startLine, style) : "",
+    parent
+  };
+}
+function makeLineSymbol(filePath, name, kind, line, sig, parent, lines, style) {
+  return {
+    filePath,
+    name,
+    kind,
+    lineStart: line,
+    lineEnd: line,
+    body: sig ?? "",
+    docstring: lines !== void 0 && style !== void 0 ? precedingDocComment(lines, line, style) : "",
+    parent: parent ?? ""
+  };
+}
+function makeSymbolEmitter(symbols, sections, seen, filePath, maxSymbols = 500, maxHeadingLen = 120) {
+  return function emit(name, kind, line) {
+    if (!name || name.length > maxHeadingLen) return;
+    if (symbols.length >= maxSymbols) return;
+    const key = `${name}\0${kind}\0${line}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    symbols.push({
+      filePath,
+      name,
+      kind,
+      lineStart: line,
+      lineEnd: line,
+      body: "",
+      docstring: "",
+      parent: ""
+    });
+    sections.push({ heading: name, level: 1, line, endLine: line });
+  };
+}
+function assignFlatEndLines(sections, totalLines) {
+  for (let i = 0; i < sections.length; i++) {
+    const next = sections[i + 1];
+    const s = sections[i];
+    if (s === void 0) continue;
+    const end = next !== void 0 ? next.line - 1 : totalLines;
+    s.endLine = end < s.line ? s.line : end;
+  }
+}
+function propagateEndLinesToSymbols(symbols, sections) {
+  const sectionMap = /* @__PURE__ */ new Map();
+  for (const sec of sections) {
+    const key = `${sec.heading}\0${sec.line}`;
+    const queue = sectionMap.get(key);
+    if (queue !== void 0) queue.push(sec.endLine);
+    else sectionMap.set(key, [sec.endLine]);
+  }
+  return symbols.map((sym) => {
+    const key = `${sym.name}\0${sym.lineStart}`;
+    const endLine = sectionMap.get(key)?.shift();
+    if (endLine !== void 0 && endLine !== sym.lineEnd) {
+      return { ...sym, lineEnd: endLine };
+    }
+    return sym;
+  });
+}
+function findMatchingBraceEndLine(content, openBraceIndex, totalLines, lineIndex, lineCommentPrefix) {
+  let depth = 0;
+  let quote = null;
+  for (let i = openBraceIndex; i < content.length; i++) {
+    const ch = content[i];
+    if (quote !== null) {
+      if (ch === "\\") {
+        i++;
+        continue;
+      }
+      if (ch === quote) quote = null;
+      continue;
+    }
+    if (lineCommentPrefix !== void 0 && content.startsWith(lineCommentPrefix, i)) {
+      while (i < content.length && content[i] !== "\n") i++;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      continue;
+    }
+    if (ch === "{") depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0) {
+        return offsetToLine(lineIndex, i);
+      }
+    }
+  }
+  return totalLines;
+}
+
+// src/languages/ini_idx.ts
+var MAX_SECTIONS = 200;
+var MAX_HEADING_LEN = 200;
+var MAX_ENV_KEYS = 200;
+var HEADER_RE = /^\[([^\]\r\n]+)\]\s*(?:[;#].*)?$/;
+var ENV_KEY_RE = /^(?:export\s+)?([A-Za-z_][\w.-]*)\s*(?:=|:(?!\/\/))/;
+function extractIni(content, filePath) {
+  const symbols = [];
+  const sections = [];
+  const seen = /* @__PURE__ */ new Set();
+  const lines = content.split(/\r?\n/);
+  const totalLines = countContentLines(content);
+  for (let i = 0; i < lines.length; i++) {
+    if (symbols.length >= MAX_SECTIONS) break;
+    const line = lines[i] ?? "";
+    if (!line || line[0] !== "[") continue;
+    const m = HEADER_RE.exec(line);
+    if (m === null) continue;
+    const name = m[1]?.trim() ?? "";
+    if (!name || name.length > MAX_HEADING_LEN) continue;
+    const key = `${name}\0${i + 1}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    symbols.push(makeLineSymbol(filePath, name, "ini_section", i + 1));
+    sections.push({ heading: name, level: 1, line: i + 1, endLine: i + 1 });
+  }
+  sections.sort((a, b) => a.line - b.line);
+  assignFlatEndLines(sections, totalLines);
+  return propagateEndLinesToSymbols(symbols, sections);
+}
+function _isEscapedQuote(line, i, q) {
+  if (q === "'") return false;
+  let backslashes = 0;
+  let j = i - 1;
+  while (j >= 0 && line[j] === "\\") {
+    backslashes++;
+    j--;
+  }
+  return backslashes % 2 === 1;
+}
+function _lineClosesQuote(line, q) {
+  for (let i = 0; i < line.length; i++) {
+    if (line[i] === q && !_isEscapedQuote(line, i, q)) return true;
+  }
+  return false;
+}
+function _detectOpenQuote(value) {
+  const trimmed = value.replace(/^\s+/, "");
+  const q = trimmed[0];
+  if (q !== '"' && q !== "'") return null;
+  for (let i = 1; i < trimmed.length; i++) {
+    if (trimmed[i] === q && !_isEscapedQuote(trimmed, i, q)) return null;
+  }
+  return q;
+}
+function extractEnv(content, filePath) {
+  const symbols = [];
+  const seen = /* @__PURE__ */ new Set();
+  const lines = content.split(/\r?\n/);
+  let openQuote = null;
+  for (let i = 0; i < lines.length; i++) {
+    if (symbols.length >= MAX_ENV_KEYS) break;
+    const line = lines[i] ?? "";
+    if (openQuote !== null) {
+      if (_lineClosesQuote(line, openQuote)) openQuote = null;
+      continue;
+    }
+    if (!line || line[0] === "#" || line[0] === ";" || line[0] === " " || line[0] === "	") continue;
+    const m = ENV_KEY_RE.exec(line);
+    if (m === null) continue;
+    const name = m[1]?.trim() ?? "";
+    if (!name || name.length > MAX_HEADING_LEN) continue;
+    const key = `${name}\0${i + 1}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    symbols.push(makeLineSymbol(filePath, name, "env_key", i + 1));
+    openQuote = _detectOpenQuote(line.slice(m[0].length));
+  }
+  return symbols;
+}
+
+// src/dotenv_redact.ts
+var DOTENV_VALUE_PLACEHOLDER = "[REDACTED:dotenv_value]";
+var ASSIGNMENT_RE = /^(\s*(?:export\s+)?[A-Za-z_][\w.-]*\s*(?:\+?=|:(?!\/\/)))/;
+var SAFE_LINE_RE = /^\s*(?:[#;].*)?$/;
+function isDotenvPath(filePath) {
+  return detectLanguage(filePath) === "env_file";
+}
+function redactDotenvValues(text) {
+  const lines = text.split("\n");
+  const out = [];
+  let openQuote = null;
+  for (const raw of lines) {
+    const hasCr = raw.endsWith("\r");
+    const line = hasCr ? raw.slice(0, -1) : raw;
+    const eol = hasCr ? "\r" : "";
+    const emit = (s) => {
+      out.push(`${s}${eol}`);
+    };
+    if (openQuote !== null) {
+      if (_lineClosesQuote(line, openQuote)) openQuote = null;
+      emit(DOTENV_VALUE_PLACEHOLDER);
+      continue;
+    }
+    if (SAFE_LINE_RE.test(line)) {
+      emit(line);
+      continue;
+    }
+    const m = ASSIGNMENT_RE.exec(line);
+    if (m === null || m[1] === void 0) {
+      emit(DOTENV_VALUE_PLACEHOLDER);
+      continue;
+    }
+    const prefix = m[1];
+    openQuote = _detectOpenQuote(line.slice(prefix.length));
+    emit(`${prefix}${DOTENV_VALUE_PLACEHOLDER}`);
+  }
+  return out.join("\n");
+}
+function redactIfDotenv(filePath, text) {
+  return isDotenvPath(filePath) ? redactDotenvValues(text) : text;
+}
+
 // src/db.ts
-init_define_import_meta_env();
 import * as fs6 from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import * as path6 from "node:path";
+import * as path7 from "node:path";
 import Database from "better-sqlite3";
 var _require = createRequire2(import.meta.url);
 var _connections = /* @__PURE__ */ new Map();
@@ -3491,7 +4568,7 @@ CREATE TRIGGER IF NOT EXISTS cache_recall_au AFTER UPDATE ON cache_recall BEGIN
   VALUES (new.row_id, new.label, new.content);
 END;
 `;
-var SCHEMA_VERSION = 10;
+var SCHEMA_VERSION = 11;
 function alterTableIdempotent(conn, sql) {
   try {
     conn.exec(sql);
@@ -3499,6 +4576,26 @@ function alterTableIdempotent(conn, sql) {
     if (!(err instanceof Error) || !/duplicate column/i.test(err.message)) throw err;
   }
 }
+function purgeDotenvEmbeddings(conn) {
+  let paths;
+  try {
+    paths = conn.prepare("SELECT DISTINCT file_path FROM chunks").all().map((r) => r.file_path).filter(isDotenvPath);
+  } catch {
+    return;
+  }
+  if (paths.length === 0) return;
+  for (const p of paths) {
+    try {
+      conn.prepare("DELETE FROM chunk_vectors WHERE rowid IN (SELECT id FROM chunks WHERE file_path = ?)").run(p);
+    } catch {
+    }
+    conn.prepare("DELETE FROM chunks WHERE file_path = ?").run(p);
+    try {
+      conn.prepare("UPDATE files SET embed_sha = NULL WHERE path = ?").run(p);
+    } catch {
+    }
+  }
+}
 var MIGRATIONS = {
   // v1 -> v2: adds files.embed_sha, tracked separately from files.sha so embedding freshness can be gated independently of parse freshness (see makeIndexer in worker.ts). A pre-existing v1 database's `files` table predates the column, so it needs an explicit ALTER TABLE here; a brand-new database already has the column from SCHEMA_SQL's CREATE TABLE above, so the ALTER TABLE would fail with "duplicate column name" there -- swallow exactly that error and rethrow anything else, so a genuine ALTER TABLE failure is never silently lost.
   1: (conn) => alterTableIdempotent(conn, "ALTER TABLE files ADD COLUMN embed_sha TEXT"),
@@ -3507,7 +4604,15 @@ var MIGRATIONS = {
   // v8 -> v9: adds symbols.parent (see SCHEMA_VERSION comment above for why). A pre-existing v8 database's `symbols` table predates the column, so it needs an explicit ALTER TABLE here; a brand-new database already has the column from SCHEMA_SQL's CREATE TABLE above, so the ALTER TABLE would fail with "duplicate column name" there -- swallow exactly that error and rethrow anything else, same pattern as v1 -> v2 / v2 -> v3 above.
   8: (conn) => alterTableIdempotent(conn, "ALTER TABLE symbols ADD COLUMN parent TEXT NOT NULL DEFAULT ''"),
   // v9 -> v10: adds hint_emissions.bytes_emitted (see SCHEMA_VERSION comment above for why). A pre-existing v9 database's `hint_emissions` table predates the column, so it needs an explicit ALTER TABLE here; a brand-new database already has the column from SCHEMA_SQL's CREATE TABLE above, so the ALTER TABLE would fail with "duplicate column name" there -- swallow exactly that error and rethrow anything else, same pattern as v1 -> v2 / v2 -> v3 / v8 -> v9 above.
-  9: (conn) => alterTableIdempotent(conn, "ALTER TABLE hint_emissions ADD COLUMN bytes_emitted INTEGER")
+  9: (conn) => alterTableIdempotent(conn, "ALTER TABLE hint_emissions ADD COLUMN bytes_emitted INTEGER"),
+  // v10 -> v11: purge chunks (and their vectors) for dotenv files. Until this version, a tracked
+  // `.env` was chunked and embedded verbatim on the git path, so `semantic` returned its values --
+  // see dotenv_redact.ts. Redacting from now on is not enough on its own: the embed-freshness gate
+  // (isEmbedFresh in parser.ts) skips a file whose bytes have not changed, so an already-indexed
+  // .env would have kept serving its pre-fix chunks indefinitely. Deleting the rows here both
+  // removes the stored secrets and, by clearing embed_sha, makes the next drain re-embed the file
+  // through the redacting path.
+  10: purgeDotenvEmbeddings
 };
 function runMigrations(conn, fromVersion, toVersion) {
   for (let v = fromVersion; v < toVersion; v++) {
@@ -3553,8 +4658,8 @@ function initConnection(conn) {
   }
 }
 function resolveDbPath(dbPath) {
-  if (path6.isAbsolute(dbPath)) return dbPath;
-  if (dbPath.includes("/") || dbPath.includes("\\")) return path6.resolve(dbPath);
+  if (path7.isAbsolute(dbPath)) return dbPath;
+  if (dbPath.includes("/") || dbPath.includes("\\")) return path7.resolve(dbPath);
   return safeJoin(dataDir(), dbPath);
 }
 function connectionKey(dbPath) {
@@ -3565,7 +4670,7 @@ function getDb(dbPath) {
   const { resolved, key } = connectionKey(dbPath);
   const existing = _connections.get(key);
   if (existing !== void 0) return existing;
-  const dir = path6.dirname(resolved);
+  const dir = path7.dirname(resolved);
   try {
     ensureDirSync(dir);
   } catch (e) {
@@ -3596,7 +4701,6 @@ function closeAllDbs() {
 registerReset(closeAllDbs);
 
 // src/render/ansi.ts
-init_define_import_meta_env();
 function _colorStream(isatty) {
   if (process.env["NO_COLOR"]) return false;
   return isatty;
@@ -3671,11 +4775,9 @@ var C = {
 };
 
 // src/stats.ts
-init_define_import_meta_env();
-import * as path7 from "node:path";
+import * as path8 from "node:path";
 
 // src/render/stats_renderer.ts
-init_define_import_meta_env();
 var _STATS_MESSAGES_FALLBACK = {
   bytesModeOnlyNote: "tracks bytes, not vision tokens",
   sessionHintSplitNote: "session_hint shows realized savings; session_hint_overhead shows injected hint cost",
@@ -4401,6 +5503,8 @@ var KIND_TO_SOURCE = {
   json_outline: SOURCE_READ,
   yaml_query: SOURCE_READ,
   yaml_outline: SOURCE_READ,
+  xml_query: SOURCE_READ,
+  xml_outline: SOURCE_READ,
   openapi_op: SOURCE_READ,
   openapi_outline: SOURCE_READ,
   zip_list: SOURCE_READ,
@@ -4486,6 +5590,8 @@ var COMMAND_KINDS = {
   "json-outline": /* @__PURE__ */ new Set(["json_outline"]),
   "yaml-query": /* @__PURE__ */ new Set(["yaml_query"]),
   "yaml-outline": /* @__PURE__ */ new Set(["yaml_outline"]),
+  "xml-query": /* @__PURE__ */ new Set(["xml_query"]),
+  "xml-outline": /* @__PURE__ */ new Set(["xml_outline"]),
   "openapi-op": /* @__PURE__ */ new Set(["openapi_op"]),
   "openapi-outline": /* @__PURE__ */ new Set(["openapi_outline"]),
   "zip-list": /* @__PURE__ */ new Set(["zip_list"]),
@@ -4565,7 +5671,7 @@ var _globalSchemaApplied = /* @__PURE__ */ new Set();
 registerReset(() => _globalSchemaApplied.clear());
 function getGlobalDb(homeDir) {
   const basePath = homeDir ? dataDirForHome(homeDir) : dataDir();
-  const dbPath = path7.join(basePath, "global.db");
+  const dbPath = path8.join(basePath, "global.db");
   const db = getDb(dbPath);
   if (!_globalSchemaApplied.has(dbPath)) {
     db.exec(GLOBAL_SCHEMA_SQL);
@@ -4803,7 +5909,6 @@ function renderStats2(opts) {
 }
 
 // src/secret_redact.ts
-init_define_import_meta_env();
 var SECRET_PATTERNS = [
   // Anthropic keys share OpenAI's "sk-" prefix but are more specific
   // ("sk-ant-"), so they're matched first — the generic OpenAI pattern's
@@ -4821,18 +5926,52 @@ var SECRET_PATTERNS = [
   // contain '_' and could otherwise partially match the classic pattern.
   ["github_token", /github_pat_[A-Za-z0-9_]{22,}/g],
   ["github_token", /gh[oprsu]_[A-Za-z0-9]{36,}/g],
+  // xapp- is Slack's app-level token (Socket Mode), a bearer credential in its own right that
+  // the xox[baprs]- prefix does not cover. It gets its own entry rather than joining the
+  // alternation above because it needs the full segmented shape (xapp-<ver>-<app id>-<digits>-
+  // <hex>) to be safe: a bare /xapp-[A-Za-z0-9-]+/ redacted ordinary identifiers like
+  // "xapp-config" and the css class "xapp-container", mangling normal source. The xox* prefixes
+  // are distinctive enough on their own; "xapp-" is not.
   ["slack_token", /xox[baprs]-[A-Za-z0-9-]+/g],
+  ["slack_token", /xapp-\d-[A-Za-z0-9]{6,}-\d{8,}-[A-Za-z0-9]{16,}/g],
   // Matches the full block (BEGIN marker through its matching END marker), not just the
   // header -- the actual secret material is the base64 body between them, so redacting only
   // the header line would leave the key bytes themselves fully readable in the cached blob.
-  // The lazy [\s\S]*? is bounded by the very next END marker (private key blocks don't nest),
-  // so this stays linear in practice despite the lazy quantifier.
-  ["private_key_block", /-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH )?PRIVATE KEY-----/g],
+  // The body is lazy and additionally refuses to cross a following BEGIN marker. Both halves
+  // matter. The laziness bounds a successful match at the very next END marker; the negative
+  // lookahead bounds a *failing* one, because a BEGIN with no END of its own would otherwise
+  // scan to end-of-input, and a blob full of such markers made the pass quadratic -- 6 ms, 20 ms
+  // and 78 ms for 2000, 4000 and 8000 of them, four times the work for twice the input, the same
+  // shape as the lookbehind incident described above. Private key blocks do not nest, so
+  // refusing to cross a BEGIN costs nothing in correctness.
+  // The algorithm and ` BLOCK` groups are backreferenced in the END marker rather than repeated,
+  // so a BEGIN only ever pairs with its own END spelling. Written as two independent optional
+  // groups, `BEGIN PGP PRIVATE KEY` would happily close on a distant `END RSA PRIVATE KEY BLOCK`
+  // and redact everything in between. A non-participating group backreferences as the empty
+  // string in JS, which is exactly what the unprefixed `BEGIN PRIVATE KEY` form needs.
+  // The algorithm list covers every armored private-key header openssl, ssh-keygen and gpg
+  // actually emit, not just the ones a first draft happened to think of. ENCRYPTED is the
+  // PKCS#8 passphrase-protected form (`openssl genpkey -aes256`, `ssh-keygen -m PKCS8`) and is
+  // the most common shape of all; DSA is legacy but still written verbatim; PGP carries the
+  // ` BLOCK` suffix, which is why that suffix is optional here. All three used to fall through
+  // to disk in full. An encrypted key is still key material: the passphrase can be attacked
+  // offline once the bytes are cached, so it is redacted like any other.
+  // PuTTY `.ppk` files are deliberately not matched. They have no END marker -- the private
+  // section is a `Private-Lines: N` count followed by exactly N base64 lines -- so bounding a
+  // match would take a stateful parse rather than a regex, on a path that runs over every
+  // command output. A regex guess at where the body ends is exactly the over-eager match this
+  // module's header warns against.
+  ["private_key_block", /-----BEGIN (RSA |DSA |EC |OPENSSH |ENCRYPTED |PGP )?PRIVATE KEY( BLOCK)?-----(?:(?!-----BEGIN )[\s\S])*?-----END \1PRIVATE KEY\2-----/g],
   // Redacts only the token itself, not the "Authorization: Bearer " prefix -- the lookbehind
   // anchors on the header name and scheme so the surrounding request-log line stays readable,
   // matching how AWS_ACCESS_KEY_ID=... above keeps its own prefix intact.
-  ["auth_bearer_token", /(?<=Authorization:\s*Bearer\s)[A-Za-z0-9\-._~+/]{10,}=*/gi],
-  ["auth_basic_token", /(?<=Authorization:\s*Basic\s)[A-Za-z0-9+/]{6,}=*/gi],
+  // The optional quotes on either side of the colon are what let this see a header carried in
+  // JSON rather than in raw wire format. Without them the lookbehind demanded the colon sit
+  // directly against the header name and the scheme directly against the space, so a body like
+  // {"Authorization": "Bearer <token>"} -- the shape any logged fetch or MCP result arrives in
+  // -- matched nothing and the token was cached verbatim.
+  ["auth_bearer_token", /(?<=Authorization["']?[ \t]{0,8}:[ \t]{0,8}["']?[ \t]{0,8}Bearer[ \t])[A-Za-z0-9\-._~+/]{10,}=*/gi],
+  ["auth_basic_token", /(?<=Authorization["']?[ \t]{0,8}:[ \t]{0,8}["']?[ \t]{0,8}Basic[ \t])[A-Za-z0-9+/]{6,}=*/gi],
   // JWTs have no distinctive prefix of their own, but the base64url encoding of the smallest
   // realistic header ('{"alg":' or similar) always starts with "eyJ", so that's the practical
   // anchor here -- each of the three dot-separated segments requires a minimum length to avoid
@@ -4851,6 +5990,13 @@ var SECRET_PATTERNS = [
   // are what make the short, generic 'sig' name safe to key on: a prose or code mention of "sig"
   // never sits directly after a query separator followed by that much opaque token.
   ["presigned_signature", /(?<=[?&](?:X-Amz-Signature|X-Goog-Signature|sig)=)[A-Za-z0-9%+/=_-]{16,}/gi],
+  // A password inside a connection url. `postgres://user:hunter2@db.internal` carries the
+  // credential in the authority section, where there is no `key=value` separator for the
+  // generic pattern below to anchor on, so a DATABASE_URL echoed by a failing migration or a
+  // psql error went through untouched. The anchors are what keep this narrow: a scheme's `://`,
+  // a userinfo segment, the colon, and a following `@`. `http://host:8080/path` has no `@` and
+  // is left alone; so is any url without credentials.
+  ["url_credentials", /(?<=:\/\/[^\s:@/]{1,64}:)[^\s:@/]{1,256}(?=@)/g],
   // Generic key=value assignments in .env-file and connection-string/query-string shape. The
   // lookbehind again redacts only the value, and the value's character class deliberately
   // excludes whitespace, '&', ';', '#', quote characters, and '[' ']' ':' -- that exclusion is
@@ -4866,13 +6012,19 @@ var SECRET_PATTERNS = [
   // this cannot backtrack catastrophically -- there is no nested or overlapping quantifier for
   // the engine to explore multiple ways of matching, so removing the upper bound does not
   // introduce a ReDoS risk.
+  // Quotes are permitted around the separator, but never inside the value class. A quoted value
+  // is the ordinary way secrets are written -- .env files, JSON, YAML, TOML all quote by default
+  // -- and the lookbehind used to stop dead at the opening quote, so `API_KEY="..."` passed
+  // through in full while the bare `API_KEY=...` was caught. The closing quote of the key name
+  // blocked it from the other side too, which is what kept every JSON body unredacted. Keeping
+  // quotes out of the value class is still what stops the match running past the closing quote.
   // The keyword may be a prefix of a longer key name rather than the whole of it, so the
   // trailing identifier class below is load-bearing: without it the lookbehind required the
   // keyword to sit immediately before the separator, and AWS_SECRET_ACCESS_KEY=,
   // SECRET_KEY=, and DB_PASSWORD_HASH= all passed through in full. That class matches
   // identifier characters only, so prose that merely mentions a keyword still never reaches
   // a separator and stays unredacted. api[_-]?key covers the apikey and api-key spellings too.
-  ["generic_secret_assignment", /(?<=(?:password|passwd|secret|api[_-]?key)[a-z0-9_-]*\s*[:=]\s*)[^\s&;#'"[\]:]{4,}/gi]
+  ["generic_secret_assignment", /(?<=(?:password|passwd|secret|api[_-]?key|access[_-]?token|refresh[_-]?token|id[_-]?token)[a-z0-9_-]{0,64}["']?[ \t]{0,8}[:=][ \t]{0,8}["']?)(?:\\[^\n]|[^\s\\&;#'"[\],{}:]){4,}/gi]
 ];
 function redactSecrets(text) {
   let count = 0;
@@ -4887,7 +6039,6 @@ function redactSecrets(text) {
 }
 
 // src/filters.ts
-init_define_import_meta_env();
 var DROP = () => null;
 var FILTERS = [
   {
@@ -4948,7 +6099,6 @@ var FILTERS = [
 ];
 
 // src/bash_compress.ts
-init_define_import_meta_env();
 function stripAnsiCodes(text) {
   return stripAnsiEscapes(text);
 }
@@ -4968,6 +6118,8 @@ export {
   normalizeDarwinSystemAlias,
   resolveIndexPath,
   toDisplayPath,
+  displaySafeText,
+  displaySafePath,
   sleepSync,
   isWindows,
   isCaseInsensitiveFs,
@@ -4999,6 +6151,7 @@ export {
   grepFilteredToEmptyNotice,
   countNoun,
   excludeTestsHiddenNote,
+  countContentLines,
   escapeRegExp,
   windowsCmdQuoteArg,
   redactUrlQuery,
@@ -5017,9 +6170,13 @@ export {
   isWithinQuietHours,
   hookCommandFor,
   suggestPackageNames,
+  detectSourceEncoding,
+  decodeSource,
+  encodeSource,
   fingerprintContent,
   shortFingerprint,
   fingerprintFile,
+  fileIsAbsent,
   canonicalize,
   makeProjectAt,
   findProject,
@@ -5042,6 +6199,36 @@ export {
   CONFIG_KEY_ENV_OVERRIDES,
   saveConfig,
   redactSecrets,
+  precedingDocComment,
+  buildLineIndex,
+  offsetToLine,
+  stripCstyleComments,
+  stripXmlComments,
+  scanQuotedStringEnd,
+  stripJsComments,
+  stripHashComments,
+  maskHtmlNoise,
+  findHtmlHeadingMatches,
+  isInsideStringLiteral,
+  stripBlockCommentSpan,
+  stripNestedBlockCommentSpan,
+  stripLineComment,
+  stripStringLiterals,
+  stripMultilineStringSpan,
+  makeSpanSymbol,
+  makeLineSymbol,
+  makeSymbolEmitter,
+  assignFlatEndLines,
+  propagateEndLinesToSymbols,
+  findMatchingBraceEndLine,
+  extractIni,
+  _lineClosesQuote,
+  _detectOpenQuote,
+  extractEnv,
+  detectLanguage,
+  unsupportedLanguageName,
+  isDotenvPath,
+  redactIfDotenv,
   getDb,
   colorStdout,
   RESET,
@@ -5062,8 +6249,8 @@ export {
 
 smol-toml/dist/date.js:
 smol-toml/dist/error.js:
-smol-toml/dist/primitive.js:
 smol-toml/dist/util.js:
+smol-toml/dist/primitive.js:
 smol-toml/dist/extract.js:
 smol-toml/dist/struct.js:
 smol-toml/dist/parse.js: