@lzehrung/codegraph 2.3.20 → 2.3.22

package/dist/bin/queryIndexWorker.js

@@ -1,4382 +0,0 @@
-import { createRequire as __codegraphCreateRequire } from 'node:module';
-const require = __codegraphCreateRequire(import.meta.url);
-
-
-// dist/agent/query-index/content.js
-import fs6 from "node:fs/promises";
-import { brotliCompressSync, constants as zlibConstants } from "node:zlib";
-
-// dist/languages/queryGenerator.js
-function generateChunkingQuery(def) {
-  const parts = [];
-  if (def.structure.comments.length) {
-    parts.push(`;; ----- Comments -----`);
-    for (const type of def.structure.comments) {
-      parts.push(`(${type}) @chunk.comment`);
-    }
-    parts.push("");
-  }
-  if (def.structure.blocks.length) {
-    parts.push(`;; ----- Blocks -----`);
-    for (const block of def.structure.blocks) {
-      let query = `(${block.type}`;
-      if (block.nameQuery) {
-        query += ` ${block.nameQuery}`;
-      }
-      const isBlockCapture = block.isBlock ?? true;
-      if (isBlockCapture) {
-        query += `) @chunk.block.${block.captureId || block.type}`;
-      } else {
-        query += `)`;
-      }
-      if (block.parentType) {
-        query = `(${block.parentType} ${query})`;
-      }
-      parts.push(query);
-    }
-    parts.push("");
-  }
-  if (def.structure.splitPoints.length) {
-    parts.push(`;; ----- Split Points -----`);
-    for (const type of def.structure.splitPoints) {
-      parts.push(`(${type}) @chunk.block.inner`);
-    }
-    parts.push("");
-  }
-  return parts.join("\n");
-}
-
-// dist/chunking/languageConfig.js
-function makeLanguageConfig(def, publicId = def.id) {
-  const queryText = generateChunkingQuery(def);
-  return {
-    id: publicId,
-    supportId: def.id,
-    queryText,
-    definition: def,
-    captures: {
-      name: "chunk.name",
-      blockPrefix: "chunk.block.",
-      innerBlock: "chunk.block.inner",
-      comments: ["chunk.comment", "chunk.docstring"]
-    }
-  };
-}
-
-// dist/languages/registry.js
-var registry = /* @__PURE__ */ new Map();
-function registerLanguage(def) {
-  registry.set(def.id, def);
-}
-function getAllLanguages() {
-  return Array.from(registry.values());
-}
-function getLanguageById(id) {
-  return registry.get(id);
-}
-
-// dist/languages/definitions/jsFamily.js
-var ECMASCRIPT_CONTROL_SPLIT_POINTS = [
-  "if_statement",
-  "else_clause",
-  "switch_statement",
-  "for_statement",
-  "for_in_statement",
-  "while_statement",
-  "do_statement",
-  "try_statement",
-  "catch_clause",
-  "finally_clause"
-];
-var ECMASCRIPT_CORE_FUNCTION_BLOCKS = [
-  {
-    type: "class_declaration",
-    nameQuery: "name: (identifier) @chunk.name",
-    captureId: "class"
-  },
-  {
-    type: "function_declaration",
-    nameQuery: "name: (identifier) @chunk.name",
-    captureId: "function"
-  },
-  {
-    type: "generator_function_declaration",
-    nameQuery: "name: (identifier) @chunk.name",
-    captureId: "function"
-  },
-  {
-    type: "method_definition",
-    nameQuery: "name: (_) @chunk.name body: (statement_block) @chunk.block.method",
-    captureId: "method"
-  },
-  {
-    type: "lexical_declaration",
-    nameQuery: `(variable_declarator name: (identifier) @chunk.name value: [ (function_expression body: (statement_block) @chunk.block.function) (arrow_function body: (statement_block) @chunk.block.function) ])`,
-    captureId: "function"
-  },
-  {
-    type: "variable_declaration",
-    nameQuery: `(variable_declarator name: (identifier) @chunk.name value: [ (function_expression body: (statement_block) @chunk.block.function) (arrow_function body: (statement_block) @chunk.block.function) ])`,
-    captureId: "function"
-  },
-  {
-    type: "assignment_expression",
-    nameQuery: `left: (_) @chunk.name right: [ (function_expression body: (statement_block) @chunk.block.function) (arrow_function body: (statement_block) @chunk.block.function) ]`,
-    captureId: "function"
-  },
-  {
-    type: "arrow_function",
-    nameQuery: "body: (statement_block) @chunk.block.function",
-    captureId: "function"
-  },
-  {
-    type: "function_expression",
-    nameQuery: "body: (statement_block) @chunk.block.function",
-    captureId: "function"
-  }
-];
-var ECMASCRIPT_MODULE_VAR_BLOCKS = [
-  { type: "import_statement", captureId: "imports" },
-  {
-    type: "lexical_declaration",
-    nameQuery: `(variable_declarator name: (identifier) @chunk.name)`,
-    captureId: "module_var",
-    parentType: "program"
-  },
-  {
-    type: "variable_declaration",
-    nameQuery: `(variable_declarator name: (identifier) @chunk.name)`,
-    captureId: "module_var",
-    parentType: "program"
-  }
-];
-
-// dist/languages/definitions/typescript.js
-function normalizeTypeScriptNativeQuery(kind, query) {
-  let normalized = query.replace(/\(class_declaration name: \(identifier\) @/g, "(class_declaration name: (type_identifier) @");
-  if (kind !== "exports") {
-    return normalized;
-  }
-  normalized = normalized.replace(/^\s*\(export_assignment \(identifier\) @ts_export_assign\)\s*$/gm, "");
-  return normalized;
-}
-var TYPESCRIPT_CLASS_BLOCK = {
-  type: "class_declaration",
-  nameQuery: "name: (type_identifier) @chunk.name",
-  captureId: "class"
-};
-var BASE_STRUCTURE = {
-  blocks: [
-    TYPESCRIPT_CLASS_BLOCK,
-    ...ECMASCRIPT_CORE_FUNCTION_BLOCKS.filter((block) => block.type !== "class_declaration"),
-    // TS Specifics
-    {
-      type: "interface_declaration",
-      nameQuery: "name: (type_identifier) @chunk.name",
-      captureId: "interface"
-    },
-    {
-      type: "enum_declaration",
-      nameQuery: "name: [ (identifier) (type_identifier) ] @chunk.name",
-      captureId: "enum"
-    },
-    {
-      type: "type_alias_declaration",
-      nameQuery: "name: (type_identifier) @chunk.name",
-      captureId: "type_alias"
-    },
-    {
-      type: "internal_module",
-      nameQuery: "name: (identifier) @chunk.name body: (statement_block) @chunk.block.namespace",
-      captureId: "namespace"
-    },
-    {
-      type: "module",
-      nameQuery: "name: (identifier) @chunk.name body: (statement_block) @chunk.block.namespace",
-      captureId: "namespace"
-    },
-    // Data
-    { type: "object", captureId: "data" },
-    // Top level vars
-    ...ECMASCRIPT_MODULE_VAR_BLOCKS.map((block) => block.type === "import_statement" ? { ...block, parentType: "program" } : block)
-  ],
-  splitPoints: [...ECMASCRIPT_CONTROL_SPLIT_POINTS, "switch_case", "switch_default"],
-  comments: ["comment"]
-};
-var BASE_GRAPH = {
-  imports: `
-    (import_statement (string) @mod) @stmt
-    ;; import x = require("...") is represented via import_require_clause
-    (import_statement (import_require_clause (string) @mod)) @stmt
-    (export_statement (string) @mod) @stmt
-    (call_expression function: (import) arguments: (arguments (string) @mod)) @stmt
-    ;; declare module "foo" {} \u2014 ambient module augmentations create a type-only
-    ;; dependency on the named module and must appear in the file graph so that
-    ;; changes to "foo" propagate to augmenting files (and vice-versa).
-    ;; The inner node type is "module" (not "module_declaration"); its string
-    ;; child uses field-name "name".
-    (ambient_declaration (module name: (string) @mod)) @stmt
-  `,
-  exports: `
-    (export_statement) @stmt
-    (export_statement declaration: (function_declaration name: (identifier) @name)) @stmt
-    (export_statement declaration: (generator_function_declaration name: (identifier) @name)) @stmt
-    (export_statement declaration: (class_declaration name: (type_identifier) @name)) @stmt
-    (export_statement declaration: (abstract_class_declaration name: (type_identifier) @name)) @stmt
-    (export_statement declaration: (enum_declaration name: [ (identifier) (type_identifier) ] @name)) @stmt
-    (export_statement declaration: (function_declaration) @anon_default) @stmt
-    (export_statement declaration: (generator_function_declaration) @anon_default) @stmt
-    (export_statement declaration: (class_declaration) @anon_default) @stmt
-    (export_statement declaration: (abstract_class_declaration) @anon_default) @stmt
-    (export_statement declaration: (lexical_declaration (variable_declarator name: (identifier) @name))) @stmt
-    (export_statement (export_clause (export_specifier name: (identifier) @src alias: (identifier) @alias)) (string) @from) @stmt
-    (export_statement (export_clause (export_specifier name: (identifier) @src !alias)) (string) @from) @stmt
-    (export_statement (export_clause (export_specifier name: (identifier) @src alias: (identifier) @alias))) @stmt
-    (export_statement (export_clause (export_specifier name: (identifier) @src !alias))) @stmt
-    (export_statement (string) @from) @stmt
-    (export_assignment (identifier) @ts_export_assign)
-  `,
-  locals: `
-    (function_declaration name: (identifier) @name)
-    (generator_function_declaration name: (identifier) @name)
-    (method_definition name: (property_identifier) @name)
-    (method_signature name: (property_identifier) @name)
-    (abstract_method_signature name: (property_identifier) @name)
-    (class_declaration name: (type_identifier) @name)
-    (abstract_class_declaration name: (type_identifier) @name)
-    (variable_declarator name: (identifier) @name)
-    (interface_declaration name: (type_identifier) @name)
-    (type_alias_declaration name: (type_identifier) @name)
-    (enum_declaration name: [ (identifier) (type_identifier) ] @name)
-  `,
-  importBindings: `
-    (import_statement) @stmt
-    (import_statement (string) @from) @stmt
-    (import_statement (import_require_clause (identifier) @def (string) @from)) @stmt
-    (import_statement (import_clause (identifier) @def) (string) @from) @stmt
-    (import_statement (import_clause (named_imports (import_specifier name: (identifier) @iname alias: (identifier) @alias))) (string) @from) @stmt
-    (import_statement (import_clause (named_imports (import_specifier name: (identifier) @iname))) (string) @from) @stmt
-    (import_statement (import_clause (namespace_import (identifier) @ns)) (string) @from) @stmt
-  `
-};
-var BASE_HELPERS = {
-  nodeTypes: {
-    identifier: ["identifier", "type_identifier"],
-    propertyIdentifier: ["property_identifier"],
-    shorthandPropertyIdentifier: ["shorthand_property_identifier", "shorthand_property_identifier_pattern"],
-    memberExpression: "member_expression"
-  },
-  classifyDefinition: (n) => {
-    const t = n.parent?.type;
-    if (t === "function_declaration")
-      return "function";
-    if (t === "generator_function_declaration")
-      return "function";
-    if (t === "method_definition")
-      return "function";
-    if (t === "method_signature")
-      return "function";
-    if (t === "abstract_method_signature")
-      return "function";
-    if (t === "class_declaration")
-      return "class";
-    if (t === "abstract_class_declaration")
-      return "class";
-    if (t === "interface_declaration")
-      return "interface";
-    if (t === "type_alias_declaration")
-      return "type";
-    if (t === "enum_declaration")
-      return "type";
-    return "variable";
-  },
-  isDeclarationName: (node) => {
-    const p = node.parent?.type;
-    return !!p && [
-      "generator_function_declaration",
-      "function_declaration",
-      "class_declaration",
-      "abstract_class_declaration",
-      "variable_declarator",
-      "interface_declaration",
-      "type_alias_declaration",
-      "enum_declaration",
-      "import_specifier",
-      "namespace_import",
-      "import_clause",
-      "import_equals_declaration",
-      // Method names in classes and abstract method signatures: needed so
-      // that editing a method name is classified as a definition change.
-      "method_definition",
-      "method_signature",
-      "abstract_method_signature"
-    ].includes(p);
-  },
-  createsBlockScope: (n) => n.type === "program" || n.type === "block" || n.type === "class_body",
-  createsFunctionScope: (n) => n.type === "generator_function_declaration" || n.type === "function_declaration" || n.type === "function" || n.type === "function_expression" || n.type === "arrow_function" || n.type === "method_definition",
-  membersAreImplicitlyInScope: false,
-  supportsCrossModuleSymbols: true
-};
-var TYPESCRIPT_DEF = {
-  id: "ts",
-  extensions: [".ts", ".mts", ".cts"],
-  structure: BASE_STRUCTURE,
-  graph: BASE_GRAPH,
-  supportsExportFromReferences: true,
-  ...BASE_HELPERS,
-  isTypeOnly: (stmtText) => /\b(import|export)\s+type\b/.test(stmtText),
-  native: {
-    normalizeQuery: normalizeTypeScriptNativeQuery,
-    authoritativeKinds: ["exports"],
-    notes: ["drops unsupported TypeScript export-assignment nodes while keeping native export results authoritative"]
-  }
-};
-registerLanguage(TYPESCRIPT_DEF);
-var TSX_DEF = {
-  id: "tsx",
-  extensions: [".tsx"],
-  structure: {
-    ...BASE_STRUCTURE,
-    blocks: [
-      ...BASE_STRUCTURE.blocks,
-      { type: "jsx_element", captureId: "jsx" },
-      { type: "jsx_self_closing_element", captureId: "jsx" }
-    ]
-  },
-  graph: BASE_GRAPH,
-  supportsExportFromReferences: true,
-  ...BASE_HELPERS,
-  isTypeOnly: (stmtText) => /\b(import|export)\s+type\b/.test(stmtText),
-  native: {
-    normalizeQuery: normalizeTypeScriptNativeQuery,
-    authoritativeKinds: ["exports"],
-    notes: ["drops unsupported TypeScript export-assignment nodes while keeping native export results authoritative"]
-  }
-};
-registerLanguage(TSX_DEF);
-
-// dist/languages/definitions/javascript.js
-var JS_OBJECT_METHOD_EXPORT_PATTERN = `
-      ;; CJS: module.exports = { helper () {} }
-      (expression_statement (assignment_expression
-        left: (member_expression object: (identifier) @mod property: (property_identifier) @prop)
-        right: (object (pair key: (property_identifier) @cjs_export_name value: (function_declaration) @cjs_fn))))
-        (#eq? @mod "module") (#eq? @prop "exports")
-`;
-var JS_OBJECT_METHOD_EXPORT_NATIVE_PATTERN = `
-      ;; CJS: module.exports = { helper () {} }
-      (expression_statement (assignment_expression
-        left: (member_expression object: (identifier) @mod property: (property_identifier) @prop)
-        right: (object (method_definition name: (property_identifier) @cjs_export_name) @cjs_fn)))
-        (#eq? @mod "module") (#eq? @prop "exports")
-`;
-var JAVASCRIPT_DEF = {
-  id: "js",
-  extensions: [".js", ".jsx", ".mjs", ".cjs"],
-  supportsExportFromReferences: true,
-  structure: {
-    blocks: [...ECMASCRIPT_CORE_FUNCTION_BLOCKS, ...ECMASCRIPT_MODULE_VAR_BLOCKS],
-    splitPoints: [...ECMASCRIPT_CONTROL_SPLIT_POINTS],
-    comments: ["comment"]
-  },
-  graph: {
-    imports: `
-      (import_statement (string) @mod) @stmt
-      (export_statement (string) @mod) @stmt
-      (call_expression function: (import) arguments: (arguments (string) @mod)) @stmt
-      ((call_expression function: (identifier) @fn arguments: (arguments (string) @mod)) @stmt
-        (#eq? @fn "require"))
-    `,
-    exports: `
-      (export_statement) @stmt
-      (export_statement declaration: (function_declaration name: (identifier) @name)) @stmt
-      (export_statement declaration: (generator_function_declaration name: (identifier) @name)) @stmt
-      (export_statement declaration: (class_declaration name: (identifier) @name)) @stmt
-      (export_statement declaration: (function_declaration) @anon_default) @stmt
-      (export_statement declaration: (generator_function_declaration) @anon_default) @stmt
-      (export_statement declaration: (class_declaration) @anon_default) @stmt
-      (export_statement declaration: (lexical_declaration (variable_declarator name: (identifier) @name))) @stmt
-      (export_statement (export_clause (export_specifier name: (identifier) @src alias: (identifier) @alias)) (string) @from)
-      (export_statement (export_clause (export_specifier name: (identifier) @src !alias)) (string) @from)
-      (export_statement (export_clause (export_specifier name: (identifier) @src alias: (identifier) @alias)))
-      (export_statement (export_clause (export_specifier name: (identifier) @src !alias)))
-      (export_statement (string) @from)
-      (expression_statement (assignment_expression
-        left: (member_expression object: (identifier) @mod property: (property_identifier) @prop)
-        right: (object (shorthand_property_identifier) @cjs_shorthand)))
-        (#eq? @mod "module") (#eq? @prop "exports")
-      ;; CJS spread export: module.exports = { ...base }
-      ((expression_statement (assignment_expression
-        left: (member_expression object: (identifier) @mod property: (property_identifier) @prop)
-        right: (object (spread_element (identifier) @cjs_spread))) @stmt)
-        (#eq? @mod "module") (#eq? @prop "exports"))
-      (expression_statement (assignment_expression
-        left: (member_expression object: (identifier) @mod property: (property_identifier) @prop)
-        right: (object (pair key: (property_identifier) @cjs_export_name value: (identifier) @cjs_local))))
-        (#eq? @mod "module") (#eq? @prop "exports")
-      (expression_statement (assignment_expression
-        left: (member_expression object: (member_expression object: (identifier) @mod property: (property_identifier) @prop) property: (property_identifier) @cjs_export_name)
-        right: (identifier) @cjs_local))
-        (#eq? @mod "module") (#eq? @prop "exports")
-      (expression_statement (assignment_expression
-        left: (member_expression object: (identifier) @exp property: (property_identifier) @cjs_export_name)
-        right: (identifier) @cjs_local))
-        (#eq? @exp "exports")
-      ;; CJS function/arrow direct exports
-      (expression_statement (assignment_expression
-        left: (member_expression object: (member_expression object: (identifier) @mod property: (property_identifier) @prop) property: (property_identifier) @cjs_export_name)
-        right: (function) @cjs_fn))
-        (#eq? @mod "module") (#eq? @prop "exports")
-      (expression_statement (assignment_expression
-        left: (member_expression object: (member_expression object: (identifier) @mod property: (property_identifier) @prop) property: (property_identifier) @cjs_export_name)
-        right: (arrow_function) @cjs_fn))
-        (#eq? @mod "module") (#eq? @prop "exports")
-      (expression_statement (assignment_expression
-        left: (member_expression object: (identifier) @exp property: (property_identifier) @cjs_export_name)
-        right: (function) @cjs_fn))
-        (#eq? @exp "exports")
-      (expression_statement (assignment_expression
-        left: (member_expression object: (identifier) @exp property: (property_identifier) @cjs_export_name)
-        right: (arrow_function) @cjs_fn))
-        (#eq? @exp "exports")
-      ;; CJS object export with function value
-      (expression_statement (assignment_expression
-        left: (member_expression object: (identifier) @mod property: (property_identifier) @prop)
-        right: (object (pair key: (property_identifier) @cjs_export_name value: (function) @cjs_fn))))
-        (#eq? @mod "module") (#eq? @prop "exports")
-      (expression_statement (assignment_expression
-        left: (member_expression object: (identifier) @mod property: (property_identifier) @prop)
-        right: (object (pair key: (property_identifier) @cjs_export_name value: (arrow_function) @cjs_fn))))
-        (#eq? @mod "module") (#eq? @prop "exports")
-      ;; CJS: module.exports = { helper () {} }
-      (expression_statement (assignment_expression
-        left: (member_expression object: (identifier) @mod property: (property_identifier) @prop)
-        right: (object (pair key: (property_identifier) @cjs_export_name value: (function_declaration) @cjs_fn))))
-        (#eq? @mod "module") (#eq? @prop "exports")
-    `,
-    locals: `
-      (function_declaration name: (identifier) @name)
-      (generator_function_declaration name: (identifier) @name)
-      (method_definition name: (property_identifier) @name)
-      (class_declaration name: (identifier) @name)
-      (variable_declarator name: (identifier) @name)
-    `,
-    importBindings: `
-      (import_statement) @stmt
-      (import_statement (string) @from) @stmt
-      (import_statement (import_clause (identifier) @def) (string) @from) @stmt
-      (import_statement (import_clause (named_imports (import_specifier name: (identifier) @iname alias: (identifier) @alias))) (string) @from) @stmt
-      (import_statement (import_clause (named_imports (import_specifier name: (identifier) @iname))) (string) @from) @stmt
-      (import_statement (import_clause (namespace_import (identifier) @ns)) (string) @from) @stmt
-      (lexical_declaration (variable_declarator name:(identifier) @def value: (call_expression (identifier) @req arguments: (arguments (string) @from)))) (#eq? @req "require")
-      (lexical_declaration (variable_declarator (object_pattern) @pattern value: (call_expression (identifier) @req arguments: (arguments (string) @from)))) (#eq? @req "require")
-    `
-  },
-  nodeTypes: {
-    identifier: ["identifier"],
-    propertyIdentifier: ["property_identifier"],
-    shorthandPropertyIdentifier: ["shorthand_property_identifier", "shorthand_property_identifier_pattern"],
-    memberExpression: "member_expression"
-  },
-  classifyDefinition: (n) => {
-    const t = n.parent?.type;
-    if (t === "function_declaration")
-      return "function";
-    if (t === "generator_function_declaration")
-      return "function";
-    if (t === "method_definition")
-      return "function";
-    if (t === "class_declaration")
-      return "class";
-    return "variable";
-  },
-  isDeclarationName: (node) => {
-    const p = node.parent?.type;
-    return !!p && [
-      "function_declaration",
-      "generator_function_declaration",
-      "class_declaration",
-      "variable_declarator",
-      "import_specifier",
-      "namespace_import",
-      "import_clause",
-      // Method names in classes: needed so that editing a method name is
-      // classified as a definition change, not an unrecognised node.
-      "method_definition"
-    ].includes(p);
-  },
-  createsBlockScope: (n) => n.type === "program" || n.type === "block" || n.type === "class_body",
-  createsFunctionScope: (n) => n.type === "function_declaration" || n.type === "generator_function_declaration" || n.type === "function" || n.type === "function_expression" || n.type === "arrow_function" || n.type === "method_definition",
-  membersAreImplicitlyInScope: false,
-  supportsCrossModuleSymbols: true,
-  native: {
-    normalizeQuery: (_kind, query) => query.replace(/\(function\)/g, "(function_expression)").replace(JS_OBJECT_METHOD_EXPORT_PATTERN, JS_OBJECT_METHOD_EXPORT_NATIVE_PATTERN),
-    authoritativeKinds: ["exports"],
-    notes: ["normalizes function node compatibility for native javascript grammar"]
-  }
-};
-registerLanguage(JAVASCRIPT_DEF);
-
-// dist/util/identifiers.js
-function hasNonAsciiCodePoint(value, includeC0Controls = false) {
-  for (const character of value) {
-    const codePoint = character.codePointAt(0);
-    if (codePoint > 127 || includeC0Controls && codePoint <= 31)
-      return true;
-  }
-  return false;
-}
-var ECMASCRIPT_IDENTIFIER_SOURCE = String.raw`[$_\p{ID_Start}](?:[$_\p{ID_Continue}]|\u200c|\u200d)*`;
-var BLOOM_FILTER_IDENTIFIER_SOURCE = String.raw`[A-Za-z0-9_$\u0000-\u0008\u000E-\u001B\u007F-\u009F\u200C\u200D\u0080-\u{10FFFF}]+`;
-var XID_IDENTIFIER_SOURCE = String.raw`[_\p{XID_Start}][_\p{XID_Continue}]*`;
-var PHP_IDENTIFIER_SOURCE = String.raw`[A-Za-z_\u{80}-\u{10FFFF}][A-Za-z0-9_\u{80}-\u{10FFFF}]*`;
-var JAVA_IDENTIFIER_IGNORABLE_SOURCE = String.raw`\p{Cf}\u0000-\u0008\u000E-\u001B\u007F-\u009F`;
-var CSHARP_IDENTIFIER_FORMAT_SOURCE = String.raw`\p{Cf}`;
-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
-var PYTHON_DEF = {
-  id: "python",
-  extensions: [".py", ".pyi"],
-  usesQueryDrivenLocals: true,
-  structure: {
-    blocks: [
-      {
-        type: "class_definition",
-        nameQuery: "name: (identifier) @chunk.name",
-        captureId: "class"
-      },
-      {
-        type: "function_definition",
-        nameQuery: "name: (identifier) @chunk.name",
-        captureId: "function"
-      },
-      // Docstrings - only capture top-level module docstrings as standalone chunks
-      {
-        type: "expression_statement",
-        nameQuery: "(string) @chunk.docstring",
-        isBlock: false,
-        parentType: "module"
-      },
-      // Top level assignments
-      {
-        type: "assignment",
-        nameQuery: "left: (identifier) @chunk.name",
-        captureId: "module_var"
-      },
-      // Imports
-      { type: "import_statement", captureId: "imports" },
-      { type: "import_from_statement", captureId: "imports" }
-    ],
-    splitPoints: [
-      "if_statement",
-      "for_statement",
-      "while_statement",
-      "try_statement",
-      "with_statement",
-      "match_statement"
-    ],
-    comments: ["comment"]
-  },
-  graph: {
-    imports: `
-      (import_statement) @stmt
-      (import_from_statement) @stmt
-      (future_import_statement) @stmt
-    `,
-    // NOTE: These __all__ queries only capture module-level assignments.
-    // Dynamic __all__ definitions inside functions, conditionals, or loops
-    // (e.g., `if PY3: __all__ = [...]`) are not detected by these patterns.
-    // This is a known limitation - such patterns are rare in practice.
-    exports: `
-      ;; __all__ = ["a", "b"] - simple list assignment
-      (assignment left: (identifier) @left right: (list (string)+ @all_item)) @stmt
-      ;; __all__ = ("a", "b") - tuple assignment
-      (assignment left: (identifier) @left right: (tuple (string)+ @all_item)) @stmt
-      ;; __all__ = ["a"] + ["b"] - concatenation (captures strings in both sides)
-      (assignment left: (identifier) @left right: (binary_operator (list (string)+ @all_item))) @stmt
-      (assignment left: (identifier) @left right: (binary_operator right: (list (string)+ @all_item))) @stmt
-      ;; __all__.extend(["a"]) - extend pattern
-      (expression_statement (call function: (attribute object: (identifier) @left attribute: (identifier) @method) arguments: (argument_list (list (string)+ @all_item)))) @stmt
-      ;; __all__.append("a") - append pattern
-      (expression_statement (call function: (attribute object: (identifier) @left attribute: (identifier) @method) arguments: (argument_list (string) @all_item))) @stmt
-      ;; __all__ += ["a"] - augmented assignment
-      (augmented_assignment left: (identifier) @left right: (list (string)+ @all_item)) @stmt
-      (function_definition name: (identifier) @name)
-      (class_definition name: (identifier) @name)
-      (assignment left: (identifier) @name)
-    `,
-    locals: `
-      (function_definition name: (identifier) @name)
-      (class_definition name: (identifier) @name)
-      (assignment left: (identifier) @name)
-      ;; \`case Point(x=x, y=y):\` binds the right-hand identifier of a keyword
-      ;; pattern as a new local, distinct from the left-hand attribute name it
-      ;; matches against.
-      ;; A bare identifier in a case pattern is represented as a single-name
-      ;; dotted_name inside a case_pattern. Nested tuple/list/or patterns
-      ;; preserve this shape for each capture.
-      (case_pattern (dotted_name (identifier) @name))
-      ;; \`case value as alias:\` binds the direct identifier child as its alias.
-      (as_pattern (identifier) @name)
-      ;; \`case [head, *tail]:\` binds the capture after the splat.
-      (splat_pattern (identifier) @name)
-    `,
-    importBindings: `
-      (import_statement) @stmt
-      (import_from_statement) @stmt
-      (future_import_statement) @stmt
-    `
-  },
-  nodeTypes: {
-    identifier: ["identifier"],
-    propertyIdentifier: ["identifier"],
-    memberExpression: "attribute"
-  },
-  classifyDefinition: (n) => {
-    const t = n.parent?.type;
-    if (t === "function_definition")
-      return "function";
-    if (t === "class_definition")
-      return "class";
-    return "variable";
-  },
-  scopeDeclarationNames: (node) => {
-    const parentType = node.parent?.type;
-    return parentType === "case_pattern" || parentType === "as_pattern" || parentType === "splat_pattern" || parentType === "dotted_name";
-  },
-  isDeclarationName: (node) => {
-    const parent = node.parent;
-    const t = parent?.type;
-    if (t === "dotted_name" && parent && parent.namedChildren.length === 1 && (parent.parent?.type === "keyword_pattern" || parent.parent?.type === "case_pattern"))
-      return true;
-    if (parent?.type === "as_pattern")
-      return true;
-    if (t === "splat_pattern")
-      return true;
-    return !!t && ["function_definition", "class_definition", "assignment", "aliased_import"].includes(t);
-  },
-  createsBlockScope: (n) => n.type === "module" || n.type === "block",
-  createsFunctionScope: (n) => n.type === "function_definition" || n.type === "lambda",
-  membersAreImplicitlyInScope: false,
-  supportsCrossModuleSymbols: true,
-  normalizeIdentifier: (name) => hasNonAsciiCodePoint(name) ? name.normalize("NFKC") : name
-};
-registerLanguage(PYTHON_DEF);
-
-// dist/languages/definitions/php.js
-var PHP_DEF = {
-  id: "php",
-  extensions: [".php"],
-  usesQueryDrivenLocals: true,
-  structure: {
-    blocks: [
-      {
-        type: "namespace_definition",
-        nameQuery: "name: (namespace_name) @chunk.name",
-        captureId: "namespace"
-      },
-      {
-        type: "class_declaration",
-        nameQuery: "name: (name) @chunk.name",
-        captureId: "class"
-      },
-      {
-        type: "interface_declaration",
-        nameQuery: "name: (name) @chunk.name",
-        captureId: "interface"
-      },
-      {
-        type: "trait_declaration",
-        nameQuery: "name: (name) @chunk.name",
-        captureId: "trait"
-      },
-      {
-        type: "enum_declaration",
-        nameQuery: "name: (name) @chunk.name",
-        captureId: "enum"
-      },
-      {
-        type: "function_definition",
-        nameQuery: "name: (name) @chunk.name",
-        captureId: "function"
-      },
-      {
-        type: "method_declaration",
-        nameQuery: "name: (name) @chunk.name",
-        captureId: "method"
-      },
-      {
-        type: "const_declaration",
-        nameQuery: "(const_element (name) @chunk.name)",
-        captureId: "const"
-      }
-    ],
-    splitPoints: [
-      "if_statement",
-      "switch_statement",
-      "for_statement",
-      "foreach_statement",
-      "while_statement",
-      "do_statement",
-      "try_statement",
-      "match_expression"
-    ],
-    comments: ["comment"]
-  },
-  graph: {
-    imports: `
-      (require_expression) @stmt
-      (include_expression) @stmt
-      (require_once_expression) @stmt
-      (include_once_expression) @stmt
-      (namespace_use_declaration) @stmt
-    `,
-    exports: `
-      (namespace_definition name: (namespace_name) @name)
-      (class_declaration name: (name) @name)
-      (interface_declaration name: (name) @name)
-      (trait_declaration name: (name) @name)
-      (enum_declaration name: (name) @name)
-      (enum_case name: (name) @name)
-      (function_definition name: (name) @name)
-      (const_declaration (const_element (name) @name))
-    `,
-    locals: `
-      (class_declaration name: (name) @name)
-      (interface_declaration name: (name) @name)
-      (trait_declaration name: (name) @name)
-      (enum_declaration name: (name) @name)
-      (enum_case name: (name) @name)
-      (function_definition name: (name) @name)
-      (method_declaration name: (name) @name)
-      (const_declaration (const_element (name) @name))
-      (property_element (variable_name) @name)
-    `,
-    importBindings: `
-      (require_expression) @stmt
-      (include_expression) @stmt
-      (require_once_expression) @stmt
-      (include_once_expression) @stmt
-      (namespace_use_declaration) @stmt
-  `
-  },
-  nodeTypes: {
-    identifier: ["name", "variable_name", "namespace_name", "qualified_name", "relative_name"],
-    propertyIdentifier: ["name"],
-    memberExpression: "member_access_expression"
-  },
-  classifyDefinition: (node) => {
-    const parentType = node.parent?.type;
-    if (parentType === "class_declaration")
-      return "class";
-    if (parentType === "interface_declaration")
-      return "interface";
-    if (parentType === "trait_declaration")
-      return "trait";
-    if (parentType === "enum_declaration")
-      return "type";
-    if (parentType === "enum_case")
-      return "constant";
-    if (parentType === "function_definition")
-      return "function";
-    if (parentType === "method_declaration")
-      return "method";
-    if (parentType === "namespace_definition")
-      return "namespace";
-    if (parentType === "const_element" || parentType === "const_declaration") {
-      return "constant";
-    }
-    return "variable";
-  },
-  normalizeIdentifier: (name) => name.replace(/^\$/, ""),
-  isDeclarationName: (node) => {
-    const parent = node.parent;
-    if (!parent)
-      return false;
-    const nameFieldOwnerTypes = /* @__PURE__ */ new Set([
-      "namespace_definition",
-      "class_declaration",
-      "interface_declaration",
-      "trait_declaration",
-      "enum_declaration",
-      "enum_case",
-      "function_definition",
-      "method_declaration"
-    ]);
-    if (nameFieldOwnerTypes.has(parent.type)) {
-      return parent.childForFieldName("name")?.id === node.id;
-    }
-    if (parent.type === "property_element" && node.type === "variable_name")
-      return true;
-    return parent.type === "const_element" && parent.namedChildren.some((child) => child.id === node.id && child.type === "name");
-  },
-  scopeDeclarationNames: (node) => node.type === "variable_name" && node.parent?.type === "property_element",
-  createsFunctionScope: (node) => node.type === "function_definition" || node.type === "method_declaration",
-  membersAreImplicitlyInScope: false,
-  supportsCrossModuleSymbols: true
-};
-registerLanguage(PHP_DEF);
-
-// dist/languages/definitions/html.js
-var HTML_DEF = {
-  id: "html",
-  extensions: [".html", ".htm"],
-  structure: {
-    blocks: [
-      {
-        type: "element",
-        nameQuery: `(start_tag (attribute (attribute_name) @attr (#eq? @attr "id") (quoted_attribute_value (attribute_value) @chunk.name)))`,
-        captureId: "element"
-      },
-      { type: "script_element", captureId: "script" },
-      { type: "style_element", captureId: "style" }
-    ],
-    splitPoints: ["element"],
-    comments: ["comment"]
-  },
-  graph: {
-    imports: `
-      (script_element (start_tag (attribute (attribute_name) @attr (#eq? @attr "src") (quoted_attribute_value (attribute_value) @mod)))) @stmt
-      (element (start_tag (tag_name) @tag (attribute (attribute_name) @attr (#eq? @attr "href") (quoted_attribute_value (attribute_value) @mod)))) @stmt (#match? @tag "^(link|a)$")
-      (element (self_closing_tag (tag_name) @tag (attribute (attribute_name) @attr (#eq? @attr "href") (quoted_attribute_value (attribute_value) @mod)))) @stmt (#match? @tag "^(link|a)$")
-      (element (start_tag (tag_name) @tag (attribute (attribute_name) @attr (#eq? @attr "src") (quoted_attribute_value (attribute_value) @mod)))) @stmt (#eq? @tag "img")
-      (element (self_closing_tag (tag_name) @tag (attribute (attribute_name) @attr (#eq? @attr "src") (quoted_attribute_value (attribute_value) @mod)))) @stmt (#eq? @tag "img")
-    `,
-    exports: "",
-    locals: `
-      (attribute (attribute_name) @attr (#eq? @attr "id") (quoted_attribute_value (attribute_value) @name))
-    `,
-    importBindings: `
-      (script_element (start_tag (attribute (attribute_name) @attr (#eq? @attr "src") (quoted_attribute_value (attribute_value) @from)))) @stmt
-      (element (start_tag (tag_name) @tag (attribute (attribute_name) @attr (#eq? @attr "href") (quoted_attribute_value (attribute_value) @from)))) @stmt (#match? @tag "^(link|a)$")
-      (element (self_closing_tag (tag_name) @tag (attribute (attribute_name) @attr (#eq? @attr "href") (quoted_attribute_value (attribute_value) @from)))) @stmt (#match? @tag "^(link|a)$")
-      (element (start_tag (tag_name) @tag (attribute (attribute_name) @attr (#eq? @attr "src") (quoted_attribute_value (attribute_value) @from)))) @stmt (#eq? @tag "img")
-      (element (self_closing_tag (tag_name) @tag (attribute (attribute_name) @attr (#eq? @attr "src") (quoted_attribute_value (attribute_value) @from)))) @stmt (#eq? @tag "img")
-    `
-  },
-  nodeTypes: {
-    identifier: ["attribute_value", "tag_name"]
-  }
-};
-registerLanguage(HTML_DEF);
-
-// dist/languages/definitions/htmlStub.js
-function htmlStubLanguage(id, extensions) {
-  return {
-    id,
-    extensions,
-    structure: {
-      blocks: [],
-      splitPoints: [],
-      comments: []
-    },
-    graph: {
-      imports: "",
-      exports: "",
-      locals: "",
-      importBindings: ""
-    },
-    nodeTypes: {
-      identifier: []
-    }
-  };
-}
-
-// dist/languages/definitions/astro.js
-var ASTRO_DEF = htmlStubLanguage("astro", [".astro"]);
-registerLanguage(ASTRO_DEF);
-
-// dist/languages/definitions/hbs.js
-var HBS_DEF = htmlStubLanguage("hbs", [".hbs", ".handlebars"]);
-registerLanguage(HBS_DEF);
-
-// dist/languages/definitions/markdown.js
-var MARKDOWN_DEF = htmlStubLanguage("markdown", [".md"]);
-registerLanguage(MARKDOWN_DEF);
-
-// dist/languages/definitions/mdx.js
-var MDX_DEF = htmlStubLanguage("mdx", [".mdx"]);
-registerLanguage(MDX_DEF);
-
-// dist/languages/definitions/rst.js
-var RST_DEF = htmlStubLanguage("rst", [".rst"]);
-registerLanguage(RST_DEF);
-
-// dist/languages/definitions/adoc.js
-var ADOC_DEF = htmlStubLanguage("adoc", [".adoc", ".asciidoc"]);
-registerLanguage(ADOC_DEF);
-
-// dist/languages/definitions/cssLike.js
-function cssLikeStructure() {
-  return {
-    blocks: [
-      { type: "rule_set", captureId: "rule" },
-      { type: "media_statement", captureId: "media" },
-      { type: "keyframes_statement", captureId: "keyframes" }
-    ],
-    splitPoints: ["rule_set"],
-    comments: ["comment", "js_comment"]
-  };
-}
-function cssLikeGraph() {
-  return {
-    imports: `
-      (import_statement (string_value) @mod) @stmt
-    `,
-    exports: "",
-    locals: `
-      (class_selector (class_name) @name)
-      (id_selector (id_name) @name)
-    `,
-    importBindings: `
-      (import_statement (string_value) @from) @stmt
-    `
-  };
-}
-function cssLikeNodeTypes() {
-  return {
-    identifier: ["class_name", "id_name"]
-  };
-}
-
-// dist/languages/definitions/css.js
-var CSS_DEF = {
-  id: "css",
-  extensions: [".css"],
-  structure: cssLikeStructure(),
-  graph: cssLikeGraph(),
-  nodeTypes: cssLikeNodeTypes()
-};
-registerLanguage(CSS_DEF);
-
-// dist/languages/definitions/scss.js
-var SCSS_SYMBOL_QUERY_PATTERNS = [
-  "(mixin_statement (name) @name)",
-  "(function_statement (name) @name)",
-  "(variable_declaration (variable) @name)",
-  "(class_selector (class_name) @name)",
-  "(id_selector (id_name) @name)"
-];
-var SCSS_DEF = {
-  id: "scss",
-  extensions: [".scss"],
-  structure: {
-    blocks: [
-      { type: "rule_set", captureId: "rule" },
-      { type: "mixin_statement", captureId: "mixin" },
-      { type: "function_statement", captureId: "function" },
-      { type: "media_statement", captureId: "media" },
-      { type: "keyframes_statement", captureId: "keyframes" }
-    ],
-    splitPoints: ["rule_set", "mixin_statement", "function_statement"],
-    comments: ["comment", "js_comment"]
-  },
-  graph: {
-    imports: `
-      (import_statement (string_value) @mod) @stmt
-      (use_statement (string_value) @mod) @stmt
-      (forward_statement (string_value) @mod) @stmt
-    `,
-    exports: `
-      (mixin_statement (name) @name)
-      (function_statement (name) @name)
-      (variable_declaration (variable) @name)
-    `,
-    locals: `
-      (mixin_statement (name) @name)
-      (function_statement (name) @name)
-      (variable_declaration (variable) @name)
-      (class_selector (class_name) @name)
-      (id_selector (id_name) @name)
-    `,
-    importBindings: `
-      (import_statement (string_value) @from) @stmt
-      (use_statement (string_value) @from) @stmt
-      (forward_statement (string_value) @from) @stmt
-    `
-  },
-  nodeTypes: {
-    identifier: ["name", "variable", "class_name", "id_name"]
-  },
-  native: {
-    normalizeQuery: (_kind, query) => SCSS_SYMBOL_QUERY_PATTERNS.some((pattern) => query.includes(pattern)) ? "" : query,
-    notes: ["skips unsupported SCSS symbol queries in the native runtime"]
-  }
-};
-registerLanguage(SCSS_DEF);
-
-// dist/languages/definitions/less.js
-var LESS_DEF = {
-  id: "less",
-  extensions: [".less"],
-  structure: cssLikeStructure(),
-  graph: cssLikeGraph(),
-  nodeTypes: cssLikeNodeTypes()
-};
-registerLanguage(LESS_DEF);
-
-// dist/languages/definitions/vue.js
-var VUE_DEF = {
-  id: "vue",
-  extensions: [".vue"],
-  structure: {
-    blocks: [
-      { type: "template_element", captureId: "template" },
-      { type: "script_element", captureId: "script" },
-      { type: "style_element", captureId: "style" }
-    ],
-    splitPoints: ["template_element", "script_element", "style_element"],
-    comments: ["comment"]
-  },
-  graph: {
-    imports: `
-      (script_element (start_tag (attribute (attribute_name) @attr (#eq? @attr "src") (quoted_attribute_value (attribute_value) @mod)))) @stmt
-    `,
-    exports: "",
-    locals: "",
-    importBindings: `
-      (script_element (start_tag (attribute (attribute_name) @attr (#eq? @attr "src") (quoted_attribute_value (attribute_value) @from)))) @stmt
-    `
-  },
-  nodeTypes: {
-    identifier: ["attribute_value"]
-  }
-};
-registerLanguage(VUE_DEF);
-
-// dist/languages/definitions/svelte.js
-var SVELTE_DEF = {
-  id: "svelte",
-  extensions: [".svelte"],
-  structure: {
-    blocks: [
-      { type: "script_element", captureId: "script" },
-      { type: "style_element", captureId: "style" },
-      { type: "element", captureId: "element" }
-    ],
-    splitPoints: ["script_element", "style_element"],
-    comments: ["comment"]
-  },
-  graph: {
-    imports: `
-      (script_element (start_tag (attribute (attribute_name) @attr (#eq? @attr "src") (quoted_attribute_value (attribute_value) @mod)))) @stmt
-    `,
-    exports: "",
-    locals: "",
-    importBindings: `
-      (script_element (start_tag (attribute (attribute_name) @attr (#eq? @attr "src") (quoted_attribute_value (attribute_value) @from)))) @stmt
-    `
-  },
-  nodeTypes: {
-    identifier: ["attribute_value"]
-  }
-};
-registerLanguage(SVELTE_DEF);
-
-// dist/languages/definitions/ruby.js
-var RUBY_DEF = {
-  id: "ruby",
-  extensions: [".rb"],
-  structure: {
-    blocks: [
-      {
-        type: "class",
-        nameQuery: "name: (constant) @chunk.name",
-        captureId: "class"
-      },
-      {
-        type: "module",
-        nameQuery: "name: (constant) @chunk.name",
-        captureId: "module"
-      },
-      {
-        type: "method",
-        nameQuery: "name: (identifier) @chunk.name",
-        captureId: "method"
-      },
-      {
-        type: "singleton_method",
-        nameQuery: "name: (identifier) @chunk.name",
-        captureId: "method"
-      }
-    ],
-    splitPoints: ["if", "unless", "case", "while", "until", "for", "begin"],
-    comments: ["comment"]
-  },
-  graph: {
-    imports: `
-      (call method: (identifier) @method arguments: (argument_list (string (string_content) @mod)) (#match? @method "^(require|require_relative)$")) @stmt
-    `,
-    exports: `
-      (class name: (constant) @name)
-      (module name: (constant) @name)
-      (method name: (identifier) @name)
-      (assignment left: (constant) @name)
-    `,
-    locals: `
-      (class name: (constant) @name)
-      (module name: (constant) @name)
-      (method name: (identifier) @name)
-      (assignment left: (identifier) @name)
-      (assignment left: (constant) @name)
-    `,
-    importBindings: `
-      ((call method: (identifier) @method arguments: (argument_list (string (string_content) @from))) @stmt (#match? @method "^(require|require_relative)$"))
-    `
-  },
-  nodeTypes: {
-    identifier: ["identifier", "constant"],
-    memberExpression: "call"
-  },
-  supportsCrossModuleSymbols: true,
-  classifyDefinition: (node) => {
-    const assignment = node.parent;
-    const value = assignment?.childForFieldName("right");
-    if (assignment?.type === "assignment" && assignment.childForFieldName("left")?.id === node.id && value?.type === "call" && value.childForFieldName("receiver")?.text === "Struct" && value.childForFieldName("method")?.text === "new") {
-      return "class";
-    }
-    return "variable";
-  },
-  scopeDeclarationNames: (node) => node.type === "constant" && node.parent?.type === "assignment",
-  createsFunctionScope: (node) => node.type === "method" || node.type === "singleton_method",
-  createsBlockScope: (node) => node.type === "do_block" || node.type === "block",
-  isDeclarationName: (node) => {
-    const p = node.parent;
-    if (!p)
-      return false;
-    if (p.type === "class" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "module" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "method" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "singleton_method" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "assignment" && p.childForFieldName("left")?.id === node.id)
-      return true;
-    return false;
-  }
-};
-registerLanguage(RUBY_DEF);
-
-// dist/languages/definitions/go.js
-var GO_DEF = {
-  id: "go",
-  extensions: [".go"],
-  usesQueryDrivenLocals: true,
-  structure: {
-    blocks: [
-      {
-        type: "function_declaration",
-        nameQuery: "name: (identifier) @chunk.name",
-        captureId: "function"
-      },
-      {
-        type: "method_declaration",
-        nameQuery: "name: (field_identifier) @chunk.name",
-        captureId: "method"
-      },
-      {
-        type: "type_declaration",
-        nameQuery: "(type_spec name: (type_identifier) @chunk.name)",
-        captureId: "type"
-      }
-    ],
-    splitPoints: [
-      "if_statement",
-      "for_statement",
-      "expression_switch_statement",
-      "type_switch_statement",
-      "select_statement"
-    ],
-    comments: ["comment"]
-  },
-  graph: {
-    imports: `
-      (import_spec path: (interpreted_string_literal) @mod) @stmt
-    `,
-    exports: `
-      (function_declaration name: (identifier) @name)
-      (method_declaration name: (field_identifier) @name)
-      (type_spec name: (type_identifier) @name)
-      (const_spec name: (identifier) @name)
-      (var_spec name: (identifier) @name)
-    `,
-    locals: `
-      (function_declaration name: (identifier) @name)
-      (method_declaration name: (field_identifier) @name)
-      (type_spec name: (type_identifier) @name)
-      (parameter_declaration name: (identifier) @name)
-      (variadic_parameter_declaration name: (identifier) @name)
-      (short_var_declaration left: (expression_list (identifier) @name))
-      (var_spec name: (identifier) @name)
-      (const_spec name: (identifier) @name)
-      (type_spec type: (struct_type (field_declaration_list (field_declaration name: (field_identifier) @name))))
-      (range_clause left: (expression_list (identifier) @name) (#not-eq? @name "_"))
-    `,
-    importBindings: `
-      (import_spec name: (package_identifier) @alias path: (interpreted_string_literal) @from) @stmt
-      (import_spec path: (interpreted_string_literal) @from) @stmt
-    `
-  },
-  nodeTypes: {
-    identifier: ["identifier", "field_identifier", "type_identifier", "package_identifier"],
-    memberExpression: "selector_expression"
-  },
-  supportsCrossModuleSymbols: true,
-  classifyDefinition: (node) => {
-    const parent = node.parent;
-    if (!parent)
-      return "variable";
-    if (parent.type === "function_declaration" || parent.type === "method_declaration")
-      return "function";
-    if (parent.type === "type_spec" && parent.childForFieldName("name")?.id === node.id)
-      return "type";
-    return "variable";
-  },
-  createsFunctionScope: (node) => node.type === "function_declaration" || node.type === "method_declaration" || node.type === "func_literal",
-  createsBlockScope: (node) => node.type === "block" || node.type === "for_statement",
-  membersAreImplicitlyInScope: false,
-  isDeclarationName: (node) => {
-    const p = node.parent;
-    if (!p)
-      return false;
-    if (p.type === "function_declaration" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "method_declaration" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "type_spec" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "var_spec" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "const_spec" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "expression_list" && p.parent?.type === "short_var_declaration")
-      return node.type === "identifier";
-    if (p.type === "expression_list" && p.parent?.type === "range_clause")
-      return node.type === "identifier" && node.text !== "_";
-    if (p.type === "parameter_declaration" || p.type === "variadic_parameter_declaration") {
-      return node.type === "identifier";
-    }
-    if (p.type === "field_declaration" && node.type === "field_identifier")
-      return true;
-    return false;
-  },
-  scopeDeclarationNames: (node) => node.type === "field_identifier" && node.parent?.type === "field_declaration" || node.type === "identifier" && node.parent?.type === "expression_list" && node.parent.parent?.type === "range_clause"
-};
-registerLanguage(GO_DEF);
-
-// dist/languages/definitions/java.js
-var JAVA_IDENTIFIER_IGNORABLE_PATTERN = new RegExp(`[${JAVA_IDENTIFIER_IGNORABLE_SOURCE}]`, "gu");
-var JAVA_DEF = {
-  id: "java",
-  extensions: [".java"],
-  usesQueryDrivenLocals: true,
-  structure: {
-    blocks: [
-      {
-        type: "class_declaration",
-        nameQuery: "name: (identifier) @chunk.name",
-        captureId: "class"
-      },
-      {
-        type: "record_declaration",
-        nameQuery: "name: (identifier) @chunk.name",
-        captureId: "class"
-      },
-      {
-        type: "interface_declaration",
-        nameQuery: "name: (identifier) @chunk.name",
-        captureId: "interface"
-      },
-      {
-        type: "enum_declaration",
-        nameQuery: "name: (identifier) @chunk.name",
-        captureId: "enum"
-      },
-      {
-        type: "annotation_type_declaration",
-        nameQuery: "name: (identifier) @chunk.name",
-        captureId: "interface"
-      },
-      {
-        type: "method_declaration",
-        nameQuery: "name: (identifier) @chunk.name",
-        captureId: "method"
-      },
-      {
-        type: "constructor_declaration",
-        nameQuery: "name: (identifier) @chunk.name",
-        captureId: "method"
-      }
-    ],
-    splitPoints: ["if_statement", "for_statement", "while_statement", "try_statement", "switch_expression"],
-    comments: ["line_comment", "block_comment"]
-  },
-  graph: {
-    imports: `
-      (import_declaration . (_) @mod) @stmt
-    `,
-    exports: `
-      (class_declaration name: (identifier) @name)
-      (record_declaration name: (identifier) @name)
-      (interface_declaration name: (identifier) @name)
-      (enum_declaration name: (identifier) @name)
-      (annotation_type_declaration name: (identifier) @name)
-      (enum_constant name: (identifier) @name)
-      (method_declaration name: (identifier) @name)
-      (field_declaration (variable_declarator name: (identifier) @name))
-    `,
-    locals: `
-      (class_declaration name: (identifier) @name)
-      (record_declaration name: (identifier) @name)
-      (interface_declaration name: (identifier) @name)
-      (enum_declaration name: (identifier) @name)
-      (annotation_type_declaration name: (identifier) @name)
-      (enum_constant name: (identifier) @name)
-      (method_declaration name: (identifier) @name)
-      (variable_declarator name: (identifier) @name)
-    `,
-    importBindings: `
-      (import_declaration . (_) @from) @stmt
-    `
-  },
-  nodeTypes: {
-    identifier: ["identifier", "type_identifier"],
-    memberExpression: "field_access"
-  },
-  supportsCrossModuleSymbols: true,
-  classifyDefinition: (node) => {
-    const parent = node.parent;
-    if (!parent)
-      return "variable";
-    if (parent.type === "method_declaration" || parent.type === "constructor_declaration")
-      return "method";
-    if (parent.type === "class_declaration" || parent.type === "record_declaration")
-      return "class";
-    if (parent.type === "interface_declaration" || parent.type === "annotation_type_declaration")
-      return "interface";
-    if (parent.type === "enum_declaration")
-      return "type";
-    return "variable";
-  },
-  createsFunctionScope: (node) => node.type === "method_declaration" || node.type === "constructor_declaration",
-  createsBlockScope: (node) => node.type === "block" || node.type === "class_body",
-  isDeclarationName: (node) => {
-    const p = node.parent;
-    if (!p)
-      return false;
-    if (p.type === "class_declaration" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "record_declaration" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "interface_declaration" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "annotation_type_declaration" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "enum_declaration" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "enum_constant" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "method_declaration" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "variable_declarator" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "formal_parameter" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    return false;
-  },
-  normalizeIdentifier: (name) => hasNonAsciiCodePoint(name, true) ? name.replace(JAVA_IDENTIFIER_IGNORABLE_PATTERN, "") : name
-};
-registerLanguage(JAVA_DEF);
-
-// dist/languages/definitions/csharp.js
-var CSHARP_IDENTIFIER_FORMAT_PATTERN = new RegExp(`[${CSHARP_IDENTIFIER_FORMAT_SOURCE}]`, "gu");
-var CSHARP_DEF = {
-  id: "csharp",
-  extensions: [".cs"],
-  usesQueryDrivenLocals: true,
-  structure: {
-    blocks: [
-      {
-        type: "class_declaration",
-        nameQuery: "name: (identifier) @chunk.name",
-        captureId: "class"
-      },
-      {
-        type: "record_declaration",
-        nameQuery: "name: (identifier) @chunk.name",
-        captureId: "class"
-      },
-      {
-        type: "interface_declaration",
-        nameQuery: "name: (identifier) @chunk.name",
-        captureId: "interface"
-      },
-      {
-        type: "enum_declaration",
-        nameQuery: "name: (identifier) @chunk.name",
-        captureId: "enum"
-      },
-      {
-        type: "method_declaration",
-        nameQuery: "name: (identifier) @chunk.name",
-        captureId: "method"
-      },
-      {
-        type: "namespace_declaration",
-        nameQuery: "name: (identifier) @chunk.name",
-        captureId: "namespace"
-      }
-    ],
-    splitPoints: [
-      "if_statement",
-      "for_statement",
-      "foreach_statement",
-      "while_statement",
-      "switch_statement",
-      "try_statement"
-    ],
-    comments: ["comment"]
-  },
-  graph: {
-    imports: `
-      (using_directive . (_) @mod) @stmt
-    `,
-    exports: `
-      (class_declaration name: (identifier) @name)
-      (record_declaration name: (identifier) @name)
-      (interface_declaration name: (identifier) @name)
-      (enum_declaration name: (identifier) @name)
-      (enum_member_declaration name: (identifier) @name)
-      (method_declaration name: (identifier) @name)
-      (property_declaration name: (identifier) @name)
-    `,
-    locals: `
-      (class_declaration name: (identifier) @name)
-      (record_declaration name: (identifier) @name)
-      (interface_declaration name: (identifier) @name)
-      (enum_declaration name: (identifier) @name)
-      (enum_member_declaration name: (identifier) @name)
-      (method_declaration name: (identifier) @name)
-      (variable_declarator (identifier) @name)
-      (declaration_pattern name: (identifier) @name)
-    `,
-    importBindings: `
-      (using_directive name: (identifier) @alias . (_) @from) @stmt
-      (using_directive . (_) @from) @stmt
-    `
-  },
-  nodeTypes: {
-    identifier: ["identifier"],
-    memberExpression: "member_access_expression"
-  },
-  supportsCrossModuleSymbols: true,
-  classifyDefinition: (node) => {
-    const parent = node.parent;
-    if (!parent)
-      return "variable";
-    if (parent.type === "method_declaration" || parent.type === "constructor_declaration")
-      return "method";
-    if (parent.type === "class_declaration" || parent.type === "record_declaration")
-      return "class";
-    if (parent.type === "interface_declaration")
-      return "interface";
-    if (parent.type === "enum_declaration")
-      return "type";
-    return "variable";
-  },
-  createsFunctionScope: (node) => node.type === "method_declaration" || node.type === "constructor_declaration",
-  createsBlockScope: (node) => node.type === "block" || node.type === "declaration_list",
-  isDeclarationName: (node) => {
-    const p = node.parent;
-    if (!p)
-      return false;
-    if (p.type === "class_declaration" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "record_declaration" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "interface_declaration" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "enum_declaration" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "enum_member_declaration" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "method_declaration" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "variable_declarator" && p.child(0)?.id === node.id)
-      return true;
-    if (p.type === "parameter" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "declaration_pattern" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    return false;
-  },
-  normalizeIdentifier: (name) => {
-    const withoutVerbatimPrefix = name.startsWith("@") ? name.slice(1) : name;
-    return hasNonAsciiCodePoint(withoutVerbatimPrefix) ? withoutVerbatimPrefix.replace(CSHARP_IDENTIFIER_FORMAT_PATTERN, "") : withoutVerbatimPrefix;
-  }
-};
-registerLanguage(CSHARP_DEF);
-
-// dist/languages/definitions/rust.js
-var RUST_DEF = {
-  id: "rust",
-  extensions: [".rs"],
-  usesQueryDrivenLocals: true,
-  structure: {
-    blocks: [
-      {
-        type: "function_item",
-        nameQuery: "name: (identifier) @chunk.name",
-        captureId: "function"
-      },
-      {
-        type: "struct_item",
-        nameQuery: "name: (type_identifier) @chunk.name",
-        captureId: "struct"
-      },
-      {
-        type: "enum_item",
-        nameQuery: "name: (type_identifier) @chunk.name",
-        captureId: "enum"
-      },
-      {
-        type: "impl_item",
-        nameQuery: "type: (type_identifier) @chunk.name",
-        captureId: "impl"
-      },
-      {
-        type: "mod_item",
-        nameQuery: "name: (identifier) @chunk.name",
-        captureId: "module"
-      },
-      {
-        type: "macro_definition",
-        nameQuery: "name: (identifier) @chunk.name",
-        captureId: "macro"
-      }
-    ],
-    splitPoints: ["if_expression", "for_expression", "while_expression", "loop_expression", "match_expression"],
-    comments: ["line_comment", "block_comment"]
-  },
-  graph: {
-    imports: `
-      (mod_item name: (identifier) @mod) @stmt
-      (extern_crate_declaration name: (identifier) @mod) @stmt
-      (use_declaration argument: (_) @mod) @stmt
-    `,
-    exports: `
-      (function_item name: (identifier) @name) @stmt
-      (struct_item name: (type_identifier) @name) @stmt
-      (trait_item name: (type_identifier) @name) @stmt
-      (enum_item name: (type_identifier) @name) @stmt
-      (enum_variant name: (identifier) @name) @stmt
-      (const_item name: (identifier) @name) @stmt
-      (static_item name: (identifier) @name) @stmt
-      (macro_definition name: (identifier) @name) @stmt
-      (use_declaration argument: (scoped_identifier path: (_) @from name: (identifier) @src)) @stmt
-      (use_declaration argument: (identifier) @src) @stmt
-      ;; Grouped imports: \`use foo::{Bar, Baz};\` (and scoped forms like
-      ;; \`use crate::foo::{Bar, Baz};\`) - emit one export per named member
-      ;; so each is a resolvable target, matching the plain scoped_identifier
-      ;; form above. The shared path may itself be scoped, so it is captured
-      ;; generically rather than requiring a single bare identifier segment.
-      (use_declaration argument: (scoped_use_list path: (_) @from list: (use_list (identifier) @src))) @stmt
-      ;; Aliased members inside a group (\`use foo::{Bar as Baz}\`) export
-      ;; under their alias, matching how a single aliased import behaves.
-      (use_declaration argument: (scoped_use_list path: (_) @from list: (use_list (use_as_clause alias: (identifier) @src)))) @stmt
-    `,
-    locals: `
-      (function_item name: (identifier) @name)
-      (struct_item name: (type_identifier) @name)
-      (trait_item name: (type_identifier) @name)
-      (enum_item name: (type_identifier) @name)
-      (enum_variant name: (identifier) @name)
-      (const_item name: (identifier) @name)
-      (static_item name: (identifier) @name)
-      (macro_definition name: (identifier) @name)
-      (let_declaration pattern: (identifier) @name)
-      (parameter pattern: (identifier) @name)
-    `,
-    importBindings: `
-      (mod_item name: (identifier) @from) @stmt
-      (extern_crate_declaration name: (identifier) @from) @stmt
-      (extern_crate_declaration name: (identifier) @from alias: (identifier) @alias) @stmt
-      (use_declaration argument: (use_as_clause path: (identifier) @from alias: (identifier) @alias)) @stmt
-      (use_declaration argument: (use_as_clause path: (scoped_identifier path: (_) @from name: (identifier) @iname) alias: (identifier) @alias)) @stmt
-      (use_declaration argument: (scoped_identifier path: (_) @from name: (identifier) @iname)) @stmt
-      (use_declaration argument: (identifier) @from) @stmt
-      (use_declaration argument: (scoped_use_list path: (_) @from list: (use_list (identifier) @iname))) @stmt
-      ;; Aliased members inside a group (\`use foo::{Bar as Baz}\`): import
-      ;; the original name under its local alias.
-      (use_declaration argument: (scoped_use_list path: (_) @from list: (use_list (use_as_clause path: (identifier) @iname alias: (identifier) @alias)))) @stmt
-    `
-  },
-  nodeTypes: {
-    identifier: ["identifier", "type_identifier"],
-    memberExpression: "field_expression"
-  },
-  supportsCrossModuleSymbols: true,
-  scopeDeclarationNames: (node) => node.parent?.type === "macro_definition",
-  classifyDefinition: (node) => {
-    const parent = node.parent;
-    if (!parent)
-      return "variable";
-    if (parent.type === "function_item" || parent.type === "macro_definition")
-      return "function";
-    if (parent.type === "enum_item")
-      return "type";
-    if (parent.type === "struct_item" || parent.type === "trait_item")
-      return "class";
-    return "variable";
-  },
-  createsFunctionScope: (node) => node.type === "function_item",
-  createsBlockScope: (node) => node.type === "block",
-  membersAreImplicitlyInScope: false,
-  isDeclarationName: (node) => {
-    const p = node.parent;
-    if (!p)
-      return false;
-    if (p.type === "function_item" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "struct_item" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "trait_item" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "enum_item" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "enum_variant" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "const_item" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "static_item" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "macro_definition" && p.childForFieldName("name")?.id === node.id)
-      return true;
-    if (p.type === "let_declaration" && p.childForFieldName("pattern")?.id === node.id)
-      return true;
-    if (p.type === "parameter" && p.childForFieldName("pattern")?.id === node.id)
-      return true;
-    return false;
-  },
-  normalizeIdentifier: (name) => hasNonAsciiCodePoint(name) ? name.normalize("NFC") : name
-};
-registerLanguage(RUST_DEF);
-
-// dist/languages/definitions/cFamily.js
-var cFamilyContainerTypes = /* @__PURE__ */ new Set([
-  "function_definition",
-  "declaration",
-  "parameter_declaration",
-  "field_declaration",
-  "type_definition",
-  "init_declarator"
-]);
-var cFamilyControlSplitPoints = [
-  "if_statement",
-  "for_statement",
-  "while_statement",
-  "do_statement",
-  "switch_statement",
-  "case_statement"
-];
-var cFamilyIncludeImportsQuery = `
-      (preproc_include path: (string_literal) @mod) @stmt
-      (preproc_include path: (system_lib_string) @mod) @stmt
-      (preproc_include path: (identifier) @mod) @stmt
-    `;
-var cFamilyIncludeBindingsQuery = `
-      (preproc_include path: (string_literal) @from) @stmt
-      (preproc_include path: (system_lib_string) @from) @stmt
-      (preproc_include path: (identifier) @from) @stmt
-    `;
-var cFamilyParameterListTypes = /* @__PURE__ */ new Set(["parameter_declaration", "parameter_list"]);
-function cFunctionNameQuery(captureName, includeFieldIdentifier) {
-  const identifierTypes = includeFieldIdentifier ? ["identifier", "field_identifier"] : ["identifier"];
-  const patterns = [];
-  for (const identifierType of identifierTypes) {
-    patterns.push(`(function_declarator declarator: (${identifierType}) @${captureName})`);
-    patterns.push(`(function_declarator declarator: (pointer_declarator declarator: (${identifierType}) @${captureName}))`);
-    patterns.push(`(pointer_declarator declarator: (function_declarator declarator: (${identifierType}) @${captureName}))`);
-    patterns.push(`(function_declarator declarator: (parenthesized_declarator (pointer_declarator declarator: (${identifierType}) @${captureName})))`);
-  }
-  return `
-  declarator: [
-    ${patterns.join("\n    ")}
-  ]
-`;
-}
-function cFamilyCoreExportQueries(functionNameQuery) {
-  return [
-    `(function_definition ${functionNameQuery})`,
-    `(declaration ${functionNameQuery})`,
-    `(struct_specifier name: (type_identifier) @name)`,
-    `(enum_specifier name: (type_identifier) @name)`,
-    `(type_definition declarator: (type_identifier) @name)`,
-    `(declaration declarator: (identifier) @name)`,
-    `(declaration declarator: (init_declarator declarator: (identifier) @name))`
-  ];
-}
-function cFamilyCoreLocalQueries(functionNameQuery) {
-  return [
-    `(function_definition ${functionNameQuery})`,
-    `(struct_specifier name: (type_identifier) @name)`,
-    `(enum_specifier name: (type_identifier) @name)`,
-    `(type_definition declarator: (type_identifier) @name)`,
-    `(declaration declarator: (identifier) @name)`,
-    `(declaration declarator: (init_declarator declarator: (identifier) @name))`,
-    `(parameter_declaration declarator: (identifier) @name)`,
-    `(field_declaration declarator: (field_identifier) @name)`
-  ];
-}
-function joinQueryPatterns(patterns) {
-  return `
-      ${patterns.join("\n      ")}
-    `;
-}
-function cFamilyBlock(type, nameQuery, captureId) {
-  return {
-    type,
-    nameQuery,
-    captureId
-  };
-}
-function cFamilyFunctionBlock(functionNameQuery) {
-  return cFamilyBlock("function_definition", functionNameQuery, "function");
-}
-function cFamilyTypeIdentifierBlock(type, captureId) {
-  return cFamilyBlock(type, "name: (type_identifier) @chunk.name", captureId);
-}
-function createCFamilyLanguageDefinition(options) {
-  const functionNameQuery = cFunctionNameQuery("chunk.name", options.includeFieldIdentifier);
-  const graphFunctionNameQuery = cFunctionNameQuery("name", options.includeFieldIdentifier);
-  return {
-    id: options.id,
-    extensions: [...options.extensions],
-    structure: {
-      blocks: options.blocks(functionNameQuery),
-      splitPoints: [...options.splitPoints ?? cFamilyControlSplitPoints],
-      comments: ["comment"]
-    },
-    graph: {
-      imports: cFamilyIncludeImportsQuery,
-      exports: joinQueryPatterns([
-        ...cFamilyCoreExportQueries(graphFunctionNameQuery),
-        ...options.extraExportQueries ?? []
-      ]),
-      locals: joinQueryPatterns([
-        ...cFamilyCoreLocalQueries(graphFunctionNameQuery),
-        ...options.extraLocalQueries ?? []
-      ]),
-      importBindings: cFamilyIncludeBindingsQuery
-    },
-    nodeTypes: options.nodeTypes,
-    classifyDefinition: options.classifyDefinition,
-    isDeclarationName: options.isDeclarationName,
-    scopeDeclarationNames: "all",
-    createsFunctionScope: options.createsFunctionScope,
-    createsBlockScope: (node) => node.type === "compound_statement",
-    supportsCrossModuleSymbols: true,
-    usesQueryDrivenLocals: options.usesQueryDrivenLocals || false
-  };
-}
-function isWithin(node, ancestor) {
-  let current = node;
-  while (current) {
-    if (ancestor && current.id === ancestor.id)
-      return true;
-    current = current.parent;
-  }
-  return false;
-}
-function isInField(node, parent, field) {
-  return isWithin(node, parent.childForFieldName(field));
-}
-function findAncestor(node, types) {
-  let current = node.parent;
-  while (current) {
-    if (types.has(current.type))
-      return current;
-    current = current.parent;
-  }
-  return null;
-}
-function isInParameterList(node) {
-  return !!findAncestor(node, cFamilyParameterListTypes);
-}
-function resolveDeclaratorRoot(ancestor) {
-  let declaratorNode = ancestor.childForFieldName("declarator");
-  if (!declaratorNode)
-    return null;
-  if (declaratorNode.type === "init_declarator") {
-    const inner = declaratorNode.childForFieldName("declarator");
-    if (inner)
-      declaratorNode = inner;
-  }
-  if (declaratorNode.type === "function_declarator") {
-    const inner = declaratorNode.childForFieldName("declarator");
-    if (inner)
-      declaratorNode = inner;
-  }
-  return declaratorNode;
-}
-function isInAncestorDeclarator(node, ancestorTypes) {
-  const ancestor = findAncestor(node, ancestorTypes);
-  if (!ancestor)
-    return false;
-  const declaratorNode = resolveDeclaratorRoot(ancestor);
-  if (!declaratorNode)
-    return false;
-  return isWithin(node, declaratorNode);
-}
-function isFunctionDeclarator(node) {
-  let current = node.parent;
-  while (current) {
-    if (current.type === "function_declarator")
-      return true;
-    if (cFamilyContainerTypes.has(current.type))
-      return false;
-    current = current.parent;
-  }
-  return false;
-}
-
-// dist/languages/definitions/c.js
-var C_DEF = createCFamilyLanguageDefinition({
-  id: "c",
-  extensions: [".c", ".h", ".i"],
-  includeFieldIdentifier: false,
-  blocks: (functionNameQuery) => [
-    cFamilyFunctionBlock(functionNameQuery),
-    cFamilyTypeIdentifierBlock("struct_specifier", "struct"),
-    cFamilyTypeIdentifierBlock("union_specifier", "union"),
-    cFamilyTypeIdentifierBlock("enum_specifier", "enum"),
-    cFamilyBlock("type_definition", "declarator: (type_identifier) @chunk.name", "type"),
-    cFamilyBlock("preproc_def", "name: (identifier) @chunk.name", "macro"),
-    cFamilyBlock("preproc_function_def", "name: (identifier) @chunk.name", "macro")
-  ],
-  extraExportQueries: [
-    `(union_specifier name: (type_identifier) @name)`,
-    `(enumerator name: (identifier) @name)`,
-    `(preproc_def name: (identifier) @name)`,
-    `(preproc_function_def name: (identifier) @name)`
-  ],
-  extraLocalQueries: [
-    `(union_specifier name: (type_identifier) @name)`,
-    `(enumerator name: (identifier) @name)`,
-    `(preproc_def name: (identifier) @name)`,
-    `(preproc_function_def name: (identifier) @name)`
-  ],
-  nodeTypes: {
-    identifier: ["identifier", "field_identifier", "type_identifier"],
-    propertyIdentifier: ["field_identifier"],
-    memberExpression: "field_expression"
-  },
-  classifyDefinition: (node) => {
-    const parent = node.parent;
-    if (!parent)
-      return "variable";
-    if (parent.type === "enum_specifier")
-      return "type";
-    if (parent.type === "struct_specifier" || parent.type === "union_specifier")
-      return "class";
-    if (parent.type === "type_definition" && isInField(node, parent, "declarator"))
-      return "type";
-    const container = findAncestor(node, cFamilyContainerTypes);
-    if (container?.type === "function_definition")
-      return "function";
-    if (container?.type === "declaration" && isFunctionDeclarator(node))
-      return "function";
-    return "variable";
-  },
-  isDeclarationName: (node) => {
-    const parent = node.parent;
-    if (!parent)
-      return false;
-    if ((parent.type === "struct_specifier" || parent.type === "union_specifier" || parent.type === "enum_specifier") && isInField(node, parent, "name"))
-      return true;
-    if (isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["parameter_declaration"])) || isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["field_declaration"])) || isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["init_declarator"])) || isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["type_definition"])))
-      return true;
-    if (isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["function_definition"])) && !isInParameterList(node))
-      return true;
-    if (isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["declaration"])) && !isInParameterList(node))
-      return true;
-    if (parent.type === "enumerator" && isInField(node, parent, "name"))
-      return true;
-    if (parent.type === "preproc_def" && isInField(node, parent, "name"))
-      return true;
-    if (parent.type === "preproc_function_def" && isInField(node, parent, "name"))
-      return true;
-    return false;
-  },
-  createsFunctionScope: (node) => node.type === "function_definition"
-});
-registerLanguage(C_DEF);
-
-// dist/languages/definitions/cpp.js
-var CPP_DEF = createCFamilyLanguageDefinition({
-  id: "cpp",
-  extensions: [".cc", ".cpp", ".cxx", ".c++", ".hpp", ".hh", ".hxx", ".ipp", ".tpp", ".inl"],
-  includeFieldIdentifier: true,
-  usesQueryDrivenLocals: true,
-  blocks: (functionNameQuery) => [
-    cFamilyFunctionBlock(functionNameQuery),
-    cFamilyTypeIdentifierBlock("class_specifier", "class"),
-    cFamilyTypeIdentifierBlock("struct_specifier", "struct"),
-    cFamilyTypeIdentifierBlock("enum_specifier", "enum"),
-    cFamilyBlock("namespace_definition", "name: (namespace_identifier) @chunk.name", "namespace"),
-    cFamilyTypeIdentifierBlock("alias_declaration", "type"),
-    cFamilyBlock("type_definition", "declarator: (type_identifier) @chunk.name", "type")
-  ],
-  splitPoints: [...cFamilyControlSplitPoints, "try_statement", "catch_clause"],
-  extraExportQueries: [
-    `(class_specifier name: (type_identifier) @name)`,
-    `(enumerator name: (identifier) @name)`,
-    `(namespace_definition name: (namespace_identifier) @name)`,
-    `(alias_declaration name: (type_identifier) @name)`,
-    `(using_declaration (qualified_identifier name: (identifier) @name))`
-  ],
-  extraLocalQueries: [
-    `(class_specifier name: (type_identifier) @name)`,
-    `(enumerator name: (identifier) @name)`,
-    `(namespace_definition name: (namespace_identifier) @name)`,
-    `(alias_declaration name: (type_identifier) @name)`
-  ],
-  nodeTypes: {
-    identifier: ["identifier", "field_identifier", "type_identifier", "namespace_identifier"],
-    propertyIdentifier: ["field_identifier", "identifier"],
-    memberExpression: "field_expression"
-  },
-  classifyDefinition: (node) => {
-    const parent = node.parent;
-    if (!parent)
-      return "variable";
-    if (parent.type === "enum_specifier")
-      return "type";
-    if (parent.type === "class_specifier" || parent.type === "struct_specifier" || parent.type === "namespace_definition")
-      return "class";
-    if (parent.type === "alias_declaration" || parent.type === "type_definition" && isInField(node, parent, "declarator"))
-      return "type";
-    const container = findAncestor(node, cFamilyContainerTypes);
-    if (container?.type === "function_definition")
-      return "function";
-    if (container?.type === "declaration" && isFunctionDeclarator(node))
-      return "function";
-    return "variable";
-  },
-  isDeclarationName: (node) => {
-    const parent = node.parent;
-    if (!parent)
-      return false;
-    if ((parent.type === "class_specifier" || parent.type === "struct_specifier" || parent.type === "enum_specifier") && isInField(node, parent, "name"))
-      return true;
-    if (parent.type === "namespace_definition" && isInField(node, parent, "name"))
-      return true;
-    if (parent.type === "alias_declaration" && isInField(node, parent, "name"))
-      return true;
-    if (isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["parameter_declaration"])) || isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["field_declaration"])) || isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["init_declarator"])) || isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["type_definition"])))
-      return true;
-    if (isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["function_definition"])) && !isInParameterList(node))
-      return true;
-    if (isInAncestorDeclarator(node, /* @__PURE__ */ new Set(["declaration"])) && !isInParameterList(node))
-      return true;
-    if (parent.type === "qualified_identifier" && parent.parent?.type === "using_declaration" && isInField(node, parent, "name"))
-      return true;
-    if (parent.type === "enumerator" && isInField(node, parent, "name"))
-      return true;
-    return false;
-  },
-  createsFunctionScope: (node) => node.type === "function_definition" || node.type === "lambda_expression"
-});
-registerLanguage(CPP_DEF);
-
-// dist/languages/definitions/kotlin.js
-function normalizeKotlinNativeQuery(kind, query) {
-  if (kind === "imports") {
-    return `
-      (import (qualified_identifier) @mod) @stmt
-    `;
-  }
-  if (kind === "importBindings") {
-    return `
-      (import (qualified_identifier) @from (identifier) @alias) @stmt
-      (import (qualified_identifier) @from "*" @wild) @stmt
-      (import (qualified_identifier) @from) @stmt
-    `;
-  }
-  const normalized = query.replace(/\bimport_header\b/g, "import").replace(/\bsimple_identifier\b/g, "identifier").replace(/\btype_identifier\b/g, "identifier");
-  return normalized;
-}
-var KOTLIN_DEF = {
-  id: "kotlin",
-  extensions: [".kt", ".kts"],
-  usesQueryDrivenLocals: true,
-  structure: {
-    blocks: [
-      {
-        type: "class_declaration",
-        nameQuery: "(type_identifier) @chunk.name",
-        captureId: "class"
-      },
-      {
-        type: "object_declaration",
-        nameQuery: "(type_identifier) @chunk.name",
-        captureId: "object"
-      },
-      {
-        type: "function_declaration",
-        nameQuery: "(simple_identifier) @chunk.name",
-        captureId: "function"
-      },
-      {
-        type: "property_declaration",
-        nameQuery: "(variable_declaration (simple_identifier) @chunk.name)",
-        captureId: "property"
-      },
-      {
-        type: "type_alias",
-        nameQuery: "(type_identifier) @chunk.name",
-        captureId: "type"
-      }
-    ],
-    splitPoints: [
-      "if_expression",
-      "when_expression",
-      "for_statement",
-      "while_statement",
-      "do_while_statement",
-      "try_expression",
-      "catch_block",
-      "finally_block"
-    ],
-    comments: ["line_comment", "block_comment"]
-  },
-  graph: {
-    imports: `
-      (import_header (identifier) @mod) @stmt
-    `,
-    exports: `
-      (class_declaration (type_identifier) @name)
-      (object_declaration (type_identifier) @name)
-      (function_declaration (simple_identifier) @name)
-      (property_declaration (variable_declaration (simple_identifier) @name))
-      (type_alias (type_identifier) @name)
-      (enum_entry (simple_identifier) @name)
-    `,
-    locals: `
-      (class_declaration (type_identifier) @name)
-      (object_declaration (type_identifier) @name)
-      (function_declaration (simple_identifier) @name)
-      (property_declaration (variable_declaration (simple_identifier) @name))
-      (type_alias (type_identifier) @name)
-      (enum_entry (simple_identifier) @name)
-      (parameter (simple_identifier) @name)
-      (class_parameter (simple_identifier) @name)
-      (type_parameter (type_identifier) @name)
-    `,
-    importBindings: `
-      (import_header (identifier) @from (import_alias (type_identifier) @alias)) @stmt
-      (import_header (identifier) @from (wildcard_import) @wild) @stmt
-      (import_header (identifier) @from) @stmt
-    `
-  },
-  nodeTypes: {
-    identifier: ["identifier", "interpolated_identifier", "simple_identifier", "type_identifier"],
-    propertyIdentifier: ["simple_identifier", "type_identifier"],
-    memberExpression: "navigation_expression"
-  },
-  classifyDefinition: (node) => {
-    const parent = node.parent;
-    if (!parent)
-      return "variable";
-    if (parent.type === "class_declaration" || parent.type === "object_declaration")
-      return "class";
-    if (parent.type === "function_declaration")
-      return "function";
-    if (parent.type === "type_alias")
-      return "type";
-    return "variable";
-  },
-  isDeclarationName: (node) => {
-    const parent = node.parent;
-    if (!parent)
-      return false;
-    if (parent.type === "class_declaration" && node.type === "type_identifier")
-      return true;
-    if (parent.type === "object_declaration" && node.type === "type_identifier")
-      return true;
-    if (parent.type === "function_declaration" && (node.type === "simple_identifier" || node.type === "identifier"))
-      return true;
-    if (parent.type === "type_alias" && node.type === "type_identifier")
-      return true;
-    if (parent.type === "variable_declaration" && node.type === "simple_identifier")
-      return true;
-    if (parent.type === "parameter" && (node.type === "simple_identifier" || node.type === "identifier"))
-      return true;
-    if (parent.type === "class_parameter" && (node.type === "simple_identifier" || node.type === "identifier"))
-      return true;
-    if (parent.type === "enum_entry" && (node.type === "simple_identifier" || node.type === "identifier"))
-      return true;
-    if (parent.type === "type_parameter" && node.type === "type_identifier")
-      return true;
-    return false;
-  },
-  scopeDeclarationNames: "all",
-  createsFunctionScope: (node) => node.type === "function_declaration" || node.type === "anonymous_function" || node.type === "lambda_literal",
-  createsBlockScope: (node) => node.type === "function_body" || node.type === "class_body" || node.type === "control_structure_body" || node.type === "catch_block" || node.type === "finally_block",
-  supportsCrossModuleSymbols: true,
-  native: {
-    normalizeQuery: normalizeKotlinNativeQuery,
-    authoritativeKinds: ["imports", "importBindings", "exports", "locals"],
-    notes: ["normalizes kotlin import and identifier node names for the native grammar"]
-  }
-};
-registerLanguage(KOTLIN_DEF);
-
-// dist/languages/definitions/swift.js
-var SWIFT_DEF = {
-  id: "swift",
-  extensions: [".swift"],
-  usesQueryDrivenLocals: true,
-  structure: {
-    blocks: [
-      {
-        type: "class_declaration",
-        nameQuery: 'declaration_kind: "class" name: (_) @chunk.name',
-        captureId: "class"
-      },
-      {
-        type: "class_declaration",
-        nameQuery: 'declaration_kind: "struct" name: (_) @chunk.name',
-        captureId: "struct"
-      },
-      {
-        type: "class_declaration",
-        nameQuery: 'declaration_kind: "enum" name: (_) @chunk.name',
-        captureId: "enum"
-      },
-      {
-        type: "class_declaration",
-        nameQuery: 'declaration_kind: "extension" name: (user_type (type_identifier) @chunk.name)',
-        captureId: "extension"
-      },
-      {
-        type: "class_declaration",
-        nameQuery: 'declaration_kind: "actor" name: (_) @chunk.name',
-        captureId: "actor"
-      },
-      {
-        type: "protocol_declaration",
-        nameQuery: "name: (type_identifier) @chunk.name",
-        captureId: "protocol"
-      },
-      {
-        type: "function_declaration",
-        nameQuery: "name: (simple_identifier) @chunk.name",
-        captureId: "function"
-      },
-      {
-        type: "property_declaration",
-        nameQuery: "name: (pattern bound_identifier: (simple_identifier) @chunk.name)",
-        captureId: "property"
-      },
-      {
-        type: "typealias_declaration",
-        nameQuery: "name: (type_identifier) @chunk.name",
-        captureId: "type"
-      },
-      {
-        type: "init_declaration",
-        captureId: "initializer"
-      },
-      {
-        type: "deinit_declaration",
-        captureId: "deinitializer"
-      },
-      {
-        type: "subscript_declaration",
-        captureId: "subscript"
-      }
-    ],
-    splitPoints: [
-      "if_statement",
-      "guard_statement",
-      "for_statement",
-      "while_statement",
-      "repeat_while_statement",
-      "switch_statement",
-      "do_statement",
-      "catch_block"
-    ],
-    comments: ["comment", "multiline_comment"]
-  },
-  graph: {
-    imports: `
-      (import_declaration (identifier) @mod) @stmt
-    `,
-    exports: `
-      (class_declaration declaration_kind: "class" name: (_) @name)
-      (class_declaration declaration_kind: "struct" name: (_) @name)
-      (class_declaration declaration_kind: "enum" name: (_) @name)
-      (class_declaration declaration_kind: "extension" name: (user_type (type_identifier) @name))
-      (class_declaration declaration_kind: "actor" name: (_) @name)
-      (enum_entry name: (simple_identifier) @name)
-      (protocol_declaration name: (type_identifier) @name)
-      (function_declaration name: (simple_identifier) @name)
-      (typealias_declaration name: (type_identifier) @name)
-      (property_declaration name: (pattern bound_identifier: (simple_identifier) @name))
-      (protocol_function_declaration name: (simple_identifier) @name)
-      (protocol_property_declaration name: (pattern bound_identifier: (simple_identifier) @name))
-    `,
-    locals: `
-      (class_declaration declaration_kind: "class" name: (_) @name)
-      (class_declaration declaration_kind: "struct" name: (_) @name)
-      (class_declaration declaration_kind: "enum" name: (_) @name)
-      (class_declaration declaration_kind: "extension" name: (user_type (type_identifier) @name))
-      (class_declaration declaration_kind: "actor" name: (_) @name)
-      (enum_entry name: (simple_identifier) @name)
-      (protocol_declaration name: (type_identifier) @name)
-      (function_declaration name: (simple_identifier) @name)
-      (typealias_declaration name: (type_identifier) @name)
-      (property_declaration name: (pattern bound_identifier: (simple_identifier) @name))
-      (parameter name: (simple_identifier) @name)
-      (protocol_function_declaration name: (simple_identifier) @name)
-      (protocol_property_declaration name: (pattern bound_identifier: (simple_identifier) @name))
-    `,
-    importBindings: `
-      (import_declaration (identifier) @from) @stmt
-    `
-  },
-  nodeTypes: {
-    identifier: ["identifier", "simple_identifier", "type_identifier"],
-    propertyIdentifier: ["simple_identifier", "type_identifier"],
-    memberExpression: "navigation_expression"
-  },
-  classifyDefinition: (node) => {
-    const parent = node.parent;
-    if (!parent)
-      return "variable";
-    if (parent.type === "function_declaration")
-      return "function";
-    if (parent.type === "protocol_function_declaration")
-      return "function";
-    if (parent.type === "class_declaration") {
-      const declarationKind = parent.childForFieldName("declaration_kind")?.text;
-      if (declarationKind === "enum")
-        return "type";
-      return "class";
-    }
-    if (parent.type === "user_type" && parent.parent?.type === "class_declaration")
-      return "class";
-    if (parent.type === "protocol_declaration" || parent.type === "typealias_declaration")
-      return "type";
-    return "variable";
-  },
-  isDeclarationName: (node) => {
-    const parent = node.parent;
-    if (!parent)
-      return false;
-    if (parent.type === "class_declaration" && parent.childForFieldName("name")?.id === node.id)
-      return true;
-    if (parent.type === "user_type" && parent.parent?.type === "class_declaration" && parent.parent.childForFieldName("name")?.id === parent.id)
-      return true;
-    if (parent.type === "protocol_declaration" && parent.childForFieldName("name")?.id === node.id)
-      return true;
-    if (parent.type === "enum_entry" && parent.childForFieldName("name")?.id === node.id)
-      return true;
-    if (parent.type === "function_declaration" && parent.childForFieldName("name")?.id === node.id)
-      return true;
-    if (parent.type === "typealias_declaration" && parent.childForFieldName("name")?.id === node.id)
-      return true;
-    if (parent.type === "parameter" && parent.childForFieldName("name")?.id === node.id)
-      return true;
-    if (parent.type === "protocol_function_declaration" && parent.childForFieldName("name")?.id === node.id)
-      return true;
-    if (parent.type === "protocol_property_declaration" && parent.childForFieldName("name")?.id === node.id)
-      return true;
-    if (parent.type === "pattern" && parent.childForFieldName("bound_identifier")?.id === node.id && (parent.parent?.type === "property_declaration" || parent.parent?.type === "protocol_property_declaration"))
-      return true;
-    return false;
-  },
-  scopeDeclarationNames: "all",
-  createsFunctionScope: (node) => node.type === "function_declaration" || node.type === "init_declaration" || node.type === "deinit_declaration" || node.type === "subscript_declaration",
-  createsBlockScope: (node) => node.type === "function_body" || node.type === "class_body" || node.type === "protocol_body" || node.type === "enum_class_body" || node.type === "catch_block" || node.type === "willset_didset_block",
-  supportsCrossModuleSymbols: true
-};
-registerLanguage(SWIFT_DEF);
-
-// dist/languages/definitions/sql.js
-var SQL_DEF = {
-  id: "sql",
-  extensions: [".sql"],
-  structure: {
-    blocks: [
-      { type: "statement", nameQuery: "(create_table)", captureId: "create" },
-      { type: "statement", nameQuery: "(create_view)", captureId: "create" },
-      { type: "statement", nameQuery: "(create_materialized_view)", captureId: "create" },
-      { type: "statement", nameQuery: "(create_index)", captureId: "create" },
-      { type: "statement", nameQuery: "(create_function)", captureId: "routine" },
-      { type: "statement", nameQuery: "(create_trigger)", captureId: "routine" },
-      { type: "statement", nameQuery: "(alter_table)", captureId: "alter" },
-      { type: "statement", nameQuery: "(drop_table)", captureId: "drop" },
-      { type: "statement", nameQuery: "(drop_view)", captureId: "drop" },
-      { type: "statement", nameQuery: "(drop_index)", captureId: "drop" },
-      { type: "statement", nameQuery: "(insert)", captureId: "write" },
-      { type: "statement", nameQuery: "(update)", captureId: "write" },
-      { type: "statement", nameQuery: "(delete)", captureId: "write" },
-      { type: "statement", nameQuery: "(select)", captureId: "select" }
-    ],
-    splitPoints: [],
-    comments: ["comment"]
-  },
-  graph: {
-    imports: "(statement) @stmt",
-    exports: "",
-    locals: "",
-    importBindings: ""
-  },
-  supportsCrossModuleSymbols: false
-};
-registerLanguage(SQL_DEF);
-
-// dist/languages/definitions/zig.js
-var ZIG_TYPE_INITIALIZER_TYPES = /* @__PURE__ */ new Set([
-  "builtin_type",
-  "struct_declaration",
-  "enum_declaration",
-  "union_declaration",
-  "opaque_declaration",
-  "error_set_declaration"
-]);
-var ZIG_DEF = {
-  id: "zig",
-  extensions: [".zig"],
-  usesQueryDrivenLocals: true,
-  structure: {
-    blocks: [
-      { type: "function_declaration", nameQuery: "name: (identifier) @chunk.name", captureId: "function" },
-      { type: "test_declaration", nameQuery: "(string) @chunk.name", captureId: "test" }
-    ],
-    splitPoints: ["if_expression", "for_expression", "while_expression", "switch_expression"],
-    comments: ["line_comment", "doc_comment"]
-  },
-  graph: {
-    imports: '(builtin_function (builtin_identifier) @fn (arguments (string) @mod) (#eq? @fn "@import")) @stmt',
-    exports: `
-      (function_declaration name: (identifier) @name)
-      (variable_declaration (identifier) @name)
-    `,
-    locals: `
-      (function_declaration name: (identifier) @name)
-      (parameter (identifier) @name)
-      (variable_declaration (identifier) @name)
-    `,
-    importBindings: `
-      (variable_declaration
-        (identifier) @alias
-        (builtin_function (builtin_identifier) @fn (arguments (string) @from) (#eq? @fn "@import"))
-      ) @stmt
-    `
-  },
-  nodeTypes: {
-    identifier: ["identifier"],
-    memberExpression: "field_expression"
-  },
-  supportsCrossModuleSymbols: true,
-  classifyDefinition: (node) => {
-    const parent = node.parent;
-    if (!parent)
-      return "variable";
-    if (parent.type === "function_declaration")
-      return "function";
-    if (parent.type !== "variable_declaration")
-      return "variable";
-    const declaredName = parent.namedChildren.find((child) => child.type === "identifier");
-    if (declaredName?.id !== node.id)
-      return "variable";
-    const initializer = parent.namedChildren.find((child) => child.id !== node.id);
-    if (initializer && ZIG_TYPE_INITIALIZER_TYPES.has(initializer.type))
-      return "type";
-    return "variable";
-  },
-  createsFunctionScope: (node) => node.type === "function_declaration",
-  createsBlockScope: (node) => node.type === "block",
-  isDeclarationName: (node) => {
-    const parent = node.parent;
-    if (!parent)
-      return false;
-    if (parent.type === "function_declaration" && parent.childForFieldName("name")?.id === node.id)
-      return true;
-    return parent.type === "variable_declaration";
-  }
-};
-registerLanguage(ZIG_DEF);
-
-// dist/bootstrap/treeSitterLanguages.js
-var idToConfigKey = {
-  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"
-};
-var LANG_CONFIGS = {};
-for (const lang of getAllLanguages()) {
-  const key = idToConfigKey[lang.id] || 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;
-  }
-  LANG_CONFIGS[key] = makeLanguageConfig(lang, key);
-}
-
-// dist/chunking/chunkBlocks.js
-function collectChunkBlockGroups(language, matches) {
-  const mainBlocks = [];
-  const innerBlocks = [];
-  const comments = [];
-  for (const match of matches) {
-    let nameCapture;
-    let blockCapture;
-    let innerCapture;
-    let blockKind;
-    for (const capture of match.captures) {
-      const { name } = capture;
-      if (name === language.captures.name) {
-        nameCapture = capture;
-      }
-      if (language.captures.comments.includes(name)) {
-        comments.push({
-          kind: name === "chunk.docstring" ? "docstring" : "comment",
-          startByte: capture.startByte,
-          endByte: capture.endByte,
-          startLine: capture.startLine,
-          endLine: capture.endLine
-        });
-      }
-      if (name === language.captures.innerBlock) {
-        innerCapture = capture;
-      }
-      if (name.startsWith(language.captures.blockPrefix) && name !== language.captures.innerBlock) {
-        blockCapture = capture;
-        blockKind = name.slice(language.captures.blockPrefix.length) || capture.nodeType;
-      }
-    }
-    if (innerCapture) {
-      innerBlocks.push({
-        kind: "inner",
-        startByte: innerCapture.startByte,
-        endByte: innerCapture.endByte,
-        startLine: innerCapture.startLine,
-        endLine: innerCapture.endLine
-      });
-    }
-    if (blockCapture) {
-      const candidate = {
-        kind: blockKind ?? "block",
-        startByte: blockCapture.startByte,
-        endByte: blockCapture.endByte,
-        startLine: blockCapture.startLine,
-        endLine: blockCapture.endLine
-      };
-      if (nameCapture) {
-        candidate.name = nameCapture.text;
-      }
-      mainBlocks.push(candidate);
-    }
-  }
-  mainBlocks.sort((a, b) => a.startByte - b.startByte || a.endByte - b.endByte);
-  innerBlocks.sort((a, b) => a.startByte - b.startByte || a.endByte - b.endByte);
-  comments.sort((a, b) => a.startByte - b.startByte || a.endByte - b.endByte);
-  return { mainBlocks, innerBlocks, comments };
-}
-
-// dist/chunking/chunkMatches.js
-import { Buffer as Buffer2 } from "node:buffer";
-
-// dist/languages.js
-import fs from "node:fs";
-import path from "node:path";
-function adaptDefinition(def) {
-  return {
-    id: def.id,
-    matchExts: def.extensions,
-    nodeTypes: def.nodeTypes || { identifier: ["identifier"] },
-    queries: def.graph,
-    classifyDefinition: def.classifyDefinition || (() => "variable"),
-    isDeclarationName: def.isDeclarationName || (() => false),
-    scopeDeclarationNames: def.scopeDeclarationNames === "all" ? () => true : def.scopeDeclarationNames ?? (() => false),
-    createsBlockScope: def.createsBlockScope || (() => false),
-    createsFunctionScope: def.createsFunctionScope || (() => false),
-    membersAreImplicitlyInScope: def.membersAreImplicitlyInScope ?? true,
-    supportsCrossModuleSymbols: def.supportsCrossModuleSymbols || false,
-    isTypeOnly: def.isTypeOnly || (() => false),
-    supportsExportFromReferences: def.supportsExportFromReferences ?? false,
-    usesQueryDrivenLocals: def.usesQueryDrivenLocals || false,
-    normalizeIdentifier: def.normalizeIdentifier || ((name) => name),
-    ...def.native ? { native: def.native } : {}
-  };
-}
-var TS_SUPPORT = adaptDefinition(getLanguageById("ts"));
-var TSX_SUPPORT = adaptDefinition(getLanguageById("tsx"));
-var JS_SUPPORT = adaptDefinition(getLanguageById("js"));
-var PY_SUPPORT = adaptDefinition(getLanguageById("python"));
-var PHP_SUPPORT = adaptDefinition(getLanguageById("php"));
-var HTML_SUPPORT = adaptDefinition(getLanguageById("html"));
-var CSS_SUPPORT = adaptDefinition(getLanguageById("css"));
-var SCSS_SUPPORT = adaptDefinition(getLanguageById("scss"));
-var LESS_SUPPORT = adaptDefinition(getLanguageById("less"));
-var VUE_SUPPORT = adaptDefinition(getLanguageById("vue"));
-var SVELTE_SUPPORT = adaptDefinition(getLanguageById("svelte"));
-var RUBY_SUPPORT = adaptDefinition(getLanguageById("ruby"));
-var GO_SUPPORT = adaptDefinition(getLanguageById("go"));
-var JAVA_SUPPORT = adaptDefinition(getLanguageById("java"));
-var CSHARP_SUPPORT = adaptDefinition(getLanguageById("csharp"));
-var RUST_SUPPORT = adaptDefinition(getLanguageById("rust"));
-var C_SUPPORT = adaptDefinition(getLanguageById("c"));
-var CPP_SUPPORT = adaptDefinition(getLanguageById("cpp"));
-var KOTLIN_SUPPORT = adaptDefinition(getLanguageById("kotlin"));
-var SWIFT_SUPPORT = adaptDefinition(getLanguageById("swift"));
-var ZIG_SUPPORT = adaptDefinition(getLanguageById("zig"));
-var SQL_SUPPORT = adaptDefinition(getLanguageById("sql"));
-var LANGUAGE_SUPPORTS = getAllLanguages().map(adaptDefinition);
-var LANGUAGE_EXTENSION_KEY_PATTERN = /^\.[a-z0-9][a-z0-9._+-]*$/;
-var NON_REMAPPABLE_EXTENSIONS = /* @__PURE__ */ new Set([".vue", ".svelte"]);
-function isLiteralLanguageExtension(extension) {
-  return LANGUAGE_EXTENSION_KEY_PATTERN.test(extension.trim().toLowerCase());
-}
-function isRemappableLanguageExtension(extension) {
-  return !NON_REMAPPABLE_EXTENSIONS.has(extension.trim().toLowerCase());
-}
-function normalizeLanguageExtensions(extensions) {
-  const entries = Object.entries(extensions ?? {}).map(([extension, languageId]) => [extension.trim().toLowerCase(), languageId.trim().toLowerCase()]).filter(([extension, languageId]) => isLiteralLanguageExtension(extension) && isRemappableLanguageExtension(extension) && !!supportById(languageId)).sort((left, right) => left[0].localeCompare(right[0]));
-  if (!entries.length)
-    return void 0;
-  return Object.fromEntries(entries);
-}
-function mappedSupportForFile(filename, extensionMap) {
-  if (!extensionMap)
-    return void 0;
-  const mappings = Object.entries(normalizeLanguageExtensions(extensionMap) ?? {}).sort((left, right) => right[0].length - left[0].length || left[0].localeCompare(right[0]));
-  const lowerFilename = filename.toLowerCase();
-  for (const [extension, languageId] of mappings) {
-    if (!lowerFilename.endsWith(extension))
-      continue;
-    return supportById(languageId);
-  }
-  return void 0;
-}
-function supportForFileWithoutHeaderSample(filename, extensionMap) {
-  const mapped = mappedSupportForFile(filename, extensionMap);
-  if (mapped)
-    return mapped;
-  const ext = path.extname(filename).toLowerCase();
-  return LANGUAGE_SUPPORTS.find((s) => s.matchExts.includes(ext));
-}
-function supportForFile(filename, extensionMap) {
-  if (path.extname(filename).toLowerCase() !== ".h") {
-    return supportForFileWithoutHeaderSample(filename, extensionMap);
-  }
-  const mapped = mappedSupportForFile(filename, extensionMap);
-  if (mapped)
-    return mapped;
-  const sample = readFileSample(filename);
-  if (sample && isLikelyCppHeader(sample))
-    return CPP_SUPPORT;
-  return C_SUPPORT;
-}
-function supportForFileWithSource(filename, source, extensionMap) {
-  if (path.extname(filename).toLowerCase() !== ".h") {
-    return supportForFileWithoutHeaderSample(filename, extensionMap);
-  }
-  const mapped = mappedSupportForFile(filename, extensionMap);
-  if (mapped)
-    return mapped;
-  if (isLikelyCppHeader(source.slice(0, HEADER_SAMPLE_SIZE)))
-    return CPP_SUPPORT;
-  return C_SUPPORT;
-}
-function supportById(id) {
-  return LANGUAGE_SUPPORTS.find((s) => s.id === id);
-}
-var HEADER_SAMPLE_SIZE = 8e3;
-var CPP_HEADER_HINT = /\b(class|namespace|template|typename|constexpr|operator|using\s+namespace)\b|::/;
-function readFileSample(filePath) {
-  try {
-    const contents = fs.readFileSync(filePath, "utf8");
-    return contents.slice(0, HEADER_SAMPLE_SIZE);
-  } catch {
-    return null;
-  }
-}
-function isLikelyCppHeader(sample) {
-  return CPP_HEADER_HINT.test(sample);
-}
-
-// dist/native/runtime.js
-import fs5 from "node:fs";
-import path5 from "node:path";
-import { createRequire } from "node:module";
-import { fileURLToPath } from "node:url";
-
-// dist/util/ast.js
-function stringifyUnknown(value) {
-  if (value instanceof Error)
-    return value.message;
-  if (typeof value === "string")
-    return value;
-  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
-    return String(value);
-  }
-  if (value === null || value === void 0) {
-    return String(value);
-  }
-  if (typeof value === "object") {
-    try {
-      return JSON.stringify(value);
-    } catch {
-      return "[Object]";
-    }
-  }
-  if (typeof value === "symbol")
-    return value.toString();
-  if (typeof value === "function") {
-    return `[Function: ${value.name || "anonymous"}]`;
-  }
-  return "unknown";
-}
-
-// dist/native/bindingLoader.js
-import fs4 from "node:fs";
-import path4 from "node:path";
-
-// dist/util/paths.js
-import fs2, {} from "node:fs";
-import fsp from "node:fs/promises";
-import path2 from "node:path";
-
-// dist/util/errors.js
-function errorMessage(error) {
-  if (error instanceof Error)
-    return error.message;
-  if (typeof error === "string")
-    return error;
-  if (error === null || error === void 0)
-    return String(error);
-  if (typeof error === "object") {
-    try {
-      const serialized = JSON.stringify(error);
-      if (serialized)
-        return serialized;
-    } catch {
-      return String(error);
-    }
-  }
-  return String(error);
-}
-
-// dist/util/paths.js
-function normalizePath(p) {
-  return typeof p === "string" ? p.replace(/\\/g, "/") : "";
-}
-function normalizeWindowsComparablePath(filePath) {
-  return normalizePath(filePath).replace(/^([A-Za-z]):/, (_, driveLetter) => `${driveLetter.toUpperCase()}:`);
-}
-var defaultCaseInsensitiveFileIdentity = process.platform === "win32" || process.platform === "darwin";
-var caseInsensitiveFileIdentity = defaultCaseInsensitiveFileIdentity;
-var fileIdentityCaseSensitivityFrozen = false;
-function fileIdentityKey(filePath) {
-  fileIdentityCaseSensitivityFrozen = true;
-  const normalized = normalizeWindowsComparablePath(filePath);
-  return caseInsensitiveFileIdentity ? normalized.toLowerCase() : normalized;
-}
-function isWindowsQualifiedAbsolutePath(filePath) {
-  const normalizedPath = normalizePath(filePath);
-  return /^[A-Za-z]:\//.test(normalizedPath) || normalizedPath.startsWith("//");
-}
-function isPosixQualifiedAbsolutePath(filePath) {
-  const normalizedPath = normalizePath(filePath);
-  return path2.posix.isAbsolute(normalizedPath) && !isWindowsQualifiedAbsolutePath(normalizedPath);
-}
-function isAbsoluteFilePath(filePath) {
-  return path2.posix.isAbsolute(filePath) || path2.win32.isAbsolute(filePath);
-}
-function resolveFilePathFromRoot(projectRoot, filePath) {
-  if (isAbsoluteFilePath(filePath)) {
-    return filePath;
-  }
-  if (isWindowsQualifiedAbsolutePath(projectRoot)) {
-    return path2.win32.resolve(projectRoot, filePath);
-  }
-  if (isPosixQualifiedAbsolutePath(projectRoot)) {
-    return path2.posix.resolve(normalizePath(projectRoot), normalizePath(filePath));
-  }
-  return path2.resolve(projectRoot, filePath);
-}
-function resolveComparableProjectRoot(projectRoot) {
-  if (isAbsoluteFilePath(projectRoot)) {
-    return projectRoot;
-  }
-  return path2.resolve(projectRoot);
-}
-function isRelativeToRoot(normalizedRoot, normalizedFile) {
-  const rootIsWindowsPath = isWindowsQualifiedAbsolutePath(normalizedRoot);
-  const fileIsWindowsPath = isWindowsQualifiedAbsolutePath(normalizedFile);
-  const rootIsPosixPath = isPosixQualifiedAbsolutePath(normalizedRoot);
-  const fileIsPosixPath = isPosixQualifiedAbsolutePath(normalizedFile);
-  const comparableRoot = rootIsWindowsPath ? normalizeWindowsComparablePath(normalizedRoot) : normalizedRoot;
-  const comparableFile = fileIsWindowsPath ? normalizeWindowsComparablePath(normalizedFile) : normalizedFile;
-  if (rootIsWindowsPath && fileIsWindowsPath) {
-    if (comparableFile === comparableRoot) {
-      return true;
-    }
-    const relativePath2 = normalizePath(path2.win32.relative(comparableRoot, comparableFile));
-    return !!relativePath2.length && !relativePath2.startsWith("..") && !path2.win32.isAbsolute(relativePath2);
-  }
-  if (rootIsWindowsPath || fileIsWindowsPath) {
-    return false;
-  }
-  if (rootIsPosixPath && fileIsPosixPath) {
-    if (comparableFile === comparableRoot) {
-      return true;
-    }
-    const relativePath2 = path2.posix.relative(comparableRoot, comparableFile);
-    return !!relativePath2.length && !relativePath2.startsWith("..") && !path2.posix.isAbsolute(relativePath2);
-  }
-  if (rootIsPosixPath || fileIsPosixPath) {
-    return false;
-  }
-  if (comparableFile === comparableRoot) {
-    return true;
-  }
-  const relativePath = path2.relative(comparableRoot, comparableFile);
-  return !!relativePath.length && !relativePath.startsWith("..") && !path2.isAbsolute(relativePath);
-}
-function isFilePathWithinRoot(projectRoot, filePath, realpathMemo) {
-  const normalizedRoot = normalizePath(resolveComparableProjectRoot(projectRoot));
-  const normalizedFile = normalizePath(resolveFilePathFromRoot(normalizedRoot, filePath));
-  if (isRelativeToRoot(normalizedRoot, normalizedFile))
-    return true;
-  return windowsAliasRelativePath(normalizedRoot, normalizedFile, realpathMemo) !== null;
-}
-function assertFilePathWithinRoot(projectRoot, filePath, label = "File") {
-  const normalizedRoot = normalizePath(resolveComparableProjectRoot(projectRoot));
-  const normalizedFile = normalizePath(resolveFilePathFromRoot(normalizedRoot, filePath));
-  if (!isFilePathWithinRoot(normalizedRoot, normalizedFile)) {
-    throw new Error(`${label} is outside project root: ${normalizedFile} (root: ${normalizedRoot})`);
-  }
-  return normalizedFile;
-}
-function resolveWindowsRealpath(filePath, realpathMemo) {
-  if (!realpathMemo)
-    return fs2.realpathSync.native(filePath);
-  const key = fileIdentityKey(filePath);
-  const cached = realpathMemo.get(key);
-  if (cached !== void 0)
-    return cached;
-  const resolved = fs2.realpathSync.native(filePath);
-  realpathMemo.set(key, resolved);
-  return resolved;
-}
-function windowsAliasRelativePath(normalizedRoot, normalizedFile, realpathMemo) {
-  if (process.platform !== "win32")
-    return null;
-  if (!isWindowsQualifiedAbsolutePath(normalizedRoot) || !isWindowsQualifiedAbsolutePath(normalizedFile)) {
-    return null;
-  }
-  try {
-    const realRoot = resolveWindowsRealpath(normalizedRoot, realpathMemo);
-    const realFile = resolveWindowsRealpath(normalizedFile, realpathMemo);
-    const directRelativePath = path2.win32.relative(realRoot, realFile);
-    if (!directRelativePath.startsWith("..") && !path2.win32.isAbsolute(directRelativePath)) {
-      return normalizePath(directRelativePath);
-    }
-    const rootHasNoReparsePoint = fileIdentityKey(realRoot) === fileIdentityKey(normalizedRoot);
-    const fileHasNoReparsePoint = fileIdentityKey(realFile) === fileIdentityKey(normalizedFile);
-    if (rootHasNoReparsePoint && fileHasNoReparsePoint) {
-      return null;
-    }
-    const rootStat = fs2.statSync(realRoot, { bigint: true });
-    let ancestorPath = realFile;
-    while (true) {
-      const ancestorStat = fs2.statSync(ancestorPath, { bigint: true });
-      if (sameWindowsDirectoryIdentity(rootStat, ancestorStat)) {
-        return normalizePath(path2.win32.relative(ancestorPath, realFile));
-      }
-      const parentPath = path2.dirname(ancestorPath);
-      if (parentPath === ancestorPath)
-        return null;
-      ancestorPath = parentPath;
-    }
-  } catch {
-    return null;
-  }
-}
-function sameWindowsDirectoryIdentity(left, right) {
-  return left.ino !== 0n && left.dev === right.dev && left.ino === right.ino && left.birthtimeNs === right.birthtimeNs;
-}
-
-// dist/native/runtimeCache.js
-import { createHash, randomBytes } from "node:crypto";
-import fs3 from "node:fs";
-import path3 from "node:path";
-var CACHE_SCHEMA_VERSION = 1;
-var HASH_BUFFER_SIZE = 1024 * 1024;
-var IDENTITY_FILE_PREFIX = "identity-";
-var IDENTITY_FILE_SUFFIX = ".json";
-var IDENTITY_VERSION = 1;
-var IDENTITY_REVERIFY_INTERVAL_MS = 24 * 60 * 60 * 1e3;
-var ABANDONED_ENTRY_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
-function asError(error) {
-  return error instanceof Error ? error : new Error(String(error));
-}
-function isWithinDirectory(filePath, directoryPath) {
-  const relative = path3.relative(directoryPath, filePath);
-  return !relative || !relative.startsWith("..") && !path3.isAbsolute(relative);
-}
-function assertSafeCacheSegment(value, label) {
-  if (!value || value === "." || value === ".." || path3.basename(value) !== value) {
-    throw new Error(`invalid native cache ${label}: ${value}`);
-  }
-  if (!/^[A-Za-z0-9._+-]+$/.test(value)) {
-    throw new Error(`invalid native cache ${label}: ${value}`);
-  }
-}
-function assertSafePathComponent(componentPath) {
-  const stats = fs3.lstatSync(componentPath);
-  if (!stats.isDirectory() || stats.isSymbolicLink()) {
-    throw new Error(`unsafe native cache path component: ${componentPath}`);
-  }
-}
-function prepareSafeDirectory(directoryPath, create = true) {
-  const absolute = path3.resolve(directoryPath);
-  const parsed = path3.parse(absolute);
-  let current = parsed.root;
-  assertSafePathComponent(current);
-  const relativeParts = absolute.slice(parsed.root.length).split(path3.sep).filter(Boolean);
-  for (const part of relativeParts) {
-    current = path3.join(current, part);
-    try {
-      assertSafePathComponent(current);
-    } catch (error) {
-      if (error.code !== "ENOENT" || !create) {
-        throw error;
-      }
-      try {
-        fs3.mkdirSync(current);
-      } catch (mkdirError) {
-        if (mkdirError.code !== "EEXIST")
-          throw mkdirError;
-      }
-      assertSafePathComponent(current);
-    }
-  }
-  return fs3.realpathSync.native(absolute);
-}
-function findProductionCacheRoot() {
-  const localAppData = process.env.LOCALAPPDATA;
-  if (!localAppData)
-    return null;
-  return path3.join(localAppData, "codegraph", "native-cache", `v${CACHE_SCHEMA_VERSION}`);
-}
-function resolveProductionCacheRoot() {
-  const cacheRoot = findProductionCacheRoot();
-  if (!cacheRoot) {
-    throw new Error("LOCALAPPDATA is unavailable; cannot prepare the Windows native runtime cache");
-  }
-  return cacheRoot;
-}
-function hashFileStreaming(filePath, onChunk) {
-  const before = fs3.statSync(filePath);
-  if (!before.isFile() || before.size <= 0) {
-    throw new Error(`native binary is not a non-empty regular file: ${filePath}`);
-  }
-  const hash = createHash("sha256");
-  const buffer = Buffer.allocUnsafe(HASH_BUFFER_SIZE);
-  const descriptor = fs3.openSync(filePath, "r");
-  let size = 0;
-  try {
-    while (true) {
-      const bytesRead = fs3.readSync(descriptor, buffer, 0, buffer.length, null);
-      if (!bytesRead)
-        break;
-      hash.update(buffer.subarray(0, bytesRead));
-      size += bytesRead;
-      onChunk?.(bytesRead);
-    }
-  } finally {
-    fs3.closeSync(descriptor);
-  }
-  const after = fs3.statSync(filePath);
-  if (!after.isFile() || size !== before.size || after.size !== before.size || after.mtimeMs !== before.mtimeMs) {
-    throw new Error(`native binary changed while hashing: ${filePath}`);
-  }
-  return { sha256: hash.digest("hex"), size, mtimeMs: before.mtimeMs };
-}
-function randomSuffix() {
-  return `${process.pid}.${randomBytes(8).toString("hex")}`;
-}
-function copyFileExclusive(sourcePath, destinationPath) {
-  const source = fs3.openSync(sourcePath, "r");
-  let destination;
-  const buffer = Buffer.allocUnsafe(HASH_BUFFER_SIZE);
-  try {
-    destination = fs3.openSync(destinationPath, "wx");
-    while (true) {
-      const bytesRead = fs3.readSync(source, buffer, 0, buffer.length, null);
-      if (!bytesRead)
-        break;
-      let written = 0;
-      while (written < bytesRead) {
-        written += fs3.writeSync(destination, buffer, written, bytesRead - written);
-      }
-    }
-    fs3.fsyncSync(destination);
-  } finally {
-    if (destination !== void 0)
-      fs3.closeSync(destination);
-    fs3.closeSync(source);
-  }
-}
-function removeRegularTemporaryFile(filePath) {
-  try {
-    const stats = fs3.lstatSync(filePath);
-    if (stats.isFile() && !stats.isSymbolicLink())
-      fs3.unlinkSync(filePath);
-  } catch {
-  }
-}
-function verifyFile(filePath, expected) {
-  try {
-    const actual = hashFileStreaming(filePath);
-    return actual.size === expected.size && actual.sha256 === expected.sha256 ? actual : null;
-  } catch {
-    return null;
-  }
-}
-function publishExclusive(temporaryPath, finalPath) {
-  try {
-    fs3.linkSync(temporaryPath, finalPath);
-    return true;
-  } catch (error) {
-    if (error.code === "EEXIST")
-      return false;
-    throw error;
-  } finally {
-    removeRegularTemporaryFile(temporaryPath);
-  }
-}
-function populateBinary(sourcePath, finalPath, expected) {
-  const temporaryPath = `${finalPath}.${randomSuffix()}.tmp`;
-  try {
-    copyFileExclusive(sourcePath, temporaryPath);
-    if (!verifyFile(temporaryPath, expected)) {
-      throw new Error("native cache temporary file failed integrity verification");
-    }
-    return publishExclusive(temporaryPath, finalPath);
-  } catch (error) {
-    removeRegularTemporaryFile(temporaryPath);
-    throw error;
-  }
-}
-function recoverCorruptFinal(finalPath) {
-  const recoveryPath = `${finalPath}.corrupt.${randomSuffix()}`;
-  fs3.renameSync(finalPath, recoveryPath);
-}
-function writeManifest(entryPath, manifest) {
-  const finalPath = path3.join(entryPath, "manifest.json");
-  if (fs3.existsSync(finalPath))
-    return;
-  const temporaryPath = `${finalPath}.${randomSuffix()}.tmp`;
-  try {
-    const descriptor = fs3.openSync(temporaryPath, "wx");
-    try {
-      fs3.writeFileSync(descriptor, `${JSON.stringify(manifest, null, 2)}
-`, "utf8");
-      fs3.fsyncSync(descriptor);
-    } finally {
-      fs3.closeSync(descriptor);
-    }
-    publishExclusive(temporaryPath, finalPath);
-  } catch (error) {
-    removeRegularTemporaryFile(temporaryPath);
-    throw error;
-  }
-}
-function currentRuntimeStamp() {
-  return { abi: process.versions.modules, platform: process.platform, arch: process.arch };
-}
-function identityFilePath(entryPath, sourcePath) {
-  const sourceKey = createHash("sha256").update(sourcePath).digest("hex");
-  return path3.join(entryPath, `${IDENTITY_FILE_PREFIX}${sourceKey}${IDENTITY_FILE_SUFFIX}`);
-}
-function isIdentityFileName(fileName) {
-  return /^identity-[a-f0-9]{64}\.json$/.test(fileName);
-}
-function readCacheIdentityFile(filePath) {
-  let parsed;
-  try {
-    parsed = JSON.parse(fs3.readFileSync(filePath, "utf8"));
-  } catch {
-    return null;
-  }
-  if (!parsed || typeof parsed !== "object")
-    return null;
-  const candidate = parsed;
-  if (candidate.version !== IDENTITY_VERSION)
-    return null;
-  const numbers = [candidate.sourceSize, candidate.sourceMtimeMs, candidate.cachedSize, candidate.cachedMtimeMs];
-  if (numbers.some((value) => typeof value !== "number" || !Number.isFinite(value)))
-    return null;
-  const strings = [
-    candidate.sha256,
-    candidate.cacheKey,
-    candidate.sourcePath,
-    candidate.loadedPath,
-    candidate.verifiedAt
-  ];
-  if (strings.some((value) => typeof value !== "string" || !value))
-    return null;
-  if (!Array.isArray(candidate.supportedLanguageIds))
-    return null;
-  if (candidate.supportedLanguageIds.some((value) => typeof value !== "string"))
-    return null;
-  const origin = candidate.origin;
-  if (!origin || typeof origin !== "object" || origin.mode !== "cache" || typeof origin.packageName !== "string") {
-    return null;
-  }
-  const runtime = candidate.runtime;
-  if (!runtime || typeof runtime !== "object")
-    return null;
-  if (typeof runtime.abi !== "string" || typeof runtime.platform !== "string" || typeof runtime.arch !== "string") {
-    return null;
-  }
-  return candidate;
-}
-function readCacheIdentity(entryPath, sourcePath) {
-  return readCacheIdentityFile(identityFilePath(entryPath, sourcePath));
-}
-function latestCacheIdentityVerifiedAt(entryPath, now) {
-  let fileNames;
-  try {
-    fileNames = fs3.readdirSync(entryPath);
-  } catch {
-    return Number.NaN;
-  }
-  let latest = Number.NaN;
-  for (const fileName of fileNames) {
-    if (!isIdentityFileName(fileName))
-      continue;
-    const identity = readCacheIdentityFile(path3.join(entryPath, fileName));
-    const verifiedAt = identity ? Date.parse(identity.verifiedAt) : Number.NaN;
-    if (!Number.isFinite(verifiedAt) || verifiedAt > now)
-      continue;
-    if (!Number.isFinite(latest) || verifiedAt > latest)
-      latest = verifiedAt;
-  }
-  return latest;
-}
-function statOrNull(filePath) {
-  try {
-    const stats = fs3.statSync(filePath);
-    return stats.isFile() ? stats : null;
-  } catch {
-    return null;
-  }
-}
-function lstatRegularFileOrNull(filePath) {
-  try {
-    const stats = fs3.lstatSync(filePath);
-    return stats.isFile() && !stats.isSymbolicLink() ? stats : null;
-  } catch {
-    return null;
-  }
-}
-function isSafeExistingDirectory(directoryPath) {
-  try {
-    prepareSafeDirectory(directoryPath, false);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function pathsResolveEqual(left, right) {
-  return path3.resolve(left) === path3.resolve(right);
-}
-function lookupNativeRuntimeCacheEntry(request) {
-  try {
-    assertSafeCacheSegment(request.target, "target");
-    assertSafeCacheSegment(request.packageVersion, "package version");
-    const cacheRoot = request.cacheRoot ?? findProductionCacheRoot();
-    if (!cacheRoot)
-      return null;
-    const sourceRealPath = fs3.realpathSync.native(request.sourcePath);
-    const sourceStats = statOrNull(sourceRealPath);
-    if (!sourceStats)
-      return null;
-    const runtime = currentRuntimeStamp();
-    const resolvedCacheRoot = path3.resolve(cacheRoot);
-    const targetPath = path3.join(resolvedCacheRoot, request.target);
-    if (!isSafeExistingDirectory(resolvedCacheRoot) || !isSafeExistingDirectory(targetPath))
-      return null;
-    const prefix = `${request.packageVersion}-`;
-    let entryNames;
-    try {
-      entryNames = fs3.readdirSync(targetPath);
-    } catch {
-      return null;
-    }
-    const now = request.now ?? Date.now();
-    for (const entryName of entryNames) {
-      if (!entryName.startsWith(prefix))
-        continue;
-      const entryPath = path3.join(targetPath, entryName);
-      if (!isSafeExistingDirectory(entryPath))
-        continue;
-      const identity = readCacheIdentity(entryPath, sourceRealPath);
-      if (!identity)
-        continue;
-      const expectedEntryName = `${request.packageVersion}-${identity.sha256}`;
-      const expectedCacheKey = `${request.packageName}@${request.packageVersion}:${request.target}:${identity.sha256}`;
-      const loadedPath = path3.resolve(identity.loadedPath);
-      if (entryName !== expectedEntryName || identity.cacheKey !== expectedCacheKey || identity.loadedPath !== loadedPath || path3.dirname(loadedPath) !== entryPath || path3.basename(loadedPath) !== path3.basename(sourceRealPath)) {
-        continue;
-      }
-      if (identity.sourcePath !== sourceRealPath)
-        continue;
-      if (identity.sourceSize !== sourceStats.size || identity.sourceMtimeMs !== sourceStats.mtimeMs)
-        continue;
-      if (identity.origin.packageName !== request.packageName || identity.origin.packageVersion !== request.packageVersion || identity.origin.target !== request.target || identity.origin.sourcePath === void 0 || identity.origin.loadedPath === void 0 || !pathsResolveEqual(identity.origin.sourcePath, sourceRealPath) || !pathsResolveEqual(identity.origin.loadedPath, identity.loadedPath) || identity.origin.cacheKey !== identity.cacheKey || identity.origin.sha256 !== identity.sha256) {
-        continue;
-      }
-      if (identity.runtime.abi !== runtime.abi || identity.runtime.platform !== runtime.platform || identity.runtime.arch !== runtime.arch) {
-        continue;
-      }
-      const cachedStats = lstatRegularFileOrNull(identity.loadedPath);
-      if (!cachedStats)
-        continue;
-      if (identity.cachedSize !== cachedStats.size || identity.cachedMtimeMs !== cachedStats.mtimeMs)
-        continue;
-      const verifiedAt = Date.parse(identity.verifiedAt);
-      if (!Number.isFinite(verifiedAt) || verifiedAt > now || now - verifiedAt >= IDENTITY_REVERIFY_INTERVAL_MS) {
-        continue;
-      }
-      if (!isWithinDirectory(identity.loadedPath, resolvedCacheRoot))
-        continue;
-      return { entryPath, identity, revalidateAt: verifiedAt + IDENTITY_REVERIFY_INTERVAL_MS };
-    }
-    return null;
-  } catch {
-    return null;
-  }
-}
-function recordNativeRuntimeCacheIdentity(identity) {
-  try {
-    const sourceStats = statOrNull(identity.sourcePath);
-    const cachedStats = lstatRegularFileOrNull(identity.loadedPath);
-    if (!sourceStats || !cachedStats || sourceStats.size !== identity.sourceSize || sourceStats.mtimeMs !== identity.sourceMtimeMs || cachedStats.size !== identity.cachedSize || cachedStats.mtimeMs !== identity.cachedMtimeMs) {
-      return;
-    }
-    const entryPath = path3.dirname(identity.loadedPath);
-    const record = {
-      version: IDENTITY_VERSION,
-      runtime: currentRuntimeStamp(),
-      ...identity
-    };
-    const finalPath = identityFilePath(entryPath, identity.sourcePath);
-    const temporaryPath = `${finalPath}.${randomSuffix()}.tmp`;
-    try {
-      const descriptor = fs3.openSync(temporaryPath, "wx");
-      try {
-        fs3.writeFileSync(descriptor, `${JSON.stringify(record, null, 2)}
-`, "utf8");
-        fs3.fsyncSync(descriptor);
-      } finally {
-        fs3.closeSync(descriptor);
-      }
-      fs3.renameSync(temporaryPath, finalPath);
-    } catch {
-      removeRegularTemporaryFile(temporaryPath);
-    }
-  } catch {
-  }
-}
-function readEntrySummary(entryPath, now) {
-  let packageVersion = null;
-  let sourceFileName = null;
-  let cachedAtMs = null;
-  try {
-    const parsed = JSON.parse(fs3.readFileSync(path3.join(entryPath, "manifest.json"), "utf8"));
-    if (parsed && typeof parsed === "object") {
-      const manifest = parsed;
-      if (typeof manifest.packageVersion === "string" && manifest.packageVersion) {
-        packageVersion = manifest.packageVersion;
-      }
-      if (typeof manifest.sourceFileName === "string" && manifest.sourceFileName && path3.basename(manifest.sourceFileName) === manifest.sourceFileName) {
-        sourceFileName = manifest.sourceFileName;
-      }
-      const cachedAt = typeof manifest.cachedAt === "string" ? Date.parse(manifest.cachedAt) : Number.NaN;
-      if (Number.isFinite(cachedAt))
-        cachedAtMs = cachedAt;
-    }
-  } catch {
-    return null;
-  }
-  if (!packageVersion || !sourceFileName)
-    return null;
-  const verifiedAt = latestCacheIdentityVerifiedAt(entryPath, now);
-  const lastUsedMs = Number.isFinite(verifiedAt) ? verifiedAt : cachedAtMs;
-  if (lastUsedMs === null)
-    return null;
-  return { packageVersion, lastUsedMs, sourceFileName };
-}
-function removeAbandonedEntry(entryPath, sourceFileName) {
-  const cachedBinaryPath = path3.join(entryPath, sourceFileName);
-  if (!isWithinDirectory(cachedBinaryPath, entryPath) || path3.dirname(cachedBinaryPath) !== entryPath) {
-    throw new Error("invalid native cache binary path");
-  }
-  const stats = fs3.lstatSync(cachedBinaryPath);
-  if (!stats.isFile() || stats.isSymbolicLink())
-    throw new Error("unsafe native cache binary");
-  fs3.unlinkSync(cachedBinaryPath);
-  fs3.rmSync(entryPath, { recursive: true, force: true });
-}
-function pruneAbandonedEntries(targetPath, cacheRoot, keepEntryPath, keepVersion, now) {
-  let entryNames;
-  try {
-    entryNames = fs3.readdirSync(targetPath);
-  } catch {
-    return;
-  }
-  for (const entryName of entryNames) {
-    const entryPath = path3.join(targetPath, entryName);
-    if (entryPath === keepEntryPath)
-      continue;
-    if (!isWithinDirectory(entryPath, cacheRoot))
-      continue;
-    try {
-      if (!fs3.lstatSync(entryPath).isDirectory())
-        continue;
-    } catch {
-      continue;
-    }
-    const summary = readEntrySummary(entryPath, now);
-    if (!summary || summary.packageVersion === keepVersion)
-      continue;
-    if (now - summary.lastUsedMs < ABANDONED_ENTRY_RETENTION_MS)
-      continue;
-    try {
-      removeAbandonedEntry(entryPath, summary.sourceFileName);
-    } catch {
-    }
-  }
-}
-function prepareNativeRuntimeCache(request) {
-  const sourcePath = path3.resolve(request.sourcePath);
-  try {
-    assertSafeCacheSegment(request.target, "target");
-    assertSafeCacheSegment(request.packageVersion, "package version");
-    const hit = lookupNativeRuntimeCacheEntry({
-      sourcePath,
-      packageName: request.packageName,
-      packageVersion: request.packageVersion,
-      target: request.target,
-      ...request.cacheRoot !== void 0 ? { cacheRoot: request.cacheRoot } : {},
-      ...request.now !== void 0 ? { now: request.now } : {}
-    });
-    if (hit) {
-      return {
-        status: "reused",
-        sourcePath: hit.identity.sourcePath,
-        loadedPath: hit.identity.loadedPath,
-        cacheKey: hit.identity.cacheKey,
-        sha256: hit.identity.sha256,
-        sourceSize: hit.identity.sourceSize,
-        sourceMtimeMs: hit.identity.sourceMtimeMs,
-        cachedSize: hit.identity.cachedSize,
-        cachedMtimeMs: hit.identity.cachedMtimeMs,
-        verified: false
-      };
-    }
-    const sourceRealPath = fs3.realpathSync.native(sourcePath);
-    const source = hashFileStreaming(sourceRealPath);
-    const cacheRoot = prepareSafeDirectory(request.cacheRoot ?? resolveProductionCacheRoot());
-    const targetPath = prepareSafeDirectory(path3.join(cacheRoot, request.target));
-    if (!isWithinDirectory(targetPath, cacheRoot)) {
-      throw new Error("native cache target escaped the cache root");
-    }
-    const cacheKey = `${request.packageName}@${request.packageVersion}:${request.target}:${source.sha256}`;
-    const entryPath = prepareSafeDirectory(path3.join(targetPath, `${request.packageVersion}-${source.sha256}`));
-    if (!isWithinDirectory(entryPath, cacheRoot)) {
-      throw new Error("native cache entry escaped the cache root");
-    }
-    const sourceFileName = path3.basename(sourceRealPath);
-    const finalPath = path3.join(entryPath, sourceFileName);
-    let status = "reused";
-    let cached = fs3.existsSync(finalPath) ? verifyFile(finalPath, source) : null;
-    if (!cached) {
-      if (fs3.existsSync(finalPath))
-        recoverCorruptFinal(finalPath);
-      status = populateBinary(sourceRealPath, finalPath, source) ? "cached" : "reused";
-      cached = verifyFile(finalPath, source);
-      if (!cached) {
-        throw new Error("native cache winner failed integrity verification");
-      }
-    }
-    writeManifest(entryPath, {
-      schemaVersion: CACHE_SCHEMA_VERSION,
-      packageName: request.packageName,
-      packageVersion: request.packageVersion,
-      target: request.target,
-      sourceFileName,
-      sourceSize: source.size,
-      sourceSha256: source.sha256,
-      cachedAt: (/* @__PURE__ */ new Date()).toISOString()
-    });
-    pruneAbandonedEntries(targetPath, cacheRoot, entryPath, request.packageVersion, request.now ?? Date.now());
-    return {
-      status,
-      sourcePath: sourceRealPath,
-      loadedPath: finalPath,
-      cacheKey,
-      sha256: source.sha256,
-      sourceSize: source.size,
-      sourceMtimeMs: source.mtimeMs,
-      cachedSize: cached.size,
-      cachedMtimeMs: cached.mtimeMs,
-      verified: true
-    };
-  } catch (error) {
-    return { status: "unavailable", sourcePath, error: asError(error) };
-  }
-}
-
-// dist/native/bindingLoader.js
-function isMuslRuntime() {
-  if (process.platform !== "linux")
-    return false;
-  const report = process.report?.getReport();
-  const header = report && typeof report === "object" && "header" in report ? report.header : null;
-  const glibcVersionRuntime = header && typeof header === "object" && "glibcVersionRuntime" in header ? header.glibcVersionRuntime : null;
-  if (typeof glibcVersionRuntime === "string" && glibcVersionRuntime)
-    return false;
-  return true;
-}
-function nativeTargetSuffixFor(platform, arch) {
-  if (platform === "win32") {
-    if (arch === "x64")
-      return "win32-x64-msvc";
-    if (arch === "arm64")
-      return "win32-arm64-msvc";
-  }
-  if (platform === "darwin") {
-    if (arch === "x64")
-      return "darwin-x64";
-    if (arch === "arm64")
-      return "darwin-arm64";
-  }
-  if (platform === "linux") {
-    const abi = isMuslRuntime() ? "musl" : "gnu";
-    if (arch === "x64")
-      return `linux-x64-${abi}`;
-    if (arch === "arm64")
-      return `linux-arm64-${abi}`;
-  }
-  return null;
-}
-function currentNativeTargetSuffix() {
-  return nativeTargetSuffixFor(process.platform, process.arch);
-}
-function normalizePathForComparison(filePath) {
-  const resolved = path4.resolve(filePath);
-  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
-}
-function isWithinDirectory2(filePath, directoryPath) {
-  const normalizedFile = normalizePathForComparison(filePath);
-  const normalizedDir = normalizePathForComparison(directoryPath);
-  return normalizedFile === normalizedDir || normalizedFile.startsWith(`${normalizedDir}${path4.sep}`);
-}
-function findLocalNativeBinary(packageRoot) {
-  const suffix = currentNativeTargetSuffix();
-  if (!suffix) {
-    return null;
-  }
-  const expectedName = `index.${suffix}.node`;
-  try {
-    const entries = fs4.readdirSync(packageRoot, { withFileTypes: true });
-    const binary = entries.find((entry) => entry.isFile() && entry.name === expectedName);
-    return binary ? path4.join(packageRoot, binary.name) : null;
-  } catch {
-    return null;
-  }
-}
-function readPlatformPackage(packageName, target, resolveFn) {
-  const platformPackageName = `${packageName}-${target}`;
-  const resolvedEntry = resolveFn(platformPackageName);
-  const expectedFileName = `index.${target}.node`;
-  if (path4.basename(resolvedEntry) !== expectedFileName) {
-    throw new Error(`unexpected native platform entry for ${platformPackageName}: ${resolvedEntry}`);
-  }
-  const sourcePath = fs4.realpathSync.native(resolvedEntry);
-  const stats = fs4.statSync(sourcePath);
-  if (!stats.isFile() || stats.size <= 0) {
-    throw new Error(`native platform entry is not a non-empty regular file: ${sourcePath}`);
-  }
-  const packageJsonPath = path4.join(path4.dirname(sourcePath), "package.json");
-  const parsed = JSON.parse(fs4.readFileSync(packageJsonPath, "utf8"));
-  if (parsed.name !== platformPackageName || !parsed.version) {
-    throw new Error(`invalid native platform package metadata: ${packageJsonPath}`);
-  }
-  return { sourcePath, packageVersion: parsed.version };
-}
-function loadNativeBinding(options) {
-  const localBinary = findLocalNativeBinary(options.localPackageRoot);
-  const localTarget = currentNativeTargetSuffix();
-  let lastError;
-  if (localBinary) {
-    try {
-      return {
-        binding: options.requireFn(localBinary),
-        origin: {
-          mode: "workspace",
-          packageName: options.packageName,
-          ...localTarget ? { target: localTarget } : {},
-          sourcePath: normalizePath(localBinary),
-          loadedPath: normalizePath(localBinary)
-        }
-      };
-    } catch (error) {
-      lastError = error;
-    }
-  }
-  const packageEntry = (() => {
-    if (!options.resolveFn)
-      return null;
-    try {
-      return options.resolveFn(options.packageName);
-    } catch {
-      return null;
-    }
-  })();
-  if (packageEntry && isWithinDirectory2(packageEntry, options.localPackageRoot)) {
-    return {
-      binding: null,
-      error: lastError ?? new Error("local workspace native addon is not built; run `npm run build:native`"),
-      origin: {
-        mode: "workspace",
-        packageName: options.packageName,
-        ...localTarget ? { target: localTarget } : {}
-      }
-    };
-  }
-  const platform = options.platform ?? process.platform;
-  const arch = options.arch ?? process.arch;
-  const target = nativeTargetSuffixFor(platform, arch);
-  let installedSourcePath;
-  let installedPackageVersion;
-  let cacheError;
-  if (target && options.resolveFn) {
-    try {
-      const platformPackage = readPlatformPackage(options.packageName, target, options.resolveFn);
-      installedSourcePath = platformPackage.sourcePath;
-      installedPackageVersion = platformPackage.packageVersion;
-    } catch (error) {
-      if (platform === "win32") {
-        cacheError = errorMessage(error);
-      }
-    }
-  }
-  if (platform === "win32" && target && installedSourcePath && installedPackageVersion) {
-    const cached = prepareNativeRuntimeCache({
-      sourcePath: installedSourcePath,
-      packageName: `${options.packageName}-${target}`,
-      packageVersion: installedPackageVersion,
-      target,
-      cacheRoot: options.cacheRoot
-    });
-    if (cached.status === "unavailable") {
-      cacheError = cached.error.message;
-    } else {
-      try {
-        return {
-          binding: options.requireFn(cached.loadedPath),
-          origin: {
-            mode: "cache",
-            packageName: `${options.packageName}-${target}`,
-            packageVersion: installedPackageVersion,
-            target,
-            sourcePath: normalizePath(cached.sourcePath),
-            loadedPath: normalizePath(cached.loadedPath),
-            cacheKey: cached.cacheKey,
-            sha256: cached.sha256
-          },
-          cacheEntry: {
-            sourcePath: cached.sourcePath,
-            loadedPath: cached.loadedPath,
-            cacheKey: cached.cacheKey,
-            sha256: cached.sha256,
-            sourceSize: cached.sourceSize,
-            sourceMtimeMs: cached.sourceMtimeMs,
-            cachedSize: cached.cachedSize,
-            cachedMtimeMs: cached.cachedMtimeMs,
-            verified: cached.verified
-          }
-        };
-      } catch (error) {
-        cacheError = `cached native addon failed to load: ${errorMessage(error)}`;
-        lastError = error;
-      }
-    }
-  }
-  let originPackageName = options.packageName;
-  let originLoadedPath = packageEntry;
-  if (target && installedSourcePath && installedPackageVersion) {
-    originPackageName = `${options.packageName}-${target}`;
-    originLoadedPath = installedSourcePath;
-  }
-  const packageOrigin = {
-    mode: "package",
-    packageName: originPackageName,
-    ...installedPackageVersion ? { packageVersion: installedPackageVersion } : {},
-    ...target ? { target } : {},
-    ...installedSourcePath ? { sourcePath: normalizePath(installedSourcePath) } : {},
-    ...originLoadedPath ? { loadedPath: normalizePath(originLoadedPath) } : {},
-    ...cacheError ? { cacheError } : {}
-  };
-  try {
-    return {
-      binding: options.requireFn(options.packageName),
-      origin: packageOrigin
-    };
-  } catch (error) {
-    return {
-      binding: null,
-      error: error ?? lastError,
-      origin: packageOrigin
-    };
-  }
-}
-
-// dist/util/windowsProcessDrain.js
-var WINDOWS_LIBUV_EXIT_DRAIN_MS = 100;
-var drainRequired = false;
-var beforeExitListener;
-function markWindowsProcessDrainRequired() {
-  drainRequired = true;
-  ensureWindowsProcessDrainHook();
-}
-function delay(ms) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms);
-  });
-}
-function ensureWindowsProcessDrainHook() {
-  if (process.platform !== "win32" || beforeExitListener)
-    return;
-  beforeExitListener = () => {
-    void drainWindowsProcessHandles();
-  };
-  process.once("beforeExit", beforeExitListener);
-}
-async function drainWindowsProcessHandles(options) {
-  const platform = options?.platform ?? process.platform;
-  const required = options?.required ?? drainRequired;
-  if (platform !== "win32" || !required)
-    return;
-  await (options?.wait ?? delay)(WINDOWS_LIBUV_EXIT_DRAIN_MS);
-}
-
-// dist/native/runtime.js
-var require2 = createRequire(import.meta.url);
-var localNativePackageRoot = path5.resolve(path5.dirname(fileURLToPath(import.meta.url)), "../../packages/codegraph-native");
-var NATIVE_REQUIRED_ERROR_PREFIX = "native tree-sitter required by explicit option but unavailable";
-var bindingState;
-var cachedRuntimeFingerprints = /* @__PURE__ */ new Map();
-function isNativeTreeSitterDisabledByEnv(env = process.env) {
-  const rawValue = env.CODEGRAPH_DISABLE_NATIVE;
-  if (typeof rawValue !== "string") {
-    return false;
-  }
-  const normalized = rawValue.trim().toLowerCase();
-  return normalized === "1" || normalized === "true" || normalized === "yes";
-}
-function normalizeNativeRuntimeMode(mode) {
-  return mode ?? "auto";
-}
-function loadBinding() {
-  if (bindingState)
-    return bindingState;
-  cachedRuntimeFingerprints.clear();
-  const loaded = loadNativeBinding({
-    packageName: "@lzehrung/codegraph-native",
-    localPackageRoot: localNativePackageRoot,
-    requireFn: require2,
-    resolveFn: require2.resolve
-  });
-  if (loaded.binding) {
-    const supportedLanguageIds = new Set(loaded.binding.supportedLanguageIds());
-    markWindowsProcessDrainRequired();
-    bindingState = {
-      loaded: true,
-      binding: loaded.binding,
-      supportedLanguageIds,
-      origin: loaded.origin
-    };
-    if (loaded.cacheEntry?.verified) {
-      recordNativeRuntimeCacheIdentity({
-        sourcePath: loaded.cacheEntry.sourcePath,
-        loadedPath: loaded.cacheEntry.loadedPath,
-        cacheKey: loaded.cacheEntry.cacheKey,
-        sha256: loaded.cacheEntry.sha256,
-        sourceSize: loaded.cacheEntry.sourceSize,
-        sourceMtimeMs: loaded.cacheEntry.sourceMtimeMs,
-        cachedSize: loaded.cacheEntry.cachedSize,
-        cachedMtimeMs: loaded.cacheEntry.cachedMtimeMs,
-        verifiedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        supportedLanguageIds: Array.from(supportedLanguageIds).sort(),
-        origin: loaded.origin
-      });
-    }
-    return bindingState;
-  }
-  bindingState = {
-    loaded: false,
-    error: loaded.error,
-    ...loaded.origin ? { origin: loaded.origin } : {}
-  };
-  return bindingState;
-}
-function resolveNativeBindingState(mode, env = process.env) {
-  const normalizedMode = normalizeNativeRuntimeMode(mode);
-  if (normalizedMode === "off") {
-    return {
-      loaded: false,
-      error: new Error("native tree-sitter disabled by explicit option")
-    };
-  }
-  if (normalizedMode === "auto" && isNativeTreeSitterDisabledByEnv(env)) {
-    return {
-      loaded: false,
-      error: new Error("native tree-sitter disabled by CODEGRAPH_DISABLE_NATIVE")
-    };
-  }
-  return loadBinding();
-}
-function throwIfNativeRequiredUnavailable(mode, state) {
-  if (normalizeNativeRuntimeMode(mode) !== "on" || state.loaded)
-    return;
-  const suffix = state.error ? `: ${stringifyUnknown(state.error)}` : "";
-  throw new Error(`${NATIVE_REQUIRED_ERROR_PREFIX}${suffix}`);
-}
-
-// dist/native/queries.js
-function normalizeNativeQueryForSupport(support, kind, queryText) {
-  return support.native?.normalizeQuery?.(kind, queryText) ?? queryText;
-}
-
-// dist/native/execution.js
-function getNativeSingleQueryExecution(source, support, queryText, mode) {
-  const state = resolveNativeBindingState(mode);
-  throwIfNativeRequiredUnavailable(mode, state);
-  if (!state.loaded) {
-    return unavailableSingleQueryExecution(state);
-  }
-  if (!state.supportedLanguageIds.has(support.id)) {
-    return { matches: null, fallbackReason: "unsupportedLanguage" };
-  }
-  if (!state.binding.runQuery) {
-    return {
-      matches: null,
-      fallbackReason: "unavailable",
-      error: "native binding does not expose runQuery"
-    };
-  }
-  const normalizedQuery = normalizeNativeQueryForSupport(support, "adHoc", queryText);
-  try {
-    return {
-      matches: state.binding.runQuery(source, support.id, normalizedQuery).matches
-    };
-  } catch (error) {
-    return {
-      matches: null,
-      fallbackReason: "queryFailure",
-      error: errorMessage(error)
-    };
-  }
-}
-function unavailableSingleQueryExecution(state) {
-  return {
-    matches: null,
-    ...unavailableNativeFailure(state)
-  };
-}
-function unavailableNativeFailure(state) {
-  if (!state.error) {
-    return { fallbackReason: "unavailable" };
-  }
-  if (state.error instanceof Error) {
-    return { fallbackReason: "unavailable", error: state.error.message };
-  }
-  return { fallbackReason: "unavailable", error: stringifyUnknown(state.error) };
-}
-
-// dist/chunking/chunkMatches.js
-function getChunkMatches(language, source, _filePath) {
-  const support = supportById(language.supportId);
-  if (support) {
-    const nativeExecution = getNativeSingleQueryExecution(source, support, language.queryText);
-    if (nativeExecution.matches) {
-      const toStringIndex = createUtf8ByteToStringIndex(source);
-      return nativeExecution.matches.map((match) => toChunkMatchFromNative(match, toStringIndex));
-    }
-  }
-  return [];
-}
-function toChunkMatchFromNative(match, toStringIndex) {
-  return {
-    captures: match.captures.map((capture) => ({
-      name: capture.name,
-      text: capture.text,
-      startByte: toStringIndex(capture.start.index),
-      endByte: toStringIndex(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/chunkId.js
-import { createHash as createHash2 } from "node:crypto";
-function withStableChunkIds(chunks, languageId, filePath) {
-  const occurrences = /* @__PURE__ */ new Map();
-  const scopedPath = filePath ?? "unknown";
-  return chunks.map((chunk) => {
-    const digest = createHash2("sha256").update("codegraph-chunk-id-v1\0").update(languageId).update("\0").update(scopedPath).update("\0").update(chunk.type).update("\0").update(chunk.name ?? "").update("\0").update(chunk.text).digest("hex");
-    const occurrence = occurrences.get(digest) ?? 0;
-    occurrences.set(digest, occurrence + 1);
-    const id = occurrence === 0 ? `${languageId}:${scopedPath}:${digest}` : `${languageId}:${scopedPath}:${digest}:${occurrence}`;
-    return { ...chunk, id };
-  });
-}
-
-// dist/chunking/chunkSplit.js
-function splitLargeBlockSimple(block, source, tokenizer, maxTokens, out, languageId, filePath) {
-  let currentStart = -1;
-  let currentEnd = -1;
-  let currentStartLine = block.startLine;
-  let currentTokens = 0;
-  const flush = () => {
-    if (currentStart === -1)
-      return;
-    emitRangeWithinBudget(block, source, currentStart, currentEnd, currentStartLine, tokenizer, maxTokens, out, languageId, filePath);
-    currentStart = -1;
-    currentEnd = -1;
-    currentTokens = 0;
-  };
-  for (const line of lineRanges(source, block.startByte, block.endByte, block.startLine)) {
-    const lineText = source.slice(line.start, line.end);
-    const lineTokens = tokenizer(lineText);
-    if (lineTokens > maxTokens) {
-      flush();
-      emitRangeWithinBudget(block, source, line.start, line.end, line.startLine, tokenizer, maxTokens, out, languageId, filePath);
-      continue;
-    }
-    if (currentStart !== -1 && currentTokens + lineTokens > maxTokens) {
-      flush();
-    }
-    if (currentStart === -1) {
-      currentStart = line.start;
-      currentStartLine = line.startLine;
-    }
-    currentEnd = line.end;
-    currentTokens += lineTokens;
-  }
-  flush();
-}
-function splitLargeBlockUsingInnerBlocks(block, _innerBlocks, source, tokenizer, maxTokens, out, languageId, _newlineOffsets, filePath) {
-  splitLargeBlockSimple(block, source, tokenizer, maxTokens, out, languageId, filePath);
-}
-function splitTextWithinTokenBudget(text, tokenizer, maxTokens) {
-  if (!text.length)
-    return [];
-  if (tokenizer(text) <= maxTokens)
-    return [text];
-  const segments = [];
-  let start = 0;
-  while (start < text.length) {
-    if (tokenizer(text.slice(start)) <= maxTokens) {
-      segments.push(text.slice(start));
-      break;
-    }
-    let low = nextCodePointBoundary(text, start);
-    let high = text.length;
-    let end = start;
-    while (low <= high) {
-      const candidate = previousCodePointBoundary(text, low + (high - low >>> 1));
-      if (candidate <= start) {
-        low = nextCodePointBoundary(text, start);
-        continue;
-      }
-      if (tokenizer(text.slice(start, candidate)) <= maxTokens) {
-        end = candidate;
-        low = candidate + 1;
-      } else {
-        high = candidate - 1;
-      }
-    }
-    if (end === start) {
-      const next = nextCodePointBoundary(text, start);
-      const singleCodePoint = text.slice(start, next);
-      if (tokenizer(singleCodePoint) > maxTokens) {
-        throw new RangeError("maxTokens is smaller than the configured tokenizer's smallest unit");
-      }
-      end = next;
-    }
-    segments.push(text.slice(start, end));
-    start = end;
-  }
-  return segments;
-}
-function emitRangeWithinBudget(block, source, start, end, startLine, tokenizer, maxTokens, out, languageId, filePath) {
-  const text = source.slice(start, end);
-  const tokenCount = tokenizer(text);
-  if (tokenCount <= maxTokens) {
-    pushRangedChunk(out, block, languageId, filePath, start, end, startLine, endLineForText(startLine, text), text, tokenCount);
-    return;
-  }
-  let segmentStart = start;
-  let segmentStartLine = startLine;
-  for (const segment of splitTextWithinTokenBudget(text, tokenizer, maxTokens)) {
-    const segmentEnd = segmentStart + segment.length;
-    pushRangedChunk(out, block, languageId, filePath, segmentStart, segmentEnd, segmentStartLine, endLineForText(segmentStartLine, segment), segment, tokenizer(segment));
-    segmentStartLine += countLineBreaks(segment);
-    segmentStart = segmentEnd;
-  }
-}
-function pushRangedChunk(out, block, languageId, filePath, sourceStart, sourceEnd, startLine, endLine, text, tokenCount) {
-  out.push({
-    id: "",
-    languageId,
-    type: block.kind,
-    startLine,
-    endLine,
-    text,
-    tokenCount,
-    sourceStart,
-    sourceEnd,
-    ...filePath !== void 0 ? { filePath } : {},
-    ...block.name !== void 0 ? { name: block.name } : {}
-  });
-}
-function lineRanges(source, start, end, startLine) {
-  const ranges = [];
-  let rangeStart = start;
-  let line = startLine;
-  for (let offset = start; offset < end; offset++) {
-    if (source[offset] !== "\n")
-      continue;
-    ranges.push({ start: rangeStart, end: offset + 1, startLine: line });
-    rangeStart = offset + 1;
-    line++;
-  }
-  if (rangeStart < end) {
-    ranges.push({ start: rangeStart, end, startLine: line });
-  }
-  return ranges;
-}
-function countLineBreaks(text) {
-  let count = 0;
-  for (let index = 0; index < text.length; index++) {
-    if (text[index] === "\n")
-      count++;
-  }
-  return count;
-}
-function endLineForText(startLine, text) {
-  const lineBreaks = countLineBreaks(text);
-  return startLine + lineBreaks - (text.endsWith("\n") ? 1 : 0);
-}
-function nextCodePointBoundary(text, index) {
-  if (index >= text.length)
-    return text.length;
-  const codePoint = text.codePointAt(index);
-  return index + (codePoint !== void 0 && codePoint > 65535 ? 2 : 1);
-}
-function previousCodePointBoundary(text, index) {
-  if (index <= 0 || index >= text.length || text.charCodeAt(index) < 56320 || text.charCodeAt(index) > 57343) {
-    return index;
-  }
-  return index - 1;
-}
-
-// dist/chunking/chunkMerge.js
-function mergeSmallChunks(chunks, minTokens, maxTokens, tokenizer) {
-  if (!chunks.length)
-    return [];
-  const merged = [];
-  let index = 0;
-  while (index < chunks.length) {
-    let current = { ...chunks[index] };
-    index++;
-    while (current.tokenCount < minTokens && index < chunks.length) {
-      if (current.type === "misc" && current.tokenCount === 0)
-        break;
-      const next = chunks[index];
-      if (next.sourceStart < current.sourceEnd)
-        break;
-      if (next.sourceStart !== current.sourceEnd)
-        break;
-      const combinedText = `${current.text}${next.text}`;
-      const combinedTokens = tokenizer(combinedText);
-      if (combinedTokens > maxTokens)
-        break;
-      const resolvedName = current.name ?? next.name;
-      let type = current.type;
-      if (current.type === "misc" && current.tokenCount === 0) {
-        type = next.type;
-      } else if (next.type === "misc" && next.tokenCount === 0) {
-        type = current.type;
-      } else if (current.type !== next.type) {
-        type = `${current.type}+${next.type}`;
-      }
-      current = {
-        ...current,
-        endLine: next.endLine,
-        sourceEnd: next.sourceEnd,
-        text: combinedText,
-        tokenCount: combinedTokens,
-        type,
-        ...resolvedName !== void 0 ? { name: resolvedName } : {}
-      };
-      index++;
-    }
-    merged.push(current);
-  }
-  return merged;
-}
-function fillGapsWithMiscChunks(chunks, source, languageId, filePath, tokenizer, minTokens, maxTokens, newlineOffsets) {
-  if (!source.length)
-    return [];
-  const result = [];
-  let currentOffset = 0;
-  const sortedChunks = [...chunks].sort((left, right) => left.sourceStart - right.sourceStart || right.sourceEnd - left.sourceEnd);
-  for (const chunk of sortedChunks) {
-    if (chunk.sourceStart > currentOffset) {
-      const appendedToPrevious = appendTriviaGap(result, source, currentOffset, chunk.sourceStart, tokenizer, maxTokens, newlineOffsets);
-      if (!appendedToPrevious) {
-        pushMiscRange(result, source, currentOffset, chunk.sourceStart, languageId, filePath, tokenizer, maxTokens, newlineOffsets);
-      }
-    }
-    result.push(chunk);
-    currentOffset = Math.max(currentOffset, chunk.sourceEnd);
-  }
-  if (currentOffset < source.length) {
-    const appendedToPrevious = appendTriviaGap(result, source, currentOffset, source.length, tokenizer, maxTokens, newlineOffsets);
-    if (!appendedToPrevious) {
-      pushMiscRange(result, source, currentOffset, source.length, languageId, filePath, tokenizer, maxTokens, newlineOffsets);
-    }
-  }
-  return mergeSmallChunks(result, minTokens, maxTokens, tokenizer);
-}
-function appendTriviaGap(chunks, source, start, end, tokenizer, maxTokens, newlineOffsets) {
-  if (!chunks.length || end <= start)
-    return false;
-  const previous = chunks[chunks.length - 1];
-  if (previous.sourceEnd !== start)
-    return false;
-  const text = source.slice(start, end);
-  if (!/^[\s;]+$/u.test(text))
-    return false;
-  const combinedText = `${previous.text}${text}`;
-  const tokenCount = tokenizer(combinedText);
-  if (tokenCount > maxTokens)
-    return false;
-  const [endRow] = locateLineFromOffset(newlineOffsets, Math.max(start, end - 1));
-  chunks[chunks.length - 1] = {
-    ...previous,
-    endLine: endRow + 1,
-    sourceEnd: end,
-    text: combinedText,
-    tokenCount
-  };
-  return true;
-}
-function pushMiscRange(out, source, start, end, languageId, filePath, tokenizer, maxTokens, newlineOffsets) {
-  if (end <= start)
-    return;
-  const [startRow] = locateLineFromOffset(newlineOffsets, start);
-  const [endRow] = locateLineFromOffset(newlineOffsets, Math.max(start, end - 1));
-  const block = {
-    kind: "misc",
-    startByte: start,
-    endByte: end,
-    startLine: startRow + 1,
-    endLine: endRow + 1
-  };
-  const text = source.slice(start, end);
-  const tokenCount = tokenizer(text);
-  if (tokenCount <= maxTokens) {
-    out.push({
-      id: "",
-      languageId,
-      type: "misc",
-      startLine: block.startLine,
-      endLine: block.endLine,
-      text,
-      tokenCount,
-      sourceStart: start,
-      sourceEnd: end,
-      ...filePath !== void 0 ? { filePath } : {}
-    });
-    return;
-  }
-  splitLargeBlockSimple(block, source, tokenizer, maxTokens, out, languageId, filePath);
-}
-function locateLineFromOffset(newlineOffsets, offset) {
-  let low = 0;
-  let high = newlineOffsets.length;
-  while (low < high) {
-    const mid = low + high >>> 1;
-    if (newlineOffsets[mid] < offset)
-      low = mid + 1;
-    else
-      high = mid;
-  }
-  const previousNewline = low > 0 ? newlineOffsets[low - 1] : -1;
-  return [low, offset - previousNewline - 1];
-}
-
-// dist/chunking/tokenizer.js
-function countWhitespaceTokens(text) {
-  if (!text.trim())
-    return 0;
-  return text.trim().split(/\s+/).length;
-}
-
-// dist/chunking/chunkFile.js
-function chunkFileWithSymbols(opts) {
-  const { language, source, filePath, minTokens = 150, maxTokens = 400, tokenizer = countWhitespaceTokens } = opts;
-  const matches = getChunkMatches(language, source, filePath);
-  const newlineOffsets = collectNewlineOffsets(source);
-  const { mainBlocks, innerBlocks, comments } = collectChunkBlockGroups(language, matches);
-  const selectedBlocks = selectMainBlocks(mainBlocks);
-  const preliminaryChunks = [];
-  const sortedInnerBlocks = [...innerBlocks].sort((left, right) => left.startByte - right.startByte || left.endByte - right.endByte);
-  for (const block of selectedBlocks) {
-    appendBlockChunks(block, sortedInnerBlocks, source, tokenizer, maxTokens, preliminaryChunks, language.id, newlineOffsets, filePath);
-  }
-  for (const comment of selectStandaloneComments(comments, selectedBlocks)) {
-    appendBlockChunks(comment, [], source, tokenizer, maxTokens, preliminaryChunks, language.id, newlineOffsets, filePath);
-  }
-  preliminaryChunks.sort((left, right) => left.sourceStart - right.sourceStart || right.sourceEnd - left.sourceEnd);
-  if (minTokens <= 1) {
-    const completeChunks2 = fillGapsWithMiscChunks(preliminaryChunks, source, language.id, filePath, tokenizer, 1, maxTokens, newlineOffsets);
-    const chunks2 = withStableChunkIds(completeChunks2.map(({ sourceStart: _sourceStart, sourceEnd: _sourceEnd, ...chunk }) => chunk), language.id, filePath);
-    return { chunks: chunks2, symbolChunks: chunks2 };
-  }
-  const completeSymbolChunks = fillGapsWithMiscChunks(preliminaryChunks, source, language.id, filePath, tokenizer, 1, maxTokens, newlineOffsets);
-  const symbolChunks = withStableChunkIds(completeSymbolChunks.map(({ sourceStart: _sourceStart, sourceEnd: _sourceEnd, ...chunk }) => chunk), language.id, filePath);
-  const mergedChunks = mergeSmallChunks([...preliminaryChunks], minTokens, maxTokens, tokenizer);
-  const completeChunks = fillGapsWithMiscChunks(mergedChunks, source, language.id, filePath, tokenizer, minTokens, maxTokens, newlineOffsets);
-  const chunks = withStableChunkIds(completeChunks.map(({ sourceStart: _sourceStart, sourceEnd: _sourceEnd, ...chunk }) => chunk), language.id, filePath);
-  return { chunks, symbolChunks };
-}
-function chunkFile(opts) {
-  return chunkFileWithSymbols(opts).chunks;
-}
-function appendBlockChunks(block, innerBlocks, source, tokenizer, maxTokens, out, languageId, newlineOffsets, filePath) {
-  const text = source.slice(block.startByte, block.endByte);
-  const tokens = tokenizer(text);
-  if (tokens <= maxTokens) {
-    out.push({
-      id: "",
-      languageId,
-      type: block.kind,
-      startLine: block.startLine,
-      endLine: block.endLine,
-      text,
-      tokenCount: tokens,
-      sourceStart: block.startByte,
-      sourceEnd: block.endByte,
-      ...filePath !== void 0 ? { filePath } : {},
-      ...block.name !== void 0 ? { name: block.name } : {}
-    });
-    return;
-  }
-  const innerInRange = collectContainedInnerBlocks(innerBlocks, block);
-  if (!innerInRange.length) {
-    splitLargeBlockSimple(block, source, tokenizer, maxTokens, out, languageId, filePath);
-    return;
-  }
-  splitLargeBlockUsingInnerBlocks(block, innerInRange, source, tokenizer, maxTokens, out, languageId, newlineOffsets, filePath);
-}
-function collectContainedInnerBlocks(sortedInnerBlocks, block) {
-  let low = 0;
-  let high = sortedInnerBlocks.length;
-  while (low < high) {
-    const mid = low + high >> 1;
-    if (sortedInnerBlocks[mid].startByte <= block.startByte)
-      low = mid + 1;
-    else
-      high = mid;
-  }
-  const innerInRange = [];
-  for (let index = low; index < sortedInnerBlocks.length; index++) {
-    const innerBlock = sortedInnerBlocks[index];
-    if (innerBlock.startByte >= block.endByte)
-      break;
-    if (innerBlock.endByte < block.endByte)
-      innerInRange.push(innerBlock);
-  }
-  return innerInRange;
-}
-function selectMainBlocks(mainBlocks) {
-  const nodes = buildBlockTree(mainBlocks);
-  const selected = [];
-  const visit = (node) => {
-    selected.push(node.block);
-    for (const child of node.children) {
-      visit(child);
-    }
-  };
-  for (const node of nodes) {
-    visit(node);
-  }
-  return selected;
-}
-function buildBlockTree(mainBlocks) {
-  const sortedBlocks = deduplicateBlocks(mainBlocks).sort((left, right) => left.startByte - right.startByte || right.endByte - left.endByte);
-  const roots = [];
-  const stack = [];
-  for (const block of sortedBlocks) {
-    while (stack.length && stack[stack.length - 1].block.endByte <= block.startByte) {
-      stack.pop();
-    }
-    const parent = stack[stack.length - 1];
-    const node = { block, children: [] };
-    if (parent && block.endByte <= parent.block.endByte) {
-      parent.children.push(node);
-      stack.push(node);
-      continue;
-    }
-    if (parent && block.startByte < parent.block.endByte) {
-      continue;
-    }
-    roots.push(node);
-    stack.push(node);
-  }
-  return roots;
-}
-function deduplicateBlocks(blocks) {
-  const byRange = /* @__PURE__ */ new Map();
-  for (const block of blocks) {
-    const key = `${block.startByte}:${block.endByte}`;
-    const existing = byRange.get(key);
-    if (!existing || !existing.name && block.name || existing.name === block.name && block.kind < existing.kind) {
-      byRange.set(key, block);
-    }
-  }
-  return [...byRange.values()];
-}
-function selectStandaloneComments(comments, selectedBlocks) {
-  const selectedComments = [];
-  for (const comment of deduplicateBlocks(comments)) {
-    if (selectedBlocks.some((block) => block.startByte <= comment.startByte && comment.endByte <= block.endByte)) {
-      continue;
-    }
-    const previous = selectedComments[selectedComments.length - 1];
-    if (previous && comment.startByte < previous.endByte)
-      continue;
-    selectedComments.push(comment);
-  }
-  return selectedComments;
-}
-function collectNewlineOffsets(source) {
-  const newlineOffsets = [];
-  for (let index = 0; index < source.length; index++) {
-    if (source[index] === "\n")
-      newlineOffsets.push(index);
-  }
-  return newlineOffsets;
-}
-
-// 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 }
-  });
-  return new Uint8Array(compressed.buffer, compressed.byteOffset, compressed.byteLength);
-}
-function normalizeQuerySearchText(input) {
-  return input.replace(/([\p{Ll}\p{Nd}])(\p{Lu})/gu, "$1 $2").replace(/(\p{Lu}+)(\p{Lu}\p{Ll})/gu, "$1 $2").toLowerCase().replace(/[^\p{L}\p{N}\p{M}_]+/gu, " ").trim();
-}
-function detectQueryIndexSurface(relativePath) {
-  const lower = relativePath.toLowerCase();
-  if (lower === "readme.md" || lower.startsWith("docs/") || lower.endsWith(".md") || lower.endsWith(".mdx") || lower.endsWith(".rst") || lower.endsWith(".adoc") || lower.endsWith(".txt")) {
-    return "docs";
-  }
-  if (lower.endsWith(".json") || lower.endsWith(".yaml") || lower.endsWith(".yml") || lower.endsWith(".toml") || lower.endsWith(".ini") || lower.endsWith(".env") || lower === "dockerfile" || lower.startsWith(".github/")) {
-    return "config";
-  }
-  return "code";
-}
-function chunkQueryText(file, text, support) {
-  const languageId = support ? CHUNK_LANGUAGE_ALIASES[support.id] ?? support.id : void 0;
-  const language = languageId ? LANG_CONFIGS[languageId] : void 0;
-  if (language) {
-    try {
-      const chunks = chunkFile({
-        language,
-        source: text,
-        filePath: file,
-        minTokens: 1,
-        maxTokens: 120
-      });
-      if (chunks.length) {
-        return chunks.map((chunk, ordinal) => ({
-          ordinal,
-          kind: chunk.type,
-          ...chunk.name ? { name: chunk.name } : {},
-          text: chunk.text,
-          normalizedText: normalizeQuerySearchText([chunk.name, chunk.text].filter(Boolean).join(" ")),
-          startLine: chunk.startLine,
-          endLine: chunk.endLine
-        }));
-      }
-    } catch {
-    }
-  }
-  return text.split(/\r?\n/).map((line, ordinal) => ({
-    ordinal,
-    kind: "line",
-    text: line,
-    normalizedText: normalizeQuerySearchText(line),
-    startLine: ordinal + 1,
-    endLine: ordinal + 1
-  }));
-}
-async function prepareQueryIndexFile(input) {
-  try {
-    const stat = await fs6.stat(input.absolutePath);
-    if (stat.size > MAX_QUERY_INDEX_TEXT_BYTES) {
-      const support2 = supportForFile(input.absolutePath);
-      return {
-        path: input.path,
-        sourceIdentity: input.sourceIdentity,
-        surface: detectQueryIndexSurface(input.path),
-        ...support2 ? { language: support2.id } : {},
-        byteLength: stat.size,
-        lineCount: 0,
-        normalizedText: compressQueryText(""),
-        chunks: [],
-        sourceRead: false
-      };
-    }
-    const text = await fs6.readFile(input.absolutePath, "utf8");
-    const support = supportForFileWithSource(input.absolutePath, text);
-    return {
-      path: input.path,
-      sourceIdentity: input.sourceIdentity,
-      surface: detectQueryIndexSurface(input.path),
-      ...support ? { language: support.id } : {},
-      byteLength: stat.size,
-      lineCount: text ? text.split(/\r?\n/).length : 0,
-      normalizedText: compressQueryText(normalizeQuerySearchText(text)),
-      chunks: chunkQueryText(input.absolutePath, text, support).map((chunk) => ({
-        ...chunk,
-        text: compressQueryText(chunk.text)
-      })),
-      sourceRead: true
-    };
-  } catch {
-    return null;
-  }
-}
-
-// dist/agent/query-index/paths.js
-import { createHash as createHash3 } from "node:crypto";
-import path6 from "node:path";
-function resolveQueryIndexSourcePath(projectRoot, relativePath) {
-  if (relativePath.includes("\0") || isAbsoluteFilePath(relativePath)) {
-    throw new Error(`Invalid query index relative path: ${relativePath}`);
-  }
-  const normalized = normalizePath(relativePath);
-  const segments = normalized.split("/");
-  if (!normalized || normalized === "." || isAbsoluteFilePath(normalized) || segments.includes("..")) {
-    throw new Error(`Invalid query index relative path: ${relativePath}`);
-  }
-  return assertFilePathWithinRoot(projectRoot, path6.resolve(projectRoot, ...segments), "Query index row");
-}
-
-// dist/agent/query-index/queryIndexWorker.js
-async function prepareQueryIndexWorkerTask(task) {
-  const absolutePath = resolveQueryIndexSourcePath(task.projectRoot, task.relativePath);
-  return await prepareQueryIndexFile({
-    absolutePath,
-    path: task.relativePath,
-    sourceIdentity: task.sourceIdentity
-  });
-}
-export {
-  prepareQueryIndexWorkerTask as default
-};