@lzehrung/codegraph 3.0.1 → 3.1.1

package/dist/bin/query-index-worker.js

@@ -148,17 +148,6 @@ var PYTHON_ROW = {
     { prefix: PYTHON_PLAIN_PREFIX, open: "'", close: "'", escape: "\\" }
   ]
 };
-var CSHARP_ROW = {
-  lineComments: ["//"],
-  blockComments: [SLASH_STAR_COMMENT],
-  strings: [
-    // A verbatim (or interpolated verbatim) string doubles its closing quote; the backslash is data.
-    { prefix: "(?:[$][@]|[@][$]|[@])", open: '"', close: '"', doubled: true },
-    { open: '"""', close: '"""', quoteRun: true },
-    { open: '"', close: '"', escape: "\\" },
-    { open: "'", close: "'", escape: "\\" }
-  ]
-};
 var GO_ROW = {
   lineComments: ["//"],
   blockComments: [SLASH_STAR_COMMENT],
@@ -212,31 +201,16 @@ var SWIFT_ROW = {
     { hashes: true, open: '"', close: '"' }
   ]
 };
-var KOTLIN_ROW = {
-  lineComments: ["//"],
-  blockComments: [NESTED_SLASH_STAR_COMMENT],
-  strings: [
-    { open: '"""', close: '"""', interpolation: { start: "${", end: "}" } },
-    { open: '"', close: '"', escape: "\\", interpolation: { start: "${", end: "}" } },
-    { open: "'", close: "'", escape: "\\" }
-  ]
-};
-var ZIG_ROW = {
+var SCSS_ROW = {
   lineComments: ["//"],
-  blockComments: [],
-  strings: [
-    { open: '"', close: '"', escape: "\\" },
-    { open: "'", close: "'", escape: "\\" }
-  ],
-  zigMultiline: true
-};
-var CSS_FAMILY_ROW = {
-  lineComments: [],
   blockComments: [SLASH_STAR_COMMENT],
   strings: [
-    { open: "'", close: "'", escape: "\\" },
-    { open: '"', close: '"', escape: "\\" }
-  ]
+    { open: "'", close: "'", escape: "\\", interpolation: { start: "#{", end: "}", excludeFromMask: true } },
+    { open: '"', close: '"', escape: "\\", interpolation: { start: "#{", end: "}", excludeFromMask: true } }
+  ],
+  unquotedCssUrl: true,
+  commentInterpolation: { start: "#{", end: "}", excludeFromMask: true },
+  unquotedEscapes: true
 };
 var C_FAMILY_ROW = {
   lineComments: ["//"],
@@ -246,29 +220,6 @@ var C_FAMILY_ROW = {
     { open: "'", close: "'", escape: "\\" }
   ]
 };
-var JAVA_ROW = {
-  lineComments: ["//"],
-  blockComments: [SLASH_STAR_COMMENT],
-  strings: [
-    { open: '"""', close: '"""', escape: "\\" },
-    { open: '"', close: '"', escape: "\\" },
-    { open: "'", close: "'", escape: "\\" }
-  ]
-};
-var SQL_ROW = {
-  lineComments: ["--"],
-  blockComments: [SLASH_STAR_COMMENT],
-  strings: [
-    { open: "'", close: "'", doubled: true },
-    { open: '"', close: '"', doubled: true }
-  ]
-};
-var TERRAFORM_ROW = {
-  lineComments: ["#", "//"],
-  blockComments: [SLASH_STAR_COMMENT],
-  strings: [{ open: '"', close: '"', escape: "\\", interpolation: { start: "${", end: "}" } }],
-  heredocs: [{ opener: "<<-?([A-Za-z_][A-Za-z0-9_-]*)", indentedTerminator: true }]
-};
 var TRIVIA_ROWS = {
   js: JS_LIKE_ROW,
   ts: JS_LIKE_ROW,
@@ -277,31 +228,49 @@ var TRIVIA_ROWS = {
   typescript: JS_LIKE_ROW,
   jsx: JS_LIKE_ROW,
   python: PYTHON_ROW,
-  csharp: CSHARP_ROW,
   go: GO_ROW,
   rust: RUST_ROW,
   php: PHP_ROW,
   ruby: RUBY_ROW,
   swift: SWIFT_ROW,
-  kotlin: KOTLIN_ROW,
-  zig: ZIG_ROW,
-  css: CSS_FAMILY_ROW,
-  less: CSS_FAMILY_ROW,
-  scss: CSS_FAMILY_ROW,
-  c: C_FAMILY_ROW,
-  cpp: C_FAMILY_ROW,
-  java: JAVA_ROW,
-  sql: SQL_ROW,
-  terraform: TERRAFORM_ROW
+  scss: SCSS_ROW,
+  cpp: C_FAMILY_ROW
 };
 function triviaRowFor(languageId) {
   return TRIVIA_ROWS[languageId] ?? JS_LIKE_ROW;
 }
 
 // dist/util/trivia.js
+function isHexUnit(unit) {
+  return unit >= 48 && unit <= 57 || unit >= 65 && unit <= 70 || unit >= 97 && unit <= 102;
+}
+function skipScssEscape(source, index) {
+  const next = index + 1;
+  if (next >= source.length)
+    return source.length;
+  const unit = source.charCodeAt(next);
+  if (unit === 10 || unit === 12)
+    return next + 1;
+  if (unit === 13)
+    return source.charCodeAt(next + 1) === 10 ? next + 2 : next + 1;
+  if (isHexUnit(unit)) {
+    let cursor = next + 1;
+    const limit = Math.min(source.length, next + 6);
+    while (cursor < limit && isHexUnit(source.charCodeAt(cursor)))
+      cursor += 1;
+    const space = source.charCodeAt(cursor);
+    if (space === 32 || space === 9 || space === 10 || space === 12)
+      return cursor + 1;
+    if (space === 13)
+      return source.charCodeAt(cursor + 1) === 10 ? cursor + 2 : cursor + 1;
+    return cursor;
+  }
+  return next + 1;
+}
 function maskTrivia(source, languageId, options) {
   const mask = buildMarkedMask(source, languageId, {
     maskStrings: options?.maskStrings ?? true,
+    maskCssUrls: options?.maskCssUrls ?? false,
     mode: "render"
   });
   let out = "";
@@ -331,14 +300,32 @@ function buildMarkedMask(source, languageId, options) {
   const length = source.length;
   let index = 0;
   while (index < length) {
+    if (row.unquotedEscapes && source.charCodeAt(index) === 92) {
+      index = skipScssEscape(source, index);
+      continue;
+    }
     if (!starters[source.charCodeAt(index)]) {
       index += 1;
       continue;
     }
+    const cssUrl = row.unquotedCssUrl ? unquotedCssUrlConstruct(source, row, index) : null;
+    if (cssUrl !== null) {
+      if (options.maskCssUrls && options.maskStrings) {
+        for (const [start, end] of constructSpans(cssUrl, options.mode)) {
+          for (let i = start; i < end; i += 1)
+            mask[i] = 1;
+        }
+      }
+      index = cssUrl.end;
+      continue;
+    }
     const commentEnd = commentSpanEnd(source, row, index);
     if (commentEnd !== null) {
-      for (let i = index; i < commentEnd; i += 1)
-        mask[i] = 1;
+      const spans = options.mode === "holes" && row.commentInterpolation ? loudCommentMaskSpans(source, row, index, commentEnd) : [[index, commentEnd]];
+      for (const [start, end] of spans) {
+        for (let i = start; i < end; i += 1)
+          mask[i] = 1;
+      }
       index = commentEnd;
       continue;
     }
@@ -371,6 +358,81 @@ function constructSpans(construct, mode) {
     return construct.renderSpans;
   return construct.maskSpans;
 }
+function isCssIdentifierUnit(unit) {
+  const isLetterOrDigit = unit >= 48 && unit <= 57 || unit >= 65 && unit <= 90 || unit >= 97 && unit <= 122;
+  return isLetterOrDigit || unit === 95 || unit === 45 || unit === 92 || unit >= 128;
+}
+function isCssSpaceUnit(unit) {
+  return unit === 32 || unit === 9 || unit === 10 || unit === 13 || unit === 12;
+}
+var CSS_URL_INTERPOLATION = {
+  start: "#{",
+  end: "}",
+  excludeFromMask: true
+};
+function unquotedCssUrlConstruct(source, row, index) {
+  if (source.charCodeAt(index + 3) !== 40 || (source.charCodeAt(index) | 32) !== 117 || (source.charCodeAt(index + 1) | 32) !== 114 || (source.charCodeAt(index + 2) | 32) !== 108) {
+    return null;
+  }
+  if (index > 0 && source.charCodeAt(index - 1) === 46)
+    return null;
+  if (index > 0 && isCssIdentifierUnit(source.charCodeAt(index - 1)))
+    return null;
+  const bodyStart = index + 4;
+  const holes = [];
+  const holeTrivia = [];
+  let cursor = bodyStart;
+  while (cursor < source.length && isCssSpaceUnit(source.charCodeAt(cursor)))
+    cursor += 1;
+  while (cursor < source.length) {
+    const unit = source.charCodeAt(cursor);
+    if (unit === 41) {
+      const maskSpans = [[index, bodyStart]];
+      let segmentStart = bodyStart;
+      for (const [holeStart, holeEnd] of holes) {
+        if (segmentStart < holeStart)
+          maskSpans.push([segmentStart, holeStart]);
+        segmentStart = holeEnd;
+      }
+      if (segmentStart < cursor)
+        maskSpans.push([segmentStart, cursor]);
+      for (const span of holeTrivia)
+        maskSpans.push(span);
+      maskSpans.push([cursor, cursor + 1]);
+      return {
+        start: index,
+        end: cursor + 1,
+        renderSpans: bodyStart < cursor ? [[bodyStart, cursor]] : [],
+        maskSpans,
+        delimitersAreTrivia: false
+      };
+    }
+    if (isCssSpaceUnit(unit)) {
+      while (cursor < source.length && isCssSpaceUnit(source.charCodeAt(cursor)))
+        cursor += 1;
+      if (source.charCodeAt(cursor) !== 41)
+        return null;
+      continue;
+    }
+    if (unit === 92) {
+      cursor = skipScssEscape(source, cursor);
+      continue;
+    }
+    if (unit === 35 && source.charCodeAt(cursor + 1) === 123) {
+      const hole = collectInterpolationSpans(source, row, cursor, CSS_URL_INTERPOLATION);
+      holes.push([cursor, hole.end]);
+      for (const span of hole.spans)
+        holeTrivia.push(span);
+      cursor = hole.end;
+      continue;
+    }
+    const isUrlUnit = unit === 33 || unit === 37 || unit === 38 || unit === 35 || unit >= 42 && unit <= 126 || unit >= 128;
+    if (!isUrlUnit)
+      return null;
+    cursor += 1;
+  }
+  return null;
+}
 var starterCache = /* @__PURE__ */ new WeakMap();
 var prefixRegexCache = /* @__PURE__ */ new WeakMap();
 var openerRegexCache = /* @__PURE__ */ new WeakMap();
@@ -402,8 +464,10 @@ function rowStarterCodes(row) {
   }
   if (row.percentLiterals)
     add("%");
-  if (row.zigMultiline)
-    add("\\");
+  if (row.unquotedCssUrl) {
+    add("u");
+    add("U");
+  }
   starterCache.set(row, starters);
   return starters;
 }
@@ -451,11 +515,45 @@ function nextTriviaConstruct(source, row, index) {
     if (percentConstruct !== null)
       return percentConstruct;
   }
-  if (row.zigMultiline && source.startsWith("\\\\", index)) {
-    return zigMultilineConstruct(source, index);
-  }
   return null;
 }
+function loudCommentMaskSpans(source, row, index, commentEnd) {
+  const interpolation = row.commentInterpolation;
+  if (!interpolation || !source.startsWith("/*", index))
+    return [[index, commentEnd]];
+  const spans = [];
+  let cursor = index;
+  let segmentStart = index;
+  while (cursor < commentEnd) {
+    if (source.startsWith(interpolation.start, cursor)) {
+      if (segmentStart < cursor)
+        spans.push([segmentStart, cursor]);
+      const inner = collectInterpolationSpans(source, row, cursor, interpolation);
+      const end = Math.min(inner.end, commentEnd);
+      if (end <= cursor) {
+        cursor += 1;
+        segmentStart = cursor;
+        continue;
+      }
+      spans.push([cursor, Math.min(cursor + interpolation.start.length, end)]);
+      for (const span of inner.spans) {
+        const start = Math.max(span[0], cursor);
+        const stop = Math.min(span[1], end);
+        if (start < stop)
+          spans.push([start, stop]);
+      }
+      if (end > cursor && end <= commentEnd && source.charCodeAt(end - 1) === 125)
+        spans.push([end - 1, end]);
+      cursor = end;
+      segmentStart = cursor;
+      continue;
+    }
+    cursor += 1;
+  }
+  if (segmentStart < commentEnd)
+    spans.push([segmentStart, commentEnd]);
+  return spans;
+}
 function commentSpanEnd(source, row, index) {
   for (const prefix of row.lineComments) {
     if (source.startsWith(prefix, index))
@@ -559,22 +657,6 @@ function quotedStringConstruct(source, row, form, index) {
       maskSpans: [[index, charEnd]],
       delimitersAreTrivia: false
     };
-  } else if (form.quoteRun) {
-    let run = 0;
-    while (source[cursor + run] === form.open[0])
-      run += 1;
-    if (run < form.open.length)
-      return null;
-    const scanned = quoteRunStringEnd(source, cursor + run, form.open[0] ?? '"', run);
-    const bodyStart2 = cursor + run;
-    const body2 = [bodyStart2, scanned.closeStart];
-    return {
-      start: index,
-      end: scanned.end,
-      renderSpans: body2[0] < body2[1] ? [body2] : [],
-      maskSpans: [[index, scanned.end]],
-      delimitersAreTrivia: false
-    };
   } else {
     if (!source.startsWith(form.open, cursor))
       return null;
@@ -610,6 +692,8 @@ function collectQuotedBody(source, row, form, start, close, hashCount) {
         if (interpolation.excludeFromMask) {
           pushSegment(cursor);
           const inner = collectInterpolationSpans(source, row, cursor, interpolation);
+          for (const span of inner.spans)
+            segments.push(span);
           cursor = inner.end;
           segmentStart = cursor;
           continue;
@@ -664,22 +748,6 @@ function charLiteralEnd(source, quoteIndex, form) {
     return cursor + 2;
   return null;
 }
-function quoteRunStringEnd(source, index, quote, runLength) {
-  let cursor = index;
-  while (cursor < source.length) {
-    if (source[cursor] !== quote) {
-      cursor += 1;
-      continue;
-    }
-    let run = 0;
-    while (source[cursor + run] === quote)
-      run += 1;
-    if (run >= runLength)
-      return { end: cursor + run, closeStart: cursor };
-    cursor += run;
-  }
-  return { end: source.length, closeStart: source.length };
-}
 function closeAloneOnItsLine(source, closeIndex) {
   const lineStart = source.lastIndexOf("\n", closeIndex - 1) + 1;
   for (let i = lineStart; i < closeIndex; i += 1) {
@@ -698,7 +766,19 @@ function collectInterpolationSpans(source, row, start, interpolation) {
   let depth = 1;
   let cursor = start + interpolation.start.length;
   while (cursor < source.length) {
+    if (row.unquotedCssUrl) {
+      const cssUrl = unquotedCssUrlConstruct(source, row, cursor);
+      if (cssUrl !== null) {
+        spans.push(...cssUrl.maskSpans);
+        cursor = cssUrl.end;
+        continue;
+      }
+    }
     const ch = source[cursor];
+    if (row.unquotedEscapes && ch === "\\") {
+      cursor = skipScssEscape(source, cursor);
+      continue;
+    }
     if (source.startsWith(interpolation.end, cursor)) {
       depth -= 1;
       if (!depth)
@@ -838,39 +918,6 @@ function percentLiteralConstructAt(source, index) {
     delimitersAreTrivia: false
   };
 }
-function zigMultilineConstruct(source, start) {
-  const renderSpans = [];
-  let cursor = start;
-  let end = source.length;
-  while (cursor < source.length) {
-    let lineEnd = cursor;
-    while (lineEnd < source.length && source[lineEnd] !== "\n")
-      lineEnd += 1;
-    if (cursor + 2 < lineEnd)
-      renderSpans.push([cursor + 2, lineEnd]);
-    if (lineEnd >= source.length) {
-      end = source.length;
-      break;
-    }
-    let probe = lineEnd + 1;
-    while (probe < source.length && (source[probe] === " " || source[probe] === "	" || source[probe] === "\r")) {
-      probe += 1;
-    }
-    if (source[probe] === "\\" && source[probe + 1] === "\\") {
-      cursor = probe;
-      continue;
-    }
-    end = lineEnd;
-    break;
-  }
-  return {
-    start,
-    end,
-    renderSpans,
-    maskSpans: [[start, end]],
-    delimitersAreTrivia: false
-  };
-}
 
 // dist/util/comments.js
 function stripJsLikeComments(src) {
@@ -1431,10 +1478,7 @@ function normalizeCsharpIdentifier(name) {
   const withoutVerbatimPrefix = name.startsWith("@") ? name.slice(1) : name;
   return hasNonAsciiCodePoint(withoutVerbatimPrefix) ? withoutVerbatimPrefix.replace(CSHARP_IDENTIFIER_FORMAT_PATTERN, "") : withoutVerbatimPrefix;
 }
-var JAVA_IDENTIFIER_SOURCE = String.raw`[\p{L}\p{Nl}\p{Sc}\p{Pc}][\p{L}\p{Nl}\p{Sc}\p{Pc}\p{Nd}\p{Mn}\p{Mc}${JAVA_IDENTIFIER_IGNORABLE_SOURCE}]*`;
-var CSHARP_IDENTIFIER_SOURCE = String.raw`@?[\p{L}\p{Nl}_][\p{L}\p{Nl}_\p{Nd}\p{Pc}\p{Mn}\p{Mc}${CSHARP_IDENTIFIER_FORMAT_SOURCE}]*`;
 var GO_IDENTIFIER_SOURCE = String.raw`[\p{L}_][\p{L}\p{Nd}_]*`;
-var KOTLIN_IDENTIFIER_SOURCE = String.raw`[\p{L}_][\p{L}\p{Nd}_]*`;
 
 // dist/languages/definitions/python.js
 function isTypeAliasLeftName(node) {
@@ -1467,7 +1511,7 @@ function isPythonReceiverAttributeAssignmentName(node) {
   const assignment = attr.parent;
   if (assignment?.type !== "assignment")
     return false;
-  return assignment.childForFieldName("left")?.id === attr.id;
+  return assignment.childForFieldName("left")?.id === attr.id && !!assignment.childForFieldName("right");
 }
 var PYTHON_GRAPH_IMPORT_QUERY = `
       (import_statement name: (dotted_name) @from) @stmt
@@ -1578,10 +1622,12 @@ var PYTHON_DEF = {
       (assignment left: [(pattern_list (identifier) @name) (tuple_pattern (identifier) @name)])
       ;; Instance / class attributes declared as \`self.x = ...\` or \`cls.x = ...\`.
       ((assignment
-        left: (attribute object: (identifier) @receiver attribute: (identifier) @name))
+        left: (attribute object: (identifier) @receiver attribute: (identifier) @name)
+        right: (_))
         (#eq? @receiver "self"))
       ((assignment
-        left: (attribute object: (identifier) @receiver attribute: (identifier) @name))
+        left: (attribute object: (identifier) @receiver attribute: (identifier) @name)
+        right: (_))
         (#eq? @receiver "cls"))
       (named_expression name: (identifier) @name)
       (type_alias_statement left: (type [(identifier) @name (generic_type (identifier) @name)]))
@@ -2255,10 +2301,6 @@ registerLanguage(GO_DEF);
 
 // dist/languages/definitions/java.js
 var JAVA_IDENTIFIER_IGNORABLE_PATTERN = new RegExp(`[${JAVA_IDENTIFIER_IGNORABLE_SOURCE}]`, "gu");
-var JAVA_IMPORT_QUERY = `
-      (import_declaration (scoped_identifier) @from (asterisk)? @wild) @stmt
-      (import_declaration (identifier) @from (asterisk)? @wild) @stmt
-    `;
 var JAVA_DEF = {
   id: "java",
   extensions: [".java"],
@@ -2305,7 +2347,8 @@ var JAVA_DEF = {
     comments: ["line_comment", "block_comment"]
   },
   graph: {
-    imports: JAVA_IMPORT_QUERY,
+    // Java imports are read from the syntax tree (src/util/jvm-tree.ts), so no imports query runs.
+    imports: "",
     exports: `
       (class_declaration name: (identifier) @name)
       (record_declaration name: (identifier) @name)
@@ -2329,7 +2372,8 @@ var JAVA_DEF = {
       (spread_parameter (variable_declarator name: (identifier) @name))
       (receiver_parameter (identifier) @name)
     `,
-    importBindings: JAVA_IMPORT_QUERY
+    // Java imports are read from the syntax tree (src/util/jvm-tree.ts), so no import-binding query runs.
+    importBindings: ""
   },
   nodeTypes: {
     identifier: ["identifier", "type_identifier"],
@@ -2426,12 +2470,8 @@ var CSHARP_DEF = {
     comments: ["comment"]
   },
   graph: {
-    // Path node is `identifier` | `qualified_name` | `alias_qualified_name` (`global::System`).
-    // An identifier/qualified_name alternation misses `alias_qualified_name`, so keep `(_)`.
-    imports: `
-      (using_directive !name (_) @from) @stmt
-      (using_directive name: (identifier) (_) @from) @stmt
-    `,
+    // C# using directives are read from the syntax tree (src/util/csharp-tree.ts), so no imports query runs.
+    imports: "",
     exports: `
       (class_declaration name: (identifier) @name)
       (record_declaration name: (identifier) @name)
@@ -2462,13 +2502,9 @@ var CSHARP_DEF = {
       (variable_declarator name: (identifier) @name)
       (declaration_pattern name: (identifier) @name)
     `,
-    // extern alias has no path node in the grammar, so there is no @from.
-    // using path node: identifier | qualified_name | alias_qualified_name — keep `(_)`.
-    importBindings: `
-      (using_directive name: (identifier) @alias (_) @from) @stmt
-      (using_directive !name (_) @from) @stmt
-      (extern_alias_directive name: (identifier) @alias) @stmt
-    `
+    // C# using and extern-alias directives are read from the syntax tree (src/util/csharp-tree.ts), so no
+    // import-binding query runs.
+    importBindings: ""
   },
   nodeTypes: {
     identifier: ["identifier"],
@@ -3096,9 +3132,8 @@ var KOTLIN_DEF = {
     comments: ["line_comment", "block_comment"]
   },
   graph: {
-    imports: `
-      (import (qualified_identifier) @from) @stmt
-    `,
+    // Kotlin imports are read from the syntax tree (src/util/jvm-tree.ts), so no imports query runs.
+    imports: "",
     exports: `
       (source_file
         [
@@ -3129,11 +3164,8 @@ var KOTLIN_DEF = {
       (class_parameter (identifier) @name)
       (type_parameter (identifier) @name)
     `,
-    importBindings: `
-      (import (qualified_identifier) @from (identifier) @alias) @stmt
-      (import (qualified_identifier) @from ("*") @wild) @stmt
-      (import (qualified_identifier) @from) @stmt
-    `
+    // Kotlin imports are read from the syntax tree (src/util/jvm-tree.ts), so no import-binding query runs.
+    importBindings: ""
   },
   nodeTypes: {
     identifier: ["identifier"],
@@ -3689,30 +3721,16 @@ var ZIG_DEF = {
 registerLanguage(ZIG_DEF);
 
 // dist/bootstrap/tree-sitter-languages.js
-var idToConfigKey = {
+var CHUNK_LANGUAGE_ALIASES = {
   js: "javascript",
-  ts: "typescript",
-  tsx: "tsx",
-  python: "python",
-  php: "php",
-  html: "html",
-  css: "css",
-  scss: "scss",
-  less: "less",
-  ruby: "ruby",
-  go: "go",
-  java: "java",
-  csharp: "csharp",
-  rust: "rust",
-  c: "c",
-  cpp: "cpp",
-  kotlin: "kotlin",
-  swift: "swift",
-  zig: "zig"
+  ts: "typescript"
 };
+function chunkLanguageKey(id) {
+  return CHUNK_LANGUAGE_ALIASES[id] ?? id;
+}
 var LANG_CONFIGS = {};
 for (const lang of getAllLanguages()) {
-  const key = idToConfigKey[lang.id] || lang.id;
+  const key = chunkLanguageKey(lang.id);
   if (lang.id === "vue" || lang.id === "svelte" || lang.id === "markdown" || lang.id === "mdx" || lang.id === "astro" || lang.id === "hbs" || lang.id === "rst" || lang.id === "adoc") {
     continue;
   }
@@ -3780,9 +3798,6 @@ function collectChunkBlockGroups(language, matches) {
   return { mainBlocks, innerBlocks, comments };
 }
 
-// dist/chunking/chunk-matches.js
-import { Buffer as Buffer2 } from "node:buffer";
-
 // dist/languages.js
 import fs from "node:fs";
 import path from "node:path";
@@ -3906,6 +3921,58 @@ function isLikelyCppHeader(sample) {
   return CPP_HEADER_HINT.test(masked) || CPP_MODULE_IMPORT_HINT.test(masked);
 }
 
+// dist/native/byte-index.js
+var EMPTY_BYTE_TO_STRING_INDEX = new Uint32Array(0);
+var EMPTY_LINE_START_BYTES = [];
+function buildByteMap(source) {
+  const byteLength = Buffer.byteLength(source, "utf8");
+  if (byteLength === source.length) {
+    return {
+      isAscii: true,
+      sourceLength: source.length,
+      byteToStringIndex: EMPTY_BYTE_TO_STRING_INDEX,
+      lineStartBytes: EMPTY_LINE_START_BYTES
+    };
+  }
+  const byteToStringIndex = new Uint32Array(byteLength + 1);
+  const lineStartBytes = [0];
+  let byteOffset = 0;
+  let stringIndex = 0;
+  while (stringIndex < source.length) {
+    const codePoint = source.codePointAt(stringIndex);
+    if (codePoint === void 0)
+      break;
+    const charStringLength = codePoint > 65535 ? 2 : 1;
+    const charByteLength = utf8ByteLengthForCodePoint(codePoint);
+    for (let offset = 1; offset < charByteLength; offset += 1) {
+      byteToStringIndex[byteOffset + offset] = stringIndex;
+    }
+    byteOffset += charByteLength;
+    stringIndex += charStringLength;
+    byteToStringIndex[byteOffset] = stringIndex;
+    if (codePoint === 10) {
+      lineStartBytes.push(byteOffset);
+    }
+  }
+  byteToStringIndex[byteOffset] = source.length;
+  return { isAscii: false, sourceLength: source.length, byteToStringIndex, lineStartBytes };
+}
+function stringIndexForByte(map, byteIndex) {
+  if (map.isAscii)
+    return Math.max(0, Math.min(byteIndex, map.sourceLength));
+  const bounded = Math.max(0, Math.min(byteIndex, map.byteToStringIndex.length - 1));
+  return map.byteToStringIndex[bounded] ?? map.sourceLength;
+}
+function utf8ByteLengthForCodePoint(codePoint) {
+  if (codePoint <= 127)
+    return 1;
+  if (codePoint <= 2047)
+    return 2;
+  if (codePoint <= 65535)
+    return 3;
+  return 4;
+}
+
 // dist/native/runtime.js
 import fs5 from "node:fs";
 import path5 from "node:path";
@@ -4947,61 +5014,25 @@ function getChunkMatches(language, source, _filePath) {
   if (support) {
     const nativeExecution = getNativeSingleQueryExecution(source, support, language.queryText);
     if (nativeExecution.matches) {
-      const toStringIndex = createUtf8ByteToStringIndex(source);
-      return nativeExecution.matches.map((match) => toChunkMatchFromNative(match, toStringIndex));
+      const byteMap = buildByteMap(source);
+      return nativeExecution.matches.map((match) => toChunkMatchFromNative(match, byteMap));
     }
   }
   return [];
 }
-function toChunkMatchFromNative(match, toStringIndex) {
+function toChunkMatchFromNative(match, byteMap) {
   return {
     captures: match.captures.map((capture) => ({
       name: capture.name,
       text: capture.text,
-      startByte: toStringIndex(capture.start.index),
-      endByte: toStringIndex(capture.end.index),
+      startByte: stringIndexForByte(byteMap, capture.start.index),
+      endByte: stringIndexForByte(byteMap, capture.end.index),
       startLine: capture.start.row + 1,
       endLine: capture.end.row + 1,
       nodeType: capture.nodeType
     }))
   };
 }
-function createUtf8ByteToStringIndex(source) {
-  const utf8Length = Buffer2.byteLength(source, "utf8");
-  if (utf8Length === source.length) {
-    return (byteOffset2) => Math.max(0, Math.min(byteOffset2, source.length));
-  }
-  const byteToStringIndex = new Uint32Array(utf8Length + 1);
-  let byteOffset = 0;
-  let stringIndex = 0;
-  while (stringIndex < source.length) {
-    const codePoint = source.codePointAt(stringIndex);
-    if (codePoint === void 0)
-      break;
-    const charStringLength = codePoint > 65535 ? 2 : 1;
-    const charByteLength = utf8ByteLengthForCodePoint(codePoint);
-    for (let offset = 1; offset < charByteLength; offset += 1) {
-      byteToStringIndex[byteOffset + offset] = stringIndex;
-    }
-    byteOffset += charByteLength;
-    stringIndex += charStringLength;
-    byteToStringIndex[byteOffset] = stringIndex;
-  }
-  byteToStringIndex[byteOffset] = source.length;
-  return (index) => {
-    const bounded = Math.max(0, Math.min(index, byteToStringIndex.length - 1));
-    return byteToStringIndex[bounded] ?? source.length;
-  };
-}
-function utf8ByteLengthForCodePoint(codePoint) {
-  if (codePoint <= 127)
-    return 1;
-  if (codePoint <= 2047)
-    return 2;
-  if (codePoint <= 65535)
-    return 3;
-  return 4;
-}
 
 // dist/chunking/chunk-id.js
 import { createHash as createHash2 } from "node:crypto";
@@ -5460,10 +5491,6 @@ function collectNewlineOffsets(source) {
 
 // dist/agent/query-index/content.js
 var MAX_QUERY_INDEX_TEXT_BYTES = 3e5;
-var CHUNK_LANGUAGE_ALIASES = {
-  js: "javascript",
-  ts: "typescript"
-};
 function compressQueryText(text) {
   const compressed = brotliCompressSync(text, {
     params: { [zlibConstants.BROTLI_PARAM_QUALITY]: 4 }
@@ -5484,7 +5511,7 @@ function detectQueryIndexSurface(relativePath) {
   return "code";
 }
 function chunkQueryText(file, text, support) {
-  const languageId = support ? CHUNK_LANGUAGE_ALIASES[support.id] ?? support.id : void 0;
+  const languageId = support ? chunkLanguageKey(support.id) : void 0;
   const language = languageId ? LANG_CONFIGS[languageId] : void 0;
   if (language) {
     try {