token-goat 2.9.30 → 2.9.31

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

@@ -0,0 +1,1178 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  escapeRegExp
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// 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
+init_define_import_meta_env();
+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 lineTextAt(content, lineIndex, line) {
+  const start = lineIndex[line - 1];
+  if (start === void 0) return "";
+  const next = lineIndex[line];
+  return content.slice(start, next === void 0 ? content.length : next - 1).trim();
+}
+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, opts = {}) {
+  const lineCommentIdx = lineCommentStartIndex(line, ["//"], from);
+  let open = line.indexOf("/*", from);
+  while (open !== -1 && (isInsideStringLiteral(line, open, from, opts) || lineCommentIdx !== -1 && open >= lineCommentIdx)) {
+    open = line.indexOf("/*", open + 1);
+  }
+  return open;
+}
+function stripBlockCommentSpan(line, inComment, opts = {}) {
+  let code = "";
+  let j = 0;
+  let comment = inComment;
+  while (j < line.length) {
+    if (!comment) {
+      const open = nextBlockCommentOpen(line, j, opts);
+      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, opts = {}) {
+  let code = "";
+  let j = 0;
+  let d = depth;
+  while (j < line.length) {
+    if (d === 0) {
+      const open = nextBlockCommentOpen(line, j, opts);
+      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 stringFrame = (idx, delim) => {
+    const quote = line[idx];
+    const prev = line[idx - 1] ?? "";
+    const bareBraceHole = quote === '"' && (idx > 0 && prev === "$" || idx > 1 && prev === "@" && line[idx - 2] === "$" || idx > 1 && prev === "$" && line[idx - 2] === "@");
+    const plain = opts.interpolatorPrefix === true && !/[A-Za-z0-9_]/.test(prev) || opts.singleQuoteHoles === true && prev === "r" && !/[A-Za-z0-9_$]/.test(line[idx - 2] ?? "");
+    return { kind: "string", quote: delim, bareBraceHole, plain };
+  };
+  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 delim = openDelim(i);
+        stack.push(stringFrame(i, delim));
+        out += delim;
+        i += delim.length;
+        continue;
+      }
+      out += ch;
+      i++;
+      continue;
+    }
+    if (top.kind === "hole") {
+      if (top.paren === true && (ch === "(" || ch === ")")) {
+        if (ch === "(") {
+          top.depth++;
+          out += ch;
+        } else {
+          if (top.depth > 0) {
+            top.depth--;
+            out += ch;
+          } else {
+            stack.pop();
+            out += " ";
+          }
+        }
+        i++;
+        continue;
+      }
+      if (top.paren === true && (ch === "{" || ch === "}")) {
+        out += ch;
+        i++;
+        continue;
+      }
+      if (opts.symbolLiterals === true && ch === "'" && scalaCharLiteralLength(line, i) === 0) {
+        out += ch;
+        i++;
+        continue;
+      }
+      if (ch === '"' || ch === "'") {
+        const delim = openDelim(i);
+        stack.push(stringFrame(i, delim));
+        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 (opts.swiftInterpolation === true && top.quote === '"' && ch === "\\" && line[i + 1] === "(") {
+      stack.push({ kind: "hole", depth: 0, paren: true });
+      out += "  ";
+      i += 2;
+      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.plain && (top.quote === '"' || opts.singleQuoteHoles === true && top.quote[0] === "'")) {
+      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 lastContentLine(rawLines) {
+  let n = rawLines.length;
+  while (n > 0 && rawLines[n - 1].trim() === "") n--;
+  return Math.max(1, n);
+}
+function nestedAngleClause(depth) {
+  let inner = "[^<>]*";
+  for (let i = 0; i < depth; i++) inner = "[^<>]*(?:<" + inner + ">[^<>]*)*";
+  return "<" + inner + ">";
+}
+var GENERIC_CLAUSE = nestedAngleClause(4);
+
+export {
+  precedingDocComment,
+  buildLineIndex,
+  offsetToLine,
+  lineTextAt,
+  stripCstyleComments,
+  stripXmlComments,
+  scanQuotedStringEnd,
+  stripJsComments,
+  stripHashComments,
+  maskHtmlNoise,
+  findHtmlHeadingMatches,
+  isInsideStringLiteral,
+  stripBlockCommentSpan,
+  stripNestedBlockCommentSpan,
+  stripLineComment,
+  scalaCharLiteralLength,
+  stripStringLiterals,
+  closingQuoteRunEnd,
+  matchRRawOpener,
+  matchGroovySlashy,
+  matchBashHeredocOpener,
+  stripMultilineStringSpan,
+  makeSpanSymbol,
+  makeLineSymbol,
+  makeSymbolEmitter,
+  assignFlatEndLines,
+  propagateEndLinesToSymbols,
+  lastContentLine,
+  GENERIC_CLAUSE
+};