token-goat 2.9.13 → 2.9.14

package/dist/token-goat-chunk-POBYR64E.mjs

@@ -0,0 +1,1632 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  countContentLines,
+  escapeRegExp
+} from "./token-goat-chunk-AMYCQJX4.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/languages/common.ts
+init_define_import_meta_env();
+
+// src/doc_comment.ts
+init_define_import_meta_env();
+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 === "vb") {
+    if (!aboveTrimmed.startsWith("'''")) return "";
+    const collected = [];
+    for (let i = aboveIdx; i >= 0; i--) {
+      const trimmed = (lines[i] ?? "").trim();
+      if (!trimmed.startsWith("'''")) break;
+      collected.unshift(trimmed.replace(/^'''\s?/, ""));
+    }
+    return collected.join("\n").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, opts = {}) {
+  let openQuote = null;
+  let i = from;
+  while (i < index) {
+    const ch = line[i];
+    if (opts.symbolLiterals === true && openQuote === null && ch === "'") {
+      const len = scalaCharLiteralLength(line, i);
+      i += len === 0 ? 1 : len;
+      continue;
+    }
+    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 nextBlockCommentOpen(line, from) {
+  const lineCommentIdx = lineCommentStartIndex(line, ["//"], from);
+  let open = line.indexOf("/*", from);
+  while (open !== -1 && (isInsideStringLiteral(line, open, from) || lineCommentIdx !== -1 && open >= lineCommentIdx)) {
+    open = line.indexOf("/*", open + 1);
+  }
+  return open;
+}
+function stripBlockCommentSpan(line, inComment) {
+  let code = "";
+  let j = 0;
+  let comment = inComment;
+  while (j < line.length) {
+    if (!comment) {
+      const open = nextBlockCommentOpen(line, j);
+      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 open = nextBlockCommentOpen(line, j);
+      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 = ["//"], opts = {}) {
+  const cutIdx = lineCommentStartIndex(line, markers, 0, opts);
+  return cutIdx === -1 ? line : line.slice(0, cutIdx);
+}
+function lineCommentStartIndex(line, markers, from = 0, opts = {}) {
+  let cutIdx = -1;
+  for (const marker of markers) {
+    let idx = line.indexOf(marker, from);
+    while (idx !== -1 && isInsideStringLiteral(line, idx, from, opts)) {
+      idx = line.indexOf(marker, idx + 1);
+    }
+    if (idx !== -1 && (cutIdx === -1 || idx < cutIdx)) cutIdx = idx;
+  }
+  return cutIdx;
+}
+function scalaCharLiteralLength(line, index) {
+  if (line[index] !== "'") return 0;
+  if (line[index + 1] === "\\") {
+    if (line[index + 2] === "u") {
+      let i = index + 3;
+      while (line[i] === "u") i++;
+      return /^[0-9a-fA-F]{4}$/.test(line.slice(i, i + 4)) && line[i + 4] === "'" ? i + 5 - index : 0;
+    }
+    return line[index + 2] !== void 0 && line[index + 3] === "'" ? 4 : 0;
+  }
+  return line[index + 1] !== void 0 && line[index + 1] !== "'" && line[index + 2] === "'" ? 3 : 0;
+}
+function stripStringLiterals(line, opts = {}) {
+  const openDelim = (idx) => {
+    const q = line[idx];
+    if (opts.tripleQuotes && line[idx + 1] === q && line[idx + 2] === q) return q + q + q;
+    return q;
+  };
+  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 (opts.symbolLiterals === true && ch === "'" && scalaCharLiteralLength(line, i) === 0) {
+        out += ch;
+        i++;
+        continue;
+      }
+      if (ch === '"' || ch === "'") {
+        const bareBraceHole = ch === '"' && i > 0 && line[i - 1] === "$";
+        const delim = openDelim(i);
+        stack.push({ kind: "string", quote: delim, bareBraceHole });
+        out += delim;
+        i += delim.length;
+        continue;
+      }
+      out += ch;
+      i++;
+      continue;
+    }
+    if (top.kind === "hole") {
+      if (opts.symbolLiterals === true && ch === "'" && scalaCharLiteralLength(line, i) === 0) {
+        out += ch;
+        i++;
+        continue;
+      }
+      if (ch === '"' || ch === "'") {
+        const bareBraceHole = ch === '"' && i > 0 && line[i - 1] === "$";
+        const delim = openDelim(i);
+        stack.push({ kind: "string", quote: delim, bareBraceHole });
+        out += delim;
+        i += delim.length;
+        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 && line[i + 1] !== "\n") {
+      out += "  ";
+      i += 2;
+      continue;
+    }
+    if (ch === top.quote[0] && (top.quote.length === 1 || line.startsWith(top.quote, i))) {
+      stack.pop();
+      out += top.quote;
+      i += top.quote.length;
+      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 closingQuoteRunEnd(text, from, quote, len, runClose) {
+  for (let i = from; i < text.length; i++) {
+    if (text[i] !== quote) continue;
+    let run = 0;
+    while (text[i + run] === quote) run++;
+    if (run >= len) return runClose === "last" ? i + run : i + len;
+    i += run - 1;
+  }
+  return -1;
+}
+var MULTILINE_CLOSER_ANCHOR = {
+  // An Elixir heredoc is terminated only by a delimiter run that begins its own line, preceded by nothing but the whitespace that also sets the indentation stripped from the body (Elixir syntax reference, section "Strings", heredocs). A run appearing mid-line inside the body is content.
+  elixir: "lineStart",
+  // The closing delimiter of a Swift multi-line string literal has to appear on a line of its own, and its indentation sets what is stripped from each body line (The Swift Programming Language, "Strings and Characters", section "Multiline String Literals"). The same section's rules apply to the extended-delimiter multi-line form (`#"""`), whose only reachable state here is the cross-line one.
+  swift: "lineStart",
+  // A PHP heredoc or nowdoc closes on its identifier at the start of a line; PHP 7.3 allowed that identifier to be indented and to be followed by other characters (PHP language reference, "Strings", section "Heredoc text"). Read by the heredoc/nowdoc branch, which builds its anchor regex from this value.
+  php: "lineStart",
+  // A PowerShell here-string terminator (`"@` / `'@`) must be the first characters on its line, with no leading whitespace at all, which is the one language here that is stricter than `'lineStart'` (about_Quoting_Rules, "Here-Strings").
+  powershell: "column0",
+  // Kotlin's raw string is terminated by the next `"""` wherever it falls, so `val s = """a"""` on one line is a complete literal (Kotlin language specification, "Expressions", section "String literals").
+  kotlin: "anywhere",
+  // Scala's multi-line string literal is likewise terminated by the next run of three quotes on any line (Scala language specification, section 1.3.5 "Character Literals and String Literals").
+  scala: "anywhere",
+  // Dart's multi-line string production is a delimiter, content, then the delimiter, with no rule about where on a line the closing delimiter falls (Dart Programming Language Specification, section "Strings").
+  dart: "anywhere",
+  // A GraphQL block string closes at the next `"""` wherever it sits: the spec's BlockString production places no positional rule on the closing delimiter, and a one-line description such as `"""A user."""` is the ordinary form (GraphQL specification, section 2.9.4 "String Value").
+  graphql: "anywhere",
+  // C# has two cross-line forms and they disagree, so the language-level value is the permissive one. A verbatim string (`@"..."`) closes on the next non-doubled quote wherever it sits and has no positional rule (C# language reference, "String literals"). A multi-line raw string literal does require its closing run to begin its own line (C# language reference, "Raw string literals"), but that rule is unreachable as a mis-pairing here: the same section forbids the content from holding a quote run as long as the delimiter, so no run inside the body can be mistaken for the closer in the first place, and the run-length rule already in `closingQuoteRunEnd` is what enforces it.
+  csharp: "anywhere",
+  // R has no fixed-delimiter multi-line form and no positional rule: an ordinary character constant runs to its next unescaped quote (R Language Definition, section 10.3.1 "Literal constants") and a raw constant to its mirrored closing punctuation (R base help page `?Quotes`, "Raw character constants"), on whatever line either lands.
+  r: "anywhere"
+};
+function closerSearchStart(line, from, anchor) {
+  if (anchor === "anywhere") return from;
+  const indent = anchor === "column0" ? 0 : /^[ \t]*/.exec(line)?.[0].length ?? 0;
+  return from <= indent ? indent : -1;
+}
+var TRIPLE_QUOTE_RUN_CLOSE = {
+  kotlin: "last",
+  scala: "last",
+  // A GraphQL block string ends at the first `"""` run, because its grammar excludes that sequence from the body outright rather than letting the longest run win (GraphQL specification, section 2.9.4 "String Value", the BlockString production).
+  graphql: "first",
+  // Swift's closing delimiter has to stand alone on its own line (The Swift Programming Language, "Strings and Characters", section "Multiline String Literals"), so no run longer than three ever terminates a valid Swift literal; it is grouped with Kotlin and Scala so that the same-line and cross-line paths agree, not to assert a rule Swift itself defines.
+  swift: "last",
+  csharp: "last",
+  // An Elixir heredoc cannot open and close on one line, because its opening `"""` must be followed by a newline, so only the cross-line closer is reachable for valid Elixir and that path has always consumed the whole run.
+  elixir: "last",
+  dart: "first",
+  // No triple-quoted literal at all: PHP uses heredoc/nowdoc, PowerShell `@"`/`@'` here-strings, R ordinary and raw character constants. Present only because the Record is exhaustive; the value is never read for these three.
+  php: "last",
+  powershell: "last",
+  r: "last"
+};
+function quoteRunCloser(line, from, quote, len, state) {
+  const anchor = state.closerAnchor ?? "anywhere";
+  const start = closerSearchStart(line, from, anchor);
+  if (start === -1) return null;
+  if (anchor !== "anywhere") {
+    let run = 0;
+    while (line[start + run] === quote) run++;
+    if (run < len) return null;
+  }
+  const end = closingQuoteRunEnd(line, start, quote, len, state.runClose ?? "last");
+  return end === -1 ? null : { maskEnd: end };
+}
+function findMultilineCloser(line, from, state) {
+  switch (state.kind) {
+    case "heredoc":
+    case "nowdoc": {
+      const indent = (state.closerAnchor ?? "anywhere") === "column0" ? "" : "[ \\t]*";
+      const re = new RegExp(`^${indent}${escapeRegExp(state.identifier)}\\b`);
+      const m = re.exec(line);
+      return m ? { maskEnd: m[0].length } : null;
+    }
+    case "sigil": {
+      const end = elixirSigilEnd(line, from, state);
+      return end === -1 ? null : { maskEnd: end };
+    }
+    case "tripleSingleQuote": {
+      return quoteRunCloser(line, from, "'", 3, state);
+    }
+    case "tripleQuote": {
+      const n = state.identifier !== "" ? parseInt(state.identifier, 10) : 3;
+      return quoteRunCloser(line, from, '"', n, state);
+    }
+    case "rRaw":
+    case "swiftExtended": {
+      const anchor = state.closerAnchor ?? "anywhere";
+      if (anchor !== "anywhere") {
+        const start = closerSearchStart(line, from, anchor);
+        if (start === -1 || !line.startsWith(state.identifier, start)) return null;
+        return { maskEnd: start + state.identifier.length };
+      }
+      const idx = line.indexOf(state.identifier, from);
+      return idx === -1 ? null : { maskEnd: idx + state.identifier.length };
+    }
+    case "rString": {
+      const idx = findRQuoteEnd(line, from, state.identifier);
+      return idx === -1 ? null : { maskEnd: idx + 1 };
+    }
+    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":
+    case "psHereSingle": {
+      const start = closerSearchStart(line, from, state.closerAnchor ?? "anywhere");
+      const terminator = state.kind === "psHereDouble" ? '"@' : "'@";
+      if (start === -1 || !line.startsWith(terminator, start)) return null;
+      return { maskEnd: start + terminator.length };
+    }
+    default:
+      return null;
+  }
+}
+var MULTILINE_OPENER_COMMENT_MARKERS = {
+  php: ["//", "#"],
+  kotlin: ["//"],
+  graphql: ["#"],
+  csharp: ["//"],
+  powershell: ["#"],
+  swift: ["//"],
+  elixir: ["#"],
+  scala: ["//"],
+  dart: ["//"],
+  r: ["#"]
+};
+var MULTILINE_OPENER_BLOCK_COMMENT_LANGS = /* @__PURE__ */ new Set(["php", "kotlin", "csharp", "swift", "scala", "dart"]);
+var R_RAW_OPENER_RE = /[rR](["'])(-*)([([{])/y;
+var R_RAW_CLOSE_BRACKET = { "(": ")", "[": "]", "{": "}" };
+var R_IDENT_CHAR_RE = /[A-Za-z0-9._]/;
+function matchRRawOpener(text, index) {
+  const ch = text[index];
+  if (ch !== "r" && ch !== "R") return null;
+  if (R_IDENT_CHAR_RE.test(text[index - 1] ?? "")) return null;
+  R_RAW_OPENER_RE.lastIndex = index;
+  const m = R_RAW_OPENER_RE.exec(text);
+  if (m === null) return null;
+  const close = R_RAW_CLOSE_BRACKET[m[3] ?? ""];
+  if (close === void 0) return null;
+  return { openerEnd: index + m[0].length, closer: `${close}${m[2] ?? ""}${m[1] ?? ""}` };
+}
+var GROOVY_OPERAND_BEFORE = /* @__PURE__ */ new Set([..."([{,;=+-*/%<>!&|^~?:"]);
+var MAX_GROOVY_SLASHY_BODY = 1024;
+var GROOVY_OPERAND_KEYWORDS = /* @__PURE__ */ new Set(["return", "case", "in", "new", "assert", "instanceof"]);
+function groovyOperandPosition(text, index) {
+  let i = index - 1;
+  while (i >= 0 && (text[i] === " " || text[i] === "	")) i--;
+  if (i < 0) return true;
+  const ch = text[i];
+  if (ch === "\n" || ch === "\r") return true;
+  if (GROOVY_OPERAND_BEFORE.has(ch)) return true;
+  if (!/[\w$]/.test(ch)) return false;
+  let j = i;
+  while (j >= 0 && /[\w$]/.test(text[j])) j--;
+  return GROOVY_OPERAND_KEYWORDS.has(text.slice(j + 1, i + 1));
+}
+function matchGroovySlashy(text, index) {
+  const dollar = text[index] === "$" && text[index + 1] === "/";
+  if (!dollar) {
+    if (text[index] !== "/") return null;
+    const next = text[index + 1];
+    if (next === "/" || next === "*") return null;
+    if (!groovyOperandPosition(text, index)) return null;
+  }
+  const bodyStart = index + (dollar ? 2 : 1);
+  const limit = Math.min(text.length, bodyStart + MAX_GROOVY_SLASHY_BODY);
+  for (let i = bodyStart; i < limit; i++) {
+    const ch = text[i];
+    if (dollar) {
+      if (ch === "$" && (text[i + 1] === "$" || text[i + 1] === "/")) {
+        i++;
+        continue;
+      }
+      if (ch === "/" && text[i + 1] === "$") return { bodyStart, bodyEnd: i, end: i + 2 };
+      continue;
+    }
+    if (ch === "\\" && text[i + 1] === "/") {
+      i++;
+      continue;
+    }
+    if (ch === "\n") return null;
+    if (ch === "/") return { bodyStart, bodyEnd: i, end: i + 1 };
+  }
+  return null;
+}
+var ELIXIR_SIGIL_CLOSER = { "(": ")", "[": "]", "{": "}", "<": ">", "/": "/", "|": "|", '"': '"', "'": "'" };
+var ELIXIR_SIGIL_OPENER = { ")": "(", "]": "[", "}": "{", ">": "<" };
+function matchElixirSigilOpener(line, index) {
+  if (line[index] !== "~") return null;
+  let i = index + 1;
+  const first = line[i] ?? "";
+  let escapes;
+  if (first >= "a" && first <= "z") {
+    escapes = true;
+    i++;
+  } else if (first >= "A" && first <= "Z") {
+    escapes = false;
+    while (i < line.length && (line[i] ?? "") >= "A" && (line[i] ?? "") <= "Z") i++;
+  } else {
+    return null;
+  }
+  const delim = line[i] ?? "";
+  const closer = ELIXIR_SIGIL_CLOSER[delim];
+  if (closer === void 0) return null;
+  if ((delim === '"' || delim === "'") && line[i + 1] === delim && line[i + 2] === delim) return null;
+  return { openerEnd: i + 1, closer, escapes };
+}
+function elixirSigilEnd(line, from, state) {
+  const closer = state.identifier;
+  const opener = ELIXIR_SIGIL_OPENER[closer];
+  for (let i = from; i < line.length; i++) {
+    const ch = line[i];
+    if (state.escapes === true && ch === "\\") {
+      i++;
+      continue;
+    }
+    if (opener !== void 0 && ch === opener) {
+      state.depth = (state.depth ?? 0) + 1;
+      continue;
+    }
+    if (ch === closer) {
+      if ((state.depth ?? 0) > 0) {
+        state.depth = (state.depth ?? 0) - 1;
+        continue;
+      }
+      return i + 1;
+    }
+  }
+  return -1;
+}
+var SWIFT_EXTENDED_OPENER_RE = /(#+)("""|")/y;
+function matchSwiftExtendedOpener(text, index) {
+  if (text[index] !== "#") return null;
+  SWIFT_EXTENDED_OPENER_RE.lastIndex = index;
+  const m = SWIFT_EXTENDED_OPENER_RE.exec(text);
+  if (m === null) return null;
+  const hashes = m[1] ?? "";
+  const multiline = m[2] === '"""';
+  return { openerEnd: index + m[0].length, multiline, closer: `${multiline ? '"""' : '"'}${hashes}` };
+}
+var BASH_WORD_TERMINATORS = /* @__PURE__ */ new Set([" ", "	", "\n", "|", "&", ";", "(", ")", "<", ">"]);
+function matchBashHeredocOpener(text, index) {
+  if (text[index] !== "<" || text[index + 1] !== "<") return null;
+  if (text[index - 1] === "<" || text[index + 2] === "<") return null;
+  let i = index + 2;
+  if (text[i] === "-") i++;
+  while (text[i] === " " || text[i] === "	") i++;
+  let terminator = "";
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === "'") {
+      const close = text.indexOf("'", i + 1);
+      if (close === -1) return null;
+      terminator += text.slice(i + 1, close);
+      i = close + 1;
+      continue;
+    }
+    if (ch === '"') {
+      let j = i + 1;
+      for (; j < text.length; j++) {
+        if (text[j] === "\\") {
+          terminator += text[j + 1] ?? "";
+          j++;
+          continue;
+        }
+        if (text[j] === '"') break;
+        terminator += text[j];
+      }
+      if (j >= text.length) return null;
+      i = j + 1;
+      continue;
+    }
+    if (ch === "\\") {
+      if (i + 1 >= text.length) break;
+      terminator += text[i + 1];
+      i += 2;
+      continue;
+    }
+    if (ch === void 0 || BASH_WORD_TERMINATORS.has(ch)) break;
+    terminator += ch;
+    i++;
+  }
+  if (terminator === "") return null;
+  return { openerEnd: i, terminator };
+}
+function findRQuoteEnd(line, start, quote) {
+  for (let j = start; j < line.length; j++) {
+    const c = line[j];
+    if (c === "\\") {
+      j++;
+      continue;
+    }
+    if (c === quote) return j;
+  }
+  return -1;
+}
+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, closerAnchor: MULTILINE_CLOSER_ANCHOR[lang] } };
+  }
+  if (lang === "kotlin" || lang === "swift" || lang === "scala" || lang === "graphql") {
+    let swiftExt = null;
+    if (lang === "swift") {
+      for (let h = line.indexOf("#", from); h !== -1; h = line.indexOf("#", h + 1)) {
+        const ext = matchSwiftExtendedOpener(line, h);
+        if (ext === null || isInsideStringLiteral(line, h, from) || isCommented(h)) continue;
+        const extClose = line.indexOf(ext.closer, ext.openerEnd);
+        const extState = { kind: "swiftExtended", identifier: ext.closer, closerAnchor: MULTILINE_CLOSER_ANCHOR[lang] };
+        if (extClose !== -1) {
+          swiftExt = { openStart: h, closesSameLine: extClose + ext.closer.length, state: extState };
+          break;
+        }
+        if (ext.multiline) {
+          swiftExt = { openStart: h, closesSameLine: null, state: extState };
+          break;
+        }
+      }
+    }
+    const idx = line.indexOf('"""', from);
+    if (swiftExt !== null && (idx === -1 || swiftExt.openStart < idx)) return swiftExt;
+    if (idx === -1 || isInsideStringLiteral(line, idx, from) || isCommented(idx)) return null;
+    const runClose = TRIPLE_QUOTE_RUN_CLOSE[lang];
+    const tripleState = { kind: "tripleQuote", identifier: "3", runClose, closerAnchor: MULTILINE_CLOSER_ANCHOR[lang] };
+    const closeEnd = closingQuoteRunEnd(line, idx + 3, '"', 3, runClose);
+    if (closeEnd !== -1) {
+      return { openStart: idx, closesSameLine: closeEnd, state: tripleState };
+    }
+    return { openStart: idx, closesSameLine: null, state: tripleState };
+  }
+  if (lang === "elixir" || lang === "dart") {
+    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 (lang === "elixir") {
+      for (let t = line.indexOf("~", from); t !== -1; t = line.indexOf("~", t + 1)) {
+        if (first !== void 0 && first[0] < t) break;
+        const open = matchElixirSigilOpener(line, t);
+        if (open === null || isInsideStringLiteral(line, t, from) || isCommented(t)) continue;
+        const state2 = { kind: "sigil", identifier: open.closer, depth: 0, escapes: open.escapes };
+        const end = elixirSigilEnd(line, open.openerEnd, state2);
+        return { openStart: t, closesSameLine: end === -1 ? null : end, state: state2 };
+      }
+    }
+    if (first === void 0) return null;
+    const [idx, kind, delim] = first;
+    if (isInsideStringLiteral(line, idx, from) || isCommented(idx)) return null;
+    const runClose = TRIPLE_QUOTE_RUN_CLOSE[lang];
+    const state = { kind, identifier: "3", runClose, closerAnchor: MULTILINE_CLOSER_ANCHOR[lang] };
+    const closeEnd = closingQuoteRunEnd(line, idx + 3, delim[0] ?? '"', 3, runClose);
+    if (closeEnd !== -1) return { openStart: idx, closesSameLine: closeEnd, state };
+    return { openStart: idx, closesSameLine: null, state };
+  }
+  if (lang === "r") {
+    const limit = commentIdx === -1 ? line.length : commentIdx;
+    let i = from;
+    while (i < limit) {
+      const ch = line[i] ?? "";
+      if (ch === "`") {
+        const end = line.indexOf("`", i + 1);
+        if (end === -1 || end >= limit) return null;
+        i = end + 1;
+        continue;
+      }
+      const raw = matchRRawOpener(line, i);
+      if (raw !== null) {
+        const closeIdx = line.indexOf(raw.closer, raw.openerEnd);
+        if (closeIdx === -1) return { openStart: i, closesSameLine: null, state: { kind: "rRaw", identifier: raw.closer, closerAnchor: MULTILINE_CLOSER_ANCHOR[lang] } };
+        i = closeIdx + raw.closer.length;
+        continue;
+      }
+      if (ch === '"' || ch === "'") {
+        const closeIdx = findRQuoteEnd(line, i + 1, ch);
+        if (closeIdx === -1) return { openStart: i, closesSameLine: null, state: { kind: "rString", identifier: ch, closerAnchor: MULTILINE_CLOSER_ANCHOR[lang] } };
+        i = closeIdx + 1;
+        continue;
+      }
+      i++;
+    }
+    return null;
+  }
+  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 rawState = { kind: "tripleQuote", identifier: String(tripleLen), runClose: TRIPLE_QUOTE_RUN_CLOSE.csharp, closerAnchor: MULTILINE_CLOSER_ANCHOR[lang] };
+      const closeEnd = closingQuoteRunEnd(line, tripleIdx + tripleLen, '"', tripleLen, rawState.runClose ?? "last");
+      if (closeEnd !== -1) {
+        return { openStart: tripleIdx, closesSameLine: closeEnd, state: rawState };
+      }
+      return { openStart: tripleIdx, closesSameLine: null, state: rawState };
+    }
+    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: "", closerAnchor: MULTILINE_CLOSER_ANCHOR[lang] } };
+  }
+  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 = 1e4, 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 s = sections[i];
+    if (s === void 0) continue;
+    let j = i + 1;
+    while (j < sections.length && (sections[j]?.line ?? 0) <= s.line) j++;
+    const next = sections[j];
+    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 tripleQuoteDelimiters(opts) {
+  const delims = [];
+  if (opts?.tripleQuote === true) delims.push('"""');
+  if (opts?.tripleSingleQuote === true) delims.push("'''");
+  return delims;
+}
+function quoteRunLength(content, i) {
+  let n = 0;
+  while (content[i + n] === '"') n++;
+  return n;
+}
+function skipRawStringQuotes(content, from, min) {
+  return closingQuoteRunEnd(content, from, '"', min, "last");
+}
+function stepPowershellString(content, i, quote) {
+  const ch = content[i];
+  if (quote === '"' && ch === "`") return { next: i + 1, open: true };
+  return { next: i, open: ch !== quote };
+}
+function opensCsharpVerbatimString(content, i) {
+  const prev = content[i - 1];
+  return prev === "@" || prev === "$" && content[i - 2] === "@";
+}
+function toLineCommentPrefixes(prefix) {
+  if (prefix === void 0) return [];
+  return typeof prefix === "string" ? [prefix] : prefix;
+}
+function atLineComment(content, i, prefixes, exceptions) {
+  if (exceptions.some((e) => content.startsWith(e, i))) return false;
+  return prefixes.some((prefix) => content.startsWith(prefix, i));
+}
+function skipBlockComment(content, start, block, nested) {
+  let i = start + block[0].length;
+  let depth = 1;
+  while (i < content.length) {
+    if (nested && content.startsWith(block[0], i)) {
+      depth++;
+      i += block[0].length;
+      continue;
+    }
+    if (content.startsWith(block[1], i)) {
+      depth--;
+      i += block[1].length;
+      if (depth === 0) return i;
+      continue;
+    }
+    i++;
+  }
+  return -1;
+}
+function findMatchingBraceEndLine(content, openBraceIndex, totalLines, lineIndex, lineCommentPrefix, opts) {
+  const linePrefixes = toLineCommentPrefixes(lineCommentPrefix);
+  const lineExceptions = opts?.lineCommentExceptions ?? [];
+  const block = opts?.blockComment;
+  const backtick = opts?.backtickQuote === true;
+  const escapes = opts?.stringEscapes ?? "backslash";
+  const nestedBlock = opts?.nestedBlockComments === true;
+  const rawString = opts?.rawStringQuotes === true;
+  const rRaw = opts?.rRawStrings === true;
+  const tripleDelims = tripleQuoteDelimiters(opts);
+  const lineString = opts?.lineStringPrefix;
+  let depth = 0;
+  let quote = null;
+  let verbatim = false;
+  for (let i = openBraceIndex; i < content.length; i++) {
+    const ch = content[i];
+    if (quote !== null) {
+      if (verbatim) {
+        if (ch === quote) {
+          if (content[i + 1] === quote) {
+            i++;
+            continue;
+          }
+          quote = null;
+          verbatim = false;
+        }
+        continue;
+      }
+      if (escapes === "powershell") {
+        const step = stepPowershellString(content, i, quote);
+        i = step.next;
+        if (!step.open) quote = null;
+        continue;
+      }
+      if (ch === "\\") {
+        i++;
+        continue;
+      }
+      if (ch === quote) quote = null;
+      continue;
+    }
+    if (block !== void 0 && content.startsWith(block[0], i)) {
+      const end = skipBlockComment(content, i, block, nestedBlock);
+      i = end === -1 ? content.length : end - 1;
+      continue;
+    }
+    if (atLineComment(content, i, linePrefixes, lineExceptions)) {
+      while (i < content.length && content[i] !== "\n") i++;
+      continue;
+    }
+    if (lineString !== void 0 && content.startsWith(lineString, i)) {
+      while (i < content.length && content[i] !== "\n") i++;
+      continue;
+    }
+    if (rRaw) {
+      const rOpen = matchRRawOpener(content, i);
+      if (rOpen !== null) {
+        const end = content.indexOf(rOpen.closer, rOpen.openerEnd);
+        i = end === -1 ? content.length : end + rOpen.closer.length - 1;
+        continue;
+      }
+    }
+    if (rawString && ch === '"') {
+      const run = quoteRunLength(content, i);
+      if (run >= 3) {
+        const end = skipRawStringQuotes(content, i + run, run);
+        i = end === -1 ? content.length : end - 1;
+        continue;
+      }
+    }
+    const tripleAt = tripleDelims.find((t) => content.startsWith(t, i));
+    if (tripleAt !== void 0) {
+      const end = closingQuoteRunEnd(content, i + 3, tripleAt[0] ?? '"', 3, opts?.tripleQuoteRunClose ?? "last");
+      i = end === -1 ? content.length : end - 1;
+      continue;
+    }
+    if (ch === '"' || ch === "'" || backtick && ch === "`") {
+      quote = ch;
+      verbatim = escapes === "csharp" && ch === '"' && opensCsharpVerbatimString(content, i);
+      continue;
+    }
+    if (ch === "{") depth++;
+    else if (ch === "}") {
+      depth--;
+      if (depth === 0) {
+        return offsetToLine(lineIndex, i);
+      }
+    }
+  }
+  return opts?.noMatchValue ?? totalLines;
+}
+function assignBraceBlockSpans(symbols, content, opts = {}) {
+  const lineCommentPrefix = opts.lineComment;
+  const stringEscapes = opts.stringEscapes ?? "backslash";
+  const nestedBlockComments = opts.nestedBlockComments ?? false;
+  const tripleQuote = opts.tripleQuote ?? false;
+  const lineStringPrefix = opts.lineStringPrefix;
+  const firstLinePrefix = toLineCommentPrefixes(lineCommentPrefix)[0];
+  if (symbols.length === 0) return [...symbols];
+  const lines = content.split("\n");
+  const totalLines = lines.length;
+  const lineIndex = buildLineIndex(content);
+  const starts = [...new Set(symbols.map((s) => s.lineStart))].sort((a, b) => a - b);
+  const scanContent = opts.multilineLang === void 0 ? content : maskMultilineStrings(content, opts.multilineLang);
+  const blockComment = opts.blockComment !== void 0 ? opts.blockComment ?? void 0 : firstLinePrefix === "//" ? ["/*", "*/"] : firstLinePrefix === "#" ? ["<#", "#>"] : void 0;
+  const scanOpts = {
+    noMatchValue: -1,
+    stringEscapes,
+    tripleQuote,
+    rawStringQuotes: opts.rawStringQuotes ?? false,
+    tripleSingleQuote: opts.tripleSingleQuote ?? false,
+    tripleQuoteRunClose: opts.tripleQuoteRunClose ?? "last",
+    ...blockComment === void 0 ? {} : { blockComment, nestedBlockComments },
+    ...lineStringPrefix === void 0 ? {} : { lineStringPrefix },
+    ...opts.lineCommentExceptions === void 0 ? {} : { lineCommentExceptions: opts.lineCommentExceptions }
+  };
+  return symbols.map((sym) => {
+    if (sym.lineEnd !== sym.lineStart) return sym;
+    const nextStart = starts.find((s) => s > sym.lineStart);
+    const lastSearchLine = Math.min(nextStart !== void 0 ? nextStart - 1 : totalLines, sym.lineStart + BRACE_SEARCH_MAX_LINES);
+    const openIndex = findBlockOpenBrace(scanContent, lineIndex, sym.lineStart, lastSearchLine, lineCommentPrefix, scanOpts);
+    if (openIndex === null) return sym;
+    const endLine = findMatchingBraceEndLine(
+      scanContent,
+      openIndex,
+      totalLines,
+      lineIndex,
+      lineCommentPrefix,
+      scanOpts
+    );
+    if (endLine <= sym.lineStart) return sym;
+    return { ...sym, lineEnd: endLine, body: lines.slice(sym.lineStart - 1, endLine).join("\n") };
+  });
+}
+var BRACE_SEARCH_MAX_LINES = 10;
+function maskMultilineStrings(content, lang) {
+  let state = null;
+  const parts = [];
+  let pos = 0;
+  for (; ; ) {
+    const nl = content.indexOf("\n", pos);
+    const end = nl === -1 ? content.length : nl;
+    const lineEnd = end > pos && content[end - 1] === "\r" ? end - 1 : end;
+    const masked = stripMultilineStringSpan(content.slice(pos, lineEnd), state, lang);
+    state = masked.state;
+    parts.push(masked.code, content.slice(lineEnd, end));
+    if (nl === -1) break;
+    parts.push("\n");
+    pos = nl + 1;
+  }
+  return parts.join("");
+}
+function findBlockOpenBrace(content, lineIndex, startLine, lastSearchLine, lineCommentPrefix, opts) {
+  const blockComment = opts?.blockComment;
+  const stringEscapes = opts?.stringEscapes ?? "backslash";
+  const nestedBlockComments = opts?.nestedBlockComments === true;
+  const rawString = opts?.rawStringQuotes === true;
+  const tripleDelims = tripleQuoteDelimiters(opts);
+  const lineString = opts?.lineStringPrefix;
+  const linePrefixes = toLineCommentPrefixes(lineCommentPrefix);
+  const lineExceptions = opts?.lineCommentExceptions ?? [];
+  const from = lineIndex[startLine - 1];
+  if (from === void 0) return null;
+  const to = lineIndex[lastSearchLine] ?? content.length;
+  let quote = null;
+  let parenDepth = 0;
+  let linesSeen = 0;
+  let atLineStart = false;
+  let verbatim = false;
+  for (let i = from; i < to; i++) {
+    const ch = content[i];
+    if (ch === void 0) break;
+    if (quote !== null) {
+      if (verbatim) {
+        if (ch === quote) {
+          if (content[i + 1] === quote) {
+            i++;
+            continue;
+          }
+          quote = null;
+          verbatim = false;
+        }
+        continue;
+      }
+      if (stringEscapes === "powershell") {
+        const step = stepPowershellString(content, i, quote);
+        i = step.next;
+        if (!step.open) quote = null;
+        continue;
+      }
+      if (ch === "\\") {
+        i++;
+        continue;
+      }
+      if (ch === quote) quote = null;
+      continue;
+    }
+    if (ch === "\n") {
+      linesSeen++;
+      atLineStart = true;
+      continue;
+    }
+    if (blockComment !== void 0 && content.startsWith(blockComment[0], i)) {
+      const end = skipBlockComment(content, i, blockComment, nestedBlockComments);
+      if (end === -1) return null;
+      i = end - 1;
+      continue;
+    }
+    if (atLineComment(content, i, linePrefixes, lineExceptions)) {
+      while (i + 1 < to && content[i + 1] !== "\n") i++;
+      continue;
+    }
+    if (atLineStart && !/\s/.test(ch)) {
+      atLineStart = false;
+      if (parenDepth === 0 && linesSeen >= 1 && startsWithBlockKeyword(content, i, to)) return null;
+    }
+    if (lineString !== void 0 && content.startsWith(lineString, i)) {
+      while (i + 1 < to && content[i + 1] !== "\n") i++;
+      continue;
+    }
+    if (rawString && ch === '"') {
+      const run = quoteRunLength(content, i);
+      if (run >= 3) {
+        const end = skipRawStringQuotes(content, i + run, run);
+        if (end === -1) return null;
+        i = end - 1;
+        continue;
+      }
+    }
+    const tripleAt = tripleDelims.find((t) => content.startsWith(t, i));
+    if (tripleAt !== void 0) {
+      const end = closingQuoteRunEnd(content, i + 3, tripleAt[0] ?? '"', 3, opts?.tripleQuoteRunClose ?? "last");
+      if (end === -1) return null;
+      i = end - 1;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      verbatim = stringEscapes === "csharp" && ch === '"' && opensCsharpVerbatimString(content, i);
+      continue;
+    }
+    if (ch === "(" || ch === "[") parenDepth++;
+    else if (ch === ")" || ch === "]") {
+      if (parenDepth > 0) parenDepth--;
+    } else if (ch === ";") return null;
+    else if (ch === "}" && parenDepth === 0) return null;
+    else if (ch === "{") return i;
+  }
+  return null;
+}
+var BLOCK_OPENING_KEYWORDS = /* @__PURE__ */ new Set([
+  "if",
+  "for",
+  "while",
+  "do",
+  "switch",
+  "when",
+  "match",
+  "try",
+  "foreach",
+  "loop",
+  "guard",
+  "repeat",
+  "unless",
+  "until"
+]);
+function startsWithBlockKeyword(content, i, to) {
+  const first = content[i];
+  if (first === void 0 || !/[A-Za-z_]/.test(first)) return false;
+  let j = i + 1;
+  while (j < to && /[A-Za-z0-9_]/.test(content[j])) j++;
+  return BLOCK_OPENING_KEYWORDS.has(content.slice(i, j));
+}
+function lastContentLine(rawLines) {
+  let n = rawLines.length;
+  while (n > 0 && rawLines[n - 1].trim() === "") n--;
+  return Math.max(1, n);
+}
+
+// src/languages/ini_idx.ts
+init_define_import_meta_env();
+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;
+    }
+    const trimmed = line.replace(/^[ \t]+/, "");
+    if (!trimmed || trimmed[0] === "#" || trimmed[0] === ";") continue;
+    const m = ENV_KEY_RE.exec(trimmed);
+    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(trimmed.slice(m[0].length));
+  }
+  return symbols;
+}
+
+// src/languages/sniff.ts
+init_define_import_meta_env();
+var SNIFF_CHARS = 8192;
+var ABL_MARKER_RES = [
+  /^&ANALYZE-SUSPEND\b/i,
+  /^&(?:SCOPED|GLOBAL)-DEFINE\s/i,
+  /^(?:ROUTINE|BLOCK)-LEVEL\s+ON\s+ERROR\s+UNDO\b/i,
+  /^DEF(?:INE)?\s+(?:NEW\s+)?(?:GLOBAL\s+)?(?:SHARED\s+)?(?:VAR|VARIABLE|TEMP-TABLE|BUFFER|QUERY|STREAM|DATASET|FRAME|(?:INPUT|OUTPUT|INPUT-OUTPUT)\s+PARAM(?:ETER)?)\s/i,
+  /^FUNCTION\s+[\w-]+\s+RETURNS\s/i,
+  /^FOR\s+EACH\s/i,
+  /^END\s+(?:PROCEDURE|FUNCTION|CLASS|INTERFACE|METHOD|CONSTRUCTOR)\s*\.$/i,
+  /^USING\s+[\w.*-]+(?:\s+FROM\s+(?:ASSEMBLY|PROPATH))?\s*\.$/i
+];
+var ABL_HEADER_RE = /^(?:PROCEDURE\s+[\w-]+|(?:CLASS|INTERFACE)\s+[\w.-]+)(?:\s|:)/i;
+var ABL_SNIFF_CHARS = SNIFF_CHARS;
+function isAblSource(content) {
+  const head = content.slice(0, ABL_SNIFF_CHARS);
+  if (head.includes("\0")) return false;
+  for (const raw of head.split(/\r?\n/)) {
+    const line = raw.trim();
+    if (line === "") continue;
+    if (ABL_MARKER_RES.some((re) => re.test(line))) return true;
+    if (ABL_HEADER_RE.test(line) && line.endsWith(":")) return true;
+  }
+  return false;
+}
+var SNIFF_FUNCTION_RE = /^function\b\s*(?:(?:\[[\w\s,~]*\]|[A-Za-z]\w*)\s*=\s*)?[A-Za-z]\w*(?:\.[A-Za-z]\w*)?\s*(?:\(|[%#;,]|$)/;
+var SNIFF_CLASSDEF_RE = /^classdef\b\s*(?:\([^)]*\)\s*)?[A-Za-z]\w*\s*(?:<|[%#]|$)/;
+function isMatlabSource(content) {
+  for (const raw of content.slice(0, SNIFF_CHARS).split("\n")) {
+    const line = raw.trim();
+    if (SNIFF_FUNCTION_RE.test(line) || SNIFF_CLASSDEF_RE.test(line)) return true;
+  }
+  return false;
+}
+function isObjcSource(content) {
+  return /^[ \t]*(?:#[ \t]*import[ \t]*[<"]|@(?:interface|implementation|protocol)\b)/m.test(content.slice(0, SNIFF_CHARS));
+}
+function isObjcHeader(content) {
+  return /^[ \t]*@(?:interface|protocol)\b/m.test(content.slice(0, SNIFF_CHARS));
+}
+function isPascalSource(content) {
+  const head = content.slice(0, SNIFF_CHARS);
+  let i = 0;
+  for (; ; ) {
+    while (i < head.length && /\s/.test(head[i])) i++;
+    if (head[i] === "{") {
+      const end = head.indexOf("}", i);
+      if (end < 0) return false;
+      i = end + 1;
+    } else if (head.startsWith("(*", i)) {
+      const end = head.indexOf("*)", i);
+      if (end < 0) return false;
+      i = end + 2;
+    } else if (head.startsWith("//", i)) {
+      const end = head.indexOf("\n", i);
+      if (end < 0) return false;
+      i = end + 1;
+    } else {
+      break;
+    }
+  }
+  return /^(?:unit|program|library)[ \t\r\n]+[A-Za-z_][\w.]*[ \t\r\n]*[;(]/i.test(head.slice(i, i + 300));
+}
+var PERL_MARKER_RE = /^(?:#!.*\bperl\b|[ \t]*use[ \t]+(?:strict|warnings|Test::More|Test2::V0|Test::Simple)\b|[ \t]*package[ \t]+[\w:]+[ \t]*;|[ \t]*my[ \t]+[$@%]|[ \t]*sub[ \t]+\w+[ \t]*\{)/m;
+function isPerlSource(content) {
+  const head = content.slice(0, SNIFF_CHARS);
+  return PERL_MARKER_RE.test(head) && !/^[ \t]*use[ \t]+v6\b/m.test(head);
+}
+function isPrologSource(content) {
+  const head = content.slice(0, SNIFF_CHARS);
+  if (PERL_MARKER_RE.test(head)) return false;
+  return /^:-/m.test(head) || /^[a-z]\w*(?:\([^()\n]*\))?[ \t]*:-/m.test(head);
+}
+var LATEX_CLASS_MARKER_RE = /\\(?:ProvidesClass|documentclass)\b/;
+function isLatexClassFile(content) {
+  return LATEX_CLASS_MARKER_RE.test(content.slice(0, SNIFF_CHARS));
+}
+
+export {
+  precedingDocComment,
+  buildLineIndex,
+  offsetToLine,
+  stripCstyleComments,
+  stripXmlComments,
+  scanQuotedStringEnd,
+  stripJsComments,
+  stripHashComments,
+  maskHtmlNoise,
+  findHtmlHeadingMatches,
+  isInsideStringLiteral,
+  stripBlockCommentSpan,
+  stripNestedBlockCommentSpan,
+  stripLineComment,
+  stripStringLiterals,
+  matchRRawOpener,
+  matchGroovySlashy,
+  matchBashHeredocOpener,
+  stripMultilineStringSpan,
+  makeSpanSymbol,
+  makeLineSymbol,
+  makeSymbolEmitter,
+  assignFlatEndLines,
+  propagateEndLinesToSymbols,
+  findMatchingBraceEndLine,
+  assignBraceBlockSpans,
+  lastContentLine,
+  extractIni,
+  _lineClosesQuote,
+  _detectOpenQuote,
+  extractEnv,
+  isAblSource,
+  isMatlabSource,
+  isObjcSource,
+  isObjcHeader,
+  isPascalSource,
+  isPerlSource,
+  isPrologSource,
+  isLatexClassFile
+};