token-goat 2.9.10 → 2.9.11

package/dist/token-goat-chunk-2ZUPQYLO.mjs

@@ -0,0 +1,3728 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  lastContentLine,
+  makeLineSymbol,
+  matchGroovySlashy,
+  precedingDocComment,
+  stripLineComment,
+  stripMultilineStringSpan,
+  stripNestedBlockCommentSpan,
+  stripStringLiterals
+} from "./token-goat-chunk-YCKCFYTM.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/languages/swift.ts
+init_define_import_meta_env();
+var IDENT_START = "A-Za-z_\\u00C0-\\uFFFF";
+var IDENT_CONT = "A-Za-z0-9_\\u00C0-\\uFFFF";
+var IDENT = `(?:\`[^\`]+\`|[${IDENT_START}][${IDENT_CONT}]*)`;
+function unquoteIdent(name) {
+  return name.startsWith("`") && name.endsWith("`") ? name.slice(1, -1) : name;
+}
+var GENERIC = "(?:<(?:[^<>]|<[^<>]*>)*>)?";
+var LEADING_ATTRIBUTE_RE = /^\s*(?:@[A-Za-z_][A-Za-z0-9_.]*(?:\((?:[^()]|\([^()]*\))*\))?\s+)+/;
+function stripLeadingAttributes(s) {
+  return s.replace(LEADING_ATTRIBUTE_RE, "");
+}
+var IMPORT_RE = new RegExp(
+  `^(?:(?:public|package|internal|fileprivate|private)\\s+)?import\\s+(?:(?:class|struct|enum|protocol|func|var|let|typealias)\\s+)?(${IDENT}(?:\\.${IDENT})*)`
+);
+var MODIFIER_ALT = "(?:(?:public|private|fileprivate|internal|open|package)(?:\\(set\\))?|(?:nonisolated|unowned)(?:\\([A-Za-z]+\\))?|static|final|class|override|required|convenience|mutating|nonmutating|dynamic|async|lazy|weak|indirect|distributed|prefix|postfix|infix|optional|consuming|borrowing|isolated)";
+var FUNC_RE = new RegExp(
+  "^\\s*(?:" + MODIFIER_ALT + `\\s+)*func\\s+(${IDENT}|[+\\-*/%=!<>&|^~]+)\\s*` + GENERIC + "\\s*(?:\\(|$)"
+);
+var INIT_RE = new RegExp(
+  "^\\s*(?:" + MODIFIER_ALT + "\\s+)*(init)[?!]?\\s*" + GENERIC + "\\s*(?:\\(|$)"
+);
+var DEINIT_RE = /^\s*deinit\s*\{/;
+var SUBSCRIPT_RE = new RegExp(
+  "^\\s*(?:" + MODIFIER_ALT + "\\s+)*(subscript)\\s*" + GENERIC + "\\s*(?:\\(|$)"
+);
+var PROPERTY_RE = new RegExp(
+  "^\\s*(?:" + MODIFIER_ALT + `\\s+)*(?:var|let)\\s+(${IDENT}[^\\n]*)`
+);
+function splitDeclaratorNames(tail) {
+  const names = [];
+  let depth = 0;
+  let start = 0;
+  const parts = [];
+  for (let i = 0; i < tail.length; i++) {
+    const c = tail[i];
+    if (c === "(" || c === "[" || c === "{" || c === "<") depth++;
+    else if (c === ")" || c === "]" || c === "}") depth = Math.max(0, depth - 1);
+    else if (c === ">" && tail[i - 1] !== "-") depth = Math.max(0, depth - 1);
+    else if (c === "," && depth === 0) {
+      parts.push(tail.slice(start, i));
+      start = i + 1;
+    }
+  }
+  parts.push(tail.slice(start));
+  const leadRe = new RegExp(`^\\s*(${IDENT})`);
+  for (const part of parts) {
+    const m = leadRe.exec(part);
+    if (m) names.push(unquoteIdent(m[1] ?? ""));
+  }
+  return names;
+}
+var TYPE_HEADER_RE = new RegExp(
+  `^(?:(?:public|private|fileprivate|internal|open|package|final|indirect|distributed|nonisolated)\\s+)*(class|struct|enum|protocol|extension|actor)\\s+(?!(?:func|var|let|subscript)\\b)(${IDENT}(?:\\.${IDENT})*)`
+);
+function stripRegexLiterals(line) {
+  return line.replace(/([=(,[:]|^|\breturn\b)(\s*)\/(?![\s/*])(?:\\.|[^\\/\n])*\//g, "$1$2");
+}
+var ALIAS_RE = new RegExp(
+  "^(?:" + MODIFIER_ALT + "\\s+)*(typealias|associatedtype|macro)\\s+(" + IDENT + ")"
+);
+function typeKindFor(keyword2) {
+  return keyword2 === "struct" ? "struct" : keyword2 === "enum" ? "enum" : keyword2 === "protocol" ? "protocol" : keyword2 === "extension" ? "extension" : keyword2 === "actor" ? "actor" : "class";
+}
+function extractSwift(content, filePath) {
+  const symbols = [];
+  const imports = [];
+  const lines = content.split(/\r?\n/);
+  const typeStack = [];
+  let braceDepth = 0;
+  let commentDepth = 0;
+  let mlState = null;
+  function pushMembers(text, parent, lineNum, sig) {
+    const noAttr = stripLeadingAttributes(text);
+    const kind = parent === void 0 ? "function" : "method";
+    const initM = INIT_RE.exec(noAttr);
+    if (initM) {
+      symbols.push(makeLineSymbol(filePath, initM[1] ?? "init", "method", lineNum, sig, parent, lines, "c"));
+      return true;
+    }
+    if (DEINIT_RE.exec(noAttr)) {
+      symbols.push(makeLineSymbol(filePath, "deinit", "method", lineNum, sig, parent, lines, "c"));
+      return true;
+    }
+    const subscriptM = SUBSCRIPT_RE.exec(noAttr);
+    if (subscriptM) {
+      symbols.push(makeLineSymbol(filePath, subscriptM[1] ?? "subscript", "method", lineNum, sig, parent, lines, "c"));
+      return true;
+    }
+    const fm = FUNC_RE.exec(noAttr);
+    if (fm) {
+      symbols.push(makeLineSymbol(filePath, unquoteIdent(fm[1] ?? ""), kind, lineNum, sig, parent, lines, "c"));
+      return true;
+    }
+    const propM = PROPERTY_RE.exec(noAttr);
+    if (propM) {
+      const names = splitDeclaratorNames(propM[1] ?? "");
+      for (const name of names) {
+        symbols.push(makeLineSymbol(filePath, name, "var", lineNum, sig, parent, lines, "c"));
+      }
+      return names.length > 0;
+    }
+    return false;
+  }
+  for (let i = 0; i < lines.length; i++) {
+    const rawLine = lines[i] ?? "";
+    const lineNum = i + 1;
+    let mlLine = rawLine;
+    if (mlState !== null || commentDepth === 0) {
+      const masked = stripMultilineStringSpan(rawLine, mlState, "swift");
+      mlLine = masked.code;
+      mlState = masked.state;
+    }
+    const { code: blockStripped, depth: nextCommentDepth } = stripNestedBlockCommentSpan(mlLine, commentDepth);
+    commentDepth = nextCommentDepth;
+    const line = stripLineComment(blockStripped).trimEnd();
+    const stripped = line.trim();
+    if (!stripped) {
+      const braceLine2 = stripRegexLiterals(stripStringLiterals(line));
+      braceDepth += (braceLine2.match(/\{/g) ?? []).length - (braceLine2.match(/\}/g) ?? []).length;
+      continue;
+    }
+    const strippedNoAttr = stripLeadingAttributes(stripped);
+    const importM = IMPORT_RE.exec(strippedNoAttr);
+    if (importM) {
+      imports.push({ kind: "import", target: unquoteIdent(importM[1] ?? ""), line: lineNum });
+    }
+    const outerFrame = typeStack.length > 0 ? typeStack[typeStack.length - 1] : null;
+    const outerDepthInType = outerFrame !== null ? braceDepth - outerFrame.startDepth : 0;
+    const typeDetectionGateOk = typeStack.length === 0 || outerDepthInType === 1;
+    const tm = typeDetectionGateOk && (braceDepth === 0 || typeStack.length > 0) ? TYPE_HEADER_RE.exec(strippedNoAttr) : null;
+    if (tm) {
+      const tname = unquoteIdent(tm[2] ?? "");
+      const parent = typeStack.length > 0 ? typeStack[typeStack.length - 1].name : void 0;
+      symbols.push(makeLineSymbol(filePath, tname, typeKindFor(tm[1] ?? "class"), lineNum, stripped.slice(0, 200), parent, lines, "c"));
+      typeStack.push({ name: tname, startDepth: braceDepth, bodyEntered: false });
+      const open = strippedNoAttr.indexOf("{");
+      if (open !== -1) {
+        const tail = strippedNoAttr.slice(open + 1).replace(/\}\s*$/, "").trim();
+        if (tail) pushMembers(tail, tname, lineNum, tail.slice(0, 200));
+      }
+    }
+    const am = tm === null && typeDetectionGateOk && (braceDepth === 0 || typeStack.length > 0) ? ALIAS_RE.exec(strippedNoAttr) : null;
+    if (am) {
+      const parent = typeStack.length > 0 ? typeStack[typeStack.length - 1].name : void 0;
+      symbols.push(makeLineSymbol(filePath, unquoteIdent(am[2] ?? ""), am[1] === "macro" ? "macro" : "type", lineNum, stripped.slice(0, 200), parent, lines, "c"));
+    }
+    const frame = typeStack.length > 0 ? typeStack[typeStack.length - 1] : null;
+    if (frame !== null && tm === null) {
+      const depthInType = braceDepth - frame.startDepth;
+      if (depthInType === 1) {
+        pushMembers(line, frame.name, lineNum, stripped.slice(0, 200));
+      }
+    } else if (frame === null && braceDepth === 0) {
+      pushMembers(line, void 0, lineNum, stripped.slice(0, 200));
+    }
+    const braceLine = stripRegexLiterals(stripStringLiterals(line));
+    for (const ch of braceLine) {
+      if (ch === "{") {
+        braceDepth++;
+        const top = typeStack.length > 0 ? typeStack[typeStack.length - 1] : null;
+        if (top !== null && braceDepth > top.startDepth) {
+          top.bodyEntered = true;
+        }
+      } else if (ch === "}") {
+        braceDepth--;
+      }
+    }
+    while (typeStack.length > 0) {
+      const top = typeStack[typeStack.length - 1];
+      if (top.bodyEntered && braceDepth <= top.startDepth) {
+        typeStack.pop();
+      } else {
+        break;
+      }
+    }
+  }
+  return { symbols, imports };
+}
+
+// src/languages/cobol.ts
+init_define_import_meta_env();
+var MAX_SYMBOLS = 1e4;
+var NAME = String.raw`[A-Za-z0-9][A-Za-z0-9_-]*`;
+var SOURCE_DIRECTIVE_RE = /^\s*>>\s*SOURCE\s+(?:FORMAT\s+)?(?:IS\s+)?(FREE|FIXED)\b/i;
+var DIVISION_RE = /^(IDENTIFICATION|ID|ENVIRONMENT|DATA|PROCEDURE)\s+DIVISION\b/i;
+var ID_PARAGRAPH_RE = /^(PROGRAM|FUNCTION)-ID\b/i;
+var END_UNIT_RE = new RegExp(String.raw`^END\s+(PROGRAM|FUNCTION)\s+(?:"([^"]+)"|'([^']+)'|(${NAME}))`, "i");
+var SECTION_RE = new RegExp(String.raw`^(${NAME})\s+SECTION(?:\s+\d+)?\s*\.`, "i");
+var PARAGRAPH_RE = new RegExp(String.raw`^(${NAME})\s*\.(?:\s|$)`);
+var LEVEL_RE = new RegExp(String.raw`^(\d{1,2})\s+(${NAME})(?=[\s.]|$)`);
+var FILE_DESCRIPTION_RE = new RegExp(String.raw`^(FD|SD)\s+(${NAME})`, "i");
+var NOT_A_PARAGRAPH = /^(?:EXIT|GOBACK|CONTINUE|ELSE|EJECT|SKIP[123]|DECLARATIVES|END-[A-Z-]+)$/i;
+var PERFORM_NOT_A_TARGET = /^(?:UNTIL|VARYING|WITH|TEST|FOREVER|TIMES)$/i;
+function startsFree(rawLines) {
+  for (const raw of rawLines) {
+    const directive = SOURCE_DIRECTIVE_RE.exec(raw);
+    if (directive) return directive[1].toUpperCase() === "FREE";
+    if (DIVISION_RE.test(raw) || raw.startsWith("*>")) return true;
+  }
+  return false;
+}
+function stripFloatingComment(text) {
+  let quote = "";
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (quote !== "") {
+      if (ch === quote) quote = "";
+    } else if (ch === '"' || ch === "'") quote = ch;
+    else if (ch === "*" && text[i + 1] === ">") return text.slice(0, i);
+  }
+  return text;
+}
+function blankStrings(text) {
+  let out = "";
+  let quote = "";
+  for (const ch of text) {
+    if (quote !== "") {
+      if (ch === quote) {
+        quote = "";
+        out += ch;
+      } else out += " ";
+    } else {
+      if (ch === '"' || ch === "'") quote = ch;
+      out += ch;
+    }
+  }
+  return out;
+}
+function joinContinuation(out, areaB) {
+  const prev = out[out.length - 1];
+  const rest = areaB.trimStart();
+  if (prev === void 0 || rest === "") return;
+  const opensLiteral = (prev.code.match(/["']/g) ?? []).length % 2 === 1;
+  const piece = (opensLiteral && (rest[0] === '"' || rest[0] === "'") ? rest.slice(1) : rest).trimEnd();
+  const text = stripFloatingComment(prev.text + piece).trimEnd();
+  out[out.length - 1] = { ...prev, text, code: blankStrings(text) };
+}
+function toLines(rawLines) {
+  const out = [];
+  let free = startsFree(rawLines);
+  for (let i = 0; i < rawLines.length; i++) {
+    const raw = rawLines[i];
+    const directive = SOURCE_DIRECTIVE_RE.exec(free ? raw : raw.slice(7));
+    if (directive) {
+      free = directive[1].toUpperCase() === "FREE";
+      continue;
+    }
+    let text;
+    let offset;
+    let areaA;
+    if (free) {
+      if (/^\s*>>/.test(raw)) continue;
+      text = raw;
+      offset = 0;
+      areaA = true;
+    } else {
+      if (raw.length <= 7) continue;
+      const indicator = raw[6];
+      if (indicator === "*" || indicator === "/" || indicator === "D" || indicator === "d") continue;
+      if (indicator === "-") {
+        joinContinuation(out, raw.slice(7, 72));
+        continue;
+      }
+      text = raw.slice(7, 72);
+      offset = 7;
+      areaA = text.slice(0, 4).trim() !== "";
+    }
+    text = stripFloatingComment(text).trimEnd();
+    if (text.trim() === "") continue;
+    const lead = text.length - text.trimStart().length;
+    out.push({ line: i + 1, text: text.trimStart(), code: blankStrings(text.trimStart()), offset: offset + lead, areaA, raw });
+  }
+  return out;
+}
+function unitName(rest, next) {
+  const source = rest.trim() !== "" ? rest : next?.text ?? "";
+  const m = new RegExp(String.raw`^(?:"([^"]+)"|'([^']+)'|(${NAME}))`).exec(source.trim());
+  return m ? m[1] ?? m[2] ?? m[3] : void 0;
+}
+function copyTarget(text, index) {
+  const m = new RegExp(String.raw`^COPY\s+(?:"([^"]+)"|'([^']+)'|(${NAME}))`, "i").exec(text.slice(index));
+  return m ? m[1] ?? m[2] ?? m[3] : void 0;
+}
+function extractCobol(content, filePath) {
+  const symbols = [];
+  const refs = [];
+  const imports = [];
+  if (content.includes("\0")) return { symbols, refs, imports };
+  const rawLines = (content.charCodeAt(0) === 65279 ? content.slice(1) : content).split(/\r?\n/);
+  const lines = toLines(rawLines);
+  const isCopybook = /\.cpy$/i.test(filePath);
+  const units = [];
+  let section;
+  let paragraph;
+  let fileDescription;
+  let record;
+  let division = "";
+  let lastLine = 0;
+  let idDivisionLine;
+  let recordLevel = 1;
+  if (isCopybook && !lines.some((l) => DIVISION_RE.test(l.code))) {
+    const levels = lines.map((l) => LEVEL_RE.exec(l.code)).filter((m) => m !== null).map((m) => Number(m[1]));
+    const first = lines[0];
+    division = first !== void 0 && LEVEL_RE.test(first.code) ? "DATA" : "PROCEDURE";
+    const structural = levels.filter((n) => n >= 1 && n <= 49);
+    if (structural.length > 0) recordLevel = structural.reduce((a, b) => b < a ? b : a, structural[0]);
+  }
+  const emit = (name, kind, line, parent) => {
+    if (symbols.length >= MAX_SYMBOLS) return void 0;
+    symbols.push({ filePath, name, kind, lineStart: line, lineEnd: line, body: "", docstring: "", parent });
+    return symbols.length - 1;
+  };
+  const close = (index, end) => {
+    if (index === void 0) return;
+    const sym = symbols[index];
+    symbols[index] = { ...sym, lineEnd: Math.max(sym.lineStart, end) };
+  };
+  const unitParent = () => {
+    const top = units[units.length - 1];
+    return top === void 0 ? "" : symbols[top].name;
+  };
+  const closeProcedure = (end) => {
+    close(paragraph, end);
+    paragraph = void 0;
+    close(section, end);
+    section = void 0;
+  };
+  const closeData = (end) => {
+    close(record, end);
+    record = void 0;
+    close(fileDescription, end);
+    fileDescription = void 0;
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const l = lines[i];
+    const code = l.code.trim();
+    for (const m of l.code.matchAll(/\bCOPY\s+/gi)) {
+      const target = copyTarget(l.text, m.index);
+      if (target !== void 0) imports.push({ kind: "import", target, line: l.line });
+    }
+    const include = /\bEXEC\s+SQL\s+INCLUDE\s+([A-Za-z0-9_-]+)/i.exec(l.code);
+    if (include) imports.push({ kind: "import", target: include[1], line: l.line });
+    const id = ID_PARAGRAPH_RE.exec(code);
+    if (id) {
+      const name = unitName(l.text.slice(l.text.search(/-ID/i) + 3).replace(/^\s*\.?/, ""), lines[i + 1]);
+      closeProcedure(lastLine);
+      closeData(lastLine);
+      if (name !== void 0) {
+        const start = idDivisionLine !== void 0 && idDivisionLine === lastLine ? idDivisionLine : l.line;
+        const index = emit(name, id[1].toUpperCase() === "FUNCTION" ? "function" : "program", start, unitParent());
+        if (index !== void 0) units.push(index);
+      }
+      division = "IDENTIFICATION";
+      lastLine = l.line;
+      continue;
+    }
+    const end = END_UNIT_RE.exec(code);
+    if (end) {
+      const name = (end[2] ?? end[3] ?? end[4]).toUpperCase();
+      closeProcedure(lastLine);
+      closeData(lastLine);
+      let at = units.length - 1;
+      while (at >= 0 && symbols[units[at]].name.toUpperCase() !== name) at--;
+      if (at >= 0) {
+        for (const u of units.splice(at)) close(u, l.line);
+      }
+      division = "";
+      lastLine = l.line;
+      continue;
+    }
+    const div = DIVISION_RE.exec(code);
+    if (div) {
+      closeProcedure(lastLine);
+      closeData(lastLine);
+      division = div[1].toUpperCase() === "ID" ? "IDENTIFICATION" : div[1].toUpperCase();
+      if (division === "IDENTIFICATION") idDivisionLine = l.line;
+      lastLine = l.line;
+      continue;
+    }
+    if (division === "DATA") {
+      if (/^[A-Za-z0-9-]+\s+SECTION\s*\./i.test(code)) {
+        closeData(lastLine);
+      } else if (FILE_DESCRIPTION_RE.test(code)) {
+        const m = FILE_DESCRIPTION_RE.exec(code);
+        closeData(lastLine);
+        fileDescription = emit(m[2], "file", l.line, unitParent());
+      } else {
+        const m = LEVEL_RE.exec(code);
+        const level = m ? Number(m[1]) : -1;
+        if (m && (level === recordLevel || level === 77)) {
+          close(record, lastLine);
+          record = void 0;
+          if (level === 77) {
+            close(fileDescription, lastLine);
+            fileDescription = void 0;
+          }
+          if (m[2].toUpperCase() !== "FILLER") {
+            const owner = fileDescription !== void 0 ? symbols[fileDescription].name : unitParent();
+            record = emit(m[2], "variable", l.line, owner);
+          }
+        }
+      }
+    } else if (division === "PROCEDURE") {
+      const sec = l.areaA ? SECTION_RE.exec(code) : null;
+      const para = l.areaA && !sec ? PARAGRAPH_RE.exec(code) : null;
+      if (sec) {
+        closeProcedure(lastLine);
+        section = emit(sec[1], "section", l.line, unitParent());
+      } else if (para && !NOT_A_PARAGRAPH.test(para[1])) {
+        close(paragraph, lastLine);
+        paragraph = emit(para[1], "paragraph", l.line, section !== void 0 ? symbols[section].name : unitParent());
+      }
+      for (const m of l.code.matchAll(new RegExp(String.raw`\bPERFORM\s+(${NAME})(?:\s+(?:THRU|THROUGH)\s+(${NAME}))?(\s+TIMES\b)?`, "gi"))) {
+        if (m[3] !== void 0 || PERFORM_NOT_A_TARGET.test(m[1]) || /^\d+$/.test(m[1])) continue;
+        refs.push({ filePath, name: m[1], line: l.line, col: l.offset + m.index, context: l.raw.trim() });
+        if (m[2] !== void 0) refs.push({ filePath, name: m[2], line: l.line, col: l.offset + m.index, context: l.raw.trim() });
+      }
+      for (const m of l.code.matchAll(new RegExp(String.raw`\bGO\s+(?:TO\s+)?(${NAME})`, "gi"))) {
+        if (/^DEPENDING$/i.test(m[1])) continue;
+        refs.push({ filePath, name: m[1], line: l.line, col: l.offset + m.index, context: l.raw.trim() });
+      }
+      for (const m of l.code.matchAll(/\bCALL\s+(["'])/gi)) {
+        const quote = m.index + m[0].length - 1;
+        const close2 = l.text.indexOf(m[1], quote + 1);
+        const name = close2 > quote ? l.text.slice(quote + 1, close2).trim() : "";
+        if (name !== "") refs.push({ filePath, name, line: l.line, col: l.offset + m.index, context: l.raw.trim() });
+      }
+    }
+    lastLine = l.line;
+  }
+  closeProcedure(lastLine);
+  closeData(lastLine);
+  for (const u of units) close(u, lastLine);
+  for (let k = 0; k < symbols.length; k++) {
+    const sym = symbols[k];
+    symbols[k] = { ...sym, body: rawLines.slice(sym.lineStart - 1, sym.lineEnd).join("\n") };
+  }
+  return { symbols, refs, imports };
+}
+
+// src/languages/natural.ts
+init_define_import_meta_env();
+import * as path from "node:path";
+var MAX_SYMBOLS2 = 1e4;
+var OBJECT_KINDS = /* @__PURE__ */ new Map([
+  [".nsp", "program"],
+  [".nsn", "subprogram"],
+  [".nss", "subroutine"],
+  [".nsh", "helproutine"],
+  [".nsc", "copycode"],
+  [".nsa", "data_area"],
+  [".nsl", "data_area"],
+  [".nsg", "data_area"]
+]);
+var DATA_AREA_EXTS = /* @__PURE__ */ new Set([".nsa", ".nsl", ".nsg"]);
+var NAME2 = String.raw`[A-Za-z#&@$_][A-Za-z0-9#&@$_-]*`;
+var DEFINE_SUBROUTINE_RE = new RegExp(String.raw`^DEFINE\s+(?:SUBROUTINE\s+)?(${NAME2})\s*$|^DEFINE\s+SUBROUTINE\s+(${NAME2})\b`, "i");
+var NOT_A_SUBROUTINE = /^(?:DATA|WINDOW|PRINTER|WORK|CLASS|PROTOTYPE|FUNCTION|SUBROUTINE)$/i;
+var DEFINE_DATA_RE = /^DEFINE\s+DATA\b/i;
+var END_DEFINE_RE = /^END-DEFINE\b/i;
+var END_SUBROUTINE_RE = /^END-SUBROUTINE\b/i;
+var LEVEL_ONE_RE = new RegExp(String.raw`^0?1\s+(${NAME2})(?:\s+VIEW\s+(?:OF\s+)?(${NAME2}))?`, "i");
+var USING_RE = new RegExp(String.raw`\b(?:LOCAL|PARAMETER|GLOBAL|CONTEXT|OBJECT)\s+USING\s+(${NAME2})`, "gi");
+var INCLUDE_RE = new RegExp(String.raw`^INCLUDE\s+(${NAME2})`, "i");
+var LINE_NUMBER_RE = /^\d{4}(?: |$)/;
+function isCommentLine(text) {
+  return /^(?:\*(?:[ *]|$)|\/\*)/.test(text);
+}
+function codeOf(text) {
+  let quote = "";
+  let code = "";
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (quote !== "") {
+      if (ch === quote) {
+        quote = "";
+        code += ch;
+      } else code += " ";
+      continue;
+    }
+    if (ch === "/" && text[i + 1] === "*" && (i === 0 || text[i - 1] === " ")) return { text: text.slice(0, i).trimEnd(), code: code.trimEnd() };
+    if (ch === "'" || ch === '"') quote = ch;
+    code += ch;
+  }
+  return { text, code };
+}
+function toLines2(rawLines) {
+  const nonBlank = rawLines.filter((l) => l.trim() !== "");
+  const numbered = nonBlank.length > 0 && nonBlank.filter((l) => LINE_NUMBER_RE.test(l)).length / nonBlank.length >= 0.8;
+  const out = [];
+  for (let i = 0; i < rawLines.length; i++) {
+    const raw = rawLines[i];
+    let offset = numbered && LINE_NUMBER_RE.test(raw) ? 5 : 0;
+    const body = raw.slice(offset);
+    const lead = body.length - body.trimStart().length;
+    offset += lead;
+    const trimmed = body.trim();
+    if (trimmed === "" || isCommentLine(trimmed)) continue;
+    const { text, code } = codeOf(trimmed);
+    if (text === "") continue;
+    out.push({ line: i + 1, text, code, offset, raw });
+  }
+  return out;
+}
+function literalAt(text, index) {
+  const m = /^(['"])([^'"]+)\1/.exec(text.slice(index));
+  return m ? m[2].trim() : void 0;
+}
+function extractNatural(content, filePath) {
+  const symbols = [];
+  const refs = [];
+  const imports = [];
+  if (content.includes("\0")) return { symbols, refs, imports };
+  const rawLines = (content.charCodeAt(0) === 65279 ? content.slice(1) : content).split(/\r?\n/);
+  const lines = toLines2(rawLines);
+  const ext = path.extname(filePath).toLowerCase();
+  const objectName = path.basename(filePath, path.extname(filePath));
+  const isDataArea = DATA_AREA_EXTS.has(ext);
+  const emit = (name, kind, line, parent) => {
+    if (symbols.length >= MAX_SYMBOLS2) return void 0;
+    symbols.push({ filePath, name, kind, lineStart: line, lineEnd: line, body: "", docstring: "", parent });
+    return symbols.length - 1;
+  };
+  const close = (index, end) => {
+    if (index === void 0) return;
+    const sym = symbols[index];
+    symbols[index] = { ...sym, lineEnd: Math.max(sym.lineStart, end) };
+  };
+  const lastLine = lines.length > 0 ? lines[lines.length - 1].line : 1;
+  const objectKind = OBJECT_KINDS.get(ext);
+  if (objectKind !== void 0 && lines.length > 0) {
+    const index = emit(objectName, objectKind, lines[0].line, "");
+    close(index, lastLine);
+  }
+  let inData = isDataArea;
+  let dataBlock;
+  let field;
+  let subroutine;
+  let previous = 0;
+  for (const l of lines) {
+    const code = l.code.trim();
+    if (DEFINE_DATA_RE.test(code)) {
+      inData = true;
+      dataBlock = emit("DEFINE DATA", "data", l.line, objectName);
+    } else if (inData && END_DEFINE_RE.test(code)) {
+      close(field, previous);
+      field = void 0;
+      close(dataBlock, l.line);
+      dataBlock = void 0;
+      inData = false;
+    } else if (inData) {
+      for (const m2 of l.code.matchAll(USING_RE)) imports.push({ kind: "import", target: m2[1], line: l.line });
+      const m = LEVEL_ONE_RE.exec(code);
+      if (m) {
+        close(field, previous);
+        field = emit(m[1], m[2] !== void 0 ? "view" : "variable", l.line, objectName);
+      } else if (/^(?:LOCAL|PARAMETER|GLOBAL|INDEPENDENT|CONTEXT|OBJECT)\b/i.test(code)) {
+        close(field, previous);
+        field = void 0;
+      }
+    } else {
+      const def = DEFINE_SUBROUTINE_RE.exec(code);
+      const name = def ? def[1] ?? def[2] : void 0;
+      if (name !== void 0 && !NOT_A_SUBROUTINE.test(name)) {
+        close(subroutine, previous);
+        subroutine = emit(name, "subroutine", l.line, objectName);
+      } else if (END_SUBROUTINE_RE.test(code)) {
+        close(subroutine, l.line);
+        subroutine = void 0;
+      } else if (/^END\s*\.?$/i.test(code)) {
+        close(subroutine, previous);
+        subroutine = void 0;
+      }
+      const include = INCLUDE_RE.exec(code);
+      if (include) imports.push({ kind: "import", target: include[1], line: l.line });
+      for (const m of l.code.matchAll(new RegExp(String.raw`\bPERFORM\s+(${NAME2})`, "gi"))) {
+        refs.push({ filePath, name: m[1], line: l.line, col: l.offset + m.index, context: l.raw.trim() });
+      }
+      for (const m of l.code.matchAll(/\b(?:CALLNAT|FETCH(?:\s+(?:RETURN|REPEAT))*)\s+(?=['"])/gi)) {
+        const name2 = literalAt(l.text, m.index + m[0].length);
+        if (name2 !== void 0) refs.push({ filePath, name: name2, line: l.line, col: l.offset + m.index, context: l.raw.trim() });
+      }
+    }
+    previous = l.line;
+  }
+  close(field, previous);
+  close(dataBlock, previous);
+  close(subroutine, previous);
+  for (let k = 0; k < symbols.length; k++) {
+    const sym = symbols[k];
+    symbols[k] = { ...sym, body: rawLines.slice(sym.lineStart - 1, sym.lineEnd).join("\n") };
+  }
+  return { symbols, refs, imports };
+}
+
+// src/languages/abap.ts
+init_define_import_meta_env();
+
+// src/languages/span_collector.ts
+init_define_import_meta_env();
+var MAX_SYMBOLS3 = 1e4;
+var MAX_NAME_LENGTH = 120;
+var SpanCollector = class {
+  constructor(filePath) {
+    this.filePath = filePath;
+  }
+  filePath;
+  items = [];
+  /** Record a symbol that starts and, until {@link close} says otherwise, ends on `line`; undefined when the name is unusable or the cap is reached. */
+  open(name, kind, line, parent = "") {
+    if (name === "" || name.length > MAX_NAME_LENGTH || this.items.length >= MAX_SYMBOLS3) return void 0;
+    this.items.push({ filePath: this.filePath, name, kind, lineStart: line, lineEnd: line, body: "", docstring: "", parent });
+    return this.items.length - 1;
+  }
+  close(index, end) {
+    if (index === void 0) return;
+    const sym = this.items[index];
+    this.items[index] = { ...sym, lineEnd: Math.max(sym.lineStart, end) };
+  }
+  name(index) {
+    return index === void 0 ? "" : this.items[index].name;
+  }
+  /** The collected symbols, each with its body sliced from `rawLines`. */
+  finish(rawLines) {
+    return this.items.map((s) => ({ ...s, body: rawLines.slice(s.lineStart - 1, s.lineEnd).join("\n") }));
+  }
+};
+function topLevelWords(text, isWordChar3) {
+  const out = [];
+  let depth = 0;
+  let word = "";
+  for (const ch of text) {
+    if (ch === "(") depth++;
+    else if (ch === ")") depth = Math.max(0, depth - 1);
+    if (depth === 0 && isWordChar3(ch)) {
+      word += ch;
+      continue;
+    }
+    if (word !== "") out.push(word);
+    word = "";
+  }
+  if (word !== "") out.push(word);
+  return out;
+}
+function wordBeforeParen(text, isWordChar3) {
+  const paren = text.indexOf("(");
+  if (paren < 0) return "";
+  let end = paren;
+  while (end > 0 && /\s/.test(text[end - 1])) end--;
+  let start = end;
+  while (start > 0 && isWordChar3(text[start - 1])) start--;
+  return text.slice(start, end);
+}
+
+// src/languages/abap.ts
+function abapStatements(rawLines) {
+  const out = [];
+  let buf = "";
+  let start = 0;
+  for (let i = 0; i < rawLines.length; i++) {
+    const raw = rawLines[i];
+    if (raw.startsWith("*")) continue;
+    let quote = "";
+    for (let j = 0; j < raw.length; j++) {
+      const ch = raw[j];
+      if (quote !== "") {
+        if (quote === "|" && ch === "\\") {
+          buf += "  ";
+          j++;
+        } else if (ch === quote && quote !== "|" && raw[j + 1] === quote) {
+          buf += "  ";
+          j++;
+        } else if (ch === quote) {
+          quote = "";
+          buf += ch;
+        } else buf += " ";
+        continue;
+      }
+      if (ch === '"') break;
+      if (ch === "'" || ch === "`" || ch === "|") quote = ch;
+      if (ch === ".") {
+        if (buf.trim() !== "") out.push({ text: buf.trim(), line: start, endLine: i + 1 });
+        buf = "";
+        start = 0;
+        continue;
+      }
+      if (start === 0 && !/\s/.test(ch)) start = i + 1;
+      buf += ch === ":" ? " " : ch;
+    }
+    buf += " ";
+  }
+  return out;
+}
+var CLOSERS = /* @__PURE__ */ new Map([
+  ["ENDCLASS", "CLASS"],
+  ["ENDINTERFACE", "INTERFACE"],
+  ["ENDMETHOD", "METHOD"],
+  ["ENDFORM", "FORM"],
+  ["ENDFUNCTION", "FUNCTION"],
+  ["ENDMODULE", "MODULE"],
+  ["END-OF-DEFINITION", "DEFINE"]
+]);
+var BLOCK_KINDS = /* @__PURE__ */ new Map([
+  ["FORM", "form"],
+  ["FUNCTION", "function"],
+  ["MODULE", "module"],
+  ["DEFINE", "macro"]
+]);
+function extractAbap(content, filePath) {
+  const imports = [];
+  const spans = new SpanCollector(filePath);
+  if (content.includes("\0")) return { symbols: [], imports };
+  const rawLines = content.split(/\r?\n/);
+  const statements = abapStatements(rawLines);
+  const lastLine = statements.length > 0 ? statements[statements.length - 1].endLine : 1;
+  const stack = [];
+  let program = false;
+  for (const st of statements) {
+    const words = st.text.split(/\s+/);
+    const w0 = words[0].toUpperCase();
+    const name = words[1] ?? "";
+    const rest = words.slice(2).map((w) => w.toUpperCase());
+    const inMacro = stack.length > 0 && stack[stack.length - 1].opener === "DEFINE";
+    const closes = CLOSERS.get(w0);
+    if (closes !== void 0) {
+      const at = stack.map((o) => o.opener).lastIndexOf(closes);
+      if (at < 0) continue;
+      for (const o of stack.splice(at)) spans.close(o.index, st.endLine);
+      continue;
+    }
+    if (inMacro || name === "") continue;
+    if (!program && (w0 === "REPORT" || w0 === "PROGRAM" || w0 === "FUNCTION-POOL")) {
+      program = true;
+      spans.close(spans.open(name, "program", st.line), lastLine);
+    } else if (w0 === "CLASS" && (rest[0] === "DEFINITION" || rest[0] === "IMPLEMENTATION")) {
+      if (rest.includes("DEFERRED") || rest.includes("LOAD") || rest.includes("LOCAL") && rest.includes("FRIENDS")) continue;
+      const kind = rest[0] === "DEFINITION" ? "class" : "implementation";
+      stack.push({ opener: "CLASS", index: spans.open(name, kind, st.line), owner: name });
+    } else if (w0 === "INTERFACE" && !rest.includes("DEFERRED") && !rest.includes("LOAD")) {
+      stack.push({ opener: "INTERFACE", index: spans.open(name, "interface", st.line), owner: name });
+    } else if (w0 === "METHOD") {
+      const owner = [...stack].reverse().find((o) => o.owner !== "")?.owner ?? "";
+      stack.push({ opener: "METHOD", index: spans.open(name, "method", st.line, owner), owner: "" });
+    } else if (BLOCK_KINDS.has(w0)) {
+      stack.push({ opener: w0, index: spans.open(name, BLOCK_KINDS.get(w0), st.line), owner: "" });
+    } else if (w0 === "INCLUDE") {
+      const target = name.toUpperCase();
+      if (target !== "TYPE" && target !== "STRUCTURE") imports.push({ kind: "include", target: name, line: st.line });
+    }
+  }
+  for (const o of stack) spans.close(o.index, lastLine);
+  return { symbols: spans.finish(rawLines), imports };
+}
+
+// src/languages/abl.ts
+init_define_import_meta_env();
+function isSpace(ch) {
+  return ch === void 0 || ch === " " || ch === "	" || ch === "\r" || ch === "\f";
+}
+function ablStatements(rawLines) {
+  const statements = [];
+  const includes = [];
+  let text = "";
+  let start = 0;
+  let quote = "";
+  let comment = 0;
+  let brace = 0;
+  let braceText = "";
+  let braceLine = 0;
+  for (let i = 0; i < rawLines.length; i++) {
+    const line = rawLines[i];
+    if (comment === 0 && quote === "" && brace === 0 && text.trim() === "" && line.trimStart().startsWith("&")) continue;
+    for (let j = 0; j < line.length; j++) {
+      const ch = line[j];
+      if (comment > 0) {
+        if (ch === "/" && line[j + 1] === "*") {
+          comment++;
+          j++;
+        } else if (ch === "*" && line[j + 1] === "/") {
+          comment--;
+          j++;
+        }
+        continue;
+      }
+      if (brace > 0) {
+        if (ch === "{") brace++;
+        else if (ch === "}") brace--;
+        if (brace === 0) {
+          const target = braceText.trim().split(/\s+/)[0] ?? "";
+          if (target !== "" && !/^[&\d*]/.test(target)) includes.push({ kind: "include", target, line: braceLine });
+          text += " ";
+        } else braceText += ch;
+        continue;
+      }
+      if (quote !== "") {
+        if (ch === "~") {
+          text += "  ";
+          j++;
+        } else if (ch === quote) {
+          quote = "";
+          text += ch;
+        } else text += " ";
+        continue;
+      }
+      if (ch === "/" && line[j + 1] === "*") {
+        comment = 1;
+        j++;
+        continue;
+      }
+      if (ch === "/" && line[j + 1] === "/") break;
+      if (ch === "{") {
+        brace = 1;
+        braceText = "";
+        braceLine = i + 1;
+        continue;
+      }
+      if ((ch === "." || ch === ":") && isSpace(line[j + 1])) {
+        const t = text.trim();
+        if (t !== "") statements.push({ text: t, line: start, endLine: i + 1, terminator: ch });
+        text = "";
+        start = 0;
+        continue;
+      }
+      if (ch === '"' || ch === "'") quote = ch;
+      if (start === 0 && !isSpace(ch)) start = i + 1;
+      text += ch;
+    }
+    text += " ";
+  }
+  return { statements, includes };
+}
+var isWordChar = (ch) => /[\w#$%&-]/.test(ch);
+function keyword(word, full, min) {
+  return word.length >= min && full.startsWith(word);
+}
+var LONE_BLOCK_WORDS = /* @__PURE__ */ new Set(["DO", "REPEAT", "FINALLY", "GET", "SET"]);
+var TYPE_KINDS = /* @__PURE__ */ new Map([
+  ["CLASS", "class"],
+  ["INTERFACE", "interface"],
+  ["ENUM", "enum"]
+]);
+var MEMBER_KINDS = /* @__PURE__ */ new Map([
+  ["METHOD", "method"],
+  ["CONSTRUCTOR", "constructor"],
+  ["DESTRUCTOR", "destructor"]
+]);
+var DEFINE_MODIFIERS = /* @__PURE__ */ new Set(["NEW", "GLOBAL", "SHARED", "PRIVATE", "PROTECTED", "PACKAGE-PRIVATE", "PACKAGE-PROTECTED", "PUBLIC", "STATIC", "SERIALIZABLE", "NON-SERIALIZABLE"]);
+function typeName(word) {
+  const dot = word.lastIndexOf(".");
+  return dot >= 0 ? word.slice(dot + 1) : word;
+}
+function extractAbl(content, filePath) {
+  const spans = new SpanCollector(filePath);
+  if (content.includes("\0")) return { symbols: [], imports: [] };
+  const rawLines = content.split(/\r?\n/);
+  const { statements, includes } = ablStatements(rawLines);
+  const imports = [...includes];
+  const stack = [];
+  let previous = 0;
+  const owner = () => {
+    for (let k = stack.length - 1; k >= 0; k--) if (stack[k].role === "type") return spans.name(stack[k].index);
+    return "";
+  };
+  const inRoutine = () => stack.some((o) => o.role === "routine");
+  for (const st of statements) {
+    const words = st.text.split(/\s+/);
+    const upper = words.map((w) => w.toUpperCase());
+    const w0 = upper[0];
+    if (st.terminator === ":") {
+      if (words.length === 1 && !LONE_BLOCK_WORDS.has(w0.replace(/\(.*$/, ""))) continue;
+      if (keyword(w0, "PROCEDURE", 5)) {
+        stack.push({ index: spans.open(words[1] ?? "", "procedure", st.line), role: "routine" });
+      } else if (w0 === "FUNCTION") {
+        stack.push({ index: spans.open(wordBeforeParen(words[1] ?? "", isWordChar) || (words[1] ?? ""), "function", st.line), role: "routine" });
+      } else if (TYPE_KINDS.has(w0)) {
+        stack.push({ index: spans.open(typeName(words[1] ?? ""), TYPE_KINDS.get(w0), st.line), role: "type" });
+      } else if (MEMBER_KINDS.has(w0)) {
+        stack.push({ index: spans.open(wordBeforeParen(st.text, isWordChar), MEMBER_KINDS.get(w0), st.line, owner()), role: "routine" });
+      } else {
+        stack.push({ index: void 0, role: "block" });
+      }
+    } else if (w0 === "END") {
+      const o = stack.pop();
+      if (o) spans.close(o.index, st.endLine);
+    } else if (MEMBER_KINDS.has(w0) && owner() !== "" && !inRoutine()) {
+      spans.open(wordBeforeParen(st.text, isWordChar), MEMBER_KINDS.get(w0), st.line, owner());
+    } else if (keyword(w0, "DEFINE", 3) && !inRoutine()) {
+      let k = 1;
+      while (k < upper.length && DEFINE_MODIFIERS.has(upper[k])) k++;
+      if (upper[k] === "TEMP-TABLE" && words[k + 1] !== void 0) spans.close(spans.open(words[k + 1], "temp_table", st.line, owner()), st.endLine);
+    } else if (w0 === "USING" && words[1] !== void 0) {
+      imports.push({ kind: "import", target: words[1], line: st.line });
+    }
+    previous = st.endLine;
+  }
+  for (const o of stack) spans.close(o.index, previous);
+  return { symbols: spans.finish(rawLines), imports };
+}
+
+// src/languages/jcl.ts
+init_define_import_meta_env();
+var STATEMENT_RE = /^\/\/(\S*)\s+(\S+)/;
+var DLM_RE = /\bDLM=(?:'([^']{2})'|([^,\s]{2}))/i;
+var MEMBER_RE = /\bMEMBER=([A-Za-z@#$][\w@#$]*)/i;
+function extractJcl(content, filePath) {
+  const imports = [];
+  const spans = new SpanCollector(filePath);
+  if (content.includes("\0")) return { symbols: [], imports };
+  const rawLines = content.split(/\r?\n/);
+  let job;
+  let proc;
+  let step;
+  let dataDelimiter = "";
+  let dataEndsAtStatement = false;
+  let previous = 0;
+  const endStep = (end) => {
+    spans.close(step, end);
+    step = void 0;
+  };
+  const endProc = (end) => {
+    endStep(end);
+    spans.close(proc, end);
+    proc = void 0;
+  };
+  const endJob = (end) => {
+    endProc(end);
+    spans.close(job, end);
+    job = void 0;
+  };
+  for (let i = 0; i < rawLines.length; i++) {
+    const raw = rawLines[i].slice(0, 72);
+    const line = i + 1;
+    if (dataDelimiter !== "") {
+      if (raw.startsWith(dataDelimiter)) {
+        dataDelimiter = "";
+        previous = line;
+        continue;
+      }
+      if (!(dataEndsAtStatement && raw.startsWith("//"))) {
+        previous = line;
+        continue;
+      }
+      dataDelimiter = "";
+    }
+    if (!raw.startsWith("//") || raw.startsWith("//*")) continue;
+    if (raw.trim() === "//") {
+      endJob(previous);
+      continue;
+    }
+    const m = STATEMENT_RE.exec(raw);
+    if (!m) continue;
+    const name = m[1];
+    const op = m[2].toUpperCase();
+    const operands = raw.slice(m[0].length).trim();
+    if (op === "JOB") {
+      endJob(previous);
+      job = spans.open(name, "job", line);
+    } else if (op === "PROC") {
+      endProc(previous);
+      proc = spans.open(name, "procedure", line, spans.name(job));
+    } else if (op === "PEND") {
+      endProc(line);
+    } else if (op === "EXEC") {
+      endStep(previous);
+      if (name !== "") step = spans.open(name, "step", line, spans.name(proc ?? job));
+    } else if (op === "INCLUDE") {
+      const member = MEMBER_RE.exec(operands);
+      if (member) imports.push({ kind: "include", target: member[1], line });
+    } else if (op === "DD") {
+      const kind = /^(\*|DATA)(?=$|[,\s])/i.exec(operands);
+      if (kind) {
+        const dlm = DLM_RE.exec(operands);
+        dataDelimiter = dlm ? dlm[1] ?? dlm[2] : "/*";
+        dataEndsAtStatement = kind[1] === "*" && !dlm;
+      }
+    }
+    previous = line;
+  }
+  endJob(previous);
+  return { symbols: spans.finish(rawLines), imports };
+}
+
+// src/languages/pli.ts
+init_define_import_meta_env();
+var SEQUENCE_FIELD_RE = /^ *\d+ *$/;
+function hasSequenceField(rawLines) {
+  const long = rawLines.filter((l) => l.length > 72);
+  if (long.length === 0) return false;
+  return long.filter((l) => SEQUENCE_FIELD_RE.test(l.slice(72, 80))).length / long.length >= 0.8;
+}
+function pliStatements(rawLines) {
+  const out = [];
+  const margin = hasSequenceField(rawLines);
+  let text = "";
+  let raw = "";
+  let start = 0;
+  let quote = "";
+  let comment = false;
+  for (let i = 0; i < rawLines.length; i++) {
+    const line = margin ? rawLines[i].slice(0, 72) : rawLines[i];
+    for (let j = 0; j < line.length; j++) {
+      const ch = line[j];
+      if (comment) {
+        if (ch === "*" && line[j + 1] === "/") {
+          comment = false;
+          j++;
+        }
+        continue;
+      }
+      if (quote !== "") {
+        raw += ch;
+        if (ch === quote && line[j + 1] === quote) {
+          raw += ch;
+          text += "  ";
+          j++;
+        } else if (ch === quote) {
+          quote = "";
+          text += ch;
+        } else text += " ";
+        continue;
+      }
+      if (ch === "/" && line[j + 1] === "*") {
+        comment = true;
+        j++;
+        continue;
+      }
+      if (ch === ";") {
+        const t = text.trim();
+        if (t !== "") out.push({ text: t, raw: raw.trim(), line: start, endLine: i + 1 });
+        text = "";
+        raw = "";
+        start = 0;
+        continue;
+      }
+      if (ch === "'" || ch === '"') quote = ch;
+      if (start === 0 && !/\s/.test(ch)) start = i + 1;
+      text += ch;
+      raw += ch;
+    }
+    text += " ";
+    raw += " ";
+  }
+  return out;
+}
+var LABEL_RE = /^(%?)([A-Za-z_@#$][\w@#$]*)\s*:/;
+var isWordChar2 = (ch) => /[\w@#$%]/.test(ch);
+var OPENERS = /* @__PURE__ */ new Set(["DO", "BEGIN", "SELECT"]);
+var INTRODUCERS = /* @__PURE__ */ new Set(["THEN", "ELSE", "OTHERWISE", "WHEN"]);
+function extractPli(content, filePath) {
+  const imports = [];
+  const spans = new SpanCollector(filePath);
+  if (content.includes("\0")) return { symbols: [], imports };
+  const rawLines = content.split(/\r?\n/);
+  const stack = [];
+  let previous = 0;
+  for (const st of pliStatements(rawLines)) {
+    let rest = st.text;
+    const labels = [];
+    let percent = false;
+    for (let m = LABEL_RE.exec(rest); m !== null; m = LABEL_RE.exec(rest)) {
+      if (m[1] === "%") percent = true;
+      labels.push(m[2]);
+      rest = rest.slice(m[0].length).trimStart();
+    }
+    if (rest.startsWith("%")) percent = true;
+    const words = topLevelWords(rest, isWordChar2).map((w) => w.replace(/^%/, "").toUpperCase());
+    const w0 = words[0] ?? "";
+    const assignment = /^%?[\w@#$]+\s*=/.test(rest);
+    const parent = () => spans.name([...stack].reverse().find((o) => o.named)?.index);
+    if (w0 === "END" && !assignment) {
+      const label = words[1];
+      const at = label === void 0 ? -1 : stack.map((o) => o.labels.some((l) => l.toUpperCase() === label)).lastIndexOf(true);
+      for (const o of stack.splice(at >= 0 ? at : Math.max(0, stack.length - 1))) spans.close(o.index, st.endLine);
+    } else if ((w0 === "PROC" || w0 === "PROCEDURE" || w0 === "PACKAGE") && !assignment) {
+      const index = percent || labels.length === 0 ? void 0 : spans.open(labels[0], w0 === "PACKAGE" ? "package" : "procedure", st.line, parent());
+      stack.push({ labels, index, named: index !== void 0 });
+    } else if (OPENERS.has(w0) && !assignment || words.some((w, k) => INTRODUCERS.has(w) && OPENERS.has(words[k + 1] ?? "")) || w0 === "ON" && words[words.length - 1] === "BEGIN") {
+      stack.push({ labels, index: void 0, named: false });
+    } else if (percent && (w0 === "INCLUDE" || w0 === "XINCLUDE")) {
+      const list = st.raw.replace(/^[^%]*%\s*X?INCLUDE\b/i, "");
+      for (const item of list.split(",")) {
+        const t = item.trim().replace(/^(['"])(.*)\1$/, "$2");
+        const member = /\(([^()]+)\)\s*$/.exec(t);
+        const target = (member ? member[1] : t).trim();
+        if (target !== "") imports.push({ kind: "include", target, line: st.line });
+      }
+    }
+    previous = st.endLine;
+  }
+  for (const o of stack) spans.close(o.index, previous);
+  return { symbols: spans.finish(rawLines), imports };
+}
+
+// src/languages/rpg.ts
+init_define_import_meta_env();
+var FIXED_SPECS = "HFDICOP";
+var COMPILE_TIME_DATA_RE = /^\*\*(?:\s|$|CTDATA\b|FTRANS\b|ALTSEQ\b)/i;
+var DIRECTIVE_RE = /^\/(?:COPY|INCLUDE)\s+(\S+)/i;
+var NAME_RE = /^[A-Za-z@#$_*][\w@#$]*/;
+function codeOf2(text) {
+  let out = "";
+  let quote = false;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (quote) {
+      if (ch === "'" && text[i + 1] === "'") {
+        out += "  ";
+        i++;
+      } else if (ch === "'") {
+        quote = false;
+        out += ch;
+      } else out += " ";
+      continue;
+    }
+    if (ch === "/" && text[i + 1] === "/") break;
+    if (ch === "'") quote = true;
+    out += ch;
+  }
+  return out;
+}
+function extractRpg(content, filePath) {
+  const imports = [];
+  const spans = new SpanCollector(filePath);
+  if (content.includes("\0")) return { symbols: [], imports };
+  const rawLines = content.split(/\r?\n/);
+  const fullyFree = /^\*\*FREE\b/i.test(rawLines[0] ?? "");
+  const stack = [];
+  let proc;
+  let longName = "";
+  let text = "";
+  let start = 0;
+  let previous = 0;
+  const closeTo = (end, line) => {
+    const at = stack.map((o) => o.end).lastIndexOf(end);
+    if (at < 0) return;
+    for (const o of stack.splice(at)) spans.close(o.index, line);
+  };
+  const openProc = (name, line) => {
+    closeTo("END-PROC", previous);
+    proc = spans.open(name, "procedure", line);
+    stack.push({ end: "END-PROC", index: proc });
+  };
+  const endProc = (line) => {
+    closeTo("END-PROC", line);
+    proc = void 0;
+  };
+  const inProc = () => stack.some((o) => o.end === "END-PROC");
+  const statement = (t, line, endLine) => {
+    const words = t.split(/\s+/);
+    const w0 = words[0].toUpperCase();
+    const name = NAME_RE.exec(words[1] ?? "")?.[0] ?? "";
+    const upper = words.map((w) => w.toUpperCase());
+    if (w0 === "DCL-PROC") openProc(name, line);
+    else if (w0 === "END-PROC") endProc(endLine);
+    else if (w0 === "BEGSR") stack.push({ end: "ENDSR", index: spans.open(name, "subroutine", line, spans.name(proc)) });
+    else if (w0 === "ENDSR") closeTo("ENDSR", endLine);
+    else if (w0 === "DCL-PR" || w0 === "DCL-DS" || w0 === "DCL-PI") {
+      const end = `END-${w0.slice(4)}`;
+      const single = upper.includes(end) || w0 === "DCL-DS" && upper.some((w) => w.startsWith("LIKEDS") || w.startsWith("LIKEREC"));
+      const emit = w0 === "DCL-PR" || w0 === "DCL-DS" && !inProc();
+      const index = emit && name !== "*N" ? spans.open(name, w0 === "DCL-PR" ? "prototype" : "data_structure", line, "") : void 0;
+      if (single) spans.close(index, endLine);
+      else stack.push({ end, index });
+    } else if (w0 === "END-PR" || w0 === "END-DS" || w0 === "END-PI") closeTo(w0, endLine);
+    else if ((w0 === "DCL-S" || w0 === "DCL-C" || w0 === "DCL-F") && !inProc()) {
+      spans.close(spans.open(name, w0 === "DCL-S" ? "variable" : w0 === "DCL-C" ? "constant" : "file", line), endLine);
+    } else if (w0 === "EXEC" && upper[1] === "SQL" && upper[2] === "INCLUDE" && words[3] !== void 0) {
+      imports.push({ kind: "include", target: words[3].replace(/^['"]|['"]$/g, ""), line });
+    }
+  };
+  const fixed = (raw, line) => {
+    const spec = raw[5].toUpperCase();
+    if (spec === "P") {
+      const field = raw.slice(6, 21).trim();
+      if (field.endsWith("...")) {
+        longName += field.slice(0, -3);
+        return;
+      }
+      const name = longName + field;
+      longName = "";
+      const be = raw.slice(23, 24).toUpperCase();
+      if (be === "B") openProc(name, line);
+      else if (be === "E") endProc(line);
+    } else if (spec === "C") {
+      const opcode = raw.slice(25, 35).trim().toUpperCase().replace(/\(.*$/, "");
+      if (opcode === "BEGSR") stack.push({ end: "ENDSR", index: spans.open(raw.slice(11, 25).trim(), "subroutine", line, spans.name(proc)) });
+      else if (opcode === "ENDSR") closeTo("ENDSR", line);
+    }
+  };
+  for (let i = fullyFree ? 1 : 0; i < rawLines.length; i++) {
+    const raw = rawLines[i];
+    const line = i + 1;
+    let code;
+    if (fullyFree) {
+      if (COMPILE_TIME_DATA_RE.test(raw)) break;
+      code = raw;
+    } else {
+      if (COMPILE_TIME_DATA_RE.test(raw)) break;
+      if (raw.length < 7 || raw[6] === "*") continue;
+      if (FIXED_SPECS.includes(raw[5].toUpperCase())) {
+        fixed(raw, line);
+        previous = line;
+        continue;
+      }
+      code = raw.slice(7, 80);
+    }
+    const trimmed = code.trimStart();
+    if (trimmed.startsWith("/") && !trimmed.startsWith("//")) {
+      const d = DIRECTIVE_RE.exec(trimmed);
+      if (d) imports.push({ kind: "include", target: d[1].replace(/^['"]|['"]$/g, ""), line });
+      continue;
+    }
+    const c = codeOf2(code);
+    let from = 0;
+    for (let k = c.indexOf(";"); k >= 0; k = c.indexOf(";", from)) {
+      const part = c.slice(from, k);
+      if (start === 0 && part.trim() !== "") start = line;
+      text += part;
+      const t = text.trim();
+      if (t !== "") statement(t, start, line);
+      text = "";
+      start = 0;
+      from = k + 1;
+      previous = line;
+    }
+    const tail = c.slice(from);
+    if (start === 0 && tail.trim() !== "") start = line;
+    text += `${tail} `;
+  }
+  for (const o of stack) spans.close(o.index, previous);
+  return { symbols: spans.finish(rawLines), imports };
+}
+
+// src/languages/sas.ts
+init_define_import_meta_env();
+var DATALINES_RE = /^(?:datalines|cards|lines|parmcards)(4?)$/i;
+function sasStatements(rawLines) {
+  const out = [];
+  let text = "";
+  let raw = "";
+  let start = 0;
+  let quote = "";
+  let blockComment = false;
+  let commentStatement = false;
+  let dataMode = 0;
+  for (let i = 0; i < rawLines.length; i++) {
+    const line = rawLines[i];
+    if (dataMode !== 0) {
+      if (dataMode === 4 ? line.trimStart().startsWith(";;;;") : line.includes(";")) dataMode = 0;
+      continue;
+    }
+    for (let j = 0; j < line.length; j++) {
+      const ch = line[j];
+      if (blockComment) {
+        if (ch === "*" && line[j + 1] === "/") {
+          blockComment = false;
+          j++;
+        }
+        continue;
+      }
+      if (ch === "/" && line[j + 1] === "*" && quote === "") {
+        blockComment = true;
+        j++;
+        continue;
+      }
+      if (commentStatement) {
+        if (ch === ";") commentStatement = false;
+        continue;
+      }
+      if (quote !== "") {
+        raw += ch;
+        if (ch === quote && line[j + 1] === quote) {
+          raw += ch;
+          text += "  ";
+          j++;
+        } else if (ch === quote) {
+          quote = "";
+          text += ch;
+        } else text += " ";
+        continue;
+      }
+      if (start === 0 && (ch === "*" || ch === "%" && line[j + 1] === "*")) {
+        commentStatement = true;
+        continue;
+      }
+      if (ch === ";") {
+        const t = text.trim();
+        if (t !== "") {
+          out.push({ text: t, raw: raw.trim(), line: start, endLine: i + 1 });
+          const m = DATALINES_RE.exec(t);
+          if (m) {
+            dataMode = m[1] === "4" ? 4 : 1;
+            break;
+          }
+        }
+        text = "";
+        raw = "";
+        start = 0;
+        continue;
+      }
+      if (ch === "'" || ch === '"') quote = ch;
+      if (start === 0 && !/\s/.test(ch)) start = i + 1;
+      text += ch;
+      raw += ch;
+    }
+    text += " ";
+    raw += " ";
+  }
+  return out;
+}
+function nameAfter(text, keywordLength) {
+  const rest = text.slice(keywordLength).trimStart();
+  let end = 0;
+  while (end < rest.length && !/[\s(/;]/.test(rest[end])) end++;
+  return rest.slice(0, end);
+}
+function includeTarget(raw) {
+  const rest = raw.replace(/^%inc(?:lude)?\b/i, "").trimStart();
+  const q = rest[0];
+  if (q === "'" || q === '"') {
+    const end2 = rest.indexOf(q, 1);
+    return end2 > 0 ? rest.slice(1, end2) : "";
+  }
+  let end = 0;
+  while (end < rest.length && !/[\s/;]/.test(rest[end])) end++;
+  return rest.slice(0, end);
+}
+function extractSas(content, filePath) {
+  const imports = [];
+  const spans = new SpanCollector(filePath);
+  if (content.includes("\0")) return { symbols: [], imports };
+  const rawLines = content.split(/\r?\n/);
+  const statements = sasStatements(rawLines);
+  const macros = [];
+  let step;
+  let previous = 0;
+  const endStep = (end) => {
+    spans.close(step, end);
+    step = void 0;
+  };
+  for (const st of statements) {
+    const keyword2 = (/^%?[A-Za-z_]\w*/.exec(st.text)?.[0] ?? "").toLowerCase();
+    if (keyword2 === "%macro") {
+      endStep(previous);
+      const parent = spans.name(macros[macros.length - 1]);
+      macros.push(spans.open(nameAfter(st.text, keyword2.length), "macro", st.line, parent));
+    } else if (keyword2 === "%mend") {
+      endStep(previous);
+      spans.close(macros.pop(), st.endLine);
+    } else if (keyword2 === "data") {
+      endStep(previous);
+      const name = nameAfter(st.text, keyword2.length);
+      if (name !== "" && name.toLowerCase() !== "_null_") step = spans.open(name, "data_step", st.line, spans.name(macros[macros.length - 1]));
+    } else if (keyword2 === "proc") {
+      endStep(previous);
+    } else if (keyword2 === "run" || keyword2 === "quit") {
+      endStep(st.endLine);
+    } else if (keyword2 === "%include" || keyword2 === "%inc") {
+      const target = includeTarget(st.raw);
+      if (target !== "") imports.push({ kind: "include", target, line: st.line });
+    }
+    previous = st.endLine;
+  }
+  endStep(previous);
+  for (const m of macros) spans.close(m, previous);
+  return { symbols: spans.finish(rawLines), imports };
+}
+
+// src/languages/groovy.ts
+init_define_import_meta_env();
+
+// src/languages/brace_engine.ts
+init_define_import_meta_env();
+var MAX_SYMBOLS4 = 1e4;
+var MAX_NAME_LENGTH2 = 200;
+var PENDING_MAX_LINES = 12;
+var HEADER_MAX_LINES = 12;
+var HEADER_MAX_CHARS = 2e3;
+function blankText(s) {
+  return s.replace(/[^\r\n]/g, " ");
+}
+function nestedCommentEnd(content, from, open, close) {
+  let depth = 0;
+  let i = from;
+  while (i < content.length) {
+    if (content.startsWith(open, i)) {
+      depth++;
+      i += open.length;
+    } else if (content.startsWith(close, i)) {
+      depth--;
+      i += close.length;
+      if (depth === 0) return i;
+    } else {
+      i++;
+    }
+  }
+  return content.length;
+}
+function maskSource(content, opts) {
+  const parts = [];
+  let keepFrom = 0;
+  const blank = (a, b) => {
+    parts.push(content.slice(keepFrom, a), blankText(content.slice(a, b)));
+    keepFrom = b;
+  };
+  const n = content.length;
+  let i = 0;
+  if (opts.shebang === true && content.startsWith("#!")) {
+    const e = content.indexOf("\n");
+    i = e < 0 ? n : e;
+    blank(0, i);
+  }
+  while (i < n) {
+    const c = content[i];
+    if (opts.lineComments.some((p) => content.startsWith(p, i))) {
+      const e = content.indexOf("\n", i);
+      const end = e < 0 ? n : e;
+      blank(i, end);
+      i = end;
+      continue;
+    }
+    const bc = opts.blockComment;
+    if (bc !== null && content.startsWith(bc[0], i)) {
+      let end;
+      if (opts.nestedBlockComments === true) {
+        end = nestedCommentEnd(content, i, bc[0], bc[1]);
+      } else {
+        const e = content.indexOf(bc[1], i + bc[0].length);
+        end = e < 0 ? n : e + bc[1].length;
+      }
+      blank(i, end);
+      i = end;
+      continue;
+    }
+    if (opts.slashyStrings === true) {
+      const slashy = matchGroovySlashy(content, i);
+      if (slashy !== null) {
+        blank(slashy.bodyStart, slashy.bodyEnd);
+        i = slashy.end;
+        continue;
+      }
+    }
+    if (opts.tripleQuotes === true && (content.startsWith('"""', i) || content.startsWith("'''", i))) {
+      const q = content.slice(i, i + 3);
+      let j = i + 3;
+      while (j < n && !content.startsWith(q, j)) j += content[j] === "\\" ? 2 : 1;
+      const closed = j < n;
+      blank(i + 3, Math.min(j, n));
+      i = closed ? j + 3 : n;
+      continue;
+    }
+    if (opts.quotes.includes(c)) {
+      let j = i + 1;
+      while (j < n) {
+        const ch = content[j];
+        if (ch === "\\") {
+          j += 2;
+          continue;
+        }
+        if (ch === c || ch === "\n") break;
+        j++;
+      }
+      const end = Math.min(j, n);
+      blank(i + 1, end);
+      i = end < n && content[end] === c ? end + 1 : end;
+      continue;
+    }
+    i++;
+  }
+  parts.push(content.slice(keepFrom));
+  return parts.join("");
+}
+function isIdentChar(ch) {
+  return ch !== void 0 && /[\w$]/.test(ch);
+}
+function trailingIdentifier(s) {
+  let start = s.length;
+  while (start > 0 && (isIdentChar(s[start - 1]) || s[start - 1] === ":" || s[start - 1] === "~")) start--;
+  const seg = s.slice(start);
+  const parts = seg.split("::");
+  const name = parts.pop() ?? "";
+  if (!/^~?[A-Za-z_$][\w$]*$/.test(name) || parts.some((p) => !/^[A-Za-z_]\w*$/.test(p))) return null;
+  return { name, qualifier: parts.join("::") };
+}
+function trimEndChars(s, chars) {
+  let end = s.length;
+  while (end > 0 && chars.includes(s[end - 1])) end--;
+  return s.slice(0, end);
+}
+function withoutTrailingBrace(code) {
+  return code.endsWith("{") ? code.slice(0, -1).trimEnd() : code;
+}
+function rawQuoted(ctx, at) {
+  const start = ctx.codeOffset + at;
+  const q = ctx.raw[start];
+  if (q !== '"' && q !== "'") return "";
+  const end = ctx.raw.indexOf(q, start + 1);
+  return end < 0 ? "" : ctx.raw.slice(start + 1, end).trim();
+}
+function quotedTarget(raw) {
+  const m = /["'<]([^"'<>]+)["'>]/.exec(raw);
+  return m === null ? null : m[1].trim();
+}
+var C_NOT_A_TYPE = /* @__PURE__ */ new Set([
+  "if",
+  "for",
+  "while",
+  "switch",
+  "return",
+  "else",
+  "do",
+  "sizeof",
+  "case",
+  "new",
+  "delete",
+  "throw",
+  "catch",
+  "typedef",
+  "using",
+  "goto",
+  "static_assert",
+  "alignof",
+  "decltype",
+  "defined",
+  "foreach",
+  "synchronized",
+  "assert",
+  "emit",
+  "await",
+  "yield",
+  "in",
+  "not"
+]);
+var C_PREFIX_RE = /^[A-Za-z_][\w\s*&:<>,[\].]*$/;
+function cFunctionHeader(code) {
+  const paren = code.indexOf("(");
+  if (paren <= 0) return null;
+  const prefix = code.slice(0, paren).trimEnd();
+  if (!C_PREFIX_RE.test(prefix) || prefix.replace(/::/g, "").includes(":")) return null;
+  const id = trailingIdentifier(prefix);
+  if (id === null) return null;
+  const typeText = prefix.slice(0, prefix.length - (id.qualifier === "" ? id.name.length : id.qualifier.length + 2 + id.name.length)).trim();
+  if (typeText === "" || typeText.endsWith(".") || typeText.endsWith(",")) return null;
+  const first = typeText.split(/[\s*&<>,[\]]/, 1)[0];
+  if (C_NOT_A_TYPE.has(first) || C_NOT_A_TYPE.has(id.name)) return null;
+  return { ...id, typeText };
+}
+function scanBraceLanguage(content, filePath, lang) {
+  const rawLines = content.split(/\r?\n/);
+  const masked = maskSource(content, lang.lex).split("\n");
+  const items = [];
+  const imports = [];
+  const frames = [];
+  let depth = 0;
+  let pending = null;
+  let continuation = false;
+  const close = (index, line) => {
+    const it = items[index];
+    it.lineEnd = Math.max(it.lineStart, line);
+  };
+  for (let i = 0; i < masked.length; i++) {
+    const code = masked[i];
+    const raw = rawLines[i] ?? "";
+    const trimmed = code.trim();
+    const directive = lang.preprocessor === true && (continuation || trimmed.startsWith("#"));
+    if (directive) {
+      continuation = trimmed.endsWith("\\");
+      const target = lang.importOf?.(trimmed, raw) ?? null;
+      if (target !== null && target !== "") imports.push({ kind: "import", target, line: i + 1 });
+      continue;
+    }
+    if (trimmed !== "") {
+      if (lang.keywordClose?.test(trimmed) === true) {
+        let k = frames.length - 1;
+        while (k >= 0 && !frames[k].keyword) k--;
+        if (k >= 0) {
+          close(frames[k].item, i + 1);
+          frames.length = k;
+          pending = null;
+        }
+        continue;
+      }
+      const target = lang.importOf?.(trimmed, raw) ?? null;
+      if (target !== null && target !== "") imports.push({ kind: "import", target, line: i + 1 });
+      const top = frames[frames.length - 1];
+      const topItem = top !== void 0 && top.item >= 0 ? items[top.item] : void 0;
+      const scope = top === void 0 ? "top" : topItem === void 0 ? "block" : topItem.container ? "container" : "function";
+      let parentIdx = -1;
+      for (let f = frames.length - 1; f >= 0 && parentIdx < 0; f--) {
+        const idx = frames[f].item;
+        if (idx >= 0 && items[idx].container) parentIdx = idx;
+      }
+      const parent = parentIdx >= 0 ? items[parentIdx] : void 0;
+      const ctx = {
+        scope,
+        insideFunction: frames.some((f) => f.item >= 0 && !items[f.item].container),
+        parent: parent?.name ?? "",
+        parentKind: parent?.kind ?? "",
+        raw,
+        codeOffset: code.length - code.trimStart().length,
+        header: () => headerFrom(masked, i)
+      };
+      const inHeader = pending !== null && pending.parens > 0;
+      const d = items.length < MAX_SYMBOLS4 && !inHeader ? lang.match(trimmed, ctx) : null;
+      if (d !== null && d.name.length <= MAX_NAME_LENGTH2 && (d.name !== "" || d.nameAfterClose === true)) {
+        pending = null;
+        items.push({
+          name: d.name,
+          kind: d.kind,
+          lineStart: i + 1,
+          lineEnd: i + 1,
+          parent: d.parent ?? ctx.parent,
+          container: d.container === true,
+          nameAfterClose: d.nameAfterClose === true
+        });
+        const idx = items.length - 1;
+        if (d.end === "brace") pending = { item: idx, depth, line: i, parens: 0, dropPrototype: d.dropPrototype === true };
+        else if (d.end === "keyword") frames.push({ item: idx, keyword: true, depth });
+      }
+    }
+    for (let c = 0; c < code.length; c++) {
+      const ch = code.charCodeAt(c);
+      if (ch === 123) {
+        depth++;
+        if (pending !== null && pending.depth === depth - 1) {
+          frames.push({ item: pending.item, keyword: false, depth });
+          pending = null;
+        } else {
+          frames.push({ item: -1, keyword: false, depth });
+        }
+      } else if (ch === 125) {
+        const top = frames[frames.length - 1];
+        if (top !== void 0 && !top.keyword && top.depth === depth) {
+          frames.pop();
+          if (top.item >= 0) {
+            close(top.item, i + 1);
+            const it = items[top.item];
+            if (it.nameAfterClose && it.name === "") it.name = /^[\s*]*([A-Za-z_]\w*)/.exec(code.slice(c + 1))?.[1] ?? "";
+          }
+        }
+        depth = Math.max(0, depth - 1);
+        if (pending !== null && depth < pending.depth) pending = null;
+      } else if (ch === 40 && pending !== null) {
+        pending.parens++;
+      } else if (ch === 41 && pending !== null) {
+        pending.parens = Math.max(0, pending.parens - 1);
+      } else if (ch === 59 && pending !== null && depth === pending.depth && pending.parens === 0) {
+        close(pending.item, i + 1);
+        if (pending.dropPrototype) items[pending.item].name = "";
+        pending = null;
+      }
+    }
+    if (pending !== null && i - pending.line >= PENDING_MAX_LINES) pending = null;
+  }
+  const symbols = items.filter((it) => it.name !== "").map((it) => ({
+    filePath,
+    name: it.name,
+    kind: it.kind,
+    lineStart: it.lineStart,
+    lineEnd: it.lineEnd,
+    body: rawLines.slice(it.lineStart - 1, it.lineEnd).join("\n"),
+    docstring: lang.docComments === true ? precedingDocComment(rawLines, it.lineStart, "c") : "",
+    parent: it.parent
+  }));
+  return { symbols, imports };
+}
+function headerFrom(masked, from) {
+  let s = "";
+  for (let j = from; j < masked.length && j < from + HEADER_MAX_LINES; j++) {
+    const t = masked[j];
+    const cut = t.search(/[{;]/);
+    s += ` ${cut < 0 ? t : t.slice(0, cut)}`;
+    if (cut >= 0 || s.length > HEADER_MAX_CHARS) break;
+  }
+  return s.trim();
+}
+function stripLeadingWords(code, words, annotations) {
+  let i = 0;
+  for (; ; ) {
+    while (i < code.length && /\s/.test(code[i])) i++;
+    if (annotations && code[i] === "@" && /[A-Za-z_]/.test(code[i + 1] ?? "") && !code.startsWith("@interface", i)) {
+      i++;
+      while (i < code.length && (isIdentChar(code[i]) || code[i] === ".")) i++;
+      let j2 = i;
+      while (j2 < code.length && code[j2] === " ") j2++;
+      if (code[j2] === "(") {
+        let d = 0;
+        for (; j2 < code.length; j2++) {
+          if (code[j2] === "(") d++;
+          else if (code[j2] === ")" && --d === 0) break;
+        }
+        i = j2 + 1;
+      }
+      continue;
+    }
+    let j = i;
+    while (j < code.length && (isIdentChar(code[j]) || code[j] === "-")) j++;
+    if (j > i && words.has(code.slice(i, j)) && (j === code.length || /\s/.test(code[j]))) {
+      i = j;
+      continue;
+    }
+    return code.slice(i);
+  }
+}
+
+// src/languages/groovy.ts
+var MODIFIERS = /* @__PURE__ */ new Set([
+  "public",
+  "private",
+  "protected",
+  "static",
+  "final",
+  "abstract",
+  "sealed",
+  "non-sealed",
+  "strictfp",
+  "synchronized",
+  "transient",
+  "volatile",
+  "native",
+  "default"
+]);
+var PRIMITIVES = /* @__PURE__ */ new Set(["void", "boolean", "byte", "char", "short", "int", "long", "float", "double", "def", "var"]);
+var TYPE_DECL_RE = /^(class|interface|trait|enum|record|@interface)\s+([A-Za-z_]\w*)/;
+var TYPE_KINDS2 = /* @__PURE__ */ new Set(["class", "enum", "record"]);
+function isReturnType(typeText) {
+  const first = typeText.split(/[\s<[]/, 1)[0];
+  if (PRIMITIVES.has(first)) return true;
+  const last = first.split(".").pop() ?? "";
+  return /^[A-Z]/.test(last);
+}
+function matchGroovy(code, ctx) {
+  const s = stripLeadingWords(code, MODIFIERS, true);
+  const at = code.length - s.length;
+  if (ctx.scope === "top" || ctx.scope === "container") {
+    const t = TYPE_DECL_RE.exec(s);
+    if (t !== null) return { name: t[2], kind: t[1] === "@interface" ? "annotation" : t[1], container: true, end: "brace" };
+    const member = ctx.scope === "container" ? "method" : "function";
+    const spock = /^def\s+(?=["'])/.exec(s);
+    if (spock !== null) {
+      const name = rawQuoted(ctx, at + spock[0].length);
+      return name === "" ? null : { name, kind: member, end: "brace" };
+    }
+    if (ctx.scope === "container" && TYPE_KINDS2.has(ctx.parentKind) && s.startsWith(ctx.parent) && /^\s*\(/.test(s.slice(ctx.parent.length))) {
+      return { name: ctx.parent, kind: "constructor", end: "brace" };
+    }
+    const fn = cFunctionHeader(s);
+    if (fn !== null && fn.qualifier === "" && isReturnType(fn.typeText)) return { name: fn.name, kind: member, end: "brace" };
+  }
+  if (ctx.insideFunction) return null;
+  const stage = /^stage\s*\(\s*(?=["'])/.exec(s);
+  if (stage !== null) {
+    const name = rawQuoted(ctx, at + stage[0].length);
+    return name === "" ? null : { name, kind: "stage", container: true, end: "brace" };
+  }
+  const task = /^task\s+([A-Za-z_]\w*)/.exec(s);
+  if (task !== null) return { name: task[1], kind: "task", end: "brace" };
+  const reg = /^tasks\s*\.\s*(?:register|create)\s*\(\s*(?=["'])/.exec(s);
+  if (reg !== null) {
+    const name = rawQuoted(ctx, at + reg[0].length);
+    return name === "" ? null : { name, kind: "task", end: s.includes("{") ? "brace" : "line" };
+  }
+  return null;
+}
+var GROOVY = {
+  lex: { lineComments: ["//"], blockComment: ["/*", "*/"], quotes: `"'`, tripleQuotes: true, shebang: true, slashyStrings: true },
+  match: matchGroovy,
+  importOf: (code) => /^import\s+(?:static\s+)?([\w.]+(?:\.\*)?)/.exec(code)?.[1] ?? null,
+  docComments: true
+};
+function extractGroovy(content, filePath) {
+  return scanBraceLanguage(content, filePath, GROOVY);
+}
+
+// src/languages/objc.ts
+init_define_import_meta_env();
+var CONTAINER_RE = /^@(interface|implementation|protocol)\s+([A-Za-z_]\w*)[ \t]*(\([ \t]*(?:([A-Za-z_]\w*)[ \t]*)?\))?/;
+var NS_ENUM_RE = /^(?:typedef\s+)?NS_(?:ENUM|OPTIONS|CLOSED_ENUM|ERROR_ENUM)\s*\([^,()]*,\s*([A-Za-z_]\w*)\s*\)/;
+var TYPEDEF_TAG_RE = /^typedef\s+(struct|enum|union)(?:\s+([A-Za-z_]\w*))?$/;
+var TYPE_RE = /^(struct|union|enum|class|namespace)\s+(?:class\s+)?([A-Za-z_]\w*)(?:\s*:[^;{]*)?$/;
+function skipParens(s, i) {
+  if (s[i] !== "(") return i;
+  let d = 0;
+  for (; i < s.length; i++) {
+    if (s[i] === "(") d++;
+    else if (s[i] === ")" && --d === 0) return i + 1;
+  }
+  return i;
+}
+function skipSpace(s, i) {
+  while (i < s.length && /\s/.test(s[i])) i++;
+  return i;
+}
+function readIdent(s, i) {
+  let j = i;
+  while (j < s.length && /\w/.test(s[j])) j++;
+  return /^[A-Za-z_]/.test(s.slice(i, j)) ? s.slice(i, j) : "";
+}
+function selectorOf(header) {
+  let i = skipSpace(header, 1);
+  i = skipSpace(header, skipParens(header, i));
+  const parts = [];
+  for (; ; ) {
+    const word = readIdent(header, i);
+    const afterWord = skipSpace(header, i + word.length);
+    if (header[afterWord] === ":") {
+      parts.push(`${word}:`);
+      i = skipSpace(header, skipParens(header, skipSpace(header, afterWord + 1)));
+      i = skipSpace(header, i + readIdent(header, i).length);
+      continue;
+    }
+    if (parts.length === 0) return word;
+    return parts.join("");
+  }
+}
+function propertyName(code) {
+  const body = code.slice("@property".length);
+  const afterAttrs = skipParens(body, skipSpace(body, 0));
+  const text = body.slice(afterAttrs, body.includes(";") ? body.indexOf(";") : body.length);
+  const block = /\(\s*\^\s*([A-Za-z_]\w*)\s*\)/.exec(text);
+  if (block !== null) return block[1];
+  const words = text.replace(/\([^()]*\)/g, " ").split(/[\s*]+/).filter((w) => w !== "");
+  while (words.length > 2 && /^[A-Z][A-Z0-9_]+$/.test(words[words.length - 1])) words.pop();
+  return trailingIdentifier(words[words.length - 1] ?? "")?.name ?? "";
+}
+function matchObjc(code, ctx) {
+  if (code.startsWith("@property")) {
+    if (ctx.scope !== "container") return null;
+    const name = propertyName(code);
+    return name === "" ? null : { name, kind: "property", end: "line" };
+  }
+  if (code.startsWith("@")) {
+    if (ctx.scope !== "top") return null;
+    const m = CONTAINER_RE.exec(code);
+    if (m === null) return null;
+    if (m[1] === "protocol" && /^[\s\w,]*;/.test(code.slice("@protocol".length))) return null;
+    const kind = m[3] === void 0 ? m[1] : m[4] === void 0 ? "extension" : "category";
+    return { name: m[2], kind, container: true, end: "keyword" };
+  }
+  if (code.startsWith("-") || code.startsWith("+")) {
+    if (ctx.scope !== "container" || !/^[-+]\s*\(/.test(code)) return null;
+    const name = selectorOf(ctx.header());
+    return name === "" ? null : { name, kind: "method", end: "brace" };
+  }
+  if (ctx.scope === "function" || ctx.scope === "block") return null;
+  const ns = NS_ENUM_RE.exec(code);
+  if (ns !== null) return { name: ns[1], kind: "enum", end: "brace" };
+  const head = withoutTrailingBrace(code);
+  const td = TYPEDEF_TAG_RE.exec(head);
+  if (td !== null) return { name: td[2] ?? "", kind: td[1], end: "brace", nameAfterClose: td[2] === void 0 };
+  const t = TYPE_RE.exec(head);
+  if (t !== null) return { name: t[2], kind: t[1], container: t[1] === "class" || t[1] === "struct" || t[1] === "namespace", end: "brace" };
+  const fn = cFunctionHeader(code);
+  if (fn !== null) return { name: fn.name, kind: "function", end: "brace", dropPrototype: true, ...fn.qualifier === "" ? {} : { parent: fn.qualifier } };
+  return null;
+}
+function importOf(code, raw) {
+  if (/^#\s*(?:import|include)\b/.test(code)) return quotedTarget(raw);
+  return /^@import\s+([\w.]+)/.exec(code)?.[1] ?? null;
+}
+var OBJC = {
+  lex: { lineComments: ["//"], blockComment: ["/*", "*/"], quotes: `"'` },
+  match: matchObjc,
+  keywordClose: /^@end\b/,
+  preprocessor: true,
+  importOf,
+  docComments: true
+};
+function extractObjc(content, filePath) {
+  return scanBraceLanguage(content, filePath, OBJC);
+}
+
+// src/languages/perl.ts
+init_define_import_meta_env();
+var MAX_SYMBOLS5 = 1e4;
+var SUB_RE = /^\s*sub\s+([A-Za-z_][\w:']*)/;
+var PACKAGE_RE = /^\s*package\s+([A-Za-z_][\w:]*)/;
+var HEREDOC_RE = /<<(~?)(?:"([^"\n]*)"|'([^'\n]*)'|([A-Za-z_]\w*))/g;
+var Q_OPEN_RE = /(?<![\w$@%&])q[qwrx]?\s*([{([<])/g;
+var CLOSER = { "{": "}", "(": ")", "[": "]", "<": ">" };
+function stripComment(line) {
+  let quote = "";
+  for (let i = 0; i < line.length; i++) {
+    const c = line[i];
+    if (quote !== "") {
+      if (c === "\\") i++;
+      else if (c === quote) quote = "";
+    } else if (c === '"' || c === "'") {
+      quote = c;
+    } else if (c === "#" && line[i - 1] !== "$") {
+      return line.slice(0, i);
+    }
+  }
+  return line;
+}
+function maskStrings(code) {
+  const out = code.split("");
+  let quote = "";
+  for (let i = 0; i < code.length; i++) {
+    const c = code[i];
+    if (quote !== "") {
+      out[i] = " ";
+      if (c === "\\") {
+        if (i + 1 < code.length) out[i + 1] = " ";
+        i++;
+      } else if (c === quote) {
+        out[i] = c;
+        quote = "";
+      }
+    } else if (c === '"' || c === "'") {
+      quote = c;
+    }
+  }
+  return out.join("");
+}
+function balance(s, open) {
+  const close = CLOSER[open];
+  let n = 0;
+  for (const c of s) {
+    if (c === open) n++;
+    else if (c === close) n--;
+  }
+  return n;
+}
+function extractPerl(content, filePath) {
+  const lines = content.split(/\r?\n/);
+  const cls = new Array(lines.length).fill("skip");
+  const decls = [];
+  const imports = [];
+  let pod = false;
+  let heredocs = [];
+  let qOpen = null;
+  let pkg = "";
+  let last = lines.length;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (heredocs.length > 0) {
+      const h = heredocs[0];
+      if ((h.indented ? line.trim() : line) === h.term) heredocs = heredocs.slice(1);
+      continue;
+    }
+    if (pod) {
+      if (/^=cut\b/.test(line)) pod = false;
+      continue;
+    }
+    if (qOpen !== null) {
+      qOpen.depth += balance(line, qOpen.open);
+      if (qOpen.depth <= 0) qOpen = null;
+      continue;
+    }
+    if (/^=[A-Za-z]/.test(line)) {
+      pod = !/^=cut\b/.test(line);
+      continue;
+    }
+    if (/^__(?:END|DATA)__\s*$/.test(line)) {
+      last = i;
+      break;
+    }
+    const code = stripComment(line);
+    cls[i] = code.trim() === "" ? line.trim() === "" ? "blank" : "comment" : "code";
+    if (cls[i] !== "code") continue;
+    const sub = SUB_RE.exec(code);
+    const p = sub === null ? PACKAGE_RE.exec(code) : null;
+    if (sub !== null && decls.length < MAX_SYMBOLS5) {
+      const rest = code.slice(sub[0].length).replace(/^\s*\([^)]*\)/, "").trimStart();
+      if (!rest.startsWith(";")) {
+        const full = sub[1].replace(/'/g, "::");
+        const cut = full.lastIndexOf("::");
+        const name = cut < 0 ? full : full.slice(cut + 2);
+        const parent = cut < 0 ? pkg === "main" ? "" : pkg : full.slice(0, cut);
+        if (name !== "") decls.push({ name, kind: "sub", line: i, parent });
+      }
+    } else if (p !== null && decls.length < MAX_SYMBOLS5) {
+      pkg = p[1];
+      decls.push({ name: pkg, kind: "package", line: i, parent: "" });
+    } else {
+      const u = /^\s*(?:use|require)\s+([A-Za-z_][\w:]*)/.exec(code);
+      if (u !== null && /[A-Z]|::/.test(u[1])) imports.push({ kind: "import", target: u[1], line: i + 1 });
+    }
+    const scan = maskStrings(code);
+    const insideString = (index) => scan[index] === " " && code[index] !== " ";
+    HEREDOC_RE.lastIndex = 0;
+    for (let m = HEREDOC_RE.exec(code); m !== null; m = HEREDOC_RE.exec(code)) {
+      if (insideString(m.index)) continue;
+      heredocs.push({ term: m[2] ?? m[3] ?? m[4] ?? "", indented: m[1] === "~" });
+    }
+    Q_OPEN_RE.lastIndex = 0;
+    for (let m = Q_OPEN_RE.exec(code); m !== null; m = Q_OPEN_RE.exec(code)) {
+      if (insideString(m.index)) continue;
+      const open = m[1];
+      const depth = balance(scan.slice(m.index + m[0].length - 1), open);
+      if (depth > 0) {
+        qOpen = { open, depth };
+        break;
+      }
+    }
+  }
+  const symbols = decls.map((d, k) => {
+    let next = k + 1;
+    while (d.kind === "package" && next < decls.length && decls[next].kind !== "package") next++;
+    let end = next < decls.length ? decls[next].line - 1 : last - 1;
+    if (d.kind === "sub") {
+      let e = end;
+      while (e > d.line && !(cls[e] === "code" && stripComment(lines[e]).trimEnd().endsWith("}"))) e--;
+      end = e > d.line ? e : d.line;
+    }
+    while (end > d.line && cls[end] !== "code") end--;
+    return {
+      filePath,
+      name: d.name,
+      kind: d.kind,
+      lineStart: d.line + 1,
+      lineEnd: end + 1,
+      body: lines.slice(d.line, end + 1).join("\n"),
+      docstring: precedingDocComment(lines, d.line + 1, "hash"),
+      parent: d.kind === "sub" ? d.parent : ""
+    };
+  });
+  return { symbols, imports };
+}
+
+// src/languages/shader.ts
+init_define_import_meta_env();
+var TYPE_RE2 = /^(struct|class|namespace|enum)\s+(?:class\s+)?([A-Za-z_]\w*)(?:\s*:[^;{]*)?$/;
+var CBUFFER_RE = /^(cbuffer|tbuffer)\s+([A-Za-z_]\w*)/;
+var GLSL_BLOCK_QUALIFIERS = /* @__PURE__ */ new Set(["uniform", "buffer", "in", "out", "shared", "readonly", "writeonly", "coherent", "restrict", "volatile"]);
+function glslBlockName(code) {
+  let s = code;
+  if (s.startsWith("layout")) {
+    const close = s.indexOf(")");
+    if (close < 0) return "";
+    s = s.slice(close + 1);
+  }
+  const words = s.trim().replace(/\{\s*$/, "").trim().split(/\s+/);
+  let i = 0;
+  while (i < words.length && GLSL_BLOCK_QUALIFIERS.has(words[i])) i++;
+  return i > 0 && i === words.length - 1 && /^[A-Za-z_]\w*$/.test(words[i]) ? words[i] : "";
+}
+function matchCShader(code, ctx) {
+  if (ctx.scope !== "top" && ctx.scope !== "container") return null;
+  const t = TYPE_RE2.exec(withoutTrailingBrace(code));
+  if (t !== null) return { name: t[2], kind: t[1], container: t[1] !== "enum", end: "brace" };
+  const cb = CBUFFER_RE.exec(code);
+  if (cb !== null) return { name: cb[2], kind: cb[1], container: true, end: "brace" };
+  if (ctx.scope === "top") {
+    const block = glslBlockName(code);
+    if (block !== "") return { name: block, kind: "block", container: true, end: "brace" };
+  }
+  const fn = cFunctionHeader(code);
+  if (fn !== null) return { name: fn.name, kind: "function", end: "brace", dropPrototype: true, ...fn.qualifier === "" ? {} : { parent: fn.qualifier } };
+  return null;
+}
+var C_SHADER = {
+  lex: { lineComments: ["//"], blockComment: ["/*", "*/"], quotes: `"'` },
+  match: matchCShader,
+  preprocessor: true,
+  importOf: (code, raw) => /^#\s*include\b/.test(code) ? quotedTarget(raw) : null,
+  docComments: true
+};
+var WGSL_DECL_RE = /^(fn|struct|alias|const|override)\s+([A-Za-z_]\w*)/;
+var WGSL_VAR_RE = /^var(?:\s*<[^<>]*>)?\s+([A-Za-z_]\w*)/;
+function matchWgsl(code, ctx) {
+  if (ctx.scope !== "top") return null;
+  const s = stripLeadingWords(code, /* @__PURE__ */ new Set(), true);
+  const d = WGSL_DECL_RE.exec(s);
+  if (d !== null) {
+    const kind = d[1] === "fn" ? "function" : d[1];
+    return { name: d[2], kind, end: d[1] === "fn" || d[1] === "struct" ? "brace" : "line" };
+  }
+  const v = WGSL_VAR_RE.exec(s);
+  return v === null ? null : { name: v[1], kind: "var", end: "line" };
+}
+var WGSL = {
+  lex: { lineComments: ["//"], blockComment: ["/*", "*/"], nestedBlockComments: true, quotes: "" },
+  match: matchWgsl,
+  docComments: true
+};
+function extractCShader(content, filePath) {
+  return scanBraceLanguage(content, filePath, C_SHADER);
+}
+function extractWgsl(content, filePath) {
+  return scanBraceLanguage(content, filePath, WGSL);
+}
+
+// src/languages/solidity.ts
+init_define_import_meta_env();
+var CONTRACT_RE = /^(?:abstract\s+)?(contract|interface|library)\s+([A-Za-z_$][\w$]*)/;
+var FUNCTION_RE = /^function\s+([A-Za-z_$][\w$]*)/;
+var SPECIAL_FUNCTION_RE = /^(constructor|fallback|receive)\s*\(/;
+var MODIFIER_RE = /^modifier\s+([A-Za-z_$][\w$]*)/;
+var TYPE_RE3 = /^(struct|enum)\s+([A-Za-z_$][\w$]*)/;
+var LINE_RE = /^(event|error)\s+([A-Za-z_$][\w$]*)/;
+var VALUE_TYPE_RE = /^type\s+([A-Za-z_$][\w$]*)\s+is\b/;
+function matchSolidity(code, ctx) {
+  if (ctx.scope === "top") {
+    const c = CONTRACT_RE.exec(code);
+    if (c !== null) return { name: c[2], kind: c[1], container: true, end: "brace" };
+  }
+  if (ctx.scope !== "top" && ctx.scope !== "container") return null;
+  const f = FUNCTION_RE.exec(code);
+  if (f !== null) return { name: f[1], kind: "function", end: "brace" };
+  const sp = SPECIAL_FUNCTION_RE.exec(code);
+  if (sp !== null) return { name: sp[1], kind: sp[1] === "constructor" ? "constructor" : "function", end: "brace" };
+  const m = MODIFIER_RE.exec(code);
+  if (m !== null) return { name: m[1], kind: "modifier", end: "brace" };
+  const t = TYPE_RE3.exec(code);
+  if (t !== null) return { name: t[2], kind: t[1], end: "brace" };
+  const l = LINE_RE.exec(code);
+  if (l !== null) return { name: l[2], kind: l[1], end: "line" };
+  const v = VALUE_TYPE_RE.exec(code);
+  if (v !== null) return { name: v[1], kind: "type", end: "line" };
+  return null;
+}
+var SOLIDITY = {
+  lex: { lineComments: ["//"], blockComment: ["/*", "*/"], quotes: `"'` },
+  match: matchSolidity,
+  importOf: (code, raw) => /^import\b/.test(code) ? quotedTarget(raw) : null,
+  docComments: true
+};
+function extractSolidity(content, filePath) {
+  return scanBraceLanguage(content, filePath, SOLIDITY);
+}
+
+// src/languages/thrift.ts
+init_define_import_meta_env();
+var DEFINITION_RE = /^(struct|union|exception|service|enum|senum)\s+([A-Za-z_][\w.]*)/;
+function matchThrift(code, ctx) {
+  if (ctx.scope === "top") {
+    const d = DEFINITION_RE.exec(code);
+    if (d !== null) return { name: d[2], kind: d[1], container: true, end: "brace" };
+    if (/^typedef\s/.test(code)) {
+      const name = trailingIdentifier(trimEndChars(code, ";, 	"))?.name;
+      return name === void 0 ? null : { name, kind: "typedef", end: "line" };
+    }
+    if (/^const\s/.test(code) && code.includes("=")) {
+      const name = trailingIdentifier(code.slice(0, code.indexOf("=")).trimEnd())?.name;
+      return name === void 0 ? null : { name, kind: "const", end: "line" };
+    }
+    return null;
+  }
+  if (ctx.scope === "container" && ctx.parentKind === "service") {
+    const fn = cFunctionHeader(code);
+    if (fn !== null && fn.qualifier === "") return { name: fn.name, kind: "method", end: "line" };
+  }
+  return null;
+}
+var THRIFT = {
+  lex: { lineComments: ["//", "#"], blockComment: ["/*", "*/"], quotes: `"'` },
+  match: matchThrift,
+  importOf: (code, raw) => /^include\s/.test(code) ? quotedTarget(raw) : null,
+  docComments: true
+};
+function extractThrift(content, filePath) {
+  return scanBraceLanguage(content, filePath, THRIFT);
+}
+
+// src/languages/fortran.ts
+init_define_import_meta_env();
+import * as path2 from "node:path";
+var FIXED_FORM_EXTENSIONS = /* @__PURE__ */ new Set([".f", ".for", ".f77"]);
+var FIXED_TEXT_END = 72;
+var Buffers = class {
+  text = "";
+  raw = "";
+  add(ch, inString) {
+    this.raw += ch;
+    this.text += inString ? " " : ch;
+  }
+};
+function scanCode(body, buf, quote, onSemicolon) {
+  for (let j = 0; j < body.length; j++) {
+    const ch = body[j];
+    if (quote !== "") {
+      if (ch === quote) {
+        if (body[j + 1] === quote) {
+          buf.add(ch, true);
+          buf.add(ch, true);
+          j++;
+          continue;
+        }
+        quote = "";
+        buf.add(ch, false);
+        continue;
+      }
+      buf.add(ch, true);
+      continue;
+    }
+    if (ch === "!") break;
+    if (ch === "'" || ch === '"') {
+      quote = ch;
+      buf.add(ch, false);
+      continue;
+    }
+    if (ch === ";" && onSemicolon !== null) {
+      onSemicolon();
+      continue;
+    }
+    buf.add(ch, false);
+  }
+  return quote;
+}
+function preprocessorInclude(line, lineNo, imports) {
+  if (!/^[ \t]*#/.test(line)) return false;
+  const m = /^[ \t]*#[ \t]*include[ \t]*["<]([^">]+)[">]/.exec(line);
+  if (m !== null) imports.push({ kind: "include", target: m[1], line: lineNo });
+  return true;
+}
+function freeFormStatements(lines, imports) {
+  const out = [];
+  let buf = new Buffers();
+  let start = 0;
+  let end = 0;
+  let quote = "";
+  let continuing = false;
+  const flush = () => {
+    if (buf.text.trim() !== "") out.push({ text: buf.text.trim(), raw: buf.raw.trim(), line: start, endLine: end });
+    buf = new Buffers();
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNo = i + 1;
+    if (!continuing && preprocessorInclude(line, lineNo, imports)) continue;
+    let body = line;
+    if (continuing) {
+      const first = body.search(/\S/);
+      if (first >= 0 && body[first] === "&") body = body.slice(first + 1);
+    } else {
+      start = lineNo;
+    }
+    const before = buf.text.length;
+    quote = scanCode(body, buf, quote, () => {
+      end = lineNo;
+      flush();
+      start = lineNo;
+    });
+    const added = buf.text.slice(before);
+    const trimmed = added.trimEnd();
+    if (trimmed.endsWith("&")) {
+      const cut = added.length - trimmed.length + 1;
+      buf.text = buf.text.slice(0, buf.text.length - cut);
+      buf.raw = buf.raw.slice(0, buf.raw.length - cut);
+      continuing = true;
+      end = lineNo;
+      continue;
+    }
+    if (continuing && added.trim() === "") continue;
+    continuing = false;
+    quote = "";
+    end = lineNo;
+    flush();
+  }
+  flush();
+  return out;
+}
+function fixedFormStatements(lines, imports) {
+  const out = [];
+  let buf = new Buffers();
+  let start = 0;
+  let end = 0;
+  const flush = () => {
+    if (buf.text.trim() !== "") out.push({ text: buf.text.trim(), raw: buf.raw.trim(), line: start, endLine: end });
+    buf = new Buffers();
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNo = i + 1;
+    const c0 = line[0];
+    if (c0 === "C" || c0 === "c" || c0 === "*" || c0 === "!" || line.trim() === "") continue;
+    if (preprocessorInclude(line, lineNo, imports)) continue;
+    let textStart = 6;
+    let continuation;
+    const tab = line.indexOf("	");
+    if (tab >= 0 && tab < 6 && /^[ 0-9]*$/.test(line.slice(0, tab))) {
+      textStart = tab + 1;
+      continuation = /[1-9]/.test(line[textStart] ?? "");
+      if (continuation) textStart++;
+    } else {
+      const label = line.slice(0, 5);
+      if (label.includes("!")) continue;
+      continuation = line.length > 5 && line[5] !== " " && line[5] !== "0";
+    }
+    const body = line.slice(textStart, tab >= 0 && tab < 6 ? void 0 : FIXED_TEXT_END);
+    if (!continuation) {
+      flush();
+      start = lineNo;
+    }
+    scanCode(body, buf, "", () => {
+      end = lineNo;
+      flush();
+      start = lineNo;
+    });
+    end = lineNo;
+  }
+  flush();
+  return out;
+}
+function hasFreeFormSignal(line) {
+  return /^[A-BD-Za-bd-z_&]/.test(line) || line.includes("::") || /&[ \t]*$/.test(line);
+}
+function hasFixedFormSignal(line) {
+  const c0 = line[0];
+  if (c0 === "C" || c0 === "c" || c0 === "*") return true;
+  if (line.length > 72) return true;
+  return line.length > 5 && /^[ \d]{5}$/.test(line.slice(0, 5)) && line[5] !== " " && line[5] !== "0";
+}
+function isFixedForm(filePath, lines) {
+  if (!FIXED_FORM_EXTENSIONS.has(path2.extname(filePath).toLowerCase())) return false;
+  if (lines.some(hasFreeFormSignal)) return false;
+  return lines.some(hasFixedFormSignal);
+}
+function isIdentStart(ch) {
+  return /[A-Za-z]/.test(ch);
+}
+function tokenize(s) {
+  const out = [];
+  let i = 0;
+  while (i < s.length) {
+    const ch = s[i];
+    if (ch === " " || ch === "	" || ch === "\r") {
+      i++;
+      continue;
+    }
+    if (isIdentStart(ch)) {
+      let j = i + 1;
+      while (j < s.length && /\w/.test(s[j])) j++;
+      out.push(s.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (/[0-9]/.test(ch)) {
+      let j = i + 1;
+      while (j < s.length && /[0-9]/.test(s[j])) j++;
+      out.push(s.slice(i, j));
+      i = j;
+      continue;
+    }
+    if (ch === ":" && s[i + 1] === ":" || ch === "=" && s[i + 1] === ">") {
+      out.push(s.slice(i, i + 2));
+      i += 2;
+      continue;
+    }
+    out.push(ch);
+    i++;
+  }
+  return out;
+}
+function isIdent(tok) {
+  return tok !== void 0 && isIdentStart(tok[0]);
+}
+function skipGroup(toks, k) {
+  let depth = 0;
+  for (; k < toks.length; k++) {
+    if (toks[k] === "(") depth++;
+    else if (toks[k] === ")" && --depth === 0) return k + 1;
+  }
+  return k;
+}
+function hasTopLevelEquals(toks) {
+  let depth = 0;
+  for (const t of toks) {
+    if (t === "(" || t === "[") depth++;
+    else if (t === ")" || t === "]") depth = Math.max(0, depth - 1);
+    else if (t === "=" && depth === 0) return true;
+  }
+  return false;
+}
+var PROCEDURE_PREFIXES = /* @__PURE__ */ new Set(["RECURSIVE", "NON_RECURSIVE", "PURE", "IMPURE", "ELEMENTAL", "MODULE"]);
+var TYPE_SPECS = /* @__PURE__ */ new Set(["INTEGER", "REAL", "COMPLEX", "LOGICAL", "CHARACTER", "DOUBLEPRECISION", "DOUBLECOMPLEX", "BYTE"]);
+function skipKind(toks, k) {
+  if (toks[k] === "(") return skipGroup(toks, k);
+  if (toks[k] === "*") return toks[k + 1] === "(" ? skipGroup(toks, k + 1) : k + 2;
+  return k;
+}
+function procedureHeader(toks) {
+  let k = 0;
+  while (k < toks.length) {
+    const u = toks[k].toUpperCase();
+    if (PROCEDURE_PREFIXES.has(u)) {
+      k++;
+    } else if (u === "DOUBLE" && /^(?:PRECISION|COMPLEX)$/i.test(toks[k + 1] ?? "")) {
+      k = skipKind(toks, k + 2);
+    } else if (TYPE_SPECS.has(u)) {
+      k = skipKind(toks, k + 1);
+    } else if ((u === "TYPE" || u === "CLASS") && toks[k + 1] === "(") {
+      k = skipGroup(toks, k + 1);
+    } else {
+      break;
+    }
+  }
+  const kw = toks[k]?.toUpperCase();
+  if (kw !== "SUBROUTINE" && kw !== "FUNCTION") return null;
+  const name = toks[k + 1];
+  const after = toks[k + 2]?.toUpperCase();
+  if (!isIdent(name) || after !== void 0 && after !== "(" && after !== "RESULT" && after !== "BIND") return null;
+  return { kind: kw === "SUBROUTINE" ? "subroutine" : "function", name };
+}
+function typeDefinitionName(toks) {
+  if (toks[0]?.toUpperCase() !== "TYPE") return null;
+  let k = 1;
+  if (toks[1] === "," || toks[1] === "::") {
+    k = toks.indexOf("::");
+    if (k < 0) return null;
+    k++;
+  } else if (toks[1]?.toUpperCase() === "IS") {
+    return null;
+  }
+  const name = toks[k];
+  if (!isIdent(name)) return null;
+  const after = toks[k + 1];
+  return after === void 0 || after === "(" ? name : null;
+}
+var END_KINDS = [
+  ["BLOCKDATA", "block_data"],
+  ["SUBMODULE", "submodule"],
+  ["SUBROUTINE", "subroutine"],
+  ["FUNCTION", "function"],
+  ["PROGRAM", "program"],
+  ["MODULE", "module"],
+  ["PROCEDURE", "procedure"],
+  ["INTERFACE", "interface"],
+  ["TYPE", "type"]
+];
+function extractFortran(content, filePath) {
+  const spans = new SpanCollector(filePath);
+  if (content.includes("\0")) return { symbols: [], imports: [] };
+  const rawLines = content.split(/\r?\n/);
+  const imports = [];
+  const statements = isFixedForm(filePath, rawLines) ? fixedFormStatements(rawLines, imports) : freeFormStatements(rawLines, imports);
+  const stack = [];
+  let previous = 0;
+  const parent = () => {
+    for (let k = stack.length - 1; k >= 0; k--) if (stack[k].index !== void 0) return spans.name(stack[k].index);
+    return "";
+  };
+  const inInterface = () => stack.length > 0 && stack[stack.length - 1].role === "interface";
+  const open = (name, kind, role, line, named = true) => {
+    const index = named && name !== void 0 && !inInterface() ? spans.open(name, kind, line, parent()) : void 0;
+    stack.push({ index, kind, role });
+  };
+  const closeTo = (match, end) => {
+    let k = stack.length - 1;
+    while (k >= 0 && !match(stack[k])) k--;
+    if (k < 0) return;
+    while (stack.length > k) spans.close(stack.pop().index, end);
+  };
+  for (const st of statements) {
+    let toks = tokenize(st.text);
+    if (toks.length > 1 && /^[0-9]+$/.test(toks[0])) toks = toks.slice(1);
+    if (toks.length === 0) continue;
+    const u0 = toks[0].toUpperCase();
+    previous = st.endLine;
+    const compact = toks.join("").toUpperCase();
+    if (/^END\w*$/.test(compact)) {
+      const rest = compact.slice(3);
+      if (rest === "") {
+        closeTo((f) => f.role === "unit", st.endLine);
+      } else {
+        const hit = END_KINDS.find(([kw]) => rest.startsWith(kw));
+        if (hit !== void 0 && !(hit[0] === "TYPE" && rest !== "TYPE" && !isIdent(rest.slice(4)))) closeTo((f) => f.kind === hit[1], st.endLine);
+      }
+      continue;
+    }
+    if (u0 === "USE") {
+      let k = 1;
+      if (toks[k] === ",") k += 2;
+      if (toks[k] === "::") k++;
+      if (isIdent(toks[k])) imports.push({ kind: "import", target: toks[k], line: st.line });
+      continue;
+    }
+    if (u0 === "INCLUDE") {
+      const m = /^include\s*(['"])([^'"]+)\1/i.exec(st.raw);
+      if (m !== null) imports.push({ kind: "include", target: m[2], line: st.line });
+      continue;
+    }
+    if (hasTopLevelEquals(toks)) continue;
+    const u1 = toks[1]?.toUpperCase();
+    if (u0 === "PROGRAM" && isIdent(toks[1]) && toks.length === 2) {
+      open(toks[1], "program", "unit", st.line);
+    } else if (u0 === "MODULE" && u1 === "PROCEDURE") {
+      if (!inInterface() && isIdent(toks[2]) && toks.length === 3) open(toks[2], "procedure", "unit", st.line);
+    } else if (u0 === "MODULE" && isIdent(toks[1]) && toks.length === 2 && u1 !== "FUNCTION" && u1 !== "SUBROUTINE") {
+      open(toks[1], "module", "unit", st.line);
+    } else if (u0 === "SUBMODULE" && toks[1] === "(") {
+      const k = skipGroup(toks, 1);
+      if (isIdent(toks[k]) && toks.length === k + 1) open(toks[k], "submodule", "unit", st.line);
+    } else if (u0 === "BLOCK" && u1 === "DATA" || u0 === "BLOCKDATA") {
+      const name = toks[u0 === "BLOCK" ? 2 : 1];
+      open(name, "block_data", "unit", st.line, isIdent(name));
+    } else if (u0 === "INTERFACE" || u0 === "ABSTRACT" && u1 === "INTERFACE") {
+      const named = u0 === "INTERFACE" && isIdent(toks[1]) && toks.length === 2;
+      open(toks[1], "interface", "interface", st.line, named);
+    } else if (u0 === "TYPE" && typeDefinitionName(toks) !== null) {
+      open(typeDefinitionName(toks), "type", "type", st.line);
+    } else {
+      const header = procedureHeader(toks);
+      if (header !== null) open(header.name, header.kind, "unit", st.line);
+    }
+  }
+  while (stack.length > 0) spans.close(stack.pop().index, previous);
+  return { symbols: spans.finish(rawLines), imports };
+}
+
+// src/languages/pascal.ts
+init_define_import_meta_env();
+import * as path3 from "node:path";
+var MAX_DEPTH = 32;
+function tokenize2(src) {
+  const toks = [];
+  let line = 1;
+  let i = 0;
+  const n = src.length;
+  const push = (type, text, at) => {
+    toks.push({ type, text, upper: text.toUpperCase(), line: at });
+  };
+  const countLines = (from, to) => {
+    for (let k = from; k < to; k++) if (src.charCodeAt(k) === 10) line++;
+  };
+  while (i < n) {
+    const ch = src[i];
+    if (ch === "\n") {
+      line++;
+      i++;
+      continue;
+    }
+    if (ch === " " || ch === "	" || ch === "\r" || ch === "\f") {
+      i++;
+      continue;
+    }
+    if (ch === "{") {
+      const end = src.indexOf("}", i + 1);
+      const stop = end < 0 ? n : end + 1;
+      countLines(i, stop);
+      i = stop;
+      continue;
+    }
+    if (ch === "(" && src[i + 1] === "*") {
+      const end = src.indexOf("*)", i + 2);
+      const stop = end < 0 ? n : end + 2;
+      countLines(i, stop);
+      i = stop;
+      continue;
+    }
+    if (ch === "/" && src[i + 1] === "/") {
+      const end = src.indexOf("\n", i);
+      i = end < 0 ? n : end;
+      continue;
+    }
+    if (ch === "'" || ch === "#") {
+      const at = line;
+      while (i < n && (src[i] === "'" || src[i] === "#")) {
+        if (src[i] === "#") {
+          i++;
+          while (i < n && /[$\w]/.test(src[i])) i++;
+          continue;
+        }
+        i++;
+        while (i < n && src[i] !== "\n") {
+          if (src[i] === "'") {
+            if (src[i + 1] === "'") {
+              i += 2;
+              continue;
+            }
+            break;
+          }
+          i++;
+        }
+        if (src[i] === "'") i++;
+      }
+      push("str", "'", at);
+      continue;
+    }
+    if (/[A-Za-z_&]/.test(ch)) {
+      let j = i + 1;
+      while (j < n && /\w/.test(src[j])) j++;
+      const text = src.slice(ch === "&" ? i + 1 : i, j);
+      if (text !== "") push("id", text, line);
+      i = j;
+      continue;
+    }
+    if (/[0-9$%]/.test(ch)) {
+      let j = i + 1;
+      while (j < n && /[\w.]/.test(src[j]) && !(src[j] === "." && src[j + 1] === ".")) j++;
+      push("num", src.slice(i, j), line);
+      i = j;
+      continue;
+    }
+    const two = src.slice(i, i + 2);
+    if (two === ":=" || two === ".." || two === "<=" || two === ">=" || two === "<>") {
+      push("sym", two, line);
+      i += 2;
+      continue;
+    }
+    push("sym", ch, line);
+    i++;
+  }
+  return toks;
+}
+var ROUTINE_WORDS = /* @__PURE__ */ new Set(["PROCEDURE", "FUNCTION", "CONSTRUCTOR", "DESTRUCTOR", "OPERATOR"]);
+var VISIBILITY = /* @__PURE__ */ new Set(["PRIVATE", "PROTECTED", "PUBLIC", "PUBLISHED", "STRICT", "AUTOMATED"]);
+var SECTION_WORDS = /* @__PURE__ */ new Set([
+  "VAR",
+  "CONST",
+  "RESOURCESTRING",
+  "THREADVAR",
+  "LABEL",
+  "EXPORTS",
+  "IMPLEMENTATION",
+  "INITIALIZATION",
+  "FINALIZATION",
+  "BEGIN",
+  "ASM",
+  "END",
+  "USES",
+  "PROPERTY",
+  "CLASS",
+  ...ROUTINE_WORDS,
+  ...VISIBILITY
+]);
+var DIRECTIVES = /* @__PURE__ */ new Set([
+  "OVERLOAD",
+  "OVERRIDE",
+  "VIRTUAL",
+  "DYNAMIC",
+  "ABSTRACT",
+  "REINTRODUCE",
+  "STATIC",
+  "INLINE",
+  "CDECL",
+  "STDCALL",
+  "REGISTER",
+  "PASCAL",
+  "SAFECALL",
+  "WINAPI",
+  "EXPORT",
+  "FORWARD",
+  "EXTERNAL",
+  "ASSEMBLER",
+  "DEPRECATED",
+  "PLATFORM",
+  "LIBRARY",
+  "EXPERIMENTAL",
+  "FINAL",
+  "VARARGS",
+  "MESSAGE",
+  "DISPID",
+  "FAR",
+  "NEAR",
+  "NOSTACKFRAME",
+  "CPPDECL",
+  "ALIAS",
+  "NORETURN",
+  "UNIMPLEMENTED",
+  "INTERRUPT",
+  "MWPASCAL",
+  "MS_ABI_DEFAULT",
+  "SYSV_ABI_DEFAULT",
+  "VECTORCALL",
+  "DELAYED"
+]);
+var HEADER_WORDS = /* @__PURE__ */ new Set(["PROGRAM", "UNIT", "LIBRARY", "PACKAGE"]);
+var IMPORT_WORDS = /* @__PURE__ */ new Set(["USES", "REQUIRES", "CONTAINS"]);
+var MEMBER_KINDS2 = { PROCEDURE: "method", FUNCTION: "method", CONSTRUCTOR: "constructor", DESTRUCTOR: "destructor", OPERATOR: "operator" };
+var PascalParser = class {
+  constructor(toks, spans) {
+    this.toks = toks;
+    this.spans = spans;
+  }
+  toks;
+  spans;
+  p = 0;
+  imports = [];
+  // Symbols that are declarations inside a class, keyed so an implementation can replace them.
+  declarations = /* @__PURE__ */ new Map();
+  implementations = /* @__PURE__ */ new Set();
+  at(k = 0) {
+    return this.toks[this.p + k];
+  }
+  upper(k = 0) {
+    return this.toks[this.p + k]?.upper ?? "";
+  }
+  isSym(text, k = 0) {
+    const t = this.toks[this.p + k];
+    return t !== void 0 && t.type === "sym" && t.text === text;
+  }
+  lastLine() {
+    return this.toks[Math.min(this.p, this.toks.length) - 1]?.line ?? 1;
+  }
+  /** Advance past the next `;` outside brackets, returning that `;`'s line. */
+  skipStatement() {
+    let depth = 0;
+    while (this.p < this.toks.length) {
+      const t = this.toks[this.p++];
+      if (t.type !== "sym") continue;
+      if (t.text === "(" || t.text === "[") depth++;
+      else if (t.text === ")" || t.text === "]") depth = Math.max(0, depth - 1);
+      else if (t.text === ";" && depth === 0) return t.line;
+    }
+    return this.lastLine();
+  }
+  /** Advance past a balanced `(...)`, `[...]` or `<...>` group starting at the current token. */
+  skipGroup(open, close) {
+    let depth = 0;
+    while (this.p < this.toks.length) {
+      const t = this.toks[this.p++];
+      if (t.type !== "sym") continue;
+      if (t.text === open) depth++;
+      else if (t.text === close && --depth === 0) return;
+      else if (t.text === ";" && open === "<") return;
+    }
+  }
+  /** A dotted name with generic parameters removed: `TList<T>.Add` gives ['TList', 'Add']. */
+  dottedName() {
+    const parts = [];
+    while (this.at()?.type === "id") {
+      parts.push(this.at().text);
+      this.p++;
+      if (this.isSym("<")) this.skipGroup("<", ">");
+      if (this.isSym(".") && this.at(1)?.type === "id") this.p++;
+      else break;
+    }
+    return parts;
+  }
+  /** True when the routine keyword at the current token starts a declaration rather than a procedural type or anonymous method. */
+  isRoutineStart() {
+    let k = this.p - 1;
+    if (this.toks[k]?.upper === "CLASS") k--;
+    const prev = this.toks[k];
+    if (prev === void 0) return true;
+    if (prev.type === "sym") return prev.text === ";" || prev.text === "]";
+    return prev.upper === "IMPLEMENTATION" || prev.upper === "INTERFACE" || VISIBILITY.has(prev.upper);
+  }
+  /** Skip the directives after a routine header; true when one of them says the routine has no body here. */
+  skipDirectives() {
+    let bodiless = false;
+    for (; ; ) {
+      if (this.isSym("[")) {
+        this.skipGroup("[", "]");
+        continue;
+      }
+      const u = this.upper();
+      if (this.at()?.type !== "id" || !DIRECTIVES.has(u)) return bodiless;
+      if (u === "FORWARD" || u === "EXTERNAL") bodiless = true;
+      this.skipStatement();
+    }
+  }
+  /** Parse a routine header at a routine keyword (after any `class`); the cursor ends past its `;`. */
+  routineHeader() {
+    if (this.upper() === "CLASS") this.p++;
+    const word = this.upper();
+    const line = this.at().line;
+    this.p++;
+    let parts = this.dottedName();
+    if (parts.length === 0 && word === "OPERATOR" && this.at()?.type === "sym") parts = [this.toks[this.p++].text];
+    const end = this.skipStatement();
+    return { word, parts, line, end };
+  }
+  /** A routine in a unit's implementation part or a program, with its nested routines, to the `end` that closes its body. */
+  routine(parent, depth) {
+    const h = this.routineHeader();
+    const bodiless = this.skipDirectives();
+    if (bodiless || h.parts.length === 0) return;
+    const name = h.parts[h.parts.length - 1];
+    const qualifier = h.parts.length > 1 ? h.parts[h.parts.length - 2] : "";
+    const kind = qualifier === "" ? h.word.toLowerCase() : MEMBER_KINDS2[h.word];
+    const index = this.spans.open(name, kind, h.line, qualifier === "" ? parent : qualifier);
+    if (qualifier !== "") this.implementations.add(`${qualifier.toUpperCase()}.${name.toUpperCase()}`);
+    if (depth >= MAX_DEPTH) return;
+    while (this.p < this.toks.length) {
+      const u = this.upper();
+      if (u === "BEGIN" || u === "ASM") break;
+      if (this.at().type === "id" && (ROUTINE_WORDS.has(u) || u === "CLASS" && ROUTINE_WORDS.has(this.upper(1))) && this.isRoutineStart()) {
+        this.routine(this.spans.name(index) || parent, depth + 1);
+        continue;
+      }
+      if (u === "TYPE" && this.at().type === "id") {
+        this.typeSection(this.spans.name(index), depth + 1);
+        continue;
+      }
+      this.p++;
+    }
+    this.spans.close(index, this.block());
+  }
+  /** Skip a `begin` or `asm` block to its balancing `end`, returning that line. */
+  block() {
+    let depth = 0;
+    while (this.p < this.toks.length) {
+      const t = this.toks[this.p++];
+      if (t.type !== "id") continue;
+      if (t.upper === "BEGIN" || t.upper === "CASE" || t.upper === "TRY" || t.upper === "ASM") depth++;
+      else if (t.upper === "END" && --depth <= 0) return t.line;
+    }
+    return this.lastLine();
+  }
+  /** A `type` section: each declaration of a class, record, object, interface or enumeration becomes a symbol under `parent`. */
+  typeSection(parent, depth) {
+    this.p++;
+    while (this.p < this.toks.length) {
+      const t = this.at();
+      if (this.isSym("[")) {
+        this.skipGroup("[", "]");
+        continue;
+      }
+      if (t.type === "id" && SECTION_WORDS.has(t.upper)) return;
+      if (t.type === "id" && t.upper === "TYPE") {
+        this.p++;
+        continue;
+      }
+      if (t.type !== "id" || !(this.isSym("=", 1) || this.isSym("<", 1))) {
+        this.p++;
+        continue;
+      }
+      this.p++;
+      if (this.isSym("<")) this.skipGroup("<", ">");
+      if (!this.isSym("=")) continue;
+      this.p++;
+      this.typeDefinition(t, parent, depth);
+    }
+  }
+  typeDefinition(name, parent, depth) {
+    while (this.upper() === "PACKED" || this.upper() === "BITPACKED") this.p++;
+    const u = this.upper();
+    if (u === "CLASS") {
+      this.p++;
+      if (this.isSym(";") || this.upper() === "OF") {
+        this.skipStatement();
+        return;
+      }
+      while (this.upper() === "SEALED" || this.upper() === "ABSTRACT") this.p++;
+      if (this.upper() === "HELPER") {
+        this.p++;
+        if (this.isSym("(")) this.skipGroup("(", ")");
+        if (this.upper() === "FOR") this.p++;
+        this.dottedName();
+      }
+      if (this.isSym("(")) this.skipGroup("(", ")");
+      if (this.isSym(";")) {
+        this.spans.close(this.spans.open(name.text, "class", name.line, parent), this.toks[this.p++].line);
+        return;
+      }
+      this.body(name, "class", parent, depth);
+      return;
+    }
+    if (u === "RECORD" || u === "OBJECT") {
+      this.p++;
+      if (this.upper() === "HELPER") {
+        this.p++;
+        if (this.upper() === "FOR") this.p++;
+        this.dottedName();
+      }
+      if (u === "OBJECT" && this.isSym("(")) this.skipGroup("(", ")");
+      this.body(name, u.toLowerCase(), parent, depth);
+      return;
+    }
+    if (u === "INTERFACE" || u === "DISPINTERFACE") {
+      this.p++;
+      if (this.isSym(";")) {
+        this.p++;
+        return;
+      }
+      if (this.isSym("(")) this.skipGroup("(", ")");
+      this.body(name, "interface", parent, depth);
+      return;
+    }
+    if (this.isSym("(")) {
+      this.skipGroup("(", ")");
+      const end = this.isSym(";") ? this.toks[this.p++].line : this.lastLine();
+      this.spans.close(this.spans.open(name.text, "enum", name.line, parent), end);
+      return;
+    }
+    let records = 0;
+    let brackets = 0;
+    while (this.p < this.toks.length) {
+      const t = this.toks[this.p++];
+      if (t.type === "id" && t.upper === "RECORD") records++;
+      else if (t.type === "id" && t.upper === "END") records = Math.max(0, records - 1);
+      else if (t.type === "sym" && (t.text === "(" || t.text === "[")) brackets++;
+      else if (t.type === "sym" && (t.text === ")" || t.text === "]")) brackets = Math.max(0, brackets - 1);
+      else if (t.type === "sym" && t.text === ";" && records === 0 && brackets === 0) return;
+    }
+  }
+  /** The members of a class, record, object or interface body, up to its `end`. */
+  body(name, kind, parent, depth) {
+    const index = this.spans.open(name.text, kind, name.line, parent);
+    const owner = this.spans.name(index);
+    let records = 0;
+    while (this.p < this.toks.length) {
+      const t = this.at();
+      if (t.type !== "id") {
+        if (this.isSym("[")) this.skipGroup("[", "]");
+        else this.p++;
+        continue;
+      }
+      if (t.upper === "END") {
+        this.p++;
+        if (records > 0) {
+          records--;
+          continue;
+        }
+        this.spans.close(index, t.line);
+        if (this.isSym(";")) this.p++;
+        return;
+      }
+      if (t.upper === "RECORD") {
+        records++;
+        this.p++;
+        continue;
+      }
+      if (records === 0 && (ROUTINE_WORDS.has(t.upper) || t.upper === "CLASS" && ROUTINE_WORDS.has(this.upper(1)))) {
+        this.member(owner);
+        continue;
+      }
+      if (records === 0 && t.upper === "PROPERTY" && this.at(1)?.type === "id") {
+        const prop = this.at(1);
+        this.p += 2;
+        let end = this.skipStatement();
+        if (this.upper() === "DEFAULT" && this.isSym(";", 1)) {
+          end = this.toks[this.p + 1].line;
+          this.p += 2;
+        }
+        this.spans.close(this.spans.open(prop.text, "property", prop.line, owner), end);
+        continue;
+      }
+      if (records === 0 && t.upper === "TYPE" && depth < MAX_DEPTH) {
+        this.typeSection(owner, depth + 1);
+        continue;
+      }
+      this.p++;
+    }
+    this.spans.close(index, this.lastLine());
+  }
+  member(owner) {
+    const h = this.routineHeader();
+    if (h.parts.length !== 1) return;
+    const end = this.skipMemberDirectives(h.end);
+    const index = this.spans.open(h.parts[0], MEMBER_KINDS2[h.word], h.line, owner);
+    this.spans.close(index, end);
+    if (index !== void 0) this.declarations.set(index, `${owner.toUpperCase()}.${h.parts[0].toUpperCase()}`);
+  }
+  /** Like skipDirectives, but returns the line the last directive ended on. */
+  skipMemberDirectives(end) {
+    for (; ; ) {
+      if (this.at()?.type !== "id" || !DIRECTIVES.has(this.upper())) return end;
+      end = this.skipStatement();
+    }
+  }
+  parse() {
+    let header;
+    let inInterface = false;
+    if (this.at()?.type === "id" && HEADER_WORDS.has(this.upper())) {
+      const word = this.upper().toLowerCase();
+      const line = this.at().line;
+      this.p++;
+      const parts = this.dottedName();
+      header = this.spans.open(parts.join("."), word, line);
+      this.skipStatement();
+    }
+    while (this.p < this.toks.length) {
+      const t = this.at();
+      if (t.type !== "id") {
+        this.p++;
+        continue;
+      }
+      const u = t.upper;
+      if (IMPORT_WORDS.has(u) && this.importAllowed()) {
+        this.p++;
+        this.importList(u);
+        continue;
+      }
+      if (u === "INTERFACE") inInterface = true;
+      else if (u === "IMPLEMENTATION") inInterface = false;
+      if (u === "TYPE") {
+        this.typeSection("", 0);
+        continue;
+      }
+      if ((ROUTINE_WORDS.has(u) || u === "CLASS" && ROUTINE_WORDS.has(this.upper(1))) && this.isRoutineStart()) {
+        if (inInterface) {
+          this.routineHeader();
+          this.skipDirectives();
+        } else {
+          this.routine("", 0);
+        }
+        continue;
+      }
+      if (u === "BEGIN" || u === "ASM") {
+        this.block();
+        if (this.isSym(".")) {
+          this.spans.close(header, this.toks[this.p - 1].line);
+          header = void 0;
+          break;
+        }
+        continue;
+      }
+      if (u === "END" && this.isSym(".", 1)) {
+        this.spans.close(header, t.line);
+        header = void 0;
+        break;
+      }
+      this.p++;
+    }
+    this.spans.close(header, this.lastLine());
+  }
+  importAllowed() {
+    const prev = this.toks[this.p - 1];
+    return prev === void 0 || prev.type === "sym" && prev.text === ";" || prev.upper === "INTERFACE" || prev.upper === "IMPLEMENTATION";
+  }
+  importList(word) {
+    while (this.p < this.toks.length) {
+      const line = this.at().line;
+      const parts = this.dottedName();
+      if (parts.length > 0) this.imports.push({ kind: word === "USES" ? "import" : word.toLowerCase(), target: parts.join("."), line });
+      if (this.upper() === "IN") this.p += 2;
+      if (this.isSym(",")) {
+        this.p++;
+        continue;
+      }
+      this.skipStatement();
+      return;
+    }
+  }
+};
+var DFM_OBJECT_RE = /^(?:object|inherited|inline)[ \t]+([A-Za-z_]\w*)/i;
+function extractDfm(content, filePath) {
+  const spans = new SpanCollector(filePath);
+  const text = content.charCodeAt(0) === 65279 ? content.slice(1) : content;
+  if (text.startsWith("TPF0") || text.includes("\0") || text.charCodeAt(0) === 65533 || text.charCodeAt(0) === 255) return { symbols: [], imports: [] };
+  const rawLines = text.split(/\r?\n/);
+  const stack = [];
+  const owner = () => {
+    for (let k = stack.length - 1; k >= 0; k--) if (stack[k] !== void 0) return spans.name(stack[k]);
+    return "";
+  };
+  for (let i = 0; i < rawLines.length; i++) {
+    const line = rawLines[i].trim();
+    const m = DFM_OBJECT_RE.exec(line);
+    if (m !== null) {
+      stack.push(spans.open(m[1], "component", i + 1, owner()));
+    } else if (/^item$/i.test(line)) {
+      stack.push(void 0);
+    } else if (/^end>?$/i.test(line) && stack.length > 0) {
+      spans.close(stack.pop(), i + 1);
+    }
+  }
+  while (stack.length > 0) spans.close(stack.pop(), rawLines.length);
+  return { symbols: spans.finish(rawLines), imports: [] };
+}
+function extractPascal(content, filePath) {
+  if (path3.extname(filePath).toLowerCase() === ".dfm") return extractDfm(content, filePath);
+  if (content.includes("\0")) return { symbols: [], imports: [] };
+  const spans = new SpanCollector(filePath);
+  const parser = new PascalParser(tokenize2(content), spans);
+  parser.parse();
+  const rawLines = content.split(/\r?\n/);
+  const symbols = spans.finish(rawLines);
+  const dropped = /* @__PURE__ */ new Set();
+  for (const [index, key] of parser.declarations) if (parser.implementations.has(key)) dropped.add(index);
+  return { symbols: symbols.filter((_, k) => !dropped.has(k)), imports: parser.imports };
+}
+
+// src/languages/matlab.ts
+init_define_import_meta_env();
+var FUNCTION_RE2 = /^function\b\s*(?:(?:\[[^\]]*\]|[A-Za-z]\w*)\s*=\s*)?([A-Za-z]\w*(?:\.[A-Za-z]\w*)*)/;
+var CLASSDEF_RE = /^classdef\b\s*(?:\([^)]*\)\s*)?([A-Za-z]\w*)/;
+var BLOCK_RE = /^(properties|methods|events|enumeration)\s*(?:\(.*\))?$/;
+var ARGUMENTS_RE = /^arguments\s*(?:\(.*\))?$/;
+var IMPORT_RE2 = /^import\s+([A-Za-z]\w*(?:\.(?:[A-Za-z]\w*|\*))*)/;
+var CONTROL_OPENERS = /* @__PURE__ */ new Set(["if", "for", "parfor", "while", "switch", "try", "spmd", "do", "unwind_protect"]);
+var CLOSERS2 = /* @__PURE__ */ new Set([
+  "end",
+  "endfunction",
+  "endif",
+  "endfor",
+  "endparfor",
+  "endwhile",
+  "endswitch",
+  "end_try_catch",
+  "end_unwind_protect",
+  "endclassdef",
+  "endproperties",
+  "endmethods",
+  "endevents",
+  "endenumeration",
+  "endspmd",
+  "until"
+]);
+function isNameChar(ch) {
+  return ch !== void 0 && /[\w.)\]}']/.test(ch);
+}
+function statementsOf(lines) {
+  const out = [];
+  let text = "";
+  let start = 0;
+  let brackets = 0;
+  let parens = 0;
+  let blockComment = 0;
+  const flush = (end) => {
+    const t = text.trim();
+    if (t !== "") out.push({ text: t, line: start, endLine: end });
+    text = "";
+    parens = 0;
+  };
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNo = i + 1;
+    const trimmed = line.trim();
+    if (trimmed === "%{" || trimmed === "#{") {
+      blockComment++;
+      continue;
+    }
+    if (blockComment > 0) {
+      if (trimmed === "%}" || trimmed === "#}") blockComment--;
+      continue;
+    }
+    if (text === "") start = lineNo;
+    let continued = false;
+    let quote = "";
+    for (let j = 0; j < line.length; j++) {
+      const ch = line[j];
+      if (quote !== "") {
+        if (ch === quote) {
+          if (line[j + 1] === quote) {
+            text += "  ";
+            j++;
+            continue;
+          }
+          quote = "";
+          text += ch;
+          continue;
+        }
+        text += " ";
+        continue;
+      }
+      if (ch === "%" || ch === "#") break;
+      if (ch === "." && line.startsWith("...", j)) {
+        continued = true;
+        break;
+      }
+      if (ch === '"' || ch === "'" && !isNameChar(line[j - 1])) {
+        quote = ch;
+        text += ch;
+        continue;
+      }
+      if (ch === "[" || ch === "{") brackets++;
+      else if (ch === "]" || ch === "}") brackets = Math.max(0, brackets - 1);
+      else if (ch === "(") parens++;
+      else if (ch === ")") parens = Math.max(0, parens - 1);
+      else if ((ch === "," || ch === ";") && brackets === 0 && parens === 0) {
+        flush(lineNo);
+        start = lineNo;
+        continue;
+      }
+      text += ch;
+    }
+    if (continued || brackets > 0) {
+      text += " ";
+      continue;
+    }
+    flush(lineNo);
+  }
+  flush(lines.length);
+  return out;
+}
+function firstWord(text) {
+  return /^[A-Za-z_]\w*/.exec(text)?.[0] ?? "";
+}
+function functionsAreEndless(statements) {
+  let opens = 0;
+  let closes = 0;
+  let functions = 0;
+  for (const st of statements) {
+    const w = firstWord(st.text);
+    if (w === "classdef") return false;
+    if (w === "function" && FUNCTION_RE2.test(st.text)) {
+      functions++;
+      opens++;
+    } else if (CONTROL_OPENERS.has(w) || ARGUMENTS_RE.test(st.text)) {
+      opens++;
+    } else if (CLOSERS2.has(w) && st.text === w) {
+      closes++;
+    }
+  }
+  return functions > 0 && opens - closes >= functions;
+}
+function extractMatlab(content, filePath) {
+  const spans = new SpanCollector(filePath);
+  if (content.includes("\0")) return { symbols: [], imports: [] };
+  const rawLines = content.split(/\r?\n/);
+  const statements = statementsOf(rawLines);
+  const endless = functionsAreEndless(statements);
+  const imports = [];
+  const stack = [];
+  let previous = 0;
+  const top = () => stack[stack.length - 1];
+  const nearest = (words) => {
+    for (let k = stack.length - 1; k >= 0; k--) if (words.has(stack[k].word)) return stack[k];
+    return void 0;
+  };
+  const push = (word, index, isEndless = false) => {
+    stack.push({ word, index, endless: isEndless, sawStatement: false });
+  };
+  const OWNERS = /* @__PURE__ */ new Set(["function", "methods"]);
+  const CLASS = /* @__PURE__ */ new Set(["classdef"]);
+  for (const st of statements) {
+    const w = firstWord(st.text);
+    const frame = top();
+    if (CLOSERS2.has(w) && (st.text === w || w === "until")) {
+      if (frame !== void 0 && !frame.endless) spans.close(stack.pop().index, st.endLine);
+      previous = st.endLine;
+      continue;
+    }
+    if (w === "function") {
+      const m = FUNCTION_RE2.exec(st.text);
+      if (m !== null) {
+        if (endless) {
+          while (stack.length > 0) spans.close(stack.pop().index, previous);
+        }
+        const owner = nearest(OWNERS);
+        const isMethod = owner?.word === "methods";
+        const parent = isMethod ? spans.name(nearest(CLASS)?.index) : spans.name(owner?.index);
+        push("function", spans.open(m[1], isMethod ? "method" : "function", st.line, parent), endless);
+        previous = st.endLine;
+        continue;
+      }
+    }
+    if (w === "classdef") {
+      const m = CLASSDEF_RE.exec(st.text);
+      if (m !== null) {
+        push("classdef", spans.open(m[1], "class", st.line));
+        previous = st.endLine;
+        continue;
+      }
+    }
+    if (frame?.word === "classdef" && BLOCK_RE.test(st.text)) {
+      push(w, void 0);
+    } else if (frame?.word === "function" && !frame.sawStatement && ARGUMENTS_RE.test(st.text)) {
+      push("arguments", void 0);
+    } else if (CONTROL_OPENERS.has(w) && !/^\w+\s*=[^=]/.test(st.text)) {
+      push(w, void 0);
+    } else if (frame !== void 0 && (frame.word === "properties" || frame.word === "events" || frame.word === "enumeration") && w !== "") {
+      const kind = frame.word === "properties" ? "property" : frame.word === "events" ? "event" : "enum_member";
+      const cls = spans.name(nearest(CLASS)?.index);
+      spans.close(spans.open(w, kind, st.line, cls), st.endLine);
+    } else if (w === "import") {
+      const m = IMPORT_RE2.exec(st.text);
+      if (m !== null) imports.push({ kind: "import", target: m[1], line: st.line });
+    }
+    if (frame !== void 0 && w !== "arguments") frame.sawStatement = true;
+    previous = st.endLine;
+  }
+  while (stack.length > 0) spans.close(stack.pop().index, previous);
+  return { symbols: spans.finish(rawLines), imports };
+}
+
+// src/languages/cmake.ts
+init_define_import_meta_env();
+var MAX_ARGS = 2;
+var TARGET_COMMANDS = /* @__PURE__ */ new Set(["add_library", "add_executable", "add_custom_target"]);
+var IMPORT_KINDS = { include: "include", add_subdirectory: "subdirectory", find_package: "package" };
+function bracketClose(src, i) {
+  if (src[i] !== "[") return -1;
+  let j = i + 1;
+  while (src[j] === "=") j++;
+  if (src[j] !== "[") return -1;
+  const close = `]${"=".repeat(j - i - 1)}]`;
+  const end = src.indexOf(close, j + 1);
+  return end < 0 ? src.length : end + close.length;
+}
+function commandsOf(src) {
+  const lineStarts = [0];
+  for (let k = 0; k < src.length; k++) if (src.charCodeAt(k) === 10) lineStarts.push(k + 1);
+  const lineAt = (offset) => {
+    let lo = 0;
+    let hi = lineStarts.length - 1;
+    while (lo < hi) {
+      const mid = lo + hi + 1 >> 1;
+      if (lineStarts[mid] <= offset) lo = mid;
+      else hi = mid - 1;
+    }
+    return lo + 1;
+  };
+  const out = [];
+  let i = 0;
+  const n = src.length;
+  const skipComment = (at) => {
+    const b = bracketClose(src, at + 1);
+    if (b >= 0) return b;
+    const nl = src.indexOf("\n", at);
+    return nl < 0 ? n : nl;
+  };
+  while (i < n) {
+    const ch = src[i];
+    if (ch === "#") {
+      i = skipComment(i);
+      continue;
+    }
+    if (!/[A-Za-z_]/.test(ch)) {
+      i++;
+      continue;
+    }
+    const start = i;
+    while (i < n && /\w/.test(src[i])) i++;
+    const name = src.slice(start, i).toLowerCase();
+    while (src[i] === " " || src[i] === "	") i++;
+    if (src[i] !== "(") continue;
+    i++;
+    const args = [];
+    let depth = 1;
+    while (i < n && depth > 0) {
+      const c = src[i];
+      if (c === "(") {
+        depth++;
+        i++;
+      } else if (c === ")") {
+        depth--;
+        i++;
+      } else if (c === "#") {
+        i = skipComment(i);
+      } else if (c === '"') {
+        let j = i + 1;
+        while (j < n && src[j] !== '"') j += src[j] === "\\" ? 2 : 1;
+        if (args.length < MAX_ARGS) args.push(src.slice(i + 1, j));
+        i = j + 1;
+      } else if (c === "[" && bracketClose(src, i) >= 0) {
+        const end = bracketClose(src, i);
+        if (args.length < MAX_ARGS) args.push("");
+        i = end;
+      } else if (/\s/.test(c)) {
+        i++;
+      } else {
+        let j = i;
+        while (j < n && !/[\s()#"]/.test(src[j])) j += src[j] === "\\" ? 2 : 1;
+        if (args.length < MAX_ARGS) args.push(src.slice(i, j));
+        i = j;
+      }
+    }
+    out.push({ name, args, line: lineAt(start), endLine: lineAt(Math.max(start, i - 1)) });
+  }
+  return out;
+}
+function extractCmake(content, filePath) {
+  const spans = new SpanCollector(filePath);
+  if (content.includes("\0")) return { symbols: [], imports: [] };
+  const rawLines = content.split(/\r?\n/);
+  const imports = [];
+  const stack = [];
+  let last = 0;
+  const parent = () => {
+    for (let k = stack.length - 1; k >= 0; k--) if (stack[k].index !== void 0) return spans.name(stack[k].index);
+    return "";
+  };
+  for (const cmd of commandsOf(content)) {
+    last = cmd.endLine;
+    const first = cmd.args[0] ?? "";
+    const literal = first !== "" && !first.includes("${");
+    if (cmd.name === "function" || cmd.name === "macro") {
+      stack.push({ kind: cmd.name, index: literal ? spans.open(first, cmd.name, cmd.line, parent()) : void 0 });
+    } else if (cmd.name === "endfunction" || cmd.name === "endmacro") {
+      const kind = cmd.name.slice(3);
+      let k = stack.length - 1;
+      while (k >= 0 && stack[k].kind !== kind) k--;
+      if (k >= 0) while (stack.length > k) spans.close(stack.pop().index, cmd.endLine);
+    } else if (TARGET_COMMANDS.has(cmd.name) || cmd.name === "project") {
+      if (literal) spans.close(spans.open(first, cmd.name === "project" ? "project" : "target", cmd.line, parent()), cmd.endLine);
+    } else if (IMPORT_KINDS[cmd.name] !== void 0 && Object.hasOwn(IMPORT_KINDS, cmd.name)) {
+      if (literal) imports.push({ kind: IMPORT_KINDS[cmd.name], target: first, line: cmd.line });
+    }
+  }
+  while (stack.length > 0) spans.close(stack.pop().index, last);
+  return { symbols: spans.finish(rawLines), imports };
+}
+
+// src/languages/asm.ts
+init_define_import_meta_env();
+var HLASM_MARKER_RE = /^(?:[A-Z@#$][A-Z0-9@#$_]*)?[ \t]+(?:CSECT|DSECT|RSECT|MACRO|MEND)(?:[ \t]|$)/;
+var HLASM_STATEMENT_COLUMNS = 71;
+var LABEL_RE2 = /^[ \t]*([A-Za-z_$?.][A-Za-z0-9_$#@~?.]*):/;
+var GAS_MACRO_RE = /^[ \t]*\.macro[ \t]+([A-Za-z_$.][A-Za-z0-9_$.]*)/;
+var GAS_ENDM_RE = /^[ \t]*\.endm\b/;
+var NASM_MACRO_RE = /^[ \t]*%i?macro[ \t]+([A-Za-z_$?.][A-Za-z0-9_$#@~?.]*)/i;
+var NASM_ENDMACRO_RE = /^[ \t]*%i?endmacro\b/i;
+var NASM_STRUC_RE = /^[ \t]*struc[ \t]+([A-Za-z_$?.][A-Za-z0-9_$#@~?.]*)/i;
+var NASM_ENDSTRUC_RE = /^[ \t]*endstruc\b/i;
+var INCLUDE_RE2 = /^[ \t]*(?:\.include|%include)[ \t]+"([^"]*)"/i;
+var HLASM_STATEMENT_RE = /^(\S*)[ \t]+(\S+)/;
+function isHlasmSource(content) {
+  for (const raw of content.split(/\r?\n/)) {
+    if (raw.startsWith("*")) continue;
+    if (HLASM_MARKER_RE.test(raw.slice(0, HLASM_STATEMENT_COLUMNS))) return true;
+  }
+  return false;
+}
+function stripComment2(line, inBlock) {
+  let out = "";
+  let block = inBlock;
+  let i = 0;
+  let quote = "";
+  while (i < line.length) {
+    const ch = line[i];
+    if (block) {
+      if (ch === "*" && line[i + 1] === "/") {
+        block = false;
+        i += 2;
+        continue;
+      }
+      i++;
+      continue;
+    }
+    if (quote !== "") {
+      if (ch === "\\") {
+        out += "  ";
+        i += 2;
+        continue;
+      }
+      if (ch === quote) quote = "";
+      out += ch;
+      i++;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      quote = ch;
+      out += ch;
+      i++;
+      continue;
+    }
+    if (ch === "/" && line[i + 1] === "*") {
+      block = true;
+      i += 2;
+      continue;
+    }
+    if (ch === ";" || ch === "#" || ch === "/" && line[i + 1] === "/") break;
+    out += ch;
+    i++;
+  }
+  return { code: out, inBlock: block };
+}
+function extractGasNasm(rawLines, spans, imports) {
+  const stack = [];
+  let label;
+  let inBlock = false;
+  const parent = () => stack.length === 0 ? "" : spans.name(stack[stack.length - 1].index);
+  const endLabel = (end) => {
+    spans.close(label, end);
+    label = void 0;
+  };
+  for (let i = 0; i < rawLines.length; i++) {
+    const line = i + 1;
+    const stripped = stripComment2(rawLines[i], inBlock);
+    inBlock = stripped.inBlock;
+    const code = stripped.code;
+    if (code.trim() === "") continue;
+    const include = INCLUDE_RE2.exec(code);
+    if (include) {
+      imports.push({ kind: "include", target: include[1], line });
+      continue;
+    }
+    const open = GAS_MACRO_RE.exec(code) ?? NASM_MACRO_RE.exec(code);
+    if (open) {
+      endLabel(line - 1);
+      stack.push({ index: spans.open(open[1], "macro", line, parent()), kind: "macro" });
+      continue;
+    }
+    const struc = NASM_STRUC_RE.exec(code);
+    if (struc) {
+      endLabel(line - 1);
+      stack.push({ index: spans.open(struc[1], "struct", line, parent()), kind: "struct" });
+      continue;
+    }
+    if (GAS_ENDM_RE.test(code) || NASM_ENDMACRO_RE.test(code) || NASM_ENDSTRUC_RE.test(code)) {
+      endLabel(line - 1);
+      const frame = stack.pop();
+      if (frame !== void 0) spans.close(frame.index, line);
+      continue;
+    }
+    const found = LABEL_RE2.exec(code);
+    if (found) {
+      const name = found[1];
+      if (name.startsWith(".")) continue;
+      endLabel(line - 1);
+      label = spans.open(name, "label", line, parent());
+    }
+  }
+  endLabel(lastContentLine(rawLines));
+  for (const frame of stack) spans.close(frame.index, lastContentLine(rawLines));
+}
+function extractHlasm(rawLines, spans) {
+  let section;
+  let macro;
+  let macroStart = 0;
+  let awaitingPrototype = false;
+  let continued = false;
+  for (let i = 0; i < rawLines.length; i++) {
+    const raw = rawLines[i];
+    const line = i + 1;
+    const statement = raw.slice(0, HLASM_STATEMENT_COLUMNS);
+    const continues = raw.length > HLASM_STATEMENT_COLUMNS && raw[HLASM_STATEMENT_COLUMNS].trim() !== "";
+    if (continued) {
+      continued = continues;
+      continue;
+    }
+    continued = continues;
+    if (statement.startsWith("*") || statement.startsWith(".*")) continue;
+    if (statement.trim() === "") continue;
+    const m = HLASM_STATEMENT_RE.exec(statement);
+    if (!m) continue;
+    const name = m[1];
+    const op = m[2].toUpperCase();
+    if (awaitingPrototype) {
+      awaitingPrototype = false;
+      macro = spans.open(op, "macro", macroStart, spans.name(section));
+      continue;
+    }
+    if (op === "MACRO") {
+      awaitingPrototype = true;
+      macroStart = line;
+      continue;
+    }
+    if (op === "MEND") {
+      spans.close(macro, line);
+      macro = void 0;
+      continue;
+    }
+    if (macro !== void 0) continue;
+    if (op === "CSECT" || op === "RSECT" || op === "START" || op === "DSECT") {
+      spans.close(section, line - 1);
+      section = name === "" ? void 0 : spans.open(name, op === "DSECT" ? "dummy section" : "section", line);
+      continue;
+    }
+    if (op === "END") {
+      spans.close(section, line);
+      section = void 0;
+    }
+  }
+  spans.close(macro, lastContentLine(rawLines));
+  spans.close(section, lastContentLine(rawLines));
+}
+function extractAsm(content, filePath) {
+  const imports = [];
+  const spans = new SpanCollector(filePath);
+  if (content.includes("\0")) return { symbols: [], imports };
+  const rawLines = content.split(/\r?\n/);
+  if (isHlasmSource(content)) extractHlasm(rawLines, spans);
+  else extractGasNasm(rawLines, spans, imports);
+  return { symbols: spans.finish(rawLines), imports };
+}
+
+// src/languages/batch.ts
+init_define_import_meta_env();
+var LABEL_RE3 = /^:([A-Za-z0-9_.$#@[\]{}-][^\s;=,]*)/;
+var REM_RE = /^rem(?:[\s]|$)/i;
+var CALL_RE = /(?:^|[\s&(])call[\s]+(?:"([^"]+\.(?:bat|cmd))"|([^\s"&|<>]+\.(?:bat|cmd)))/i;
+function extractBatch(content, filePath) {
+  const imports = [];
+  const spans = new SpanCollector(filePath);
+  if (content.includes("\0")) return { symbols: [], imports };
+  const rawLines = content.split(/\r?\n/);
+  let label;
+  for (let i = 0; i < rawLines.length; i++) {
+    const line = i + 1;
+    const text = rawLines[i].replace(/^[\s@]+/, "");
+    if (text === "") continue;
+    const found = LABEL_RE3.exec(text);
+    if (found) {
+      spans.close(label, line - 1);
+      label = spans.open(found[1], "label", line);
+      continue;
+    }
+    if (text.startsWith(":") || REM_RE.test(text)) continue;
+    const call = CALL_RE.exec(text);
+    if (call) imports.push({ kind: "call", target: call[1] ?? call[2], line });
+  }
+  spans.close(label, lastContentLine(rawLines));
+  return { symbols: spans.finish(rawLines), imports };
+}
+
+// src/languages/erlang.ts
+init_define_import_meta_env();
+var HEAD_CHARS = 512;
+var MODULE_RE = /^-\s*module\s*\(\s*(?:'([^'\n]*)'|([a-z][A-Za-z0-9_@]*))/;
+var RECORD_RE = /^-\s*record\s*\(\s*(?:'([^'\n]*)'|([a-z][A-Za-z0-9_@]*))/;
+var DEFINE_RE = /^-\s*define\s*\(\s*([A-Za-z_][A-Za-z0-9_@]*)/;
+var TYPE_RE4 = /^-\s*(?:type|opaque)\s+(?:'([^'\n]*)'|([a-z][A-Za-z0-9_@]*))\s*\(/;
+var INCLUDE_RE3 = /^-\s*(include_lib|include)\s*\(\s*"([^"\n]*)"/;
+var IMPORT_RE3 = /^-\s*import\s*\(\s*(?:'([^'\n]*)'|([a-z][A-Za-z0-9_@]*))/;
+var FUNCTION_RE3 = /^(?:'([^'\n]*)'|([a-z][A-Za-z0-9_@]*))\s*\(/;
+function formsOf(content) {
+  const out = [];
+  let line = 1;
+  let startOffset = -1;
+  let startLine = 1;
+  let depth = 0;
+  for (let i = 0; i < content.length; i++) {
+    const ch = content[i];
+    if (ch === "\n") {
+      line++;
+      continue;
+    }
+    if (ch === "%") {
+      const nl = content.indexOf("\n", i);
+      i = nl < 0 ? content.length : nl - 1;
+      continue;
+    }
+    if (ch === "$") {
+      i += content[i + 1] === "\\" ? 2 : 1;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      const close = ch;
+      i++;
+      while (i < content.length && content[i] !== close) {
+        if (content[i] === "\n") line++;
+        if (content[i] === "\\") i++;
+        i++;
+      }
+      continue;
+    }
+    if (startOffset < 0 && !/\s/.test(ch)) {
+      startOffset = i;
+      startLine = line;
+    }
+    if (ch === "(" || ch === "[" || ch === "{") depth++;
+    else if (ch === ")" || ch === "]" || ch === "}") depth = Math.max(0, depth - 1);
+    else if (ch === "." && depth === 0) {
+      const next = content[i + 1];
+      if (next === void 0 || /\s/.test(next)) {
+        if (startOffset >= 0) out.push({ head: content.slice(startOffset, startOffset + HEAD_CHARS), line: startLine, endLine: line });
+        startOffset = -1;
+      }
+    }
+  }
+  if (startOffset >= 0) out.push({ head: content.slice(startOffset, startOffset + HEAD_CHARS), line: startLine, endLine: line });
+  return out;
+}
+function extractErlang(content, filePath) {
+  const imports = [];
+  const spans = new SpanCollector(filePath);
+  if (content.includes("\0")) return { symbols: [], imports };
+  const rawLines = content.split(/\r?\n/);
+  for (const form of formsOf(content)) {
+    const head = form.head;
+    const emit = (name, kind) => {
+      spans.close(spans.open(name, kind, form.line), form.endLine);
+    };
+    const include = INCLUDE_RE3.exec(head);
+    if (include) {
+      imports.push({ kind: include[1].toLowerCase(), target: include[2], line: form.line });
+      continue;
+    }
+    const imported = IMPORT_RE3.exec(head);
+    if (imported) {
+      imports.push({ kind: "import", target: imported[1] ?? imported[2], line: form.line });
+      continue;
+    }
+    const named = (re) => {
+      const m = re.exec(head);
+      return m === null ? void 0 : m[1] ?? m[2];
+    };
+    const module = named(MODULE_RE);
+    if (module !== void 0) {
+      emit(module, "module");
+      continue;
+    }
+    const record = named(RECORD_RE);
+    if (record !== void 0) {
+      emit(record, "record");
+      continue;
+    }
+    const define = DEFINE_RE.exec(head);
+    if (define) {
+      emit(define[1], "macro");
+      continue;
+    }
+    const type = named(TYPE_RE4);
+    if (type !== void 0) {
+      emit(type, "type");
+      continue;
+    }
+    if (head.startsWith("-")) continue;
+    const fn = named(FUNCTION_RE3);
+    if (fn !== void 0) emit(fn, "function");
+  }
+  return { symbols: spans.finish(rawLines), imports };
+}
+
+export {
+  stripLeadingAttributes,
+  IMPORT_RE,
+  extractSwift,
+  extractCobol,
+  extractNatural,
+  SpanCollector,
+  extractAbap,
+  extractAbl,
+  extractJcl,
+  extractPli,
+  extractRpg,
+  extractSas,
+  extractGroovy,
+  extractObjc,
+  extractPerl,
+  extractCShader,
+  extractWgsl,
+  extractSolidity,
+  extractThrift,
+  extractFortran,
+  extractPascal,
+  extractMatlab,
+  extractCmake,
+  extractAsm,
+  extractBatch,
+  extractErlang
+};