@levnikolaevich/hex-line-mcp 1.3.4 → 1.3.5

package/dist/server.mjs

@@ -1,3974 +1,4 @@
 #!/usr/bin/env node
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name2 in all)
-    __defProp(target, name2, { get: all[name2], enumerable: true });
-};
-
-// ../node_modules/web-tree-sitter/tree-sitter.js
-var tree_sitter_exports = {};
-__export(tree_sitter_exports, {
-  CaptureQuantifier: () => CaptureQuantifier,
-  LANGUAGE_VERSION: () => LANGUAGE_VERSION,
-  Language: () => Language,
-  LookaheadIterator: () => LookaheadIterator,
-  MIN_COMPATIBLE_VERSION: () => MIN_COMPATIBLE_VERSION,
-  Node: () => Node,
-  Parser: () => Parser,
-  Query: () => Query,
-  Tree: () => Tree,
-  TreeCursor: () => TreeCursor
-});
-function assertInternal(x) {
-  if (x !== INTERNAL) throw new Error("Illegal constructor");
-}
-function isPoint(point) {
-  return !!point && typeof point.row === "number" && typeof point.column === "number";
-}
-function setModule(module2) {
-  C = module2;
-}
-function getText(tree, startIndex, endIndex, startPosition) {
-  const length = endIndex - startIndex;
-  let result = tree.textCallback(startIndex, startPosition);
-  if (result) {
-    startIndex += result.length;
-    while (startIndex < endIndex) {
-      const string = tree.textCallback(startIndex, startPosition);
-      if (string && string.length > 0) {
-        startIndex += string.length;
-        result += string;
-      } else {
-        break;
-      }
-    }
-    if (startIndex > endIndex) {
-      result = result.slice(0, length);
-    }
-  }
-  return result ?? "";
-}
-function unmarshalCaptures(query, tree, address, patternIndex, result) {
-  for (let i2 = 0, n = result.length; i2 < n; i2++) {
-    const captureIndex = C.getValue(address, "i32");
-    address += SIZE_OF_INT;
-    const node = unmarshalNode(tree, address);
-    address += SIZE_OF_NODE;
-    result[i2] = { patternIndex, name: query.captureNames[captureIndex], node };
-  }
-  return address;
-}
-function marshalNode(node, index = 0) {
-  let address = TRANSFER_BUFFER + index * SIZE_OF_NODE;
-  C.setValue(address, node.id, "i32");
-  address += SIZE_OF_INT;
-  C.setValue(address, node.startIndex, "i32");
-  address += SIZE_OF_INT;
-  C.setValue(address, node.startPosition.row, "i32");
-  address += SIZE_OF_INT;
-  C.setValue(address, node.startPosition.column, "i32");
-  address += SIZE_OF_INT;
-  C.setValue(address, node[0], "i32");
-}
-function unmarshalNode(tree, address = TRANSFER_BUFFER) {
-  const id = C.getValue(address, "i32");
-  address += SIZE_OF_INT;
-  if (id === 0) return null;
-  const index = C.getValue(address, "i32");
-  address += SIZE_OF_INT;
-  const row = C.getValue(address, "i32");
-  address += SIZE_OF_INT;
-  const column = C.getValue(address, "i32");
-  address += SIZE_OF_INT;
-  const other = C.getValue(address, "i32");
-  const result = new Node(INTERNAL, {
-    id,
-    tree,
-    startIndex: index,
-    startPosition: { row, column },
-    other
-  });
-  return result;
-}
-function marshalTreeCursor(cursor, address = TRANSFER_BUFFER) {
-  C.setValue(address + 0 * SIZE_OF_INT, cursor[0], "i32");
-  C.setValue(address + 1 * SIZE_OF_INT, cursor[1], "i32");
-  C.setValue(address + 2 * SIZE_OF_INT, cursor[2], "i32");
-  C.setValue(address + 3 * SIZE_OF_INT, cursor[3], "i32");
-}
-function unmarshalTreeCursor(cursor) {
-  cursor[0] = C.getValue(TRANSFER_BUFFER + 0 * SIZE_OF_INT, "i32");
-  cursor[1] = C.getValue(TRANSFER_BUFFER + 1 * SIZE_OF_INT, "i32");
-  cursor[2] = C.getValue(TRANSFER_BUFFER + 2 * SIZE_OF_INT, "i32");
-  cursor[3] = C.getValue(TRANSFER_BUFFER + 3 * SIZE_OF_INT, "i32");
-}
-function marshalPoint(address, point) {
-  C.setValue(address, point.row, "i32");
-  C.setValue(address + SIZE_OF_INT, point.column, "i32");
-}
-function unmarshalPoint(address) {
-  const result = {
-    row: C.getValue(address, "i32") >>> 0,
-    column: C.getValue(address + SIZE_OF_INT, "i32") >>> 0
-  };
-  return result;
-}
-function marshalRange(address, range) {
-  marshalPoint(address, range.startPosition);
-  address += SIZE_OF_POINT;
-  marshalPoint(address, range.endPosition);
-  address += SIZE_OF_POINT;
-  C.setValue(address, range.startIndex, "i32");
-  address += SIZE_OF_INT;
-  C.setValue(address, range.endIndex, "i32");
-  address += SIZE_OF_INT;
-}
-function unmarshalRange(address) {
-  const result = {};
-  result.startPosition = unmarshalPoint(address);
-  address += SIZE_OF_POINT;
-  result.endPosition = unmarshalPoint(address);
-  address += SIZE_OF_POINT;
-  result.startIndex = C.getValue(address, "i32") >>> 0;
-  address += SIZE_OF_INT;
-  result.endIndex = C.getValue(address, "i32") >>> 0;
-  return result;
-}
-function marshalEdit(edit, address = TRANSFER_BUFFER) {
-  marshalPoint(address, edit.startPosition);
-  address += SIZE_OF_POINT;
-  marshalPoint(address, edit.oldEndPosition);
-  address += SIZE_OF_POINT;
-  marshalPoint(address, edit.newEndPosition);
-  address += SIZE_OF_POINT;
-  C.setValue(address, edit.startIndex, "i32");
-  address += SIZE_OF_INT;
-  C.setValue(address, edit.oldEndIndex, "i32");
-  address += SIZE_OF_INT;
-  C.setValue(address, edit.newEndIndex, "i32");
-  address += SIZE_OF_INT;
-}
-function unmarshalLanguageMetadata(address) {
-  const major_version = C.getValue(address, "i32");
-  const minor_version = C.getValue(address += SIZE_OF_INT, "i32");
-  const patch_version = C.getValue(address += SIZE_OF_INT, "i32");
-  return { major_version, minor_version, patch_version };
-}
-function parseAnyPredicate(steps, index, operator, textPredicates) {
-  if (steps.length !== 3) {
-    throw new Error(
-      `Wrong number of arguments to \`#${operator}\` predicate. Expected 2, got ${steps.length - 1}`
-    );
-  }
-  if (!isCaptureStep(steps[1])) {
-    throw new Error(
-      `First argument of \`#${operator}\` predicate must be a capture. Got "${steps[1].value}"`
-    );
-  }
-  const isPositive = operator === "eq?" || operator === "any-eq?";
-  const matchAll = !operator.startsWith("any-");
-  if (isCaptureStep(steps[2])) {
-    const captureName1 = steps[1].name;
-    const captureName2 = steps[2].name;
-    textPredicates[index].push((captures) => {
-      const nodes1 = [];
-      const nodes2 = [];
-      for (const c of captures) {
-        if (c.name === captureName1) nodes1.push(c.node);
-        if (c.name === captureName2) nodes2.push(c.node);
-      }
-      const compare = /* @__PURE__ */ __name((n1, n2, positive) => {
-        return positive ? n1.text === n2.text : n1.text !== n2.text;
-      }, "compare");
-      return matchAll ? nodes1.every((n1) => nodes2.some((n2) => compare(n1, n2, isPositive))) : nodes1.some((n1) => nodes2.some((n2) => compare(n1, n2, isPositive)));
-    });
-  } else {
-    const captureName = steps[1].name;
-    const stringValue = steps[2].value;
-    const matches = /* @__PURE__ */ __name((n) => n.text === stringValue, "matches");
-    const doesNotMatch = /* @__PURE__ */ __name((n) => n.text !== stringValue, "doesNotMatch");
-    textPredicates[index].push((captures) => {
-      const nodes = [];
-      for (const c of captures) {
-        if (c.name === captureName) nodes.push(c.node);
-      }
-      const test = isPositive ? matches : doesNotMatch;
-      return matchAll ? nodes.every(test) : nodes.some(test);
-    });
-  }
-}
-function parseMatchPredicate(steps, index, operator, textPredicates) {
-  if (steps.length !== 3) {
-    throw new Error(
-      `Wrong number of arguments to \`#${operator}\` predicate. Expected 2, got ${steps.length - 1}.`
-    );
-  }
-  if (steps[1].type !== "capture") {
-    throw new Error(
-      `First argument of \`#${operator}\` predicate must be a capture. Got "${steps[1].value}".`
-    );
-  }
-  if (steps[2].type !== "string") {
-    throw new Error(
-      `Second argument of \`#${operator}\` predicate must be a string. Got @${steps[2].name}.`
-    );
-  }
-  const isPositive = operator === "match?" || operator === "any-match?";
-  const matchAll = !operator.startsWith("any-");
-  const captureName = steps[1].name;
-  const regex = new RegExp(steps[2].value);
-  textPredicates[index].push((captures) => {
-    const nodes = [];
-    for (const c of captures) {
-      if (c.name === captureName) nodes.push(c.node.text);
-    }
-    const test = /* @__PURE__ */ __name((text, positive) => {
-      return positive ? regex.test(text) : !regex.test(text);
-    }, "test");
-    if (nodes.length === 0) return !isPositive;
-    return matchAll ? nodes.every((text) => test(text, isPositive)) : nodes.some((text) => test(text, isPositive));
-  });
-}
-function parseAnyOfPredicate(steps, index, operator, textPredicates) {
-  if (steps.length < 2) {
-    throw new Error(
-      `Wrong number of arguments to \`#${operator}\` predicate. Expected at least 1. Got ${steps.length - 1}.`
-    );
-  }
-  if (steps[1].type !== "capture") {
-    throw new Error(
-      `First argument of \`#${operator}\` predicate must be a capture. Got "${steps[1].value}".`
-    );
-  }
-  const isPositive = operator === "any-of?";
-  const captureName = steps[1].name;
-  const stringSteps = steps.slice(2);
-  if (!stringSteps.every(isStringStep)) {
-    throw new Error(
-      `Arguments to \`#${operator}\` predicate must be strings.".`
-    );
-  }
-  const values = stringSteps.map((s) => s.value);
-  textPredicates[index].push((captures) => {
-    const nodes = [];
-    for (const c of captures) {
-      if (c.name === captureName) nodes.push(c.node.text);
-    }
-    if (nodes.length === 0) return !isPositive;
-    return nodes.every((text) => values.includes(text)) === isPositive;
-  });
-}
-function parseIsPredicate(steps, index, operator, assertedProperties, refutedProperties) {
-  if (steps.length < 2 || steps.length > 3) {
-    throw new Error(
-      `Wrong number of arguments to \`#${operator}\` predicate. Expected 1 or 2. Got ${steps.length - 1}.`
-    );
-  }
-  if (!steps.every(isStringStep)) {
-    throw new Error(
-      `Arguments to \`#${operator}\` predicate must be strings.".`
-    );
-  }
-  const properties = operator === "is?" ? assertedProperties : refutedProperties;
-  if (!properties[index]) properties[index] = {};
-  properties[index][steps[1].value] = steps[2]?.value ?? null;
-}
-function parseSetDirective(steps, index, setProperties) {
-  if (steps.length < 2 || steps.length > 3) {
-    throw new Error(`Wrong number of arguments to \`#set!\` predicate. Expected 1 or 2. Got ${steps.length - 1}.`);
-  }
-  if (!steps.every(isStringStep)) {
-    throw new Error(`Arguments to \`#set!\` predicate must be strings.".`);
-  }
-  if (!setProperties[index]) setProperties[index] = {};
-  setProperties[index][steps[1].value] = steps[2]?.value ?? null;
-}
-function parsePattern(index, stepType, stepValueId, captureNames, stringValues, steps, textPredicates, predicates, setProperties, assertedProperties, refutedProperties) {
-  if (stepType === PREDICATE_STEP_TYPE_CAPTURE) {
-    const name2 = captureNames[stepValueId];
-    steps.push({ type: "capture", name: name2 });
-  } else if (stepType === PREDICATE_STEP_TYPE_STRING) {
-    steps.push({ type: "string", value: stringValues[stepValueId] });
-  } else if (steps.length > 0) {
-    if (steps[0].type !== "string") {
-      throw new Error("Predicates must begin with a literal value");
-    }
-    const operator = steps[0].value;
-    switch (operator) {
-      case "any-not-eq?":
-      case "not-eq?":
-      case "any-eq?":
-      case "eq?":
-        parseAnyPredicate(steps, index, operator, textPredicates);
-        break;
-      case "any-not-match?":
-      case "not-match?":
-      case "any-match?":
-      case "match?":
-        parseMatchPredicate(steps, index, operator, textPredicates);
-        break;
-      case "not-any-of?":
-      case "any-of?":
-        parseAnyOfPredicate(steps, index, operator, textPredicates);
-        break;
-      case "is?":
-      case "is-not?":
-        parseIsPredicate(steps, index, operator, assertedProperties, refutedProperties);
-        break;
-      case "set!":
-        parseSetDirective(steps, index, setProperties);
-        break;
-      default:
-        predicates[index].push({ operator, operands: steps.slice(1) });
-    }
-    steps.length = 0;
-  }
-}
-async function initializeBinding(moduleOptions) {
-  if (!Module3) {
-    Module3 = await tree_sitter_default(moduleOptions);
-  }
-  return Module3;
-}
-function checkModule() {
-  return !!Module3;
-}
-var __defProp2, __name, SIZE_OF_SHORT, SIZE_OF_INT, SIZE_OF_CURSOR, SIZE_OF_NODE, SIZE_OF_POINT, SIZE_OF_RANGE, ZERO_POINT, INTERNAL, C, LookaheadIterator, Tree, TreeCursor, Node, PREDICATE_STEP_TYPE_CAPTURE, PREDICATE_STEP_TYPE_STRING, QUERY_WORD_REGEX, CaptureQuantifier, isCaptureStep, isStringStep, QueryErrorKind, QueryError, Query, LANGUAGE_FUNCTION_REGEX, Language, Module2, tree_sitter_default, Module3, TRANSFER_BUFFER, LANGUAGE_VERSION, MIN_COMPATIBLE_VERSION, Parser;
-var init_tree_sitter = __esm({
-  "../node_modules/web-tree-sitter/tree-sitter.js"() {
-    __defProp2 = Object.defineProperty;
-    __name = (target, value) => __defProp2(target, "name", { value, configurable: true });
-    SIZE_OF_SHORT = 2;
-    SIZE_OF_INT = 4;
-    SIZE_OF_CURSOR = 4 * SIZE_OF_INT;
-    SIZE_OF_NODE = 5 * SIZE_OF_INT;
-    SIZE_OF_POINT = 2 * SIZE_OF_INT;
-    SIZE_OF_RANGE = 2 * SIZE_OF_INT + 2 * SIZE_OF_POINT;
-    ZERO_POINT = { row: 0, column: 0 };
-    INTERNAL = /* @__PURE__ */ Symbol("INTERNAL");
-    __name(assertInternal, "assertInternal");
-    __name(isPoint, "isPoint");
-    __name(setModule, "setModule");
-    LookaheadIterator = class {
-      static {
-        __name(this, "LookaheadIterator");
-      }
-      /** @internal */
-      [0] = 0;
-      // Internal handle for WASM
-      /** @internal */
-      language;
-      /** @internal */
-      constructor(internal, address, language) {
-        assertInternal(internal);
-        this[0] = address;
-        this.language = language;
-      }
-      /** Get the current symbol of the lookahead iterator. */
-      get currentTypeId() {
-        return C._ts_lookahead_iterator_current_symbol(this[0]);
-      }
-      /** Get the current symbol name of the lookahead iterator. */
-      get currentType() {
-        return this.language.types[this.currentTypeId] || "ERROR";
-      }
-      /** Delete the lookahead iterator, freeing its resources. */
-      delete() {
-        C._ts_lookahead_iterator_delete(this[0]);
-        this[0] = 0;
-      }
-      /**
-       * Reset the lookahead iterator.
-       *
-       * This returns `true` if the language was set successfully and `false`
-       * otherwise.
-       */
-      reset(language, stateId) {
-        if (C._ts_lookahead_iterator_reset(this[0], language[0], stateId)) {
-          this.language = language;
-          return true;
-        }
-        return false;
-      }
-      /**
-       * Reset the lookahead iterator to another state.
-       *
-       * This returns `true` if the iterator was reset to the given state and
-       * `false` otherwise.
-       */
-      resetState(stateId) {
-        return Boolean(C._ts_lookahead_iterator_reset_state(this[0], stateId));
-      }
-      /**
-       * Returns an iterator that iterates over the symbols of the lookahead iterator.
-       *
-       * The iterator will yield the current symbol name as a string for each step
-       * until there are no more symbols to iterate over.
-       */
-      [Symbol.iterator]() {
-        return {
-          next: /* @__PURE__ */ __name(() => {
-            if (C._ts_lookahead_iterator_next(this[0])) {
-              return { done: false, value: this.currentType };
-            }
-            return { done: true, value: "" };
-          }, "next")
-        };
-      }
-    };
-    __name(getText, "getText");
-    Tree = class _Tree {
-      static {
-        __name(this, "Tree");
-      }
-      /** @internal */
-      [0] = 0;
-      // Internal handle for WASM
-      /** @internal */
-      textCallback;
-      /** The language that was used to parse the syntax tree. */
-      language;
-      /** @internal */
-      constructor(internal, address, language, textCallback) {
-        assertInternal(internal);
-        this[0] = address;
-        this.language = language;
-        this.textCallback = textCallback;
-      }
-      /** Create a shallow copy of the syntax tree. This is very fast. */
-      copy() {
-        const address = C._ts_tree_copy(this[0]);
-        return new _Tree(INTERNAL, address, this.language, this.textCallback);
-      }
-      /** Delete the syntax tree, freeing its resources. */
-      delete() {
-        C._ts_tree_delete(this[0]);
-        this[0] = 0;
-      }
-      /** Get the root node of the syntax tree. */
-      get rootNode() {
-        C._ts_tree_root_node_wasm(this[0]);
-        return unmarshalNode(this);
-      }
-      /**
-       * Get the root node of the syntax tree, but with its position shifted
-       * forward by the given offset.
-       */
-      rootNodeWithOffset(offsetBytes, offsetExtent) {
-        const address = TRANSFER_BUFFER + SIZE_OF_NODE;
-        C.setValue(address, offsetBytes, "i32");
-        marshalPoint(address + SIZE_OF_INT, offsetExtent);
-        C._ts_tree_root_node_with_offset_wasm(this[0]);
-        return unmarshalNode(this);
-      }
-      /**
-       * Edit the syntax tree to keep it in sync with source code that has been
-       * edited.
-       *
-       * You must describe the edit both in terms of byte offsets and in terms of
-       * row/column coordinates.
-       */
-      edit(edit) {
-        marshalEdit(edit);
-        C._ts_tree_edit_wasm(this[0]);
-      }
-      /** Create a new {@link TreeCursor} starting from the root of the tree. */
-      walk() {
-        return this.rootNode.walk();
-      }
-      /**
-       * Compare this old edited syntax tree to a new syntax tree representing
-       * the same document, returning a sequence of ranges whose syntactic
-       * structure has changed.
-       *
-       * For this to work correctly, this syntax tree must have been edited such
-       * that its ranges match up to the new tree. Generally, you'll want to
-       * call this method right after calling one of the [`Parser::parse`]
-       * functions. Call it on the old tree that was passed to parse, and
-       * pass the new tree that was returned from `parse`.
-       */
-      getChangedRanges(other) {
-        if (!(other instanceof _Tree)) {
-          throw new TypeError("Argument must be a Tree");
-        }
-        C._ts_tree_get_changed_ranges_wasm(this[0], other[0]);
-        const count = C.getValue(TRANSFER_BUFFER, "i32");
-        const buffer = C.getValue(TRANSFER_BUFFER + SIZE_OF_INT, "i32");
-        const result = new Array(count);
-        if (count > 0) {
-          let address = buffer;
-          for (let i2 = 0; i2 < count; i2++) {
-            result[i2] = unmarshalRange(address);
-            address += SIZE_OF_RANGE;
-          }
-          C._free(buffer);
-        }
-        return result;
-      }
-      /** Get the included ranges that were used to parse the syntax tree. */
-      getIncludedRanges() {
-        C._ts_tree_included_ranges_wasm(this[0]);
-        const count = C.getValue(TRANSFER_BUFFER, "i32");
-        const buffer = C.getValue(TRANSFER_BUFFER + SIZE_OF_INT, "i32");
-        const result = new Array(count);
-        if (count > 0) {
-          let address = buffer;
-          for (let i2 = 0; i2 < count; i2++) {
-            result[i2] = unmarshalRange(address);
-            address += SIZE_OF_RANGE;
-          }
-          C._free(buffer);
-        }
-        return result;
-      }
-    };
-    TreeCursor = class _TreeCursor {
-      static {
-        __name(this, "TreeCursor");
-      }
-      /** @internal */
-      // @ts-expect-error: never read
-      [0] = 0;
-      // Internal handle for Wasm
-      /** @internal */
-      // @ts-expect-error: never read
-      [1] = 0;
-      // Internal handle for Wasm
-      /** @internal */
-      // @ts-expect-error: never read
-      [2] = 0;
-      // Internal handle for Wasm
-      /** @internal */
-      // @ts-expect-error: never read
-      [3] = 0;
-      // Internal handle for Wasm
-      /** @internal */
-      tree;
-      /** @internal */
-      constructor(internal, tree) {
-        assertInternal(internal);
-        this.tree = tree;
-        unmarshalTreeCursor(this);
-      }
-      /** Creates a deep copy of the tree cursor. This allocates new memory. */
-      copy() {
-        const copy = new _TreeCursor(INTERNAL, this.tree);
-        C._ts_tree_cursor_copy_wasm(this.tree[0]);
-        unmarshalTreeCursor(copy);
-        return copy;
-      }
-      /** Delete the tree cursor, freeing its resources. */
-      delete() {
-        marshalTreeCursor(this);
-        C._ts_tree_cursor_delete_wasm(this.tree[0]);
-        this[0] = this[1] = this[2] = 0;
-      }
-      /** Get the tree cursor's current {@link Node}. */
-      get currentNode() {
-        marshalTreeCursor(this);
-        C._ts_tree_cursor_current_node_wasm(this.tree[0]);
-        return unmarshalNode(this.tree);
-      }
-      /**
-       * Get the numerical field id of this tree cursor's current node.
-       *
-       * See also {@link TreeCursor#currentFieldName}.
-       */
-      get currentFieldId() {
-        marshalTreeCursor(this);
-        return C._ts_tree_cursor_current_field_id_wasm(this.tree[0]);
-      }
-      /** Get the field name of this tree cursor's current node. */
-      get currentFieldName() {
-        return this.tree.language.fields[this.currentFieldId];
-      }
-      /**
-       * Get the depth of the cursor's current node relative to the original
-       * node that the cursor was constructed with.
-       */
-      get currentDepth() {
-        marshalTreeCursor(this);
-        return C._ts_tree_cursor_current_depth_wasm(this.tree[0]);
-      }
-      /**
-       * Get the index of the cursor's current node out of all of the
-       * descendants of the original node that the cursor was constructed with.
-       */
-      get currentDescendantIndex() {
-        marshalTreeCursor(this);
-        return C._ts_tree_cursor_current_descendant_index_wasm(this.tree[0]);
-      }
-      /** Get the type of the cursor's current node. */
-      get nodeType() {
-        return this.tree.language.types[this.nodeTypeId] || "ERROR";
-      }
-      /** Get the type id of the cursor's current node. */
-      get nodeTypeId() {
-        marshalTreeCursor(this);
-        return C._ts_tree_cursor_current_node_type_id_wasm(this.tree[0]);
-      }
-      /** Get the state id of the cursor's current node. */
-      get nodeStateId() {
-        marshalTreeCursor(this);
-        return C._ts_tree_cursor_current_node_state_id_wasm(this.tree[0]);
-      }
-      /** Get the id of the cursor's current node. */
-      get nodeId() {
-        marshalTreeCursor(this);
-        return C._ts_tree_cursor_current_node_id_wasm(this.tree[0]);
-      }
-      /**
-       * Check if the cursor's current node is *named*.
-       *
-       * Named nodes correspond to named rules in the grammar, whereas
-       * *anonymous* nodes correspond to string literals in the grammar.
-       */
-      get nodeIsNamed() {
-        marshalTreeCursor(this);
-        return C._ts_tree_cursor_current_node_is_named_wasm(this.tree[0]) === 1;
-      }
-      /**
-       * Check if the cursor's current node is *missing*.
-       *
-       * Missing nodes are inserted by the parser in order to recover from
-       * certain kinds of syntax errors.
-       */
-      get nodeIsMissing() {
-        marshalTreeCursor(this);
-        return C._ts_tree_cursor_current_node_is_missing_wasm(this.tree[0]) === 1;
-      }
-      /** Get the string content of the cursor's current node. */
-      get nodeText() {
-        marshalTreeCursor(this);
-        const startIndex = C._ts_tree_cursor_start_index_wasm(this.tree[0]);
-        const endIndex = C._ts_tree_cursor_end_index_wasm(this.tree[0]);
-        C._ts_tree_cursor_start_position_wasm(this.tree[0]);
-        const startPosition = unmarshalPoint(TRANSFER_BUFFER);
-        return getText(this.tree, startIndex, endIndex, startPosition);
-      }
-      /** Get the start position of the cursor's current node. */
-      get startPosition() {
-        marshalTreeCursor(this);
-        C._ts_tree_cursor_start_position_wasm(this.tree[0]);
-        return unmarshalPoint(TRANSFER_BUFFER);
-      }
-      /** Get the end position of the cursor's current node. */
-      get endPosition() {
-        marshalTreeCursor(this);
-        C._ts_tree_cursor_end_position_wasm(this.tree[0]);
-        return unmarshalPoint(TRANSFER_BUFFER);
-      }
-      /** Get the start index of the cursor's current node. */
-      get startIndex() {
-        marshalTreeCursor(this);
-        return C._ts_tree_cursor_start_index_wasm(this.tree[0]);
-      }
-      /** Get the end index of the cursor's current node. */
-      get endIndex() {
-        marshalTreeCursor(this);
-        return C._ts_tree_cursor_end_index_wasm(this.tree[0]);
-      }
-      /**
-       * Move this cursor to the first child of its current node.
-       *
-       * This returns `true` if the cursor successfully moved, and returns
-       * `false` if there were no children.
-       */
-      gotoFirstChild() {
-        marshalTreeCursor(this);
-        const result = C._ts_tree_cursor_goto_first_child_wasm(this.tree[0]);
-        unmarshalTreeCursor(this);
-        return result === 1;
-      }
-      /**
-       * Move this cursor to the last child of its current node.
-       *
-       * This returns `true` if the cursor successfully moved, and returns
-       * `false` if there were no children.
-       *
-       * Note that this function may be slower than
-       * {@link TreeCursor#gotoFirstChild} because it needs to
-       * iterate through all the children to compute the child's position.
-       */
-      gotoLastChild() {
-        marshalTreeCursor(this);
-        const result = C._ts_tree_cursor_goto_last_child_wasm(this.tree[0]);
-        unmarshalTreeCursor(this);
-        return result === 1;
-      }
-      /**
-       * Move this cursor to the parent of its current node.
-       *
-       * This returns `true` if the cursor successfully moved, and returns
-       * `false` if there was no parent node (the cursor was already on the
-       * root node).
-       *
-       * Note that the node the cursor was constructed with is considered the root
-       * of the cursor, and the cursor cannot walk outside this node.
-       */
-      gotoParent() {
-        marshalTreeCursor(this);
-        const result = C._ts_tree_cursor_goto_parent_wasm(this.tree[0]);
-        unmarshalTreeCursor(this);
-        return result === 1;
-      }
-      /**
-       * Move this cursor to the next sibling of its current node.
-       *
-       * This returns `true` if the cursor successfully moved, and returns
-       * `false` if there was no next sibling node.
-       *
-       * Note that the node the cursor was constructed with is considered the root
-       * of the cursor, and the cursor cannot walk outside this node.
-       */
-      gotoNextSibling() {
-        marshalTreeCursor(this);
-        const result = C._ts_tree_cursor_goto_next_sibling_wasm(this.tree[0]);
-        unmarshalTreeCursor(this);
-        return result === 1;
-      }
-      /**
-       * Move this cursor to the previous sibling of its current node.
-       *
-       * This returns `true` if the cursor successfully moved, and returns
-       * `false` if there was no previous sibling node.
-       *
-       * Note that this function may be slower than
-       * {@link TreeCursor#gotoNextSibling} due to how node
-       * positions are stored. In the worst case, this will need to iterate
-       * through all the children up to the previous sibling node to recalculate
-       * its position. Also note that the node the cursor was constructed with is
-       * considered the root of the cursor, and the cursor cannot walk outside this node.
-       */
-      gotoPreviousSibling() {
-        marshalTreeCursor(this);
-        const result = C._ts_tree_cursor_goto_previous_sibling_wasm(this.tree[0]);
-        unmarshalTreeCursor(this);
-        return result === 1;
-      }
-      /**
-       * Move the cursor to the node that is the nth descendant of
-       * the original node that the cursor was constructed with, where
-       * zero represents the original node itself.
-       */
-      gotoDescendant(goalDescendantIndex) {
-        marshalTreeCursor(this);
-        C._ts_tree_cursor_goto_descendant_wasm(this.tree[0], goalDescendantIndex);
-        unmarshalTreeCursor(this);
-      }
-      /**
-       * Move this cursor to the first child of its current node that contains or
-       * starts after the given byte offset.
-       *
-       * This returns `true` if the cursor successfully moved to a child node, and returns
-       * `false` if no such child was found.
-       */
-      gotoFirstChildForIndex(goalIndex) {
-        marshalTreeCursor(this);
-        C.setValue(TRANSFER_BUFFER + SIZE_OF_CURSOR, goalIndex, "i32");
-        const result = C._ts_tree_cursor_goto_first_child_for_index_wasm(this.tree[0]);
-        unmarshalTreeCursor(this);
-        return result === 1;
-      }
-      /**
-       * Move this cursor to the first child of its current node that contains or
-       * starts after the given byte offset.
-       *
-       * This returns the index of the child node if one was found, and returns
-       * `null` if no such child was found.
-       */
-      gotoFirstChildForPosition(goalPosition) {
-        marshalTreeCursor(this);
-        marshalPoint(TRANSFER_BUFFER + SIZE_OF_CURSOR, goalPosition);
-        const result = C._ts_tree_cursor_goto_first_child_for_position_wasm(this.tree[0]);
-        unmarshalTreeCursor(this);
-        return result === 1;
-      }
-      /**
-       * Re-initialize this tree cursor to start at the original node that the
-       * cursor was constructed with.
-       */
-      reset(node) {
-        marshalNode(node);
-        marshalTreeCursor(this, TRANSFER_BUFFER + SIZE_OF_NODE);
-        C._ts_tree_cursor_reset_wasm(this.tree[0]);
-        unmarshalTreeCursor(this);
-      }
-      /**
-       * Re-initialize a tree cursor to the same position as another cursor.
-       *
-       * Unlike {@link TreeCursor#reset}, this will not lose parent
-       * information and allows reusing already created cursors.
-       */
-      resetTo(cursor) {
-        marshalTreeCursor(this, TRANSFER_BUFFER);
-        marshalTreeCursor(cursor, TRANSFER_BUFFER + SIZE_OF_CURSOR);
-        C._ts_tree_cursor_reset_to_wasm(this.tree[0], cursor.tree[0]);
-        unmarshalTreeCursor(this);
-      }
-    };
-    Node = class {
-      static {
-        __name(this, "Node");
-      }
-      /** @internal */
-      // @ts-expect-error: never read
-      [0] = 0;
-      // Internal handle for Wasm
-      /** @internal */
-      _children;
-      /** @internal */
-      _namedChildren;
-      /** @internal */
-      constructor(internal, {
-        id,
-        tree,
-        startIndex,
-        startPosition,
-        other
-      }) {
-        assertInternal(internal);
-        this[0] = other;
-        this.id = id;
-        this.tree = tree;
-        this.startIndex = startIndex;
-        this.startPosition = startPosition;
-      }
-      /**
-       * The numeric id for this node that is unique.
-       *
-       * Within a given syntax tree, no two nodes have the same id. However:
-       *
-       * * If a new tree is created based on an older tree, and a node from the old tree is reused in
-       *   the process, then that node will have the same id in both trees.
-       *
-       * * A node not marked as having changes does not guarantee it was reused.
-       *
-       * * If a node is marked as having changed in the old tree, it will not be reused.
-       */
-      id;
-      /** The byte index where this node starts. */
-      startIndex;
-      /** The position where this node starts. */
-      startPosition;
-      /** The tree that this node belongs to. */
-      tree;
-      /** Get this node's type as a numerical id. */
-      get typeId() {
-        marshalNode(this);
-        return C._ts_node_symbol_wasm(this.tree[0]);
-      }
-      /**
-       * Get the node's type as a numerical id as it appears in the grammar,
-       * ignoring aliases.
-       */
-      get grammarId() {
-        marshalNode(this);
-        return C._ts_node_grammar_symbol_wasm(this.tree[0]);
-      }
-      /** Get this node's type as a string. */
-      get type() {
-        return this.tree.language.types[this.typeId] || "ERROR";
-      }
-      /**
-       * Get this node's symbol name as it appears in the grammar, ignoring
-       * aliases as a string.
-       */
-      get grammarType() {
-        return this.tree.language.types[this.grammarId] || "ERROR";
-      }
-      /**
-       * Check if this node is *named*.
-       *
-       * Named nodes correspond to named rules in the grammar, whereas
-       * *anonymous* nodes correspond to string literals in the grammar.
-       */
-      get isNamed() {
-        marshalNode(this);
-        return C._ts_node_is_named_wasm(this.tree[0]) === 1;
-      }
-      /**
-       * Check if this node is *extra*.
-       *
-       * Extra nodes represent things like comments, which are not required
-       * by the grammar, but can appear anywhere.
-       */
-      get isExtra() {
-        marshalNode(this);
-        return C._ts_node_is_extra_wasm(this.tree[0]) === 1;
-      }
-      /**
-       * Check if this node represents a syntax error.
-       *
-       * Syntax errors represent parts of the code that could not be incorporated
-       * into a valid syntax tree.
-       */
-      get isError() {
-        marshalNode(this);
-        return C._ts_node_is_error_wasm(this.tree[0]) === 1;
-      }
-      /**
-       * Check if this node is *missing*.
-       *
-       * Missing nodes are inserted by the parser in order to recover from
-       * certain kinds of syntax errors.
-       */
-      get isMissing() {
-        marshalNode(this);
-        return C._ts_node_is_missing_wasm(this.tree[0]) === 1;
-      }
-      /** Check if this node has been edited. */
-      get hasChanges() {
-        marshalNode(this);
-        return C._ts_node_has_changes_wasm(this.tree[0]) === 1;
-      }
-      /**
-       * Check if this node represents a syntax error or contains any syntax
-       * errors anywhere within it.
-       */
-      get hasError() {
-        marshalNode(this);
-        return C._ts_node_has_error_wasm(this.tree[0]) === 1;
-      }
-      /** Get the byte index where this node ends. */
-      get endIndex() {
-        marshalNode(this);
-        return C._ts_node_end_index_wasm(this.tree[0]);
-      }
-      /** Get the position where this node ends. */
-      get endPosition() {
-        marshalNode(this);
-        C._ts_node_end_point_wasm(this.tree[0]);
-        return unmarshalPoint(TRANSFER_BUFFER);
-      }
-      /** Get the string content of this node. */
-      get text() {
-        return getText(this.tree, this.startIndex, this.endIndex, this.startPosition);
-      }
-      /** Get this node's parse state. */
-      get parseState() {
-        marshalNode(this);
-        return C._ts_node_parse_state_wasm(this.tree[0]);
-      }
-      /** Get the parse state after this node. */
-      get nextParseState() {
-        marshalNode(this);
-        return C._ts_node_next_parse_state_wasm(this.tree[0]);
-      }
-      /** Check if this node is equal to another node. */
-      equals(other) {
-        return this.tree === other.tree && this.id === other.id;
-      }
-      /**
-       * Get the node's child at the given index, where zero represents the first child.
-       *
-       * This method is fairly fast, but its cost is technically log(n), so if
-       * you might be iterating over a long list of children, you should use
-       * {@link Node#children} instead.
-       */
-      child(index) {
-        marshalNode(this);
-        C._ts_node_child_wasm(this.tree[0], index);
-        return unmarshalNode(this.tree);
-      }
-      /**
-       * Get this node's *named* child at the given index.
-       *
-       * See also {@link Node#isNamed}.
-       * This method is fairly fast, but its cost is technically log(n), so if
-       * you might be iterating over a long list of children, you should use
-       * {@link Node#namedChildren} instead.
-       */
-      namedChild(index) {
-        marshalNode(this);
-        C._ts_node_named_child_wasm(this.tree[0], index);
-        return unmarshalNode(this.tree);
-      }
-      /**
-       * Get this node's child with the given numerical field id.
-       *
-       * See also {@link Node#childForFieldName}. You can
-       * convert a field name to an id using {@link Language#fieldIdForName}.
-       */
-      childForFieldId(fieldId) {
-        marshalNode(this);
-        C._ts_node_child_by_field_id_wasm(this.tree[0], fieldId);
-        return unmarshalNode(this.tree);
-      }
-      /**
-       * Get the first child with the given field name.
-       *
-       * If multiple children may have the same field name, access them using
-       * {@link Node#childrenForFieldName}.
-       */
-      childForFieldName(fieldName) {
-        const fieldId = this.tree.language.fields.indexOf(fieldName);
-        if (fieldId !== -1) return this.childForFieldId(fieldId);
-        return null;
-      }
-      /** Get the field name of this node's child at the given index. */
-      fieldNameForChild(index) {
-        marshalNode(this);
-        const address = C._ts_node_field_name_for_child_wasm(this.tree[0], index);
-        if (!address) return null;
-        return C.AsciiToString(address);
-      }
-      /** Get the field name of this node's named child at the given index. */
-      fieldNameForNamedChild(index) {
-        marshalNode(this);
-        const address = C._ts_node_field_name_for_named_child_wasm(this.tree[0], index);
-        if (!address) return null;
-        return C.AsciiToString(address);
-      }
-      /**
-       * Get an array of this node's children with a given field name.
-       *
-       * See also {@link Node#children}.
-       */
-      childrenForFieldName(fieldName) {
-        const fieldId = this.tree.language.fields.indexOf(fieldName);
-        if (fieldId !== -1 && fieldId !== 0) return this.childrenForFieldId(fieldId);
-        return [];
-      }
-      /**
-        * Get an array of this node's children with a given field id.
-        *
-        * See also {@link Node#childrenForFieldName}.
-        */
-      childrenForFieldId(fieldId) {
-        marshalNode(this);
-        C._ts_node_children_by_field_id_wasm(this.tree[0], fieldId);
-        const count = C.getValue(TRANSFER_BUFFER, "i32");
-        const buffer = C.getValue(TRANSFER_BUFFER + SIZE_OF_INT, "i32");
-        const result = new Array(count);
-        if (count > 0) {
-          let address = buffer;
-          for (let i2 = 0; i2 < count; i2++) {
-            result[i2] = unmarshalNode(this.tree, address);
-            address += SIZE_OF_NODE;
-          }
-          C._free(buffer);
-        }
-        return result;
-      }
-      /** Get the node's first child that contains or starts after the given byte offset. */
-      firstChildForIndex(index) {
-        marshalNode(this);
-        const address = TRANSFER_BUFFER + SIZE_OF_NODE;
-        C.setValue(address, index, "i32");
-        C._ts_node_first_child_for_byte_wasm(this.tree[0]);
-        return unmarshalNode(this.tree);
-      }
-      /** Get the node's first named child that contains or starts after the given byte offset. */
-      firstNamedChildForIndex(index) {
-        marshalNode(this);
-        const address = TRANSFER_BUFFER + SIZE_OF_NODE;
-        C.setValue(address, index, "i32");
-        C._ts_node_first_named_child_for_byte_wasm(this.tree[0]);
-        return unmarshalNode(this.tree);
-      }
-      /** Get this node's number of children. */
-      get childCount() {
-        marshalNode(this);
-        return C._ts_node_child_count_wasm(this.tree[0]);
-      }
-      /**
-       * Get this node's number of *named* children.
-       *
-       * See also {@link Node#isNamed}.
-       */
-      get namedChildCount() {
-        marshalNode(this);
-        return C._ts_node_named_child_count_wasm(this.tree[0]);
-      }
-      /** Get this node's first child. */
-      get firstChild() {
-        return this.child(0);
-      }
-      /**
-       * Get this node's first named child.
-       *
-       * See also {@link Node#isNamed}.
-       */
-      get firstNamedChild() {
-        return this.namedChild(0);
-      }
-      /** Get this node's last child. */
-      get lastChild() {
-        return this.child(this.childCount - 1);
-      }
-      /**
-       * Get this node's last named child.
-       *
-       * See also {@link Node#isNamed}.
-       */
-      get lastNamedChild() {
-        return this.namedChild(this.namedChildCount - 1);
-      }
-      /**
-       * Iterate over this node's children.
-       *
-       * If you're walking the tree recursively, you may want to use the
-       * {@link TreeCursor} APIs directly instead.
-       */
-      get children() {
-        if (!this._children) {
-          marshalNode(this);
-          C._ts_node_children_wasm(this.tree[0]);
-          const count = C.getValue(TRANSFER_BUFFER, "i32");
-          const buffer = C.getValue(TRANSFER_BUFFER + SIZE_OF_INT, "i32");
-          this._children = new Array(count);
-          if (count > 0) {
-            let address = buffer;
-            for (let i2 = 0; i2 < count; i2++) {
-              this._children[i2] = unmarshalNode(this.tree, address);
-              address += SIZE_OF_NODE;
-            }
-            C._free(buffer);
-          }
-        }
-        return this._children;
-      }
-      /**
-       * Iterate over this node's named children.
-       *
-       * See also {@link Node#children}.
-       */
-      get namedChildren() {
-        if (!this._namedChildren) {
-          marshalNode(this);
-          C._ts_node_named_children_wasm(this.tree[0]);
-          const count = C.getValue(TRANSFER_BUFFER, "i32");
-          const buffer = C.getValue(TRANSFER_BUFFER + SIZE_OF_INT, "i32");
-          this._namedChildren = new Array(count);
-          if (count > 0) {
-            let address = buffer;
-            for (let i2 = 0; i2 < count; i2++) {
-              this._namedChildren[i2] = unmarshalNode(this.tree, address);
-              address += SIZE_OF_NODE;
-            }
-            C._free(buffer);
-          }
-        }
-        return this._namedChildren;
-      }
-      /**
-       * Get the descendants of this node that are the given type, or in the given types array.
-       *
-       * The types array should contain node type strings, which can be retrieved from {@link Language#types}.
-       *
-       * Additionally, a `startPosition` and `endPosition` can be passed in to restrict the search to a byte range.
-       */
-      descendantsOfType(types, startPosition = ZERO_POINT, endPosition = ZERO_POINT) {
-        if (!Array.isArray(types)) types = [types];
-        const symbols = [];
-        const typesBySymbol = this.tree.language.types;
-        for (const node_type of types) {
-          if (node_type == "ERROR") {
-            symbols.push(65535);
-          }
-        }
-        for (let i2 = 0, n = typesBySymbol.length; i2 < n; i2++) {
-          if (types.includes(typesBySymbol[i2])) {
-            symbols.push(i2);
-          }
-        }
-        const symbolsAddress = C._malloc(SIZE_OF_INT * symbols.length);
-        for (let i2 = 0, n = symbols.length; i2 < n; i2++) {
-          C.setValue(symbolsAddress + i2 * SIZE_OF_INT, symbols[i2], "i32");
-        }
-        marshalNode(this);
-        C._ts_node_descendants_of_type_wasm(
-          this.tree[0],
-          symbolsAddress,
-          symbols.length,
-          startPosition.row,
-          startPosition.column,
-          endPosition.row,
-          endPosition.column
-        );
-        const descendantCount = C.getValue(TRANSFER_BUFFER, "i32");
-        const descendantAddress = C.getValue(TRANSFER_BUFFER + SIZE_OF_INT, "i32");
-        const result = new Array(descendantCount);
-        if (descendantCount > 0) {
-          let address = descendantAddress;
-          for (let i2 = 0; i2 < descendantCount; i2++) {
-            result[i2] = unmarshalNode(this.tree, address);
-            address += SIZE_OF_NODE;
-          }
-        }
-        C._free(descendantAddress);
-        C._free(symbolsAddress);
-        return result;
-      }
-      /** Get this node's next sibling. */
-      get nextSibling() {
-        marshalNode(this);
-        C._ts_node_next_sibling_wasm(this.tree[0]);
-        return unmarshalNode(this.tree);
-      }
-      /** Get this node's previous sibling. */
-      get previousSibling() {
-        marshalNode(this);
-        C._ts_node_prev_sibling_wasm(this.tree[0]);
-        return unmarshalNode(this.tree);
-      }
-      /**
-       * Get this node's next *named* sibling.
-       *
-       * See also {@link Node#isNamed}.
-       */
-      get nextNamedSibling() {
-        marshalNode(this);
-        C._ts_node_next_named_sibling_wasm(this.tree[0]);
-        return unmarshalNode(this.tree);
-      }
-      /**
-       * Get this node's previous *named* sibling.
-       *
-       * See also {@link Node#isNamed}.
-       */
-      get previousNamedSibling() {
-        marshalNode(this);
-        C._ts_node_prev_named_sibling_wasm(this.tree[0]);
-        return unmarshalNode(this.tree);
-      }
-      /** Get the node's number of descendants, including one for the node itself. */
-      get descendantCount() {
-        marshalNode(this);
-        return C._ts_node_descendant_count_wasm(this.tree[0]);
-      }
-      /**
-       * Get this node's immediate parent.
-       * Prefer {@link Node#childWithDescendant} for iterating over this node's ancestors.
-       */
-      get parent() {
-        marshalNode(this);
-        C._ts_node_parent_wasm(this.tree[0]);
-        return unmarshalNode(this.tree);
-      }
-      /**
-       * Get the node that contains `descendant`.
-       *
-       * Note that this can return `descendant` itself.
-       */
-      childWithDescendant(descendant) {
-        marshalNode(this);
-        marshalNode(descendant, 1);
-        C._ts_node_child_with_descendant_wasm(this.tree[0]);
-        return unmarshalNode(this.tree);
-      }
-      /** Get the smallest node within this node that spans the given byte range. */
-      descendantForIndex(start2, end = start2) {
-        if (typeof start2 !== "number" || typeof end !== "number") {
-          throw new Error("Arguments must be numbers");
-        }
-        marshalNode(this);
-        const address = TRANSFER_BUFFER + SIZE_OF_NODE;
-        C.setValue(address, start2, "i32");
-        C.setValue(address + SIZE_OF_INT, end, "i32");
-        C._ts_node_descendant_for_index_wasm(this.tree[0]);
-        return unmarshalNode(this.tree);
-      }
-      /** Get the smallest named node within this node that spans the given byte range. */
-      namedDescendantForIndex(start2, end = start2) {
-        if (typeof start2 !== "number" || typeof end !== "number") {
-          throw new Error("Arguments must be numbers");
-        }
-        marshalNode(this);
-        const address = TRANSFER_BUFFER + SIZE_OF_NODE;
-        C.setValue(address, start2, "i32");
-        C.setValue(address + SIZE_OF_INT, end, "i32");
-        C._ts_node_named_descendant_for_index_wasm(this.tree[0]);
-        return unmarshalNode(this.tree);
-      }
-      /** Get the smallest node within this node that spans the given point range. */
-      descendantForPosition(start2, end = start2) {
-        if (!isPoint(start2) || !isPoint(end)) {
-          throw new Error("Arguments must be {row, column} objects");
-        }
-        marshalNode(this);
-        const address = TRANSFER_BUFFER + SIZE_OF_NODE;
-        marshalPoint(address, start2);
-        marshalPoint(address + SIZE_OF_POINT, end);
-        C._ts_node_descendant_for_position_wasm(this.tree[0]);
-        return unmarshalNode(this.tree);
-      }
-      /** Get the smallest named node within this node that spans the given point range. */
-      namedDescendantForPosition(start2, end = start2) {
-        if (!isPoint(start2) || !isPoint(end)) {
-          throw new Error("Arguments must be {row, column} objects");
-        }
-        marshalNode(this);
-        const address = TRANSFER_BUFFER + SIZE_OF_NODE;
-        marshalPoint(address, start2);
-        marshalPoint(address + SIZE_OF_POINT, end);
-        C._ts_node_named_descendant_for_position_wasm(this.tree[0]);
-        return unmarshalNode(this.tree);
-      }
-      /**
-       * Create a new {@link TreeCursor} starting from this node.
-       *
-       * Note that the given node is considered the root of the cursor,
-       * and the cursor cannot walk outside this node.
-       */
-      walk() {
-        marshalNode(this);
-        C._ts_tree_cursor_new_wasm(this.tree[0]);
-        return new TreeCursor(INTERNAL, this.tree);
-      }
-      /**
-       * Edit this node to keep it in-sync with source code that has been edited.
-       *
-       * This function is only rarely needed. When you edit a syntax tree with
-       * the {@link Tree#edit} method, all of the nodes that you retrieve from
-       * the tree afterward will already reflect the edit. You only need to
-       * use {@link Node#edit} when you have a specific {@link Node} instance that
-       * you want to keep and continue to use after an edit.
-       */
-      edit(edit) {
-        if (this.startIndex >= edit.oldEndIndex) {
-          this.startIndex = edit.newEndIndex + (this.startIndex - edit.oldEndIndex);
-          let subbedPointRow;
-          let subbedPointColumn;
-          if (this.startPosition.row > edit.oldEndPosition.row) {
-            subbedPointRow = this.startPosition.row - edit.oldEndPosition.row;
-            subbedPointColumn = this.startPosition.column;
-          } else {
-            subbedPointRow = 0;
-            subbedPointColumn = this.startPosition.column;
-            if (this.startPosition.column >= edit.oldEndPosition.column) {
-              subbedPointColumn = this.startPosition.column - edit.oldEndPosition.column;
-            }
-          }
-          if (subbedPointRow > 0) {
-            this.startPosition.row += subbedPointRow;
-            this.startPosition.column = subbedPointColumn;
-          } else {
-            this.startPosition.column += subbedPointColumn;
-          }
-        } else if (this.startIndex > edit.startIndex) {
-          this.startIndex = edit.newEndIndex;
-          this.startPosition.row = edit.newEndPosition.row;
-          this.startPosition.column = edit.newEndPosition.column;
-        }
-      }
-      /** Get the S-expression representation of this node. */
-      toString() {
-        marshalNode(this);
-        const address = C._ts_node_to_string_wasm(this.tree[0]);
-        const result = C.AsciiToString(address);
-        C._free(address);
-        return result;
-      }
-    };
-    __name(unmarshalCaptures, "unmarshalCaptures");
-    __name(marshalNode, "marshalNode");
-    __name(unmarshalNode, "unmarshalNode");
-    __name(marshalTreeCursor, "marshalTreeCursor");
-    __name(unmarshalTreeCursor, "unmarshalTreeCursor");
-    __name(marshalPoint, "marshalPoint");
-    __name(unmarshalPoint, "unmarshalPoint");
-    __name(marshalRange, "marshalRange");
-    __name(unmarshalRange, "unmarshalRange");
-    __name(marshalEdit, "marshalEdit");
-    __name(unmarshalLanguageMetadata, "unmarshalLanguageMetadata");
-    PREDICATE_STEP_TYPE_CAPTURE = 1;
-    PREDICATE_STEP_TYPE_STRING = 2;
-    QUERY_WORD_REGEX = /[\w-]+/g;
-    CaptureQuantifier = {
-      Zero: 0,
-      ZeroOrOne: 1,
-      ZeroOrMore: 2,
-      One: 3,
-      OneOrMore: 4
-    };
-    isCaptureStep = /* @__PURE__ */ __name((step) => step.type === "capture", "isCaptureStep");
-    isStringStep = /* @__PURE__ */ __name((step) => step.type === "string", "isStringStep");
-    QueryErrorKind = {
-      Syntax: 1,
-      NodeName: 2,
-      FieldName: 3,
-      CaptureName: 4,
-      PatternStructure: 5
-    };
-    QueryError = class _QueryError extends Error {
-      constructor(kind, info2, index, length) {
-        super(_QueryError.formatMessage(kind, info2));
-        this.kind = kind;
-        this.info = info2;
-        this.index = index;
-        this.length = length;
-        this.name = "QueryError";
-      }
-      static {
-        __name(this, "QueryError");
-      }
-      /** Formats an error message based on the error kind and info */
-      static formatMessage(kind, info2) {
-        switch (kind) {
-          case QueryErrorKind.NodeName:
-            return `Bad node name '${info2.word}'`;
-          case QueryErrorKind.FieldName:
-            return `Bad field name '${info2.word}'`;
-          case QueryErrorKind.CaptureName:
-            return `Bad capture name @${info2.word}`;
-          case QueryErrorKind.PatternStructure:
-            return `Bad pattern structure at offset ${info2.suffix}`;
-          case QueryErrorKind.Syntax:
-            return `Bad syntax at offset ${info2.suffix}`;
-        }
-      }
-    };
-    __name(parseAnyPredicate, "parseAnyPredicate");
-    __name(parseMatchPredicate, "parseMatchPredicate");
-    __name(parseAnyOfPredicate, "parseAnyOfPredicate");
-    __name(parseIsPredicate, "parseIsPredicate");
-    __name(parseSetDirective, "parseSetDirective");
-    __name(parsePattern, "parsePattern");
-    Query = class {
-      static {
-        __name(this, "Query");
-      }
-      /** @internal */
-      [0] = 0;
-      // Internal handle for WASM
-      /** @internal */
-      exceededMatchLimit;
-      /** @internal */
-      textPredicates;
-      /** The names of the captures used in the query. */
-      captureNames;
-      /** The quantifiers of the captures used in the query. */
-      captureQuantifiers;
-      /**
-       * The other user-defined predicates associated with the given index.
-       *
-       * This includes predicates with operators other than:
-       * - `match?`
-       * - `eq?` and `not-eq?`
-       * - `any-of?` and `not-any-of?`
-       * - `is?` and `is-not?`
-       * - `set!`
-       */
-      predicates;
-      /** The properties for predicates with the operator `set!`. */
-      setProperties;
-      /** The properties for predicates with the operator `is?`. */
-      assertedProperties;
-      /** The properties for predicates with the operator `is-not?`. */
-      refutedProperties;
-      /** The maximum number of in-progress matches for this cursor. */
-      matchLimit;
-      /**
-       * Create a new query from a string containing one or more S-expression
-       * patterns.
-       *
-       * The query is associated with a particular language, and can only be run
-       * on syntax nodes parsed with that language. References to Queries can be
-       * shared between multiple threads.
-       *
-       * @link {@see https://tree-sitter.github.io/tree-sitter/using-parsers/queries}
-       */
-      constructor(language, source) {
-        const sourceLength = C.lengthBytesUTF8(source);
-        const sourceAddress = C._malloc(sourceLength + 1);
-        C.stringToUTF8(source, sourceAddress, sourceLength + 1);
-        const address = C._ts_query_new(
-          language[0],
-          sourceAddress,
-          sourceLength,
-          TRANSFER_BUFFER,
-          TRANSFER_BUFFER + SIZE_OF_INT
-        );
-        if (!address) {
-          const errorId = C.getValue(TRANSFER_BUFFER + SIZE_OF_INT, "i32");
-          const errorByte = C.getValue(TRANSFER_BUFFER, "i32");
-          const errorIndex = C.UTF8ToString(sourceAddress, errorByte).length;
-          const suffix = source.slice(errorIndex, errorIndex + 100).split("\n")[0];
-          const word = suffix.match(QUERY_WORD_REGEX)?.[0] ?? "";
-          C._free(sourceAddress);
-          switch (errorId) {
-            case QueryErrorKind.Syntax:
-              throw new QueryError(QueryErrorKind.Syntax, { suffix: `${errorIndex}: '${suffix}'...` }, errorIndex, 0);
-            case QueryErrorKind.NodeName:
-              throw new QueryError(errorId, { word }, errorIndex, word.length);
-            case QueryErrorKind.FieldName:
-              throw new QueryError(errorId, { word }, errorIndex, word.length);
-            case QueryErrorKind.CaptureName:
-              throw new QueryError(errorId, { word }, errorIndex, word.length);
-            case QueryErrorKind.PatternStructure:
-              throw new QueryError(errorId, { suffix: `${errorIndex}: '${suffix}'...` }, errorIndex, 0);
-          }
-        }
-        const stringCount = C._ts_query_string_count(address);
-        const captureCount = C._ts_query_capture_count(address);
-        const patternCount = C._ts_query_pattern_count(address);
-        const captureNames = new Array(captureCount);
-        const captureQuantifiers = new Array(patternCount);
-        const stringValues = new Array(stringCount);
-        for (let i2 = 0; i2 < captureCount; i2++) {
-          const nameAddress = C._ts_query_capture_name_for_id(
-            address,
-            i2,
-            TRANSFER_BUFFER
-          );
-          const nameLength = C.getValue(TRANSFER_BUFFER, "i32");
-          captureNames[i2] = C.UTF8ToString(nameAddress, nameLength);
-        }
-        for (let i2 = 0; i2 < patternCount; i2++) {
-          const captureQuantifiersArray = new Array(captureCount);
-          for (let j = 0; j < captureCount; j++) {
-            const quantifier = C._ts_query_capture_quantifier_for_id(address, i2, j);
-            captureQuantifiersArray[j] = quantifier;
-          }
-          captureQuantifiers[i2] = captureQuantifiersArray;
-        }
-        for (let i2 = 0; i2 < stringCount; i2++) {
-          const valueAddress = C._ts_query_string_value_for_id(
-            address,
-            i2,
-            TRANSFER_BUFFER
-          );
-          const nameLength = C.getValue(TRANSFER_BUFFER, "i32");
-          stringValues[i2] = C.UTF8ToString(valueAddress, nameLength);
-        }
-        const setProperties = new Array(patternCount);
-        const assertedProperties = new Array(patternCount);
-        const refutedProperties = new Array(patternCount);
-        const predicates = new Array(patternCount);
-        const textPredicates = new Array(patternCount);
-        for (let i2 = 0; i2 < patternCount; i2++) {
-          const predicatesAddress = C._ts_query_predicates_for_pattern(address, i2, TRANSFER_BUFFER);
-          const stepCount = C.getValue(TRANSFER_BUFFER, "i32");
-          predicates[i2] = [];
-          textPredicates[i2] = [];
-          const steps = new Array();
-          let stepAddress = predicatesAddress;
-          for (let j = 0; j < stepCount; j++) {
-            const stepType = C.getValue(stepAddress, "i32");
-            stepAddress += SIZE_OF_INT;
-            const stepValueId = C.getValue(stepAddress, "i32");
-            stepAddress += SIZE_OF_INT;
-            parsePattern(
-              i2,
-              stepType,
-              stepValueId,
-              captureNames,
-              stringValues,
-              steps,
-              textPredicates,
-              predicates,
-              setProperties,
-              assertedProperties,
-              refutedProperties
-            );
-          }
-          Object.freeze(textPredicates[i2]);
-          Object.freeze(predicates[i2]);
-          Object.freeze(setProperties[i2]);
-          Object.freeze(assertedProperties[i2]);
-          Object.freeze(refutedProperties[i2]);
-        }
-        C._free(sourceAddress);
-        this[0] = address;
-        this.captureNames = captureNames;
-        this.captureQuantifiers = captureQuantifiers;
-        this.textPredicates = textPredicates;
-        this.predicates = predicates;
-        this.setProperties = setProperties;
-        this.assertedProperties = assertedProperties;
-        this.refutedProperties = refutedProperties;
-        this.exceededMatchLimit = false;
-      }
-      /** Delete the query, freeing its resources. */
-      delete() {
-        C._ts_query_delete(this[0]);
-        this[0] = 0;
-      }
-      /**
-       * Iterate over all of the matches in the order that they were found.
-       *
-       * Each match contains the index of the pattern that matched, and a list of
-       * captures. Because multiple patterns can match the same set of nodes,
-       * one match may contain captures that appear *before* some of the
-       * captures from a previous match.
-       *
-       * @param {Node} node - The node to execute the query on.
-       *
-       * @param {QueryOptions} options - Options for query execution.
-       */
-      matches(node, options = {}) {
-        const startPosition = options.startPosition ?? ZERO_POINT;
-        const endPosition = options.endPosition ?? ZERO_POINT;
-        const startIndex = options.startIndex ?? 0;
-        const endIndex = options.endIndex ?? 0;
-        const matchLimit = options.matchLimit ?? 4294967295;
-        const maxStartDepth = options.maxStartDepth ?? 4294967295;
-        const timeoutMicros = options.timeoutMicros ?? 0;
-        const progressCallback = options.progressCallback;
-        if (typeof matchLimit !== "number") {
-          throw new Error("Arguments must be numbers");
-        }
-        this.matchLimit = matchLimit;
-        if (endIndex !== 0 && startIndex > endIndex) {
-          throw new Error("`startIndex` cannot be greater than `endIndex`");
-        }
-        if (endPosition !== ZERO_POINT && (startPosition.row > endPosition.row || startPosition.row === endPosition.row && startPosition.column > endPosition.column)) {
-          throw new Error("`startPosition` cannot be greater than `endPosition`");
-        }
-        if (progressCallback) {
-          C.currentQueryProgressCallback = progressCallback;
-        }
-        marshalNode(node);
-        C._ts_query_matches_wasm(
-          this[0],
-          node.tree[0],
-          startPosition.row,
-          startPosition.column,
-          endPosition.row,
-          endPosition.column,
-          startIndex,
-          endIndex,
-          matchLimit,
-          maxStartDepth,
-          timeoutMicros
-        );
-        const rawCount = C.getValue(TRANSFER_BUFFER, "i32");
-        const startAddress = C.getValue(TRANSFER_BUFFER + SIZE_OF_INT, "i32");
-        const didExceedMatchLimit = C.getValue(TRANSFER_BUFFER + 2 * SIZE_OF_INT, "i32");
-        const result = new Array(rawCount);
-        this.exceededMatchLimit = Boolean(didExceedMatchLimit);
-        let filteredCount = 0;
-        let address = startAddress;
-        for (let i2 = 0; i2 < rawCount; i2++) {
-          const patternIndex = C.getValue(address, "i32");
-          address += SIZE_OF_INT;
-          const captureCount = C.getValue(address, "i32");
-          address += SIZE_OF_INT;
-          const captures = new Array(captureCount);
-          address = unmarshalCaptures(this, node.tree, address, patternIndex, captures);
-          if (this.textPredicates[patternIndex].every((p) => p(captures))) {
-            result[filteredCount] = { pattern: patternIndex, patternIndex, captures };
-            const setProperties = this.setProperties[patternIndex];
-            result[filteredCount].setProperties = setProperties;
-            const assertedProperties = this.assertedProperties[patternIndex];
-            result[filteredCount].assertedProperties = assertedProperties;
-            const refutedProperties = this.refutedProperties[patternIndex];
-            result[filteredCount].refutedProperties = refutedProperties;
-            filteredCount++;
-          }
-        }
-        result.length = filteredCount;
-        C._free(startAddress);
-        C.currentQueryProgressCallback = null;
-        return result;
-      }
-      /**
-       * Iterate over all of the individual captures in the order that they
-       * appear.
-       *
-       * This is useful if you don't care about which pattern matched, and just
-       * want a single, ordered sequence of captures.
-       *
-       * @param {Node} node - The node to execute the query on.
-       *
-       * @param {QueryOptions} options - Options for query execution.
-       */
-      captures(node, options = {}) {
-        const startPosition = options.startPosition ?? ZERO_POINT;
-        const endPosition = options.endPosition ?? ZERO_POINT;
-        const startIndex = options.startIndex ?? 0;
-        const endIndex = options.endIndex ?? 0;
-        const matchLimit = options.matchLimit ?? 4294967295;
-        const maxStartDepth = options.maxStartDepth ?? 4294967295;
-        const timeoutMicros = options.timeoutMicros ?? 0;
-        const progressCallback = options.progressCallback;
-        if (typeof matchLimit !== "number") {
-          throw new Error("Arguments must be numbers");
-        }
-        this.matchLimit = matchLimit;
-        if (endIndex !== 0 && startIndex > endIndex) {
-          throw new Error("`startIndex` cannot be greater than `endIndex`");
-        }
-        if (endPosition !== ZERO_POINT && (startPosition.row > endPosition.row || startPosition.row === endPosition.row && startPosition.column > endPosition.column)) {
-          throw new Error("`startPosition` cannot be greater than `endPosition`");
-        }
-        if (progressCallback) {
-          C.currentQueryProgressCallback = progressCallback;
-        }
-        marshalNode(node);
-        C._ts_query_captures_wasm(
-          this[0],
-          node.tree[0],
-          startPosition.row,
-          startPosition.column,
-          endPosition.row,
-          endPosition.column,
-          startIndex,
-          endIndex,
-          matchLimit,
-          maxStartDepth,
-          timeoutMicros
-        );
-        const count = C.getValue(TRANSFER_BUFFER, "i32");
-        const startAddress = C.getValue(TRANSFER_BUFFER + SIZE_OF_INT, "i32");
-        const didExceedMatchLimit = C.getValue(TRANSFER_BUFFER + 2 * SIZE_OF_INT, "i32");
-        const result = new Array();
-        this.exceededMatchLimit = Boolean(didExceedMatchLimit);
-        const captures = new Array();
-        let address = startAddress;
-        for (let i2 = 0; i2 < count; i2++) {
-          const patternIndex = C.getValue(address, "i32");
-          address += SIZE_OF_INT;
-          const captureCount = C.getValue(address, "i32");
-          address += SIZE_OF_INT;
-          const captureIndex = C.getValue(address, "i32");
-          address += SIZE_OF_INT;
-          captures.length = captureCount;
-          address = unmarshalCaptures(this, node.tree, address, patternIndex, captures);
-          if (this.textPredicates[patternIndex].every((p) => p(captures))) {
-            const capture = captures[captureIndex];
-            const setProperties = this.setProperties[patternIndex];
-            capture.setProperties = setProperties;
-            const assertedProperties = this.assertedProperties[patternIndex];
-            capture.assertedProperties = assertedProperties;
-            const refutedProperties = this.refutedProperties[patternIndex];
-            capture.refutedProperties = refutedProperties;
-            result.push(capture);
-          }
-        }
-        C._free(startAddress);
-        C.currentQueryProgressCallback = null;
-        return result;
-      }
-      /** Get the predicates for a given pattern. */
-      predicatesForPattern(patternIndex) {
-        return this.predicates[patternIndex];
-      }
-      /**
-       * Disable a certain capture within a query.
-       *
-       * This prevents the capture from being returned in matches, and also
-       * avoids any resource usage associated with recording the capture.
-       */
-      disableCapture(captureName) {
-        const captureNameLength = C.lengthBytesUTF8(captureName);
-        const captureNameAddress = C._malloc(captureNameLength + 1);
-        C.stringToUTF8(captureName, captureNameAddress, captureNameLength + 1);
-        C._ts_query_disable_capture(this[0], captureNameAddress, captureNameLength);
-        C._free(captureNameAddress);
-      }
-      /**
-       * Disable a certain pattern within a query.
-       *
-       * This prevents the pattern from matching, and also avoids any resource
-       * usage associated with the pattern. This throws an error if the pattern
-       * index is out of bounds.
-       */
-      disablePattern(patternIndex) {
-        if (patternIndex >= this.predicates.length) {
-          throw new Error(
-            `Pattern index is ${patternIndex} but the pattern count is ${this.predicates.length}`
-          );
-        }
-        C._ts_query_disable_pattern(this[0], patternIndex);
-      }
-      /**
-       * Check if, on its last execution, this cursor exceeded its maximum number
-       * of in-progress matches.
-       */
-      didExceedMatchLimit() {
-        return this.exceededMatchLimit;
-      }
-      /** Get the byte offset where the given pattern starts in the query's source. */
-      startIndexForPattern(patternIndex) {
-        if (patternIndex >= this.predicates.length) {
-          throw new Error(
-            `Pattern index is ${patternIndex} but the pattern count is ${this.predicates.length}`
-          );
-        }
-        return C._ts_query_start_byte_for_pattern(this[0], patternIndex);
-      }
-      /** Get the byte offset where the given pattern ends in the query's source. */
-      endIndexForPattern(patternIndex) {
-        if (patternIndex >= this.predicates.length) {
-          throw new Error(
-            `Pattern index is ${patternIndex} but the pattern count is ${this.predicates.length}`
-          );
-        }
-        return C._ts_query_end_byte_for_pattern(this[0], patternIndex);
-      }
-      /** Get the number of patterns in the query. */
-      patternCount() {
-        return C._ts_query_pattern_count(this[0]);
-      }
-      /** Get the index for a given capture name. */
-      captureIndexForName(captureName) {
-        return this.captureNames.indexOf(captureName);
-      }
-      /** Check if a given pattern within a query has a single root node. */
-      isPatternRooted(patternIndex) {
-        return C._ts_query_is_pattern_rooted(this[0], patternIndex) === 1;
-      }
-      /** Check if a given pattern within a query has a single root node. */
-      isPatternNonLocal(patternIndex) {
-        return C._ts_query_is_pattern_non_local(this[0], patternIndex) === 1;
-      }
-      /**
-       * Check if a given step in a query is 'definite'.
-       *
-       * A query step is 'definite' if its parent pattern will be guaranteed to
-       * match successfully once it reaches the step.
-       */
-      isPatternGuaranteedAtStep(byteIndex) {
-        return C._ts_query_is_pattern_guaranteed_at_step(this[0], byteIndex) === 1;
-      }
-    };
-    LANGUAGE_FUNCTION_REGEX = /^tree_sitter_\w+$/;
-    Language = class _Language {
-      static {
-        __name(this, "Language");
-      }
-      /** @internal */
-      [0] = 0;
-      // Internal handle for WASM
-      /**
-       * A list of all node types in the language. The index of each type in this
-       * array is its node type id.
-       */
-      types;
-      /**
-       * A list of all field names in the language. The index of each field name in
-       * this array is its field id.
-       */
-      fields;
-      /** @internal */
-      constructor(internal, address) {
-        assertInternal(internal);
-        this[0] = address;
-        this.types = new Array(C._ts_language_symbol_count(this[0]));
-        for (let i2 = 0, n = this.types.length; i2 < n; i2++) {
-          if (C._ts_language_symbol_type(this[0], i2) < 2) {
-            this.types[i2] = C.UTF8ToString(C._ts_language_symbol_name(this[0], i2));
-          }
-        }
-        this.fields = new Array(C._ts_language_field_count(this[0]) + 1);
-        for (let i2 = 0, n = this.fields.length; i2 < n; i2++) {
-          const fieldName = C._ts_language_field_name_for_id(this[0], i2);
-          if (fieldName !== 0) {
-            this.fields[i2] = C.UTF8ToString(fieldName);
-          } else {
-            this.fields[i2] = null;
-          }
-        }
-      }
-      /**
-       * Gets the name of the language.
-       */
-      get name() {
-        const ptr = C._ts_language_name(this[0]);
-        if (ptr === 0) return null;
-        return C.UTF8ToString(ptr);
-      }
-      /**
-       * @deprecated since version 0.25.0, use {@link Language#abiVersion} instead
-       * Gets the version of the language.
-       */
-      get version() {
-        return C._ts_language_version(this[0]);
-      }
-      /**
-       * Gets the ABI version of the language.
-       */
-      get abiVersion() {
-        return C._ts_language_abi_version(this[0]);
-      }
-      /**
-      * Get the metadata for this language. This information is generated by the
-      * CLI, and relies on the language author providing the correct metadata in
-      * the language's `tree-sitter.json` file.
-      */
-      get metadata() {
-        C._ts_language_metadata(this[0]);
-        const length = C.getValue(TRANSFER_BUFFER, "i32");
-        const address = C.getValue(TRANSFER_BUFFER + SIZE_OF_INT, "i32");
-        if (length === 0) return null;
-        return unmarshalLanguageMetadata(address);
-      }
-      /**
-       * Gets the number of fields in the language.
-       */
-      get fieldCount() {
-        return this.fields.length - 1;
-      }
-      /**
-       * Gets the number of states in the language.
-       */
-      get stateCount() {
-        return C._ts_language_state_count(this[0]);
-      }
-      /**
-       * Get the field id for a field name.
-       */
-      fieldIdForName(fieldName) {
-        const result = this.fields.indexOf(fieldName);
-        return result !== -1 ? result : null;
-      }
-      /**
-       * Get the field name for a field id.
-       */
-      fieldNameForId(fieldId) {
-        return this.fields[fieldId] ?? null;
-      }
-      /**
-       * Get the node type id for a node type name.
-       */
-      idForNodeType(type, named) {
-        const typeLength = C.lengthBytesUTF8(type);
-        const typeAddress = C._malloc(typeLength + 1);
-        C.stringToUTF8(type, typeAddress, typeLength + 1);
-        const result = C._ts_language_symbol_for_name(this[0], typeAddress, typeLength, named ? 1 : 0);
-        C._free(typeAddress);
-        return result || null;
-      }
-      /**
-       * Gets the number of node types in the language.
-       */
-      get nodeTypeCount() {
-        return C._ts_language_symbol_count(this[0]);
-      }
-      /**
-       * Get the node type name for a node type id.
-       */
-      nodeTypeForId(typeId) {
-        const name2 = C._ts_language_symbol_name(this[0], typeId);
-        return name2 ? C.UTF8ToString(name2) : null;
-      }
-      /**
-       * Check if a node type is named.
-       *
-       * @see {@link https://tree-sitter.github.io/tree-sitter/using-parsers/2-basic-parsing.html#named-vs-anonymous-nodes}
-       */
-      nodeTypeIsNamed(typeId) {
-        return C._ts_language_type_is_named_wasm(this[0], typeId) ? true : false;
-      }
-      /**
-       * Check if a node type is visible.
-       */
-      nodeTypeIsVisible(typeId) {
-        return C._ts_language_type_is_visible_wasm(this[0], typeId) ? true : false;
-      }
-      /**
-       * Get the supertypes ids of this language.
-       *
-       * @see {@link https://tree-sitter.github.io/tree-sitter/using-parsers/6-static-node-types.html?highlight=supertype#supertype-nodes}
-       */
-      get supertypes() {
-        C._ts_language_supertypes_wasm(this[0]);
-        const count = C.getValue(TRANSFER_BUFFER, "i32");
-        const buffer = C.getValue(TRANSFER_BUFFER + SIZE_OF_INT, "i32");
-        const result = new Array(count);
-        if (count > 0) {
-          let address = buffer;
-          for (let i2 = 0; i2 < count; i2++) {
-            result[i2] = C.getValue(address, "i16");
-            address += SIZE_OF_SHORT;
-          }
-        }
-        return result;
-      }
-      /**
-       * Get the subtype ids for a given supertype node id.
-       */
-      subtypes(supertype) {
-        C._ts_language_subtypes_wasm(this[0], supertype);
-        const count = C.getValue(TRANSFER_BUFFER, "i32");
-        const buffer = C.getValue(TRANSFER_BUFFER + SIZE_OF_INT, "i32");
-        const result = new Array(count);
-        if (count > 0) {
-          let address = buffer;
-          for (let i2 = 0; i2 < count; i2++) {
-            result[i2] = C.getValue(address, "i16");
-            address += SIZE_OF_SHORT;
-          }
-        }
-        return result;
-      }
-      /**
-       * Get the next state id for a given state id and node type id.
-       */
-      nextState(stateId, typeId) {
-        return C._ts_language_next_state(this[0], stateId, typeId);
-      }
-      /**
-       * Create a new lookahead iterator for this language and parse state.
-       *
-       * This returns `null` if state is invalid for this language.
-       *
-       * Iterating {@link LookaheadIterator} will yield valid symbols in the given
-       * parse state. Newly created lookahead iterators will return the `ERROR`
-       * symbol from {@link LookaheadIterator#currentType}.
-       *
-       * Lookahead iterators can be useful for generating suggestions and improving
-       * syntax error diagnostics. To get symbols valid in an `ERROR` node, use the
-       * lookahead iterator on its first leaf node state. For `MISSING` nodes, a
-       * lookahead iterator created on the previous non-extra leaf node may be
-       * appropriate.
-       */
-      lookaheadIterator(stateId) {
-        const address = C._ts_lookahead_iterator_new(this[0], stateId);
-        if (address) return new LookaheadIterator(INTERNAL, address, this);
-        return null;
-      }
-      /**
-       * @deprecated since version 0.25.0, call `new` on a {@link Query} instead
-       *
-       * Create a new query from a string containing one or more S-expression
-       * patterns.
-       *
-       * The query is associated with a particular language, and can only be run
-       * on syntax nodes parsed with that language. References to Queries can be
-       * shared between multiple threads.
-       *
-       * @link {@see https://tree-sitter.github.io/tree-sitter/using-parsers/queries}
-       */
-      query(source) {
-        console.warn("Language.query is deprecated. Use new Query(language, source) instead.");
-        return new Query(this, source);
-      }
-      /**
-       * Load a language from a WebAssembly module.
-       * The module can be provided as a path to a file or as a buffer.
-       */
-      static async load(input) {
-        let bytes;
-        if (input instanceof Uint8Array) {
-          bytes = Promise.resolve(input);
-        } else {
-          if (globalThis.process?.versions.node) {
-            const fs2 = await import("fs/promises");
-            bytes = fs2.readFile(input);
-          } else {
-            bytes = fetch(input).then((response) => response.arrayBuffer().then((buffer) => {
-              if (response.ok) {
-                return new Uint8Array(buffer);
-              } else {
-                const body2 = new TextDecoder("utf-8").decode(buffer);
-                throw new Error(`Language.load failed with status ${response.status}.
-
-${body2}`);
-              }
-            }));
-          }
-        }
-        const mod = await C.loadWebAssemblyModule(await bytes, { loadAsync: true });
-        const symbolNames = Object.keys(mod);
-        const functionName = symbolNames.find((key) => LANGUAGE_FUNCTION_REGEX.test(key) && !key.includes("external_scanner_"));
-        if (!functionName) {
-          console.log(`Couldn't find language function in WASM file. Symbols:
-${JSON.stringify(symbolNames, null, 2)}`);
-          throw new Error("Language.load failed: no language function found in WASM file");
-        }
-        const languageAddress = mod[functionName]();
-        return new _Language(INTERNAL, languageAddress);
-      }
-    };
-    Module2 = (() => {
-      var _scriptName = import.meta.url;
-      return async function(moduleArg = {}) {
-        var moduleRtn;
-        var Module = moduleArg;
-        var readyPromiseResolve, readyPromiseReject;
-        var readyPromise = new Promise((resolve8, reject) => {
-          readyPromiseResolve = resolve8;
-          readyPromiseReject = reject;
-        });
-        var ENVIRONMENT_IS_WEB = typeof window == "object";
-        var ENVIRONMENT_IS_WORKER = typeof WorkerGlobalScope != "undefined";
-        var ENVIRONMENT_IS_NODE = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string" && process.type != "renderer";
-        var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
-        if (ENVIRONMENT_IS_NODE) {
-          const { createRequire: createRequire3 } = await import("module");
-          var require = createRequire3(import.meta.url);
-        }
-        Module.currentQueryProgressCallback = null;
-        Module.currentProgressCallback = null;
-        Module.currentLogCallback = null;
-        Module.currentParseCallback = null;
-        var moduleOverrides = Object.assign({}, Module);
-        var arguments_ = [];
-        var thisProgram = "./this.program";
-        var quit_ = /* @__PURE__ */ __name((status, toThrow) => {
-          throw toThrow;
-        }, "quit_");
-        var scriptDirectory = "";
-        function locateFile(path) {
-          if (Module["locateFile"]) {
-            return Module["locateFile"](path, scriptDirectory);
-          }
-          return scriptDirectory + path;
-        }
-        __name(locateFile, "locateFile");
-        var readAsync, readBinary;
-        if (ENVIRONMENT_IS_NODE) {
-          var fs = require("fs");
-          var nodePath = require("path");
-          if (!import.meta.url.startsWith("data:")) {
-            scriptDirectory = nodePath.dirname(require("url").fileURLToPath(import.meta.url)) + "/";
-          }
-          readBinary = /* @__PURE__ */ __name((filename) => {
-            filename = isFileURI(filename) ? new URL(filename) : filename;
-            var ret = fs.readFileSync(filename);
-            return ret;
-          }, "readBinary");
-          readAsync = /* @__PURE__ */ __name(async (filename, binary2 = true) => {
-            filename = isFileURI(filename) ? new URL(filename) : filename;
-            var ret = fs.readFileSync(filename, binary2 ? void 0 : "utf8");
-            return ret;
-          }, "readAsync");
-          if (!Module["thisProgram"] && process.argv.length > 1) {
-            thisProgram = process.argv[1].replace(/\\/g, "/");
-          }
-          arguments_ = process.argv.slice(2);
-          quit_ = /* @__PURE__ */ __name((status, toThrow) => {
-            process.exitCode = status;
-            throw toThrow;
-          }, "quit_");
-        } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
-          if (ENVIRONMENT_IS_WORKER) {
-            scriptDirectory = self.location.href;
-          } else if (typeof document != "undefined" && document.currentScript) {
-            scriptDirectory = document.currentScript.src;
-          }
-          if (_scriptName) {
-            scriptDirectory = _scriptName;
-          }
-          if (scriptDirectory.startsWith("blob:")) {
-            scriptDirectory = "";
-          } else {
-            scriptDirectory = scriptDirectory.slice(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1);
-          }
-          {
-            if (ENVIRONMENT_IS_WORKER) {
-              readBinary = /* @__PURE__ */ __name((url) => {
-                var xhr = new XMLHttpRequest();
-                xhr.open("GET", url, false);
-                xhr.responseType = "arraybuffer";
-                xhr.send(null);
-                return new Uint8Array(
-                  /** @type{!ArrayBuffer} */
-                  xhr.response
-                );
-              }, "readBinary");
-            }
-            readAsync = /* @__PURE__ */ __name(async (url) => {
-              if (isFileURI(url)) {
-                return new Promise((resolve8, reject) => {
-                  var xhr = new XMLHttpRequest();
-                  xhr.open("GET", url, true);
-                  xhr.responseType = "arraybuffer";
-                  xhr.onload = () => {
-                    if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
-                      resolve8(xhr.response);
-                      return;
-                    }
-                    reject(xhr.status);
-                  };
-                  xhr.onerror = reject;
-                  xhr.send(null);
-                });
-              }
-              var response = await fetch(url, {
-                credentials: "same-origin"
-              });
-              if (response.ok) {
-                return response.arrayBuffer();
-              }
-              throw new Error(response.status + " : " + response.url);
-            }, "readAsync");
-          }
-        } else {
-        }
-        var out = Module["print"] || console.log.bind(console);
-        var err = Module["printErr"] || console.error.bind(console);
-        Object.assign(Module, moduleOverrides);
-        moduleOverrides = null;
-        if (Module["arguments"]) arguments_ = Module["arguments"];
-        if (Module["thisProgram"]) thisProgram = Module["thisProgram"];
-        var dynamicLibraries = Module["dynamicLibraries"] || [];
-        var wasmBinary = Module["wasmBinary"];
-        var wasmMemory;
-        var ABORT = false;
-        var EXITSTATUS;
-        function assert(condition, text) {
-          if (!condition) {
-            abort(text);
-          }
-        }
-        __name(assert, "assert");
-        var HEAP, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAP64, HEAPU64, HEAPF64;
-        var HEAP_DATA_VIEW;
-        var runtimeInitialized = false;
-        var isFileURI = /* @__PURE__ */ __name((filename) => filename.startsWith("file://"), "isFileURI");
-        function updateMemoryViews() {
-          var b = wasmMemory.buffer;
-          Module["HEAP_DATA_VIEW"] = HEAP_DATA_VIEW = new DataView(b);
-          Module["HEAP8"] = HEAP8 = new Int8Array(b);
-          Module["HEAP16"] = HEAP16 = new Int16Array(b);
-          Module["HEAPU8"] = HEAPU8 = new Uint8Array(b);
-          Module["HEAPU16"] = HEAPU16 = new Uint16Array(b);
-          Module["HEAP32"] = HEAP32 = new Int32Array(b);
-          Module["HEAPU32"] = HEAPU32 = new Uint32Array(b);
-          Module["HEAPF32"] = HEAPF32 = new Float32Array(b);
-          Module["HEAPF64"] = HEAPF64 = new Float64Array(b);
-          Module["HEAP64"] = HEAP64 = new BigInt64Array(b);
-          Module["HEAPU64"] = HEAPU64 = new BigUint64Array(b);
-        }
-        __name(updateMemoryViews, "updateMemoryViews");
-        if (Module["wasmMemory"]) {
-          wasmMemory = Module["wasmMemory"];
-        } else {
-          var INITIAL_MEMORY = Module["INITIAL_MEMORY"] || 33554432;
-          wasmMemory = new WebAssembly.Memory({
-            "initial": INITIAL_MEMORY / 65536,
-            // In theory we should not need to emit the maximum if we want "unlimited"
-            // or 4GB of memory, but VMs error on that atm, see
-            // https://github.com/emscripten-core/emscripten/issues/14130
-            // And in the pthreads case we definitely need to emit a maximum. So
-            // always emit one.
-            "maximum": 32768
-          });
-        }
-        updateMemoryViews();
-        var __RELOC_FUNCS__ = [];
-        function preRun() {
-          if (Module["preRun"]) {
-            if (typeof Module["preRun"] == "function") Module["preRun"] = [Module["preRun"]];
-            while (Module["preRun"].length) {
-              addOnPreRun(Module["preRun"].shift());
-            }
-          }
-          callRuntimeCallbacks(onPreRuns);
-        }
-        __name(preRun, "preRun");
-        function initRuntime() {
-          runtimeInitialized = true;
-          callRuntimeCallbacks(__RELOC_FUNCS__);
-          wasmExports["__wasm_call_ctors"]();
-          callRuntimeCallbacks(onPostCtors);
-        }
-        __name(initRuntime, "initRuntime");
-        function preMain() {
-        }
-        __name(preMain, "preMain");
-        function postRun() {
-          if (Module["postRun"]) {
-            if (typeof Module["postRun"] == "function") Module["postRun"] = [Module["postRun"]];
-            while (Module["postRun"].length) {
-              addOnPostRun(Module["postRun"].shift());
-            }
-          }
-          callRuntimeCallbacks(onPostRuns);
-        }
-        __name(postRun, "postRun");
-        var runDependencies = 0;
-        var dependenciesFulfilled = null;
-        function getUniqueRunDependency(id) {
-          return id;
-        }
-        __name(getUniqueRunDependency, "getUniqueRunDependency");
-        function addRunDependency(id) {
-          runDependencies++;
-          Module["monitorRunDependencies"]?.(runDependencies);
-        }
-        __name(addRunDependency, "addRunDependency");
-        function removeRunDependency(id) {
-          runDependencies--;
-          Module["monitorRunDependencies"]?.(runDependencies);
-          if (runDependencies == 0) {
-            if (dependenciesFulfilled) {
-              var callback = dependenciesFulfilled;
-              dependenciesFulfilled = null;
-              callback();
-            }
-          }
-        }
-        __name(removeRunDependency, "removeRunDependency");
-        function abort(what) {
-          Module["onAbort"]?.(what);
-          what = "Aborted(" + what + ")";
-          err(what);
-          ABORT = true;
-          what += ". Build with -sASSERTIONS for more info.";
-          var e = new WebAssembly.RuntimeError(what);
-          readyPromiseReject(e);
-          throw e;
-        }
-        __name(abort, "abort");
-        var wasmBinaryFile;
-        function findWasmBinary() {
-          if (Module["locateFile"]) {
-            return locateFile("tree-sitter.wasm");
-          }
-          return new URL("tree-sitter.wasm", import.meta.url).href;
-        }
-        __name(findWasmBinary, "findWasmBinary");
-        function getBinarySync(file) {
-          if (file == wasmBinaryFile && wasmBinary) {
-            return new Uint8Array(wasmBinary);
-          }
-          if (readBinary) {
-            return readBinary(file);
-          }
-          throw "both async and sync fetching of the wasm failed";
-        }
-        __name(getBinarySync, "getBinarySync");
-        async function getWasmBinary(binaryFile) {
-          if (!wasmBinary) {
-            try {
-              var response = await readAsync(binaryFile);
-              return new Uint8Array(response);
-            } catch {
-            }
-          }
-          return getBinarySync(binaryFile);
-        }
-        __name(getWasmBinary, "getWasmBinary");
-        async function instantiateArrayBuffer(binaryFile, imports) {
-          try {
-            var binary2 = await getWasmBinary(binaryFile);
-            var instance2 = await WebAssembly.instantiate(binary2, imports);
-            return instance2;
-          } catch (reason) {
-            err(`failed to asynchronously prepare wasm: ${reason}`);
-            abort(reason);
-          }
-        }
-        __name(instantiateArrayBuffer, "instantiateArrayBuffer");
-        async function instantiateAsync(binary2, binaryFile, imports) {
-          if (!binary2 && typeof WebAssembly.instantiateStreaming == "function" && !isFileURI(binaryFile) && !ENVIRONMENT_IS_NODE) {
-            try {
-              var response = fetch(binaryFile, {
-                credentials: "same-origin"
-              });
-              var instantiationResult = await WebAssembly.instantiateStreaming(response, imports);
-              return instantiationResult;
-            } catch (reason) {
-              err(`wasm streaming compile failed: ${reason}`);
-              err("falling back to ArrayBuffer instantiation");
-            }
-          }
-          return instantiateArrayBuffer(binaryFile, imports);
-        }
-        __name(instantiateAsync, "instantiateAsync");
-        function getWasmImports() {
-          return {
-            "env": wasmImports,
-            "wasi_snapshot_preview1": wasmImports,
-            "GOT.mem": new Proxy(wasmImports, GOTHandler),
-            "GOT.func": new Proxy(wasmImports, GOTHandler)
-          };
-        }
-        __name(getWasmImports, "getWasmImports");
-        async function createWasm() {
-          function receiveInstance(instance2, module2) {
-            wasmExports = instance2.exports;
-            wasmExports = relocateExports(wasmExports, 1024);
-            var metadata2 = getDylinkMetadata(module2);
-            if (metadata2.neededDynlibs) {
-              dynamicLibraries = metadata2.neededDynlibs.concat(dynamicLibraries);
-            }
-            mergeLibSymbols(wasmExports, "main");
-            LDSO.init();
-            loadDylibs();
-            __RELOC_FUNCS__.push(wasmExports["__wasm_apply_data_relocs"]);
-            removeRunDependency("wasm-instantiate");
-            return wasmExports;
-          }
-          __name(receiveInstance, "receiveInstance");
-          addRunDependency("wasm-instantiate");
-          function receiveInstantiationResult(result2) {
-            return receiveInstance(result2["instance"], result2["module"]);
-          }
-          __name(receiveInstantiationResult, "receiveInstantiationResult");
-          var info2 = getWasmImports();
-          if (Module["instantiateWasm"]) {
-            return new Promise((resolve8, reject) => {
-              Module["instantiateWasm"](info2, (mod, inst) => {
-                receiveInstance(mod, inst);
-                resolve8(mod.exports);
-              });
-            });
-          }
-          wasmBinaryFile ??= findWasmBinary();
-          try {
-            var result = await instantiateAsync(wasmBinary, wasmBinaryFile, info2);
-            var exports = receiveInstantiationResult(result);
-            return exports;
-          } catch (e) {
-            readyPromiseReject(e);
-            return Promise.reject(e);
-          }
-        }
-        __name(createWasm, "createWasm");
-        var ASM_CONSTS = {};
-        class ExitStatus {
-          static {
-            __name(this, "ExitStatus");
-          }
-          name = "ExitStatus";
-          constructor(status) {
-            this.message = `Program terminated with exit(${status})`;
-            this.status = status;
-          }
-        }
-        var GOT = {};
-        var currentModuleWeakSymbols = /* @__PURE__ */ new Set([]);
-        var GOTHandler = {
-          get(obj, symName) {
-            var rtn = GOT[symName];
-            if (!rtn) {
-              rtn = GOT[symName] = new WebAssembly.Global({
-                "value": "i32",
-                "mutable": true
-              });
-            }
-            if (!currentModuleWeakSymbols.has(symName)) {
-              rtn.required = true;
-            }
-            return rtn;
-          }
-        };
-        var LE_HEAP_LOAD_F32 = /* @__PURE__ */ __name((byteOffset) => HEAP_DATA_VIEW.getFloat32(byteOffset, true), "LE_HEAP_LOAD_F32");
-        var LE_HEAP_LOAD_F64 = /* @__PURE__ */ __name((byteOffset) => HEAP_DATA_VIEW.getFloat64(byteOffset, true), "LE_HEAP_LOAD_F64");
-        var LE_HEAP_LOAD_I16 = /* @__PURE__ */ __name((byteOffset) => HEAP_DATA_VIEW.getInt16(byteOffset, true), "LE_HEAP_LOAD_I16");
-        var LE_HEAP_LOAD_I32 = /* @__PURE__ */ __name((byteOffset) => HEAP_DATA_VIEW.getInt32(byteOffset, true), "LE_HEAP_LOAD_I32");
-        var LE_HEAP_LOAD_U16 = /* @__PURE__ */ __name((byteOffset) => HEAP_DATA_VIEW.getUint16(byteOffset, true), "LE_HEAP_LOAD_U16");
-        var LE_HEAP_LOAD_U32 = /* @__PURE__ */ __name((byteOffset) => HEAP_DATA_VIEW.getUint32(byteOffset, true), "LE_HEAP_LOAD_U32");
-        var LE_HEAP_STORE_F32 = /* @__PURE__ */ __name((byteOffset, value) => HEAP_DATA_VIEW.setFloat32(byteOffset, value, true), "LE_HEAP_STORE_F32");
-        var LE_HEAP_STORE_F64 = /* @__PURE__ */ __name((byteOffset, value) => HEAP_DATA_VIEW.setFloat64(byteOffset, value, true), "LE_HEAP_STORE_F64");
-        var LE_HEAP_STORE_I16 = /* @__PURE__ */ __name((byteOffset, value) => HEAP_DATA_VIEW.setInt16(byteOffset, value, true), "LE_HEAP_STORE_I16");
-        var LE_HEAP_STORE_I32 = /* @__PURE__ */ __name((byteOffset, value) => HEAP_DATA_VIEW.setInt32(byteOffset, value, true), "LE_HEAP_STORE_I32");
-        var LE_HEAP_STORE_U16 = /* @__PURE__ */ __name((byteOffset, value) => HEAP_DATA_VIEW.setUint16(byteOffset, value, true), "LE_HEAP_STORE_U16");
-        var LE_HEAP_STORE_U32 = /* @__PURE__ */ __name((byteOffset, value) => HEAP_DATA_VIEW.setUint32(byteOffset, value, true), "LE_HEAP_STORE_U32");
-        var callRuntimeCallbacks = /* @__PURE__ */ __name((callbacks) => {
-          while (callbacks.length > 0) {
-            callbacks.shift()(Module);
-          }
-        }, "callRuntimeCallbacks");
-        var onPostRuns = [];
-        var addOnPostRun = /* @__PURE__ */ __name((cb) => onPostRuns.unshift(cb), "addOnPostRun");
-        var onPreRuns = [];
-        var addOnPreRun = /* @__PURE__ */ __name((cb) => onPreRuns.unshift(cb), "addOnPreRun");
-        var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder() : void 0;
-        var UTF8ArrayToString = /* @__PURE__ */ __name((heapOrArray, idx = 0, maxBytesToRead = NaN) => {
-          var endIdx = idx + maxBytesToRead;
-          var endPtr = idx;
-          while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;
-          if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
-            return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
-          }
-          var str = "";
-          while (idx < endPtr) {
-            var u0 = heapOrArray[idx++];
-            if (!(u0 & 128)) {
-              str += String.fromCharCode(u0);
-              continue;
-            }
-            var u1 = heapOrArray[idx++] & 63;
-            if ((u0 & 224) == 192) {
-              str += String.fromCharCode((u0 & 31) << 6 | u1);
-              continue;
-            }
-            var u2 = heapOrArray[idx++] & 63;
-            if ((u0 & 240) == 224) {
-              u0 = (u0 & 15) << 12 | u1 << 6 | u2;
-            } else {
-              u0 = (u0 & 7) << 18 | u1 << 12 | u2 << 6 | heapOrArray[idx++] & 63;
-            }
-            if (u0 < 65536) {
-              str += String.fromCharCode(u0);
-            } else {
-              var ch = u0 - 65536;
-              str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
-            }
-          }
-          return str;
-        }, "UTF8ArrayToString");
-        var getDylinkMetadata = /* @__PURE__ */ __name((binary2) => {
-          var offset = 0;
-          var end = 0;
-          function getU8() {
-            return binary2[offset++];
-          }
-          __name(getU8, "getU8");
-          function getLEB() {
-            var ret = 0;
-            var mul = 1;
-            while (1) {
-              var byte = binary2[offset++];
-              ret += (byte & 127) * mul;
-              mul *= 128;
-              if (!(byte & 128)) break;
-            }
-            return ret;
-          }
-          __name(getLEB, "getLEB");
-          function getString() {
-            var len = getLEB();
-            offset += len;
-            return UTF8ArrayToString(binary2, offset - len, len);
-          }
-          __name(getString, "getString");
-          function failIf(condition, message) {
-            if (condition) throw new Error(message);
-          }
-          __name(failIf, "failIf");
-          var name2 = "dylink.0";
-          if (binary2 instanceof WebAssembly.Module) {
-            var dylinkSection = WebAssembly.Module.customSections(binary2, name2);
-            if (dylinkSection.length === 0) {
-              name2 = "dylink";
-              dylinkSection = WebAssembly.Module.customSections(binary2, name2);
-            }
-            failIf(dylinkSection.length === 0, "need dylink section");
-            binary2 = new Uint8Array(dylinkSection[0]);
-            end = binary2.length;
-          } else {
-            var int32View = new Uint32Array(new Uint8Array(binary2.subarray(0, 24)).buffer);
-            var magicNumberFound = int32View[0] == 1836278016 || int32View[0] == 6386541;
-            failIf(!magicNumberFound, "need to see wasm magic number");
-            failIf(binary2[8] !== 0, "need the dylink section to be first");
-            offset = 9;
-            var section_size = getLEB();
-            end = offset + section_size;
-            name2 = getString();
-          }
-          var customSection = {
-            neededDynlibs: [],
-            tlsExports: /* @__PURE__ */ new Set(),
-            weakImports: /* @__PURE__ */ new Set()
-          };
-          if (name2 == "dylink") {
-            customSection.memorySize = getLEB();
-            customSection.memoryAlign = getLEB();
-            customSection.tableSize = getLEB();
-            customSection.tableAlign = getLEB();
-            var neededDynlibsCount = getLEB();
-            for (var i2 = 0; i2 < neededDynlibsCount; ++i2) {
-              var libname = getString();
-              customSection.neededDynlibs.push(libname);
-            }
-          } else {
-            failIf(name2 !== "dylink.0");
-            var WASM_DYLINK_MEM_INFO = 1;
-            var WASM_DYLINK_NEEDED = 2;
-            var WASM_DYLINK_EXPORT_INFO = 3;
-            var WASM_DYLINK_IMPORT_INFO = 4;
-            var WASM_SYMBOL_TLS = 256;
-            var WASM_SYMBOL_BINDING_MASK = 3;
-            var WASM_SYMBOL_BINDING_WEAK = 1;
-            while (offset < end) {
-              var subsectionType = getU8();
-              var subsectionSize = getLEB();
-              if (subsectionType === WASM_DYLINK_MEM_INFO) {
-                customSection.memorySize = getLEB();
-                customSection.memoryAlign = getLEB();
-                customSection.tableSize = getLEB();
-                customSection.tableAlign = getLEB();
-              } else if (subsectionType === WASM_DYLINK_NEEDED) {
-                var neededDynlibsCount = getLEB();
-                for (var i2 = 0; i2 < neededDynlibsCount; ++i2) {
-                  libname = getString();
-                  customSection.neededDynlibs.push(libname);
-                }
-              } else if (subsectionType === WASM_DYLINK_EXPORT_INFO) {
-                var count = getLEB();
-                while (count--) {
-                  var symname = getString();
-                  var flags2 = getLEB();
-                  if (flags2 & WASM_SYMBOL_TLS) {
-                    customSection.tlsExports.add(symname);
-                  }
-                }
-              } else if (subsectionType === WASM_DYLINK_IMPORT_INFO) {
-                var count = getLEB();
-                while (count--) {
-                  var modname = getString();
-                  var symname = getString();
-                  var flags2 = getLEB();
-                  if ((flags2 & WASM_SYMBOL_BINDING_MASK) == WASM_SYMBOL_BINDING_WEAK) {
-                    customSection.weakImports.add(symname);
-                  }
-                }
-              } else {
-                offset += subsectionSize;
-              }
-            }
-          }
-          return customSection;
-        }, "getDylinkMetadata");
-        function getValue(ptr, type = "i8") {
-          if (type.endsWith("*")) type = "*";
-          switch (type) {
-            case "i1":
-              return HEAP8[ptr];
-            case "i8":
-              return HEAP8[ptr];
-            case "i16":
-              return LE_HEAP_LOAD_I16((ptr >> 1) * 2);
-            case "i32":
-              return LE_HEAP_LOAD_I32((ptr >> 2) * 4);
-            case "i64":
-              return HEAP64[ptr >> 3];
-            case "float":
-              return LE_HEAP_LOAD_F32((ptr >> 2) * 4);
-            case "double":
-              return LE_HEAP_LOAD_F64((ptr >> 3) * 8);
-            case "*":
-              return LE_HEAP_LOAD_U32((ptr >> 2) * 4);
-            default:
-              abort(`invalid type for getValue: ${type}`);
-          }
-        }
-        __name(getValue, "getValue");
-        var newDSO = /* @__PURE__ */ __name((name2, handle2, syms) => {
-          var dso = {
-            refcount: Infinity,
-            name: name2,
-            exports: syms,
-            global: true
-          };
-          LDSO.loadedLibsByName[name2] = dso;
-          if (handle2 != void 0) {
-            LDSO.loadedLibsByHandle[handle2] = dso;
-          }
-          return dso;
-        }, "newDSO");
-        var LDSO = {
-          loadedLibsByName: {},
-          loadedLibsByHandle: {},
-          init() {
-            newDSO("__main__", 0, wasmImports);
-          }
-        };
-        var ___heap_base = 78224;
-        var alignMemory = /* @__PURE__ */ __name((size, alignment) => Math.ceil(size / alignment) * alignment, "alignMemory");
-        var getMemory = /* @__PURE__ */ __name((size) => {
-          if (runtimeInitialized) {
-            return _calloc(size, 1);
-          }
-          var ret = ___heap_base;
-          var end = ret + alignMemory(size, 16);
-          ___heap_base = end;
-          GOT["__heap_base"].value = end;
-          return ret;
-        }, "getMemory");
-        var isInternalSym = /* @__PURE__ */ __name((symName) => ["__cpp_exception", "__c_longjmp", "__wasm_apply_data_relocs", "__dso_handle", "__tls_size", "__tls_align", "__set_stack_limits", "_emscripten_tls_init", "__wasm_init_tls", "__wasm_call_ctors", "__start_em_asm", "__stop_em_asm", "__start_em_js", "__stop_em_js"].includes(symName) || symName.startsWith("__em_js__"), "isInternalSym");
-        var uleb128Encode = /* @__PURE__ */ __name((n, target) => {
-          if (n < 128) {
-            target.push(n);
-          } else {
-            target.push(n % 128 | 128, n >> 7);
-          }
-        }, "uleb128Encode");
-        var sigToWasmTypes = /* @__PURE__ */ __name((sig) => {
-          var typeNames = {
-            "i": "i32",
-            "j": "i64",
-            "f": "f32",
-            "d": "f64",
-            "e": "externref",
-            "p": "i32"
-          };
-          var type = {
-            parameters: [],
-            results: sig[0] == "v" ? [] : [typeNames[sig[0]]]
-          };
-          for (var i2 = 1; i2 < sig.length; ++i2) {
-            type.parameters.push(typeNames[sig[i2]]);
-          }
-          return type;
-        }, "sigToWasmTypes");
-        var generateFuncType = /* @__PURE__ */ __name((sig, target) => {
-          var sigRet = sig.slice(0, 1);
-          var sigParam = sig.slice(1);
-          var typeCodes = {
-            "i": 127,
-            // i32
-            "p": 127,
-            // i32
-            "j": 126,
-            // i64
-            "f": 125,
-            // f32
-            "d": 124,
-            // f64
-            "e": 111
-          };
-          target.push(96);
-          uleb128Encode(sigParam.length, target);
-          for (var i2 = 0; i2 < sigParam.length; ++i2) {
-            target.push(typeCodes[sigParam[i2]]);
-          }
-          if (sigRet == "v") {
-            target.push(0);
-          } else {
-            target.push(1, typeCodes[sigRet]);
-          }
-        }, "generateFuncType");
-        var convertJsFunctionToWasm = /* @__PURE__ */ __name((func2, sig) => {
-          if (typeof WebAssembly.Function == "function") {
-            return new WebAssembly.Function(sigToWasmTypes(sig), func2);
-          }
-          var typeSectionBody = [1];
-          generateFuncType(sig, typeSectionBody);
-          var bytes = [
-            0,
-            97,
-            115,
-            109,
-            // magic ("\0asm")
-            1,
-            0,
-            0,
-            0,
-            // version: 1
-            1
-          ];
-          uleb128Encode(typeSectionBody.length, bytes);
-          bytes.push(...typeSectionBody);
-          bytes.push(
-            2,
-            7,
-            // import section
-            // (import "e" "f" (func 0 (type 0)))
-            1,
-            1,
-            101,
-            1,
-            102,
-            0,
-            0,
-            7,
-            5,
-            // export section
-            // (export "f" (func 0 (type 0)))
-            1,
-            1,
-            102,
-            0,
-            0
-          );
-          var module2 = new WebAssembly.Module(new Uint8Array(bytes));
-          var instance2 = new WebAssembly.Instance(module2, {
-            "e": {
-              "f": func2
-            }
-          });
-          var wrappedFunc = instance2.exports["f"];
-          return wrappedFunc;
-        }, "convertJsFunctionToWasm");
-        var wasmTableMirror = [];
-        var wasmTable = new WebAssembly.Table({
-          "initial": 31,
-          "element": "anyfunc"
-        });
-        var getWasmTableEntry = /* @__PURE__ */ __name((funcPtr) => {
-          var func2 = wasmTableMirror[funcPtr];
-          if (!func2) {
-            if (funcPtr >= wasmTableMirror.length) wasmTableMirror.length = funcPtr + 1;
-            wasmTableMirror[funcPtr] = func2 = wasmTable.get(funcPtr);
-          }
-          return func2;
-        }, "getWasmTableEntry");
-        var updateTableMap = /* @__PURE__ */ __name((offset, count) => {
-          if (functionsInTableMap) {
-            for (var i2 = offset; i2 < offset + count; i2++) {
-              var item = getWasmTableEntry(i2);
-              if (item) {
-                functionsInTableMap.set(item, i2);
-              }
-            }
-          }
-        }, "updateTableMap");
-        var functionsInTableMap;
-        var getFunctionAddress = /* @__PURE__ */ __name((func2) => {
-          if (!functionsInTableMap) {
-            functionsInTableMap = /* @__PURE__ */ new WeakMap();
-            updateTableMap(0, wasmTable.length);
-          }
-          return functionsInTableMap.get(func2) || 0;
-        }, "getFunctionAddress");
-        var freeTableIndexes = [];
-        var getEmptyTableSlot = /* @__PURE__ */ __name(() => {
-          if (freeTableIndexes.length) {
-            return freeTableIndexes.pop();
-          }
-          try {
-            wasmTable.grow(1);
-          } catch (err2) {
-            if (!(err2 instanceof RangeError)) {
-              throw err2;
-            }
-            throw "Unable to grow wasm table. Set ALLOW_TABLE_GROWTH.";
-          }
-          return wasmTable.length - 1;
-        }, "getEmptyTableSlot");
-        var setWasmTableEntry = /* @__PURE__ */ __name((idx, func2) => {
-          wasmTable.set(idx, func2);
-          wasmTableMirror[idx] = wasmTable.get(idx);
-        }, "setWasmTableEntry");
-        var addFunction = /* @__PURE__ */ __name((func2, sig) => {
-          var rtn = getFunctionAddress(func2);
-          if (rtn) {
-            return rtn;
-          }
-          var ret = getEmptyTableSlot();
-          try {
-            setWasmTableEntry(ret, func2);
-          } catch (err2) {
-            if (!(err2 instanceof TypeError)) {
-              throw err2;
-            }
-            var wrapped = convertJsFunctionToWasm(func2, sig);
-            setWasmTableEntry(ret, wrapped);
-          }
-          functionsInTableMap.set(func2, ret);
-          return ret;
-        }, "addFunction");
-        var updateGOT = /* @__PURE__ */ __name((exports, replace) => {
-          for (var symName in exports) {
-            if (isInternalSym(symName)) {
-              continue;
-            }
-            var value = exports[symName];
-            GOT[symName] ||= new WebAssembly.Global({
-              "value": "i32",
-              "mutable": true
-            });
-            if (replace || GOT[symName].value == 0) {
-              if (typeof value == "function") {
-                GOT[symName].value = addFunction(value);
-              } else if (typeof value == "number") {
-                GOT[symName].value = value;
-              } else {
-                err(`unhandled export type for '${symName}': ${typeof value}`);
-              }
-            }
-          }
-        }, "updateGOT");
-        var relocateExports = /* @__PURE__ */ __name((exports, memoryBase2, replace) => {
-          var relocated = {};
-          for (var e in exports) {
-            var value = exports[e];
-            if (typeof value == "object") {
-              value = value.value;
-            }
-            if (typeof value == "number") {
-              value += memoryBase2;
-            }
-            relocated[e] = value;
-          }
-          updateGOT(relocated, replace);
-          return relocated;
-        }, "relocateExports");
-        var isSymbolDefined = /* @__PURE__ */ __name((symName) => {
-          var existing = wasmImports[symName];
-          if (!existing || existing.stub) {
-            return false;
-          }
-          return true;
-        }, "isSymbolDefined");
-        var dynCall = /* @__PURE__ */ __name((sig, ptr, args2 = []) => {
-          var rtn = getWasmTableEntry(ptr)(...args2);
-          return rtn;
-        }, "dynCall");
-        var stackSave = /* @__PURE__ */ __name(() => _emscripten_stack_get_current(), "stackSave");
-        var stackRestore = /* @__PURE__ */ __name((val) => __emscripten_stack_restore(val), "stackRestore");
-        var createInvokeFunction = /* @__PURE__ */ __name((sig) => (ptr, ...args2) => {
-          var sp = stackSave();
-          try {
-            return dynCall(sig, ptr, args2);
-          } catch (e) {
-            stackRestore(sp);
-            if (e !== e + 0) throw e;
-            _setThrew(1, 0);
-            if (sig[0] == "j") return 0n;
-          }
-        }, "createInvokeFunction");
-        var resolveGlobalSymbol = /* @__PURE__ */ __name((symName, direct = false) => {
-          var sym;
-          if (isSymbolDefined(symName)) {
-            sym = wasmImports[symName];
-          } else if (symName.startsWith("invoke_")) {
-            sym = wasmImports[symName] = createInvokeFunction(symName.split("_")[1]);
-          }
-          return {
-            sym,
-            name: symName
-          };
-        }, "resolveGlobalSymbol");
-        var onPostCtors = [];
-        var addOnPostCtor = /* @__PURE__ */ __name((cb) => onPostCtors.unshift(cb), "addOnPostCtor");
-        var UTF8ToString = /* @__PURE__ */ __name((ptr, maxBytesToRead) => ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "", "UTF8ToString");
-        var loadWebAssemblyModule = /* @__PURE__ */ __name((binary, flags, libName, localScope, handle) => {
-          var metadata = getDylinkMetadata(binary);
-          currentModuleWeakSymbols = metadata.weakImports;
-          function loadModule() {
-            var memAlign = Math.pow(2, metadata.memoryAlign);
-            var memoryBase = metadata.memorySize ? alignMemory(getMemory(metadata.memorySize + memAlign), memAlign) : 0;
-            var tableBase = metadata.tableSize ? wasmTable.length : 0;
-            if (handle) {
-              HEAP8[handle + 8] = 1;
-              LE_HEAP_STORE_U32((handle + 12 >> 2) * 4, memoryBase);
-              LE_HEAP_STORE_I32((handle + 16 >> 2) * 4, metadata.memorySize);
-              LE_HEAP_STORE_U32((handle + 20 >> 2) * 4, tableBase);
-              LE_HEAP_STORE_I32((handle + 24 >> 2) * 4, metadata.tableSize);
-            }
-            if (metadata.tableSize) {
-              wasmTable.grow(metadata.tableSize);
-            }
-            var moduleExports;
-            function resolveSymbol(sym) {
-              var resolved = resolveGlobalSymbol(sym).sym;
-              if (!resolved && localScope) {
-                resolved = localScope[sym];
-              }
-              if (!resolved) {
-                resolved = moduleExports[sym];
-              }
-              return resolved;
-            }
-            __name(resolveSymbol, "resolveSymbol");
-            var proxyHandler = {
-              get(stubs, prop) {
-                switch (prop) {
-                  case "__memory_base":
-                    return memoryBase;
-                  case "__table_base":
-                    return tableBase;
-                }
-                if (prop in wasmImports && !wasmImports[prop].stub) {
-                  var res = wasmImports[prop];
-                  return res;
-                }
-                if (!(prop in stubs)) {
-                  var resolved;
-                  stubs[prop] = (...args2) => {
-                    resolved ||= resolveSymbol(prop);
-                    return resolved(...args2);
-                  };
-                }
-                return stubs[prop];
-              }
-            };
-            var proxy = new Proxy({}, proxyHandler);
-            var info = {
-              "GOT.mem": new Proxy({}, GOTHandler),
-              "GOT.func": new Proxy({}, GOTHandler),
-              "env": proxy,
-              "wasi_snapshot_preview1": proxy
-            };
-            function postInstantiation(module, instance) {
-              updateTableMap(tableBase, metadata.tableSize);
-              moduleExports = relocateExports(instance.exports, memoryBase);
-              if (!flags.allowUndefined) {
-                reportUndefinedSymbols();
-              }
-              function addEmAsm(addr, body) {
-                var args = [];
-                var arity = 0;
-                for (; arity < 16; arity++) {
-                  if (body.indexOf("$" + arity) != -1) {
-                    args.push("$" + arity);
-                  } else {
-                    break;
-                  }
-                }
-                args = args.join(",");
-                var func = `(${args}) => { ${body} };`;
-                ASM_CONSTS[start] = eval(func);
-              }
-              __name(addEmAsm, "addEmAsm");
-              if ("__start_em_asm" in moduleExports) {
-                var start = moduleExports["__start_em_asm"];
-                var stop = moduleExports["__stop_em_asm"];
-                while (start < stop) {
-                  var jsString = UTF8ToString(start);
-                  addEmAsm(start, jsString);
-                  start = HEAPU8.indexOf(0, start) + 1;
-                }
-              }
-              function addEmJs(name, cSig, body) {
-                var jsArgs = [];
-                cSig = cSig.slice(1, -1);
-                if (cSig != "void") {
-                  cSig = cSig.split(",");
-                  for (var i in cSig) {
-                    var jsArg = cSig[i].split(" ").pop();
-                    jsArgs.push(jsArg.replace("*", ""));
-                  }
-                }
-                var func = `(${jsArgs}) => ${body};`;
-                moduleExports[name] = eval(func);
-              }
-              __name(addEmJs, "addEmJs");
-              for (var name in moduleExports) {
-                if (name.startsWith("__em_js__")) {
-                  var start = moduleExports[name];
-                  var jsString = UTF8ToString(start);
-                  var parts = jsString.split("<::>");
-                  addEmJs(name.replace("__em_js__", ""), parts[0], parts[1]);
-                  delete moduleExports[name];
-                }
-              }
-              var applyRelocs = moduleExports["__wasm_apply_data_relocs"];
-              if (applyRelocs) {
-                if (runtimeInitialized) {
-                  applyRelocs();
-                } else {
-                  __RELOC_FUNCS__.push(applyRelocs);
-                }
-              }
-              var init = moduleExports["__wasm_call_ctors"];
-              if (init) {
-                if (runtimeInitialized) {
-                  init();
-                } else {
-                  addOnPostCtor(init);
-                }
-              }
-              return moduleExports;
-            }
-            __name(postInstantiation, "postInstantiation");
-            if (flags.loadAsync) {
-              if (binary instanceof WebAssembly.Module) {
-                var instance = new WebAssembly.Instance(binary, info);
-                return Promise.resolve(postInstantiation(binary, instance));
-              }
-              return WebAssembly.instantiate(binary, info).then((result) => postInstantiation(result.module, result.instance));
-            }
-            var module = binary instanceof WebAssembly.Module ? binary : new WebAssembly.Module(binary);
-            var instance = new WebAssembly.Instance(module, info);
-            return postInstantiation(module, instance);
-          }
-          __name(loadModule, "loadModule");
-          if (flags.loadAsync) {
-            return metadata.neededDynlibs.reduce((chain, dynNeeded) => chain.then(() => loadDynamicLibrary(dynNeeded, flags, localScope)), Promise.resolve()).then(loadModule);
-          }
-          metadata.neededDynlibs.forEach((needed) => loadDynamicLibrary(needed, flags, localScope));
-          return loadModule();
-        }, "loadWebAssemblyModule");
-        var mergeLibSymbols = /* @__PURE__ */ __name((exports, libName2) => {
-          for (var [sym, exp] of Object.entries(exports)) {
-            const setImport = /* @__PURE__ */ __name((target) => {
-              if (!isSymbolDefined(target)) {
-                wasmImports[target] = exp;
-              }
-            }, "setImport");
-            setImport(sym);
-            const main_alias = "__main_argc_argv";
-            if (sym == "main") {
-              setImport(main_alias);
-            }
-            if (sym == main_alias) {
-              setImport("main");
-            }
-          }
-        }, "mergeLibSymbols");
-        var asyncLoad = /* @__PURE__ */ __name(async (url) => {
-          var arrayBuffer = await readAsync(url);
-          return new Uint8Array(arrayBuffer);
-        }, "asyncLoad");
-        function loadDynamicLibrary(libName2, flags2 = {
-          global: true,
-          nodelete: true
-        }, localScope2, handle2) {
-          var dso = LDSO.loadedLibsByName[libName2];
-          if (dso) {
-            if (!flags2.global) {
-              if (localScope2) {
-                Object.assign(localScope2, dso.exports);
-              }
-            } else if (!dso.global) {
-              dso.global = true;
-              mergeLibSymbols(dso.exports, libName2);
-            }
-            if (flags2.nodelete && dso.refcount !== Infinity) {
-              dso.refcount = Infinity;
-            }
-            dso.refcount++;
-            if (handle2) {
-              LDSO.loadedLibsByHandle[handle2] = dso;
-            }
-            return flags2.loadAsync ? Promise.resolve(true) : true;
-          }
-          dso = newDSO(libName2, handle2, "loading");
-          dso.refcount = flags2.nodelete ? Infinity : 1;
-          dso.global = flags2.global;
-          function loadLibData() {
-            if (handle2) {
-              var data = LE_HEAP_LOAD_U32((handle2 + 28 >> 2) * 4);
-              var dataSize = LE_HEAP_LOAD_U32((handle2 + 32 >> 2) * 4);
-              if (data && dataSize) {
-                var libData = HEAP8.slice(data, data + dataSize);
-                return flags2.loadAsync ? Promise.resolve(libData) : libData;
-              }
-            }
-            var libFile = locateFile(libName2);
-            if (flags2.loadAsync) {
-              return asyncLoad(libFile);
-            }
-            if (!readBinary) {
-              throw new Error(`${libFile}: file not found, and synchronous loading of external files is not available`);
-            }
-            return readBinary(libFile);
-          }
-          __name(loadLibData, "loadLibData");
-          function getExports() {
-            if (flags2.loadAsync) {
-              return loadLibData().then((libData) => loadWebAssemblyModule(libData, flags2, libName2, localScope2, handle2));
-            }
-            return loadWebAssemblyModule(loadLibData(), flags2, libName2, localScope2, handle2);
-          }
-          __name(getExports, "getExports");
-          function moduleLoaded(exports) {
-            if (dso.global) {
-              mergeLibSymbols(exports, libName2);
-            } else if (localScope2) {
-              Object.assign(localScope2, exports);
-            }
-            dso.exports = exports;
-          }
-          __name(moduleLoaded, "moduleLoaded");
-          if (flags2.loadAsync) {
-            return getExports().then((exports) => {
-              moduleLoaded(exports);
-              return true;
-            });
-          }
-          moduleLoaded(getExports());
-          return true;
-        }
-        __name(loadDynamicLibrary, "loadDynamicLibrary");
-        var reportUndefinedSymbols = /* @__PURE__ */ __name(() => {
-          for (var [symName, entry] of Object.entries(GOT)) {
-            if (entry.value == 0) {
-              var value = resolveGlobalSymbol(symName, true).sym;
-              if (!value && !entry.required) {
-                continue;
-              }
-              if (typeof value == "function") {
-                entry.value = addFunction(value, value.sig);
-              } else if (typeof value == "number") {
-                entry.value = value;
-              } else {
-                throw new Error(`bad export type for '${symName}': ${typeof value}`);
-              }
-            }
-          }
-        }, "reportUndefinedSymbols");
-        var loadDylibs = /* @__PURE__ */ __name(() => {
-          if (!dynamicLibraries.length) {
-            reportUndefinedSymbols();
-            return;
-          }
-          addRunDependency("loadDylibs");
-          dynamicLibraries.reduce((chain, lib) => chain.then(() => loadDynamicLibrary(lib, {
-            loadAsync: true,
-            global: true,
-            nodelete: true,
-            allowUndefined: true
-          })), Promise.resolve()).then(() => {
-            reportUndefinedSymbols();
-            removeRunDependency("loadDylibs");
-          });
-        }, "loadDylibs");
-        var noExitRuntime = Module["noExitRuntime"] || true;
-        function setValue(ptr, value, type = "i8") {
-          if (type.endsWith("*")) type = "*";
-          switch (type) {
-            case "i1":
-              HEAP8[ptr] = value;
-              break;
-            case "i8":
-              HEAP8[ptr] = value;
-              break;
-            case "i16":
-              LE_HEAP_STORE_I16((ptr >> 1) * 2, value);
-              break;
-            case "i32":
-              LE_HEAP_STORE_I32((ptr >> 2) * 4, value);
-              break;
-            case "i64":
-              HEAP64[ptr >> 3] = BigInt(value);
-              break;
-            case "float":
-              LE_HEAP_STORE_F32((ptr >> 2) * 4, value);
-              break;
-            case "double":
-              LE_HEAP_STORE_F64((ptr >> 3) * 8, value);
-              break;
-            case "*":
-              LE_HEAP_STORE_U32((ptr >> 2) * 4, value);
-              break;
-            default:
-              abort(`invalid type for setValue: ${type}`);
-          }
-        }
-        __name(setValue, "setValue");
-        var ___memory_base = new WebAssembly.Global({
-          "value": "i32",
-          "mutable": false
-        }, 1024);
-        var ___stack_pointer = new WebAssembly.Global({
-          "value": "i32",
-          "mutable": true
-        }, 78224);
-        var ___table_base = new WebAssembly.Global({
-          "value": "i32",
-          "mutable": false
-        }, 1);
-        var __abort_js = /* @__PURE__ */ __name(() => abort(""), "__abort_js");
-        __abort_js.sig = "v";
-        var _emscripten_get_now = /* @__PURE__ */ __name(() => performance.now(), "_emscripten_get_now");
-        _emscripten_get_now.sig = "d";
-        var _emscripten_date_now = /* @__PURE__ */ __name(() => Date.now(), "_emscripten_date_now");
-        _emscripten_date_now.sig = "d";
-        var nowIsMonotonic = 1;
-        var checkWasiClock = /* @__PURE__ */ __name((clock_id) => clock_id >= 0 && clock_id <= 3, "checkWasiClock");
-        var INT53_MAX = 9007199254740992;
-        var INT53_MIN = -9007199254740992;
-        var bigintToI53Checked = /* @__PURE__ */ __name((num) => num < INT53_MIN || num > INT53_MAX ? NaN : Number(num), "bigintToI53Checked");
-        function _clock_time_get(clk_id, ignored_precision, ptime) {
-          ignored_precision = bigintToI53Checked(ignored_precision);
-          if (!checkWasiClock(clk_id)) {
-            return 28;
-          }
-          var now;
-          if (clk_id === 0) {
-            now = _emscripten_date_now();
-          } else if (nowIsMonotonic) {
-            now = _emscripten_get_now();
-          } else {
-            return 52;
-          }
-          var nsec = Math.round(now * 1e3 * 1e3);
-          HEAP64[ptime >> 3] = BigInt(nsec);
-          return 0;
-        }
-        __name(_clock_time_get, "_clock_time_get");
-        _clock_time_get.sig = "iijp";
-        var getHeapMax = /* @__PURE__ */ __name(() => (
-          // Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate
-          // full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side
-          // for any code that deals with heap sizes, which would require special
-          // casing all heap size related code to treat 0 specially.
-          2147483648
-        ), "getHeapMax");
-        var growMemory = /* @__PURE__ */ __name((size) => {
-          var b = wasmMemory.buffer;
-          var pages = (size - b.byteLength + 65535) / 65536 | 0;
-          try {
-            wasmMemory.grow(pages);
-            updateMemoryViews();
-            return 1;
-          } catch (e) {
-          }
-        }, "growMemory");
-        var _emscripten_resize_heap = /* @__PURE__ */ __name((requestedSize) => {
-          var oldSize = HEAPU8.length;
-          requestedSize >>>= 0;
-          var maxHeapSize = getHeapMax();
-          if (requestedSize > maxHeapSize) {
-            return false;
-          }
-          for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
-            var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown);
-            overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
-            var newSize = Math.min(maxHeapSize, alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536));
-            var replacement = growMemory(newSize);
-            if (replacement) {
-              return true;
-            }
-          }
-          return false;
-        }, "_emscripten_resize_heap");
-        _emscripten_resize_heap.sig = "ip";
-        var _fd_close = /* @__PURE__ */ __name((fd) => 52, "_fd_close");
-        _fd_close.sig = "ii";
-        function _fd_seek(fd, offset, whence, newOffset) {
-          offset = bigintToI53Checked(offset);
-          return 70;
-        }
-        __name(_fd_seek, "_fd_seek");
-        _fd_seek.sig = "iijip";
-        var printCharBuffers = [null, [], []];
-        var printChar = /* @__PURE__ */ __name((stream, curr) => {
-          var buffer = printCharBuffers[stream];
-          if (curr === 0 || curr === 10) {
-            (stream === 1 ? out : err)(UTF8ArrayToString(buffer));
-            buffer.length = 0;
-          } else {
-            buffer.push(curr);
-          }
-        }, "printChar");
-        var flush_NO_FILESYSTEM = /* @__PURE__ */ __name(() => {
-          if (printCharBuffers[1].length) printChar(1, 10);
-          if (printCharBuffers[2].length) printChar(2, 10);
-        }, "flush_NO_FILESYSTEM");
-        var SYSCALLS = {
-          varargs: void 0,
-          getStr(ptr) {
-            var ret = UTF8ToString(ptr);
-            return ret;
-          }
-        };
-        var _fd_write = /* @__PURE__ */ __name((fd, iov, iovcnt, pnum) => {
-          var num = 0;
-          for (var i2 = 0; i2 < iovcnt; i2++) {
-            var ptr = LE_HEAP_LOAD_U32((iov >> 2) * 4);
-            var len = LE_HEAP_LOAD_U32((iov + 4 >> 2) * 4);
-            iov += 8;
-            for (var j = 0; j < len; j++) {
-              printChar(fd, HEAPU8[ptr + j]);
-            }
-            num += len;
-          }
-          LE_HEAP_STORE_U32((pnum >> 2) * 4, num);
-          return 0;
-        }, "_fd_write");
-        _fd_write.sig = "iippp";
-        function _tree_sitter_log_callback(isLexMessage, messageAddress) {
-          if (Module.currentLogCallback) {
-            const message = UTF8ToString(messageAddress);
-            Module.currentLogCallback(message, isLexMessage !== 0);
-          }
-        }
-        __name(_tree_sitter_log_callback, "_tree_sitter_log_callback");
-        function _tree_sitter_parse_callback(inputBufferAddress, index, row, column, lengthAddress) {
-          const INPUT_BUFFER_SIZE = 10 * 1024;
-          const string = Module.currentParseCallback(index, {
-            row,
-            column
-          });
-          if (typeof string === "string") {
-            setValue(lengthAddress, string.length, "i32");
-            stringToUTF16(string, inputBufferAddress, INPUT_BUFFER_SIZE);
-          } else {
-            setValue(lengthAddress, 0, "i32");
-          }
-        }
-        __name(_tree_sitter_parse_callback, "_tree_sitter_parse_callback");
-        function _tree_sitter_progress_callback(currentOffset, hasError) {
-          if (Module.currentProgressCallback) {
-            return Module.currentProgressCallback({
-              currentOffset,
-              hasError
-            });
-          }
-          return false;
-        }
-        __name(_tree_sitter_progress_callback, "_tree_sitter_progress_callback");
-        function _tree_sitter_query_progress_callback(currentOffset) {
-          if (Module.currentQueryProgressCallback) {
-            return Module.currentQueryProgressCallback({
-              currentOffset
-            });
-          }
-          return false;
-        }
-        __name(_tree_sitter_query_progress_callback, "_tree_sitter_query_progress_callback");
-        var runtimeKeepaliveCounter = 0;
-        var keepRuntimeAlive = /* @__PURE__ */ __name(() => noExitRuntime || runtimeKeepaliveCounter > 0, "keepRuntimeAlive");
-        var _proc_exit = /* @__PURE__ */ __name((code) => {
-          EXITSTATUS = code;
-          if (!keepRuntimeAlive()) {
-            Module["onExit"]?.(code);
-            ABORT = true;
-          }
-          quit_(code, new ExitStatus(code));
-        }, "_proc_exit");
-        _proc_exit.sig = "vi";
-        var exitJS = /* @__PURE__ */ __name((status, implicit) => {
-          EXITSTATUS = status;
-          _proc_exit(status);
-        }, "exitJS");
-        var handleException = /* @__PURE__ */ __name((e) => {
-          if (e instanceof ExitStatus || e == "unwind") {
-            return EXITSTATUS;
-          }
-          quit_(1, e);
-        }, "handleException");
-        var lengthBytesUTF8 = /* @__PURE__ */ __name((str) => {
-          var len = 0;
-          for (var i2 = 0; i2 < str.length; ++i2) {
-            var c = str.charCodeAt(i2);
-            if (c <= 127) {
-              len++;
-            } else if (c <= 2047) {
-              len += 2;
-            } else if (c >= 55296 && c <= 57343) {
-              len += 4;
-              ++i2;
-            } else {
-              len += 3;
-            }
-          }
-          return len;
-        }, "lengthBytesUTF8");
-        var stringToUTF8Array = /* @__PURE__ */ __name((str, heap, outIdx, maxBytesToWrite) => {
-          if (!(maxBytesToWrite > 0)) return 0;
-          var startIdx = outIdx;
-          var endIdx = outIdx + maxBytesToWrite - 1;
-          for (var i2 = 0; i2 < str.length; ++i2) {
-            var u = str.charCodeAt(i2);
-            if (u >= 55296 && u <= 57343) {
-              var u1 = str.charCodeAt(++i2);
-              u = 65536 + ((u & 1023) << 10) | u1 & 1023;
-            }
-            if (u <= 127) {
-              if (outIdx >= endIdx) break;
-              heap[outIdx++] = u;
-            } else if (u <= 2047) {
-              if (outIdx + 1 >= endIdx) break;
-              heap[outIdx++] = 192 | u >> 6;
-              heap[outIdx++] = 128 | u & 63;
-            } else if (u <= 65535) {
-              if (outIdx + 2 >= endIdx) break;
-              heap[outIdx++] = 224 | u >> 12;
-              heap[outIdx++] = 128 | u >> 6 & 63;
-              heap[outIdx++] = 128 | u & 63;
-            } else {
-              if (outIdx + 3 >= endIdx) break;
-              heap[outIdx++] = 240 | u >> 18;
-              heap[outIdx++] = 128 | u >> 12 & 63;
-              heap[outIdx++] = 128 | u >> 6 & 63;
-              heap[outIdx++] = 128 | u & 63;
-            }
-          }
-          heap[outIdx] = 0;
-          return outIdx - startIdx;
-        }, "stringToUTF8Array");
-        var stringToUTF8 = /* @__PURE__ */ __name((str, outPtr, maxBytesToWrite) => stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite), "stringToUTF8");
-        var stackAlloc = /* @__PURE__ */ __name((sz) => __emscripten_stack_alloc(sz), "stackAlloc");
-        var stringToUTF8OnStack = /* @__PURE__ */ __name((str) => {
-          var size = lengthBytesUTF8(str) + 1;
-          var ret = stackAlloc(size);
-          stringToUTF8(str, ret, size);
-          return ret;
-        }, "stringToUTF8OnStack");
-        var AsciiToString = /* @__PURE__ */ __name((ptr) => {
-          var str = "";
-          while (1) {
-            var ch = HEAPU8[ptr++];
-            if (!ch) return str;
-            str += String.fromCharCode(ch);
-          }
-        }, "AsciiToString");
-        var stringToUTF16 = /* @__PURE__ */ __name((str, outPtr, maxBytesToWrite) => {
-          maxBytesToWrite ??= 2147483647;
-          if (maxBytesToWrite < 2) return 0;
-          maxBytesToWrite -= 2;
-          var startPtr = outPtr;
-          var numCharsToWrite = maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length;
-          for (var i2 = 0; i2 < numCharsToWrite; ++i2) {
-            var codeUnit = str.charCodeAt(i2);
-            LE_HEAP_STORE_I16((outPtr >> 1) * 2, codeUnit);
-            outPtr += 2;
-          }
-          LE_HEAP_STORE_I16((outPtr >> 1) * 2, 0);
-          return outPtr - startPtr;
-        }, "stringToUTF16");
-        var wasmImports = {
-          /** @export */
-          __heap_base: ___heap_base,
-          /** @export */
-          __indirect_function_table: wasmTable,
-          /** @export */
-          __memory_base: ___memory_base,
-          /** @export */
-          __stack_pointer: ___stack_pointer,
-          /** @export */
-          __table_base: ___table_base,
-          /** @export */
-          _abort_js: __abort_js,
-          /** @export */
-          clock_time_get: _clock_time_get,
-          /** @export */
-          emscripten_resize_heap: _emscripten_resize_heap,
-          /** @export */
-          fd_close: _fd_close,
-          /** @export */
-          fd_seek: _fd_seek,
-          /** @export */
-          fd_write: _fd_write,
-          /** @export */
-          memory: wasmMemory,
-          /** @export */
-          tree_sitter_log_callback: _tree_sitter_log_callback,
-          /** @export */
-          tree_sitter_parse_callback: _tree_sitter_parse_callback,
-          /** @export */
-          tree_sitter_progress_callback: _tree_sitter_progress_callback,
-          /** @export */
-          tree_sitter_query_progress_callback: _tree_sitter_query_progress_callback
-        };
-        var wasmExports = await createWasm();
-        var ___wasm_call_ctors = wasmExports["__wasm_call_ctors"];
-        var _malloc = Module["_malloc"] = wasmExports["malloc"];
-        var _calloc = Module["_calloc"] = wasmExports["calloc"];
-        var _realloc = Module["_realloc"] = wasmExports["realloc"];
-        var _free = Module["_free"] = wasmExports["free"];
-        var _memcmp = Module["_memcmp"] = wasmExports["memcmp"];
-        var _ts_language_symbol_count = Module["_ts_language_symbol_count"] = wasmExports["ts_language_symbol_count"];
-        var _ts_language_state_count = Module["_ts_language_state_count"] = wasmExports["ts_language_state_count"];
-        var _ts_language_version = Module["_ts_language_version"] = wasmExports["ts_language_version"];
-        var _ts_language_abi_version = Module["_ts_language_abi_version"] = wasmExports["ts_language_abi_version"];
-        var _ts_language_metadata = Module["_ts_language_metadata"] = wasmExports["ts_language_metadata"];
-        var _ts_language_name = Module["_ts_language_name"] = wasmExports["ts_language_name"];
-        var _ts_language_field_count = Module["_ts_language_field_count"] = wasmExports["ts_language_field_count"];
-        var _ts_language_next_state = Module["_ts_language_next_state"] = wasmExports["ts_language_next_state"];
-        var _ts_language_symbol_name = Module["_ts_language_symbol_name"] = wasmExports["ts_language_symbol_name"];
-        var _ts_language_symbol_for_name = Module["_ts_language_symbol_for_name"] = wasmExports["ts_language_symbol_for_name"];
-        var _strncmp = Module["_strncmp"] = wasmExports["strncmp"];
-        var _ts_language_symbol_type = Module["_ts_language_symbol_type"] = wasmExports["ts_language_symbol_type"];
-        var _ts_language_field_name_for_id = Module["_ts_language_field_name_for_id"] = wasmExports["ts_language_field_name_for_id"];
-        var _ts_lookahead_iterator_new = Module["_ts_lookahead_iterator_new"] = wasmExports["ts_lookahead_iterator_new"];
-        var _ts_lookahead_iterator_delete = Module["_ts_lookahead_iterator_delete"] = wasmExports["ts_lookahead_iterator_delete"];
-        var _ts_lookahead_iterator_reset_state = Module["_ts_lookahead_iterator_reset_state"] = wasmExports["ts_lookahead_iterator_reset_state"];
-        var _ts_lookahead_iterator_reset = Module["_ts_lookahead_iterator_reset"] = wasmExports["ts_lookahead_iterator_reset"];
-        var _ts_lookahead_iterator_next = Module["_ts_lookahead_iterator_next"] = wasmExports["ts_lookahead_iterator_next"];
-        var _ts_lookahead_iterator_current_symbol = Module["_ts_lookahead_iterator_current_symbol"] = wasmExports["ts_lookahead_iterator_current_symbol"];
-        var _ts_parser_delete = Module["_ts_parser_delete"] = wasmExports["ts_parser_delete"];
-        var _ts_parser_reset = Module["_ts_parser_reset"] = wasmExports["ts_parser_reset"];
-        var _ts_parser_set_language = Module["_ts_parser_set_language"] = wasmExports["ts_parser_set_language"];
-        var _ts_parser_timeout_micros = Module["_ts_parser_timeout_micros"] = wasmExports["ts_parser_timeout_micros"];
-        var _ts_parser_set_timeout_micros = Module["_ts_parser_set_timeout_micros"] = wasmExports["ts_parser_set_timeout_micros"];
-        var _ts_parser_set_included_ranges = Module["_ts_parser_set_included_ranges"] = wasmExports["ts_parser_set_included_ranges"];
-        var _ts_query_new = Module["_ts_query_new"] = wasmExports["ts_query_new"];
-        var _ts_query_delete = Module["_ts_query_delete"] = wasmExports["ts_query_delete"];
-        var _iswspace = Module["_iswspace"] = wasmExports["iswspace"];
-        var _iswalnum = Module["_iswalnum"] = wasmExports["iswalnum"];
-        var _ts_query_pattern_count = Module["_ts_query_pattern_count"] = wasmExports["ts_query_pattern_count"];
-        var _ts_query_capture_count = Module["_ts_query_capture_count"] = wasmExports["ts_query_capture_count"];
-        var _ts_query_string_count = Module["_ts_query_string_count"] = wasmExports["ts_query_string_count"];
-        var _ts_query_capture_name_for_id = Module["_ts_query_capture_name_for_id"] = wasmExports["ts_query_capture_name_for_id"];
-        var _ts_query_capture_quantifier_for_id = Module["_ts_query_capture_quantifier_for_id"] = wasmExports["ts_query_capture_quantifier_for_id"];
-        var _ts_query_string_value_for_id = Module["_ts_query_string_value_for_id"] = wasmExports["ts_query_string_value_for_id"];
-        var _ts_query_predicates_for_pattern = Module["_ts_query_predicates_for_pattern"] = wasmExports["ts_query_predicates_for_pattern"];
-        var _ts_query_start_byte_for_pattern = Module["_ts_query_start_byte_for_pattern"] = wasmExports["ts_query_start_byte_for_pattern"];
-        var _ts_query_end_byte_for_pattern = Module["_ts_query_end_byte_for_pattern"] = wasmExports["ts_query_end_byte_for_pattern"];
-        var _ts_query_is_pattern_rooted = Module["_ts_query_is_pattern_rooted"] = wasmExports["ts_query_is_pattern_rooted"];
-        var _ts_query_is_pattern_non_local = Module["_ts_query_is_pattern_non_local"] = wasmExports["ts_query_is_pattern_non_local"];
-        var _ts_query_is_pattern_guaranteed_at_step = Module["_ts_query_is_pattern_guaranteed_at_step"] = wasmExports["ts_query_is_pattern_guaranteed_at_step"];
-        var _ts_query_disable_capture = Module["_ts_query_disable_capture"] = wasmExports["ts_query_disable_capture"];
-        var _ts_query_disable_pattern = Module["_ts_query_disable_pattern"] = wasmExports["ts_query_disable_pattern"];
-        var _ts_tree_copy = Module["_ts_tree_copy"] = wasmExports["ts_tree_copy"];
-        var _ts_tree_delete = Module["_ts_tree_delete"] = wasmExports["ts_tree_delete"];
-        var _ts_init = Module["_ts_init"] = wasmExports["ts_init"];
-        var _ts_parser_new_wasm = Module["_ts_parser_new_wasm"] = wasmExports["ts_parser_new_wasm"];
-        var _ts_parser_enable_logger_wasm = Module["_ts_parser_enable_logger_wasm"] = wasmExports["ts_parser_enable_logger_wasm"];
-        var _ts_parser_parse_wasm = Module["_ts_parser_parse_wasm"] = wasmExports["ts_parser_parse_wasm"];
-        var _ts_parser_included_ranges_wasm = Module["_ts_parser_included_ranges_wasm"] = wasmExports["ts_parser_included_ranges_wasm"];
-        var _ts_language_type_is_named_wasm = Module["_ts_language_type_is_named_wasm"] = wasmExports["ts_language_type_is_named_wasm"];
-        var _ts_language_type_is_visible_wasm = Module["_ts_language_type_is_visible_wasm"] = wasmExports["ts_language_type_is_visible_wasm"];
-        var _ts_language_supertypes_wasm = Module["_ts_language_supertypes_wasm"] = wasmExports["ts_language_supertypes_wasm"];
-        var _ts_language_subtypes_wasm = Module["_ts_language_subtypes_wasm"] = wasmExports["ts_language_subtypes_wasm"];
-        var _ts_tree_root_node_wasm = Module["_ts_tree_root_node_wasm"] = wasmExports["ts_tree_root_node_wasm"];
-        var _ts_tree_root_node_with_offset_wasm = Module["_ts_tree_root_node_with_offset_wasm"] = wasmExports["ts_tree_root_node_with_offset_wasm"];
-        var _ts_tree_edit_wasm = Module["_ts_tree_edit_wasm"] = wasmExports["ts_tree_edit_wasm"];
-        var _ts_tree_included_ranges_wasm = Module["_ts_tree_included_ranges_wasm"] = wasmExports["ts_tree_included_ranges_wasm"];
-        var _ts_tree_get_changed_ranges_wasm = Module["_ts_tree_get_changed_ranges_wasm"] = wasmExports["ts_tree_get_changed_ranges_wasm"];
-        var _ts_tree_cursor_new_wasm = Module["_ts_tree_cursor_new_wasm"] = wasmExports["ts_tree_cursor_new_wasm"];
-        var _ts_tree_cursor_copy_wasm = Module["_ts_tree_cursor_copy_wasm"] = wasmExports["ts_tree_cursor_copy_wasm"];
-        var _ts_tree_cursor_delete_wasm = Module["_ts_tree_cursor_delete_wasm"] = wasmExports["ts_tree_cursor_delete_wasm"];
-        var _ts_tree_cursor_reset_wasm = Module["_ts_tree_cursor_reset_wasm"] = wasmExports["ts_tree_cursor_reset_wasm"];
-        var _ts_tree_cursor_reset_to_wasm = Module["_ts_tree_cursor_reset_to_wasm"] = wasmExports["ts_tree_cursor_reset_to_wasm"];
-        var _ts_tree_cursor_goto_first_child_wasm = Module["_ts_tree_cursor_goto_first_child_wasm"] = wasmExports["ts_tree_cursor_goto_first_child_wasm"];
-        var _ts_tree_cursor_goto_last_child_wasm = Module["_ts_tree_cursor_goto_last_child_wasm"] = wasmExports["ts_tree_cursor_goto_last_child_wasm"];
-        var _ts_tree_cursor_goto_first_child_for_index_wasm = Module["_ts_tree_cursor_goto_first_child_for_index_wasm"] = wasmExports["ts_tree_cursor_goto_first_child_for_index_wasm"];
-        var _ts_tree_cursor_goto_first_child_for_position_wasm = Module["_ts_tree_cursor_goto_first_child_for_position_wasm"] = wasmExports["ts_tree_cursor_goto_first_child_for_position_wasm"];
-        var _ts_tree_cursor_goto_next_sibling_wasm = Module["_ts_tree_cursor_goto_next_sibling_wasm"] = wasmExports["ts_tree_cursor_goto_next_sibling_wasm"];
-        var _ts_tree_cursor_goto_previous_sibling_wasm = Module["_ts_tree_cursor_goto_previous_sibling_wasm"] = wasmExports["ts_tree_cursor_goto_previous_sibling_wasm"];
-        var _ts_tree_cursor_goto_descendant_wasm = Module["_ts_tree_cursor_goto_descendant_wasm"] = wasmExports["ts_tree_cursor_goto_descendant_wasm"];
-        var _ts_tree_cursor_goto_parent_wasm = Module["_ts_tree_cursor_goto_parent_wasm"] = wasmExports["ts_tree_cursor_goto_parent_wasm"];
-        var _ts_tree_cursor_current_node_type_id_wasm = Module["_ts_tree_cursor_current_node_type_id_wasm"] = wasmExports["ts_tree_cursor_current_node_type_id_wasm"];
-        var _ts_tree_cursor_current_node_state_id_wasm = Module["_ts_tree_cursor_current_node_state_id_wasm"] = wasmExports["ts_tree_cursor_current_node_state_id_wasm"];
-        var _ts_tree_cursor_current_node_is_named_wasm = Module["_ts_tree_cursor_current_node_is_named_wasm"] = wasmExports["ts_tree_cursor_current_node_is_named_wasm"];
-        var _ts_tree_cursor_current_node_is_missing_wasm = Module["_ts_tree_cursor_current_node_is_missing_wasm"] = wasmExports["ts_tree_cursor_current_node_is_missing_wasm"];
-        var _ts_tree_cursor_current_node_id_wasm = Module["_ts_tree_cursor_current_node_id_wasm"] = wasmExports["ts_tree_cursor_current_node_id_wasm"];
-        var _ts_tree_cursor_start_position_wasm = Module["_ts_tree_cursor_start_position_wasm"] = wasmExports["ts_tree_cursor_start_position_wasm"];
-        var _ts_tree_cursor_end_position_wasm = Module["_ts_tree_cursor_end_position_wasm"] = wasmExports["ts_tree_cursor_end_position_wasm"];
-        var _ts_tree_cursor_start_index_wasm = Module["_ts_tree_cursor_start_index_wasm"] = wasmExports["ts_tree_cursor_start_index_wasm"];
-        var _ts_tree_cursor_end_index_wasm = Module["_ts_tree_cursor_end_index_wasm"] = wasmExports["ts_tree_cursor_end_index_wasm"];
-        var _ts_tree_cursor_current_field_id_wasm = Module["_ts_tree_cursor_current_field_id_wasm"] = wasmExports["ts_tree_cursor_current_field_id_wasm"];
-        var _ts_tree_cursor_current_depth_wasm = Module["_ts_tree_cursor_current_depth_wasm"] = wasmExports["ts_tree_cursor_current_depth_wasm"];
-        var _ts_tree_cursor_current_descendant_index_wasm = Module["_ts_tree_cursor_current_descendant_index_wasm"] = wasmExports["ts_tree_cursor_current_descendant_index_wasm"];
-        var _ts_tree_cursor_current_node_wasm = Module["_ts_tree_cursor_current_node_wasm"] = wasmExports["ts_tree_cursor_current_node_wasm"];
-        var _ts_node_symbol_wasm = Module["_ts_node_symbol_wasm"] = wasmExports["ts_node_symbol_wasm"];
-        var _ts_node_field_name_for_child_wasm = Module["_ts_node_field_name_for_child_wasm"] = wasmExports["ts_node_field_name_for_child_wasm"];
-        var _ts_node_field_name_for_named_child_wasm = Module["_ts_node_field_name_for_named_child_wasm"] = wasmExports["ts_node_field_name_for_named_child_wasm"];
-        var _ts_node_children_by_field_id_wasm = Module["_ts_node_children_by_field_id_wasm"] = wasmExports["ts_node_children_by_field_id_wasm"];
-        var _ts_node_first_child_for_byte_wasm = Module["_ts_node_first_child_for_byte_wasm"] = wasmExports["ts_node_first_child_for_byte_wasm"];
-        var _ts_node_first_named_child_for_byte_wasm = Module["_ts_node_first_named_child_for_byte_wasm"] = wasmExports["ts_node_first_named_child_for_byte_wasm"];
-        var _ts_node_grammar_symbol_wasm = Module["_ts_node_grammar_symbol_wasm"] = wasmExports["ts_node_grammar_symbol_wasm"];
-        var _ts_node_child_count_wasm = Module["_ts_node_child_count_wasm"] = wasmExports["ts_node_child_count_wasm"];
-        var _ts_node_named_child_count_wasm = Module["_ts_node_named_child_count_wasm"] = wasmExports["ts_node_named_child_count_wasm"];
-        var _ts_node_child_wasm = Module["_ts_node_child_wasm"] = wasmExports["ts_node_child_wasm"];
-        var _ts_node_named_child_wasm = Module["_ts_node_named_child_wasm"] = wasmExports["ts_node_named_child_wasm"];
-        var _ts_node_child_by_field_id_wasm = Module["_ts_node_child_by_field_id_wasm"] = wasmExports["ts_node_child_by_field_id_wasm"];
-        var _ts_node_next_sibling_wasm = Module["_ts_node_next_sibling_wasm"] = wasmExports["ts_node_next_sibling_wasm"];
-        var _ts_node_prev_sibling_wasm = Module["_ts_node_prev_sibling_wasm"] = wasmExports["ts_node_prev_sibling_wasm"];
-        var _ts_node_next_named_sibling_wasm = Module["_ts_node_next_named_sibling_wasm"] = wasmExports["ts_node_next_named_sibling_wasm"];
-        var _ts_node_prev_named_sibling_wasm = Module["_ts_node_prev_named_sibling_wasm"] = wasmExports["ts_node_prev_named_sibling_wasm"];
-        var _ts_node_descendant_count_wasm = Module["_ts_node_descendant_count_wasm"] = wasmExports["ts_node_descendant_count_wasm"];
-        var _ts_node_parent_wasm = Module["_ts_node_parent_wasm"] = wasmExports["ts_node_parent_wasm"];
-        var _ts_node_child_with_descendant_wasm = Module["_ts_node_child_with_descendant_wasm"] = wasmExports["ts_node_child_with_descendant_wasm"];
-        var _ts_node_descendant_for_index_wasm = Module["_ts_node_descendant_for_index_wasm"] = wasmExports["ts_node_descendant_for_index_wasm"];
-        var _ts_node_named_descendant_for_index_wasm = Module["_ts_node_named_descendant_for_index_wasm"] = wasmExports["ts_node_named_descendant_for_index_wasm"];
-        var _ts_node_descendant_for_position_wasm = Module["_ts_node_descendant_for_position_wasm"] = wasmExports["ts_node_descendant_for_position_wasm"];
-        var _ts_node_named_descendant_for_position_wasm = Module["_ts_node_named_descendant_for_position_wasm"] = wasmExports["ts_node_named_descendant_for_position_wasm"];
-        var _ts_node_start_point_wasm = Module["_ts_node_start_point_wasm"] = wasmExports["ts_node_start_point_wasm"];
-        var _ts_node_end_point_wasm = Module["_ts_node_end_point_wasm"] = wasmExports["ts_node_end_point_wasm"];
-        var _ts_node_start_index_wasm = Module["_ts_node_start_index_wasm"] = wasmExports["ts_node_start_index_wasm"];
-        var _ts_node_end_index_wasm = Module["_ts_node_end_index_wasm"] = wasmExports["ts_node_end_index_wasm"];
-        var _ts_node_to_string_wasm = Module["_ts_node_to_string_wasm"] = wasmExports["ts_node_to_string_wasm"];
-        var _ts_node_children_wasm = Module["_ts_node_children_wasm"] = wasmExports["ts_node_children_wasm"];
-        var _ts_node_named_children_wasm = Module["_ts_node_named_children_wasm"] = wasmExports["ts_node_named_children_wasm"];
-        var _ts_node_descendants_of_type_wasm = Module["_ts_node_descendants_of_type_wasm"] = wasmExports["ts_node_descendants_of_type_wasm"];
-        var _ts_node_is_named_wasm = Module["_ts_node_is_named_wasm"] = wasmExports["ts_node_is_named_wasm"];
-        var _ts_node_has_changes_wasm = Module["_ts_node_has_changes_wasm"] = wasmExports["ts_node_has_changes_wasm"];
-        var _ts_node_has_error_wasm = Module["_ts_node_has_error_wasm"] = wasmExports["ts_node_has_error_wasm"];
-        var _ts_node_is_error_wasm = Module["_ts_node_is_error_wasm"] = wasmExports["ts_node_is_error_wasm"];
-        var _ts_node_is_missing_wasm = Module["_ts_node_is_missing_wasm"] = wasmExports["ts_node_is_missing_wasm"];
-        var _ts_node_is_extra_wasm = Module["_ts_node_is_extra_wasm"] = wasmExports["ts_node_is_extra_wasm"];
-        var _ts_node_parse_state_wasm = Module["_ts_node_parse_state_wasm"] = wasmExports["ts_node_parse_state_wasm"];
-        var _ts_node_next_parse_state_wasm = Module["_ts_node_next_parse_state_wasm"] = wasmExports["ts_node_next_parse_state_wasm"];
-        var _ts_query_matches_wasm = Module["_ts_query_matches_wasm"] = wasmExports["ts_query_matches_wasm"];
-        var _ts_query_captures_wasm = Module["_ts_query_captures_wasm"] = wasmExports["ts_query_captures_wasm"];
-        var _memset = Module["_memset"] = wasmExports["memset"];
-        var _memcpy = Module["_memcpy"] = wasmExports["memcpy"];
-        var _memmove = Module["_memmove"] = wasmExports["memmove"];
-        var _iswalpha = Module["_iswalpha"] = wasmExports["iswalpha"];
-        var _iswblank = Module["_iswblank"] = wasmExports["iswblank"];
-        var _iswdigit = Module["_iswdigit"] = wasmExports["iswdigit"];
-        var _iswlower = Module["_iswlower"] = wasmExports["iswlower"];
-        var _iswupper = Module["_iswupper"] = wasmExports["iswupper"];
-        var _iswxdigit = Module["_iswxdigit"] = wasmExports["iswxdigit"];
-        var _memchr = Module["_memchr"] = wasmExports["memchr"];
-        var _strlen = Module["_strlen"] = wasmExports["strlen"];
-        var _strcmp = Module["_strcmp"] = wasmExports["strcmp"];
-        var _strncat = Module["_strncat"] = wasmExports["strncat"];
-        var _strncpy = Module["_strncpy"] = wasmExports["strncpy"];
-        var _towlower = Module["_towlower"] = wasmExports["towlower"];
-        var _towupper = Module["_towupper"] = wasmExports["towupper"];
-        var _setThrew = wasmExports["setThrew"];
-        var __emscripten_stack_restore = wasmExports["_emscripten_stack_restore"];
-        var __emscripten_stack_alloc = wasmExports["_emscripten_stack_alloc"];
-        var _emscripten_stack_get_current = wasmExports["emscripten_stack_get_current"];
-        var ___wasm_apply_data_relocs = wasmExports["__wasm_apply_data_relocs"];
-        Module["setValue"] = setValue;
-        Module["getValue"] = getValue;
-        Module["UTF8ToString"] = UTF8ToString;
-        Module["stringToUTF8"] = stringToUTF8;
-        Module["lengthBytesUTF8"] = lengthBytesUTF8;
-        Module["AsciiToString"] = AsciiToString;
-        Module["stringToUTF16"] = stringToUTF16;
-        Module["loadWebAssemblyModule"] = loadWebAssemblyModule;
-        function callMain(args2 = []) {
-          var entryFunction = resolveGlobalSymbol("main").sym;
-          if (!entryFunction) return;
-          args2.unshift(thisProgram);
-          var argc = args2.length;
-          var argv = stackAlloc((argc + 1) * 4);
-          var argv_ptr = argv;
-          args2.forEach((arg) => {
-            LE_HEAP_STORE_U32((argv_ptr >> 2) * 4, stringToUTF8OnStack(arg));
-            argv_ptr += 4;
-          });
-          LE_HEAP_STORE_U32((argv_ptr >> 2) * 4, 0);
-          try {
-            var ret = entryFunction(argc, argv);
-            exitJS(
-              ret,
-              /* implicit = */
-              true
-            );
-            return ret;
-          } catch (e) {
-            return handleException(e);
-          }
-        }
-        __name(callMain, "callMain");
-        function run(args2 = arguments_) {
-          if (runDependencies > 0) {
-            dependenciesFulfilled = run;
-            return;
-          }
-          preRun();
-          if (runDependencies > 0) {
-            dependenciesFulfilled = run;
-            return;
-          }
-          function doRun() {
-            Module["calledRun"] = true;
-            if (ABORT) return;
-            initRuntime();
-            preMain();
-            readyPromiseResolve(Module);
-            Module["onRuntimeInitialized"]?.();
-            var noInitialRun = Module["noInitialRun"];
-            if (!noInitialRun) callMain(args2);
-            postRun();
-          }
-          __name(doRun, "doRun");
-          if (Module["setStatus"]) {
-            Module["setStatus"]("Running...");
-            setTimeout(() => {
-              setTimeout(() => Module["setStatus"](""), 1);
-              doRun();
-            }, 1);
-          } else {
-            doRun();
-          }
-        }
-        __name(run, "run");
-        if (Module["preInit"]) {
-          if (typeof Module["preInit"] == "function") Module["preInit"] = [Module["preInit"]];
-          while (Module["preInit"].length > 0) {
-            Module["preInit"].pop()();
-          }
-        }
-        run();
-        moduleRtn = readyPromise;
-        return moduleRtn;
-      };
-    })();
-    tree_sitter_default = Module2;
-    Module3 = null;
-    __name(initializeBinding, "initializeBinding");
-    __name(checkModule, "checkModule");
-    Parser = class {
-      static {
-        __name(this, "Parser");
-      }
-      /** @internal */
-      [0] = 0;
-      // Internal handle for WASM
-      /** @internal */
-      [1] = 0;
-      // Internal handle for WASM
-      /** @internal */
-      logCallback = null;
-      /** The parser's current language. */
-      language = null;
-      /**
-       * This must always be called before creating a Parser.
-       *
-       * You can optionally pass in options to configure the WASM module, the most common
-       * one being `locateFile` to help the module find the `.wasm` file.
-       */
-      static async init(moduleOptions) {
-        setModule(await initializeBinding(moduleOptions));
-        TRANSFER_BUFFER = C._ts_init();
-        LANGUAGE_VERSION = C.getValue(TRANSFER_BUFFER, "i32");
-        MIN_COMPATIBLE_VERSION = C.getValue(TRANSFER_BUFFER + SIZE_OF_INT, "i32");
-      }
-      /**
-       * Create a new parser.
-       */
-      constructor() {
-        this.initialize();
-      }
-      /** @internal */
-      initialize() {
-        if (!checkModule()) {
-          throw new Error("cannot construct a Parser before calling `init()`");
-        }
-        C._ts_parser_new_wasm();
-        this[0] = C.getValue(TRANSFER_BUFFER, "i32");
-        this[1] = C.getValue(TRANSFER_BUFFER + SIZE_OF_INT, "i32");
-      }
-      /** Delete the parser, freeing its resources. */
-      delete() {
-        C._ts_parser_delete(this[0]);
-        C._free(this[1]);
-        this[0] = 0;
-        this[1] = 0;
-      }
-      /**
-       * Set the language that the parser should use for parsing.
-       *
-       * If the language was not successfully assigned, an error will be thrown.
-       * This happens if the language was generated with an incompatible
-       * version of the Tree-sitter CLI. Check the language's version using
-       * {@link Language#version} and compare it to this library's
-       * {@link LANGUAGE_VERSION} and {@link MIN_COMPATIBLE_VERSION} constants.
-       */
-      setLanguage(language) {
-        let address;
-        if (!language) {
-          address = 0;
-          this.language = null;
-        } else if (language.constructor === Language) {
-          address = language[0];
-          const version2 = C._ts_language_version(address);
-          if (version2 < MIN_COMPATIBLE_VERSION || LANGUAGE_VERSION < version2) {
-            throw new Error(
-              `Incompatible language version ${version2}. Compatibility range ${MIN_COMPATIBLE_VERSION} through ${LANGUAGE_VERSION}.`
-            );
-          }
-          this.language = language;
-        } else {
-          throw new Error("Argument must be a Language");
-        }
-        C._ts_parser_set_language(this[0], address);
-        return this;
-      }
-      /**
-       * Parse a slice of UTF8 text.
-       *
-       * @param {string | ParseCallback} callback - The UTF8-encoded text to parse or a callback function.
-       *
-       * @param {Tree | null} [oldTree] - A previous syntax tree parsed from the same document. If the text of the
-       *   document has changed since `oldTree` was created, then you must edit `oldTree` to match
-       *   the new text using {@link Tree#edit}.
-       *
-       * @param {ParseOptions} [options] - Options for parsing the text.
-       *  This can be used to set the included ranges, or a progress callback.
-       *
-       * @returns {Tree | null} A {@link Tree} if parsing succeeded, or `null` if:
-       *  - The parser has not yet had a language assigned with {@link Parser#setLanguage}.
-       *  - The progress callback returned true.
-       */
-      parse(callback, oldTree, options) {
-        if (typeof callback === "string") {
-          C.currentParseCallback = (index) => callback.slice(index);
-        } else if (typeof callback === "function") {
-          C.currentParseCallback = callback;
-        } else {
-          throw new Error("Argument must be a string or a function");
-        }
-        if (options?.progressCallback) {
-          C.currentProgressCallback = options.progressCallback;
-        } else {
-          C.currentProgressCallback = null;
-        }
-        if (this.logCallback) {
-          C.currentLogCallback = this.logCallback;
-          C._ts_parser_enable_logger_wasm(this[0], 1);
-        } else {
-          C.currentLogCallback = null;
-          C._ts_parser_enable_logger_wasm(this[0], 0);
-        }
-        let rangeCount = 0;
-        let rangeAddress = 0;
-        if (options?.includedRanges) {
-          rangeCount = options.includedRanges.length;
-          rangeAddress = C._calloc(rangeCount, SIZE_OF_RANGE);
-          let address = rangeAddress;
-          for (let i2 = 0; i2 < rangeCount; i2++) {
-            marshalRange(address, options.includedRanges[i2]);
-            address += SIZE_OF_RANGE;
-          }
-        }
-        const treeAddress = C._ts_parser_parse_wasm(
-          this[0],
-          this[1],
-          oldTree ? oldTree[0] : 0,
-          rangeAddress,
-          rangeCount
-        );
-        if (!treeAddress) {
-          C.currentParseCallback = null;
-          C.currentLogCallback = null;
-          C.currentProgressCallback = null;
-          return null;
-        }
-        if (!this.language) {
-          throw new Error("Parser must have a language to parse");
-        }
-        const result = new Tree(INTERNAL, treeAddress, this.language, C.currentParseCallback);
-        C.currentParseCallback = null;
-        C.currentLogCallback = null;
-        C.currentProgressCallback = null;
-        return result;
-      }
-      /**
-       * Instruct the parser to start the next parse from the beginning.
-       *
-       * If the parser previously failed because of a timeout, cancellation,
-       * or callback, then by default, it will resume where it left off on the
-       * next call to {@link Parser#parse} or other parsing functions.
-       * If you don't want to resume, and instead intend to use this parser to
-       * parse some other document, you must call `reset` first.
-       */
-      reset() {
-        C._ts_parser_reset(this[0]);
-      }
-      /** Get the ranges of text that the parser will include when parsing. */
-      getIncludedRanges() {
-        C._ts_parser_included_ranges_wasm(this[0]);
-        const count = C.getValue(TRANSFER_BUFFER, "i32");
-        const buffer = C.getValue(TRANSFER_BUFFER + SIZE_OF_INT, "i32");
-        const result = new Array(count);
-        if (count > 0) {
-          let address = buffer;
-          for (let i2 = 0; i2 < count; i2++) {
-            result[i2] = unmarshalRange(address);
-            address += SIZE_OF_RANGE;
-          }
-          C._free(buffer);
-        }
-        return result;
-      }
-      /**
-       * @deprecated since version 0.25.0, prefer passing a progress callback to {@link Parser#parse}
-       *
-       * Get the duration in microseconds that parsing is allowed to take.
-       *
-       * This is set via {@link Parser#setTimeoutMicros}.
-       */
-      getTimeoutMicros() {
-        return C._ts_parser_timeout_micros(this[0]);
-      }
-      /**
-       * @deprecated since version 0.25.0, prefer passing a progress callback to {@link Parser#parse}
-       *
-       * Set the maximum duration in microseconds that parsing should be allowed
-       * to take before halting.
-       *
-       * If parsing takes longer than this, it will halt early, returning `null`.
-       * See {@link Parser#parse} for more information.
-       */
-      setTimeoutMicros(timeout) {
-        C._ts_parser_set_timeout_micros(this[0], 0, timeout);
-      }
-      /** Set the logging callback that a parser should use during parsing. */
-      setLogger(callback) {
-        if (!callback) {
-          this.logCallback = null;
-        } else if (typeof callback !== "function") {
-          throw new Error("Logger callback must be a function");
-        } else {
-          this.logCallback = callback;
-        }
-        return this;
-      }
-      /** Get the parser's current logger. */
-      getLogger() {
-        return this.logCallback;
-      }
-    };
-  }
-});
 
 // server.mjs
 import { writeFileSync as writeFileSync4, mkdirSync as mkdirSync2 } from "node:fs";
@@ -3976,21 +6,21 @@ import { dirname as dirname4 } from "node:path";
 import { z as z2 } from "zod";
 
 // ../hex-common/src/runtime/mcp-bootstrap.mjs
-async function createServerRuntime({ name: name2, version: version2, installDir }) {
+async function createServerRuntime({ name, version: version2, installDir }) {
   let McpServer, StdioServerTransport2;
   try {
     ({ McpServer } = await import("@modelcontextprotocol/sdk/server/mcp.js"));
     ({ StdioServerTransport: StdioServerTransport2 } = await import("@modelcontextprotocol/sdk/server/stdio.js"));
   } catch {
     process.stderr.write(
-      `${name2}: @modelcontextprotocol/sdk not found.
+      `${name}: @modelcontextprotocol/sdk not found.
 Run: cd ${installDir} && npm install
 `
     );
     process.exit(1);
   }
   return {
-    server: new McpServer({ name: name2, version: version2 }),
+    server: new McpServer({ name, version: version2 }),
     StdioServerTransport: StdioServerTransport2
   };
 }
@@ -4045,9 +75,9 @@ async function fetchLatest(packageName) {
 function compareVersions(a, b) {
   const pa = a.split(".").map(Number);
   const pb = b.split(".").map(Number);
-  for (let i2 = 0; i2 < 3; i2++) {
-    if ((pa[i2] || 0) < (pb[i2] || 0)) return -1;
-    if ((pa[i2] || 0) > (pb[i2] || 0)) return 1;
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] || 0) < (pb[i] || 0)) return -1;
+    if ((pa[i] || 0) > (pb[i] || 0)) return 1;
   }
   return 0;
 }
@@ -4081,13 +111,13 @@ var TAG_CHARS = "abcdefghijklmnopqrstuvwxyz234567";
 function fnv1a(str) {
   const normalized = str.replace(/\r$/, "").replace(/\s+/g, "");
   let h = FNV_OFFSET;
-  for (let i2 = 0; i2 < normalized.length; i2++) {
-    let code = normalized.charCodeAt(i2);
-    if (code >= 55296 && code <= 56319 && i2 + 1 < normalized.length) {
-      const lo = normalized.charCodeAt(i2 + 1);
+  for (let i = 0; i < normalized.length; i++) {
+    let code = normalized.charCodeAt(i);
+    if (code >= 55296 && code <= 56319 && i + 1 < normalized.length) {
+      const lo = normalized.charCodeAt(i + 1);
       if (lo >= 56320 && lo <= 57343) {
         code = (code - 55296 << 10) + (lo - 56320) + 65536;
-        i2++;
+        i++;
       }
     }
     if (code < 128) {
@@ -4171,16 +201,16 @@ function countFileLines(filePath, size, maxSize = 1e6) {
   try {
     const buf = readFileSync(filePath);
     const checkLen = Math.min(buf.length, 8192);
-    for (let i2 = 0; i2 < checkLen; i2++) if (buf[i2] === 0) return null;
+    for (let i = 0; i < checkLen; i++) if (buf[i] === 0) return null;
     let count = 1;
-    for (let i2 = 0; i2 < buf.length; i2++) if (buf[i2] === 10) count++;
+    for (let i = 0; i < buf.length; i++) if (buf[i] === 10) count++;
     return count;
   } catch {
     return null;
   }
 }
 function listDirectory(dirPath, opts = {}) {
-  const { limit = 0, metadata: metadata2 = false, compact = false, indent = "  " } = opts;
+  const { limit = 0, metadata = false, compact = false, indent = "  " } = opts;
   let entries;
   try {
     entries = readdirSync(dirPath, { withFileTypes: true });
@@ -4197,24 +227,24 @@ function listDirectory(dirPath, opts = {}) {
   const visible = limit > 0 ? entries.slice(0, limit) : entries;
   const lines = visible.map((entry) => {
     const isDir = entry.isDirectory();
-    if (!metadata2) {
+    if (!metadata) {
       return `${indent}${isDir ? "d" : "f"} ${entry.name}`;
     }
     if (isDir) {
       return `${indent}${entry.name}/`;
     }
     const full = join2(dirPath, entry.name);
-    const parts2 = [];
+    const parts = [];
     try {
       const st = statSync(full);
       const lineCount = countFileLines(full, st.size);
-      if (lineCount !== null) parts2.push(`${lineCount}L`);
-      parts2.push(formatSize(st.size));
-      if (st.mtime) parts2.push(relativeTime(st.mtime, compact));
+      if (lineCount !== null) parts.push(`${lineCount}L`);
+      parts.push(formatSize(st.size));
+      if (st.mtime) parts.push(relativeTime(st.mtime, compact));
     } catch {
-      parts2.push("?");
+      parts.push("?");
     }
-    return `${indent}${entry.name} (${parts2.join(", ")})`;
+    return `${indent}${entry.name} (${parts.join(", ")})`;
   });
   return { text: lines.join("\n"), total };
 }
@@ -4271,8 +301,8 @@ ${text}`;
   const probe = Buffer.alloc(8192);
   const bytesRead = readSync(bfd, probe, 0, 8192, 0);
   closeSync(bfd);
-  for (let i2 = 0; i2 < bytesRead; i2++) {
-    if (probe[i2] === 0) {
+  for (let i = 0; i < bytesRead; i++) {
+    if (probe[i] === 0) {
       throw new Error(`BINARY_FILE: ${real}. Use built-in Read tool (supports images, PDFs, notebooks).`);
     }
   }
@@ -4337,11 +367,11 @@ function validateHexLineContract(db) {
     return false;
   }
 }
-function symbolAnnotation(db, file, name2) {
+function symbolAnnotation(db, file, name) {
   try {
     const node = db.prepare(
       "SELECT callees, callers FROM hex_line_symbol_annotations WHERE file = ? AND name = ? LIMIT 1"
-    ).get(file, name2);
+    ).get(file, name);
     if (!node) return null;
     if (node.callees === 0 && node.callers === 0) return null;
     return `[${node.callees}\u2193 ${node.callers}\u2191]`;
@@ -4422,14 +452,14 @@ function getRelativePath(filePath) {
 }
 function findProjectRoot(filePath) {
   let dir = dirname2(filePath);
-  for (let i2 = 0; i2 < 10; i2++) {
+  for (let i = 0; i < 10; i++) {
     if (existsSync2(join3(dir, ".codegraph", "index.db"))) return dir;
     const parent = dirname2(dir);
     if (parent === dir) break;
     dir = parent;
   }
   dir = dirname2(filePath);
-  for (let i2 = 0; i2 < 10; i2++) {
+  for (let i = 0; i < 10; i++) {
     if (existsSync2(join3(dir, ".git"))) return dir;
     const parent = dirname2(dir);
     if (parent === dir) break;
@@ -4486,15 +516,15 @@ function rememberRevisionId(filePath, revision) {
 function buildUniqueTagIndex(lineHashes) {
   const index = /* @__PURE__ */ new Map();
   const duplicates = /* @__PURE__ */ new Set();
-  for (let i2 = 0; i2 < lineHashes.length; i2++) {
-    const tag = lineTag(lineHashes[i2]);
+  for (let i = 0; i < lineHashes.length; i++) {
+    const tag = lineTag(lineHashes[i]);
     if (duplicates.has(tag)) continue;
     if (index.has(tag)) {
       index.delete(tag);
       duplicates.add(tag);
       continue;
     }
-    index.set(tag, i2);
+    index.set(tag, i);
   }
   return index;
 }
@@ -4509,9 +539,9 @@ function coalesceRanges(ranges) {
   if (!ranges.length) return [];
   const sorted = [...ranges].sort((a, b) => a.start - b.start || a.end - b.end);
   const merged = [sorted[0]];
-  for (let i2 = 1; i2 < sorted.length; i2++) {
+  for (let i = 1; i < sorted.length; i++) {
     const prev = merged[merged.length - 1];
-    const curr = sorted[i2];
+    const curr = sorted[i];
     if (curr.start <= prev.end + 1) {
       prev.end = Math.max(prev.end, curr.end);
       prev.kind = prev.kind === curr.kind ? prev.kind : "mixed";
@@ -4524,15 +554,15 @@ function coalesceRanges(ranges) {
 function computeChangedRanges(oldLines, newLines) {
   const oldText = oldLines.join("\n") + "\n";
   const newText = newLines.join("\n") + "\n";
-  const parts2 = diffLines(oldText, newText);
+  const parts = diffLines(oldText, newText);
   const ranges = [];
   let oldNum = 1;
   let newNum = 1;
-  for (let i2 = 0; i2 < parts2.length; i2++) {
-    const part = parts2[i2];
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
     const count = diffLineCount(part.value);
     if (part.removed) {
-      const next = parts2[i2 + 1];
+      const next = parts[i + 1];
       if (next?.added) {
         const addedCount = diffLineCount(next.value);
         ranges.push({
@@ -4542,7 +572,7 @@ function computeChangedRanges(oldLines, newLines) {
         });
         oldNum += count;
         newNum += addedCount;
-        i2++;
+        i++;
         continue;
       }
       ranges.push({ start: newNum, end: newNum, kind: "delete" });
@@ -4657,16 +687,16 @@ ${text}
     const maxLines = opts.limit && opts.limit > 0 ? opts.limit : DEFAULT_LIMIT;
     ranges = [{ start: startLine, end: Math.min(total, startLine - 1 + maxLines) }];
   }
-  const parts2 = [];
+  const parts = [];
   let cappedAtLine = 0;
   for (const range of ranges) {
     const selected = lines.slice(range.start - 1, range.end);
     const lineHashes = [];
     const formatted = [];
     let charCount = 0;
-    for (let i2 = 0; i2 < selected.length; i2++) {
-      const line = selected[i2];
-      const num = range.start + i2;
+    for (let i = 0; i < selected.length; i++) {
+      const line = selected[i];
+      const num = range.start + i;
       const hash32 = fnv1a(line);
       const entry = opts.plain ? `${num}|${line}` : `${lineTag(hash32)}.${num}	${line}`;
       if (charCount + entry.length > MAX_OUTPUT_CHARS && formatted.length > 0) {
@@ -4679,9 +709,9 @@ ${text}
     }
     const actualEnd = formatted.length > 0 ? range.start + formatted.length - 1 : range.start;
     range.end = actualEnd;
-    parts2.push(formatted.join("\n"));
+    parts.push(formatted.join("\n"));
     const cs = rangeChecksum(lineHashes, range.start, actualEnd);
-    parts2.push(`
+    parts.push(`
 checksum: ${cs}`);
     if (cappedAtLine) break;
   }
@@ -4717,7 +747,7 @@ revision: ${snapshot.revision}
 file: ${snapshot.fileChecksum}
 
 \`\`\`
-${parts2.join("\n")}
+${parts.join("\n")}
 \`\`\``;
   if (total > 200 && (!opts.offset || opts.offset <= 1) && !cappedAtLine) {
     result += `
@@ -4747,14 +777,14 @@ function restoreIndent(origLines, newLines) {
   });
 }
 function buildErrorSnippet(lines, centerIdx, radius = 5) {
-  const start2 = Math.max(0, centerIdx - radius);
+  const start = Math.max(0, centerIdx - radius);
   const end = Math.min(lines.length, centerIdx + radius + 1);
-  const text = lines.slice(start2, end).map((line, i2) => {
-    const num = start2 + i2 + 1;
+  const text = lines.slice(start, end).map((line, i) => {
+    const num = start + i + 1;
     const tag = lineTag(fnv1a(line));
     return `${tag}.${num}	${line}`;
   }).join("\n");
-  return { start: start2 + 1, end, text };
+  return { start: start + 1, end, text };
 }
 function findLine(lines, lineNum, expectedTag, hashIndex) {
   const idx = lineNum - 1;
@@ -4787,9 +817,9 @@ Tip: Use updated hashes above for retry.`
   const CONFUSABLE_RE = /[\u2010\u2011\u2012\u2013\u2014\u2212\uFE63\uFF0D]/g;
   const norm = (t) => t.replace(CONFUSABLE_RE, "-");
   const normalizedExpected = norm(expectedTag);
-  for (let i2 = Math.max(0, idx - 10); i2 <= Math.min(lines.length - 1, idx + 10); i2++) {
-    const normalizedActual = norm(lineTag(fnv1a(norm(lines[i2]))));
-    if (normalizedActual === normalizedExpected) return i2;
+  for (let i = Math.max(0, idx - 10); i <= Math.min(lines.length - 1, idx + 10); i++) {
+    const normalizedActual = norm(lineTag(fnv1a(norm(lines[i]))));
+    if (normalizedActual === normalizedExpected) return i;
   }
   if (hashIndex) {
     const relocated = hashIndex.get(expectedTag);
@@ -4808,42 +838,42 @@ Tip: Use updated hashes above for retry.`
 function simpleDiff(oldLines, newLines, ctx = 3) {
   const oldText = oldLines.join("\n") + "\n";
   const newText = newLines.join("\n") + "\n";
-  const parts2 = diffLines2(oldText, newText);
-  const out2 = [];
+  const parts = diffLines2(oldText, newText);
+  const out = [];
   let oldNum = 1, newNum = 1;
   let lastChange = false;
-  for (let i2 = 0; i2 < parts2.length; i2++) {
-    const part = parts2[i2];
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
     const lines = part.value.replace(/\n$/, "").split("\n");
     if (part.added || part.removed) {
       for (const line of lines) {
         if (part.removed) {
-          out2.push(`-${oldNum}| ${line}`);
+          out.push(`-${oldNum}| ${line}`);
           oldNum++;
         } else {
-          out2.push(`+${newNum}| ${line}`);
+          out.push(`+${newNum}| ${line}`);
           newNum++;
         }
       }
       lastChange = true;
     } else {
-      const next = i2 < parts2.length - 1 && (parts2[i2 + 1].added || parts2[i2 + 1].removed);
+      const next = i < parts.length - 1 && (parts[i + 1].added || parts[i + 1].removed);
       if (lastChange || next) {
-        let start2 = 0, end = lines.length;
-        if (!lastChange) start2 = Math.max(0, end - ctx);
-        if (!next && end - start2 > ctx) end = start2 + ctx;
-        if (start2 > 0) {
-          out2.push("...");
-          oldNum += start2;
-          newNum += start2;
-        }
-        for (let k = start2; k < end; k++) {
-          out2.push(` ${oldNum}| ${lines[k]}`);
+        let start = 0, end = lines.length;
+        if (!lastChange) start = Math.max(0, end - ctx);
+        if (!next && end - start > ctx) end = start + ctx;
+        if (start > 0) {
+          out.push("...");
+          oldNum += start;
+          newNum += start;
+        }
+        for (let k = start; k < end; k++) {
+          out.push(` ${oldNum}| ${lines[k]}`);
           oldNum++;
           newNum++;
         }
         if (end < lines.length) {
-          out2.push("...");
+          out.push("...");
           oldNum += lines.length - end;
           newNum += lines.length - end;
         }
@@ -4854,13 +884,13 @@ function simpleDiff(oldLines, newLines, ctx = 3) {
       lastChange = false;
     }
   }
-  return out2.length ? out2.join("\n") : null;
+  return out.length ? out.join("\n") : null;
 }
 function verifyChecksumAgainstSnapshot(snapshot, rc) {
-  const { start: start2, end, hex } = parseChecksum(rc);
-  const actual = buildRangeChecksum(snapshot, start2, end);
-  if (!actual) return { ok: false, actual: null, start: start2, end };
-  return { ok: actual.split(":")[1] === hex, actual, start: start2, end };
+  const { start, end, hex } = parseChecksum(rc);
+  const actual = buildRangeChecksum(snapshot, start, end);
+  if (!actual) return { ok: false, actual: null, start, end };
+  return { ok: actual.split(":")[1] === hex, actual, start, end };
 }
 function buildConflictMessage({
   filePath,
@@ -4941,9 +971,9 @@ function editFile(filePath, edits, opts = {}) {
       editTargets.push({ start: s, end: en });
     }
   }
-  for (let i2 = 0; i2 < editTargets.length; i2++) {
-    for (let j = i2 + 1; j < editTargets.length; j++) {
-      const a = editTargets[i2], b = editTargets[j];
+  for (let i = 0; i < editTargets.length; i++) {
+    for (let j = i + 1; j < editTargets.length; j++) {
+      const a = editTargets[i], b = editTargets[j];
       if (a.insert || b.insert) continue;
       if (a.start <= b.end && b.start <= a.end) {
         throw new Error(
@@ -5215,10 +1245,10 @@ ${diff}
       const ctxEnd = Math.min(newLinesAll.length, maxLine + 5);
       const ctxLines = [];
       const ctxHashes = [];
-      for (let i2 = ctxStart; i2 < ctxEnd; i2++) {
-        const h = fnv1a(newLinesAll[i2]);
+      for (let i = ctxStart; i < ctxEnd; i++) {
+        const h = fnv1a(newLinesAll[i]);
         ctxHashes.push(h);
-        ctxLines.push(`${lineTag(h)}.${i2 + 1}	${newLinesAll[i2]}`);
+        ctxLines.push(`${lineTag(h)}.${i + 1}	${newLinesAll[i]}`);
       }
       const ctxCs = rangeChecksum(ctxHashes, ctxStart + 1, ctxEnd);
       msg += `
@@ -5242,13 +1272,13 @@ try {
 var DEFAULT_LIMIT2 = 100;
 var MAX_OUTPUT = 10 * 1024 * 1024;
 var TIMEOUT2 = 3e4;
-function spawnRg(args2) {
+function spawnRg(args) {
   return new Promise((resolve_, reject) => {
     let stdout = "";
     let totalBytes = 0;
     let killed = false;
     let stderrBuf = "";
-    const child = spawn(rgBin, args2, { timeout: TIMEOUT2 });
+    const child = spawn(rgBin, args, { timeout: TIMEOUT2 });
     child.stdout.on("data", (chunk) => {
       totalBytes += chunk.length;
       if (totalBytes > MAX_OUTPUT) {
@@ -5261,8 +1291,8 @@ function spawnRg(args2) {
     child.stderr.on("data", (chunk) => {
       stderrBuf += chunk.toString("utf-8");
     });
-    child.on("error", (err2) => {
-      reject(new Error(`rg spawn error: ${err2.message}`));
+    child.on("error", (err) => {
+      reject(new Error(`rg spawn error: ${err.message}`));
     });
     child.on("close", (code) => {
       resolve_({ stdout, code, stderr: stderrBuf, killed });
@@ -5345,10 +1375,10 @@ async function contentMode(pattern, target, opts, plain, totalLimit) {
   function flushGroup() {
     if (groupLines.length === 0) return;
     const sorted = [...groupLines].sort((a, b) => a.lineNum - b.lineNum);
-    const start2 = sorted[0].lineNum;
+    const start = sorted[0].lineNum;
     const end = sorted[sorted.length - 1].lineNum;
     const hashes = sorted.map((l) => l.hash32);
-    const cs = rangeChecksum(hashes, start2, end);
+    const cs = rangeChecksum(hashes, start, end);
     formatted.push(`checksum: ${cs}`);
     groupLines = [];
   }
@@ -5387,9 +1417,9 @@ async function contentMode(pattern, target, opts, plain, totalLimit) {
       flushGroup();
       groupFile = filePath;
     }
-    for (let i2 = 0; i2 < subLines.length; i2++) {
-      const ln = lineNum + i2;
-      const lineContent = subLines[i2];
+    for (let i = 0; i < subLines.length; i++) {
+      const ln = lineNum + i;
+      const lineContent = subLines[i];
       const hash32 = fnv1a(lineContent);
       const tag = lineTag(hash32);
       if (groupLines.length > 0) {
@@ -5444,15 +1474,15 @@ var parserInstance = null;
 var languageCache = /* @__PURE__ */ new Map();
 async function getParser() {
   if (parserInstance) return parserInstance;
-  const { Parser: Parser2 } = await Promise.resolve().then(() => (init_tree_sitter(), tree_sitter_exports));
-  await Parser2.init();
-  parserInstance = new Parser2();
+  const { Parser } = await import("web-tree-sitter");
+  await Parser.init();
+  parserInstance = new Parser();
   return parserInstance;
 }
 async function getLanguage(grammar) {
   if (languageCache.has(grammar)) return languageCache.get(grammar);
   await getParser();
-  const { Language: Language2 } = await Promise.resolve().then(() => (init_tree_sitter(), tree_sitter_exports));
+  const { Language } = await import("web-tree-sitter");
   const require2 = createRequire2(import.meta.url);
   const wasmPath = resolve3(
     require2.resolve("tree-sitter-wasms/package.json"),
@@ -5460,7 +1490,7 @@ async function getLanguage(grammar) {
     "out",
     `tree-sitter-${grammar}.wasm`
   );
-  const lang = await Language2.load(wasmPath);
+  const lang = await Language.load(wasmPath);
   languageCache.set(grammar, lang);
   return lang;
 }
@@ -5532,8 +1562,8 @@ function extractOutline(rootNode, config, sourceLines) {
   const outlineTypes = new Set(config.outline);
   const recurseTypes = new Set(config.recurse);
   function walk(node, depth) {
-    for (let i2 = 0; i2 < node.childCount; i2++) {
-      const child = node.child(i2);
+    for (let i = 0; i < node.childCount; i++) {
+      const child = node.child(i);
       const type = child.type;
       const startLine = child.startPosition.row + 1;
       const endLine = child.endPosition.row + 1;
@@ -5541,13 +1571,13 @@ function extractOutline(rootNode, config, sourceLines) {
       if (outlineTypes.has(type)) {
         const firstLine = sourceLines[startLine - 1] || "";
         const nameMatch = firstLine.match(/(?:function|class|interface|type|enum|struct|def|fn|pub\s+fn)\s+(\w+)|(?:const|let|var|export\s+(?:const|let|var|function|class))\s+(\w+)/);
-        const name2 = nameMatch ? nameMatch[1] || nameMatch[2] : null;
+        const name = nameMatch ? nameMatch[1] || nameMatch[2] : null;
         entries.push({
           start: startLine,
           end: endLine,
           depth,
           text: firstLine.trim().slice(0, 120),
-          name: name2
+          name
         });
         for (let j = 0; j < child.childCount; j++) {
           const sub = child.child(j);
@@ -5557,8 +1587,8 @@ function extractOutline(rootNode, config, sourceLines) {
     }
   }
   const skippedRanges = [];
-  for (let i2 = 0; i2 < rootNode.childCount; i2++) {
-    const child = rootNode.child(i2);
+  for (let i = 0; i < rootNode.childCount; i++) {
+    const child = rootNode.child(i);
     if (skipTypes.has(child.type)) {
       skippedRanges.push({
         start: child.startPosition.row + 1,
@@ -5763,20 +1793,20 @@ function directoryTree(dirPath, opts = {}) {
     });
     let subTotal = 0;
     for (const entry of entries) {
-      const name2 = entry.name;
+      const name = entry.name;
       const isDir = entry.isDirectory();
-      if (SKIP_DIRS.has(name2) && isDir) continue;
-      const full = join4(dir, name2);
+      if (SKIP_DIRS.has(name) && isDir) continue;
+      const full = join4(dir, name);
       const rel = relative2(abs, full).replace(/\\/g, "/");
       if (isIgnored(ig, rel, isDir)) continue;
       if (isDir) {
         if (compact) {
-          lines.push(`${prefix}${name2}/`);
+          lines.push(`${prefix}${name}/`);
         } else {
           const lineIdx = lines.length;
           lines.push("");
           const count = depth < maxDepth ? walk(full, prefix + "  ", depth + 1) : countSubtreeFiles(full, ig, abs);
-          lines[lineIdx] = `${prefix}${name2}/ (${count} files)`;
+          lines[lineIdx] = `${prefix}${name}/ (${count} files)`;
           subTotal += count;
         }
         if (compact) walk(full, prefix + "  ", depth + 1);
@@ -5784,7 +1814,7 @@ function directoryTree(dirPath, opts = {}) {
         totalFiles++;
         subTotal++;
         if (compact) {
-          lines.push(`${prefix}${name2}`);
+          lines.push(`${prefix}${name}`);
         } else {
           let size = 0, mtime = null, lineCount = null;
           try {
@@ -5795,11 +1825,11 @@ function directoryTree(dirPath, opts = {}) {
           }
           totalSize += size;
           lineCount = countFileLines(full, size);
-          const parts2 = [];
-          if (lineCount !== null) parts2.push(`${lineCount}L`);
-          parts2.push(formatSize(size));
-          if (mtime) parts2.push(relativeTime(mtime, true));
-          lines.push(`${prefix}${name2} (${parts2.join(", ")})`);
+          const parts = [];
+          if (lineCount !== null) parts.push(`${lineCount}L`);
+          parts.push(formatSize(size));
+          if (mtime) parts.push(relativeTime(mtime, true));
+          lines.push(`${prefix}${name} (${parts.join(", ")})`);
         }
       }
     }
@@ -5899,8 +1929,8 @@ function detectBinary(filePath, size) {
   const probe = Buffer.alloc(Math.min(size, 8192));
   const bytesRead = readSync2(fd, probe, 0, probe.length, 0);
   closeSync2(fd);
-  for (let i2 = 0; i2 < bytesRead; i2++) {
-    if (probe[i2] === 0) return true;
+  for (let i = 0; i < bytesRead; i++) {
+    if (probe[i] === 0) return true;
   }
   return false;
 }
@@ -5913,10 +1943,10 @@ function fileInfo(filePath) {
   const size = stat.size;
   const mtime = stat.mtime;
   const ext = extname2(abs).toLowerCase();
-  const name2 = basename2(abs);
+  const name = basename2(abs);
   let typeName = EXT_NAMES[ext] || (ext ? `${ext.slice(1).toUpperCase()} file` : "Unknown type");
-  if (name2 === "Dockerfile") typeName = "Dockerfile";
-  if (name2 === "Makefile") typeName = "Makefile";
+  if (name === "Dockerfile") typeName = "Dockerfile";
+  if (name === "Makefile") typeName = "Makefile";
   const isBinary = size > 0 ? detectBinary(abs, size) : false;
   const lineCount = !isBinary && size > 0 ? countFileLines(abs, size, MAX_LINE_COUNT_SIZE) : null;
   const sizeStr = lineCount !== null ? `Size: ${formatSize(size)} (${lineCount} lines)` : `Size: ${formatSize(size)}`;
@@ -6103,7 +2133,7 @@ Restart Claude Code to apply changes.`;
     throw new Error(`UNKNOWN_AGENT: '${agent}'. Supported: claude, gemini, codex, all`);
   }
   const targets = target === "all" ? Object.keys(AGENTS) : [target];
-  const results = targets.map((name2) => "  " + AGENTS[name2]());
+  const results = targets.map((name) => "  " + AGENTS[name]());
   const header = `Hooks configured for ${target}:`;
   const footer = "\nRestart Claude Code to apply hook changes.";
   return [header, ...results, footer].join("\n");
@@ -6116,17 +2146,17 @@ import { extname as extname3 } from "node:path";
 function symbolName(text) {
   const clean = text.replace(/\s*\{?\s*$/, "").trim();
   const noParams = clean.replace(/\(.*$/, "").trim();
-  const parts2 = noParams.split(/\s+/);
-  const eqIdx = parts2.indexOf("=");
-  if (eqIdx > 0) return parts2[eqIdx - 1];
-  return parts2[parts2.length - 1] || text;
+  const parts = noParams.split(/\s+/);
+  const eqIdx = parts.indexOf("=");
+  if (eqIdx > 0) return parts[eqIdx - 1];
+  return parts[parts.length - 1] || text;
 }
 function toSymbolMap(entries) {
   const map = /* @__PURE__ */ new Map();
   for (const e of entries) {
-    const name2 = symbolName(e.text);
+    const name = symbolName(e.text);
     const lines = e.end - e.start + 1;
-    map.set(name2, { name: name2, text: e.text, lines, start: e.start, end: e.end });
+    map.set(name, { name, text: e.text, lines, start: e.start, end: e.end });
   }
   return map;
 }
@@ -6190,49 +2220,49 @@ Use changes on a specific file for symbol-level diff.`;
   const added = [];
   const removed = [];
   const modified = [];
-  for (const [name2, sym] of currentMap) {
-    if (!gitMap.has(name2)) {
+  for (const [name, sym] of currentMap) {
+    if (!gitMap.has(name)) {
       added.push(sym);
     } else {
-      const gitSym = gitMap.get(name2);
+      const gitSym = gitMap.get(name);
       if (gitSym.lines !== sym.lines) {
         modified.push({ current: sym, git: gitSym });
       }
     }
   }
-  for (const [name2, sym] of gitMap) {
-    if (!currentMap.has(name2)) {
+  for (const [name, sym] of gitMap) {
+    if (!currentMap.has(name)) {
       removed.push(sym);
     }
   }
-  const parts2 = [`Changes in ${filePath} vs ${compareAgainst}:`];
+  const parts = [`Changes in ${filePath} vs ${compareAgainst}:`];
   if (added.length) {
-    parts2.push("\nAdded:");
-    for (const s of added) parts2.push(`  + ${s.start}-${s.end}: ${s.text}`);
+    parts.push("\nAdded:");
+    for (const s of added) parts.push(`  + ${s.start}-${s.end}: ${s.text}`);
   }
   if (removed.length) {
-    parts2.push("\nRemoved:");
-    for (const s of removed) parts2.push(`  - ${s.start}-${s.end}: ${s.text}`);
+    parts.push("\nRemoved:");
+    for (const s of removed) parts.push(`  - ${s.start}-${s.end}: ${s.text}`);
   }
   if (modified.length) {
-    parts2.push("\nModified:");
+    parts.push("\nModified:");
     for (const m of modified) {
       const delta = m.current.lines - m.git.lines;
       const sign = delta > 0 ? "+" : "";
-      parts2.push(`  ~ ${m.current.start}-${m.current.end}: ${m.current.text}  (${sign}${delta} lines)`);
+      parts.push(`  ~ ${m.current.start}-${m.current.end}: ${m.current.text}  (${sign}${delta} lines)`);
     }
   }
   if (!added.length && !removed.length && !modified.length) {
-    parts2.push("\nNo symbol changes detected.");
+    parts.push("\nNo symbol changes detected.");
   }
   const summary = `${added.length} added, ${removed.length} removed, ${modified.length} modified`;
-  parts2.push(`
+  parts.push(`
 Summary: ${summary}`);
-  return parts2.join("\n");
+  return parts.join("\n");
 }
 
 // lib/bulk-replace.mjs
-import { writeFileSync as writeFileSync3, readdirSync as readdirSync3, statSync as statSync9 } from "node:fs";
+import { writeFileSync as writeFileSync3, readdirSync as readdirSync3 } from "node:fs";
 import { resolve as resolve7, relative as relative3, join as join5 } from "node:path";
 var ignoreMod;
 try {
@@ -6328,7 +2358,7 @@ ${results.join("\n\n")}` : header;
 }
 
 // server.mjs
-var version = true ? "1.3.4" : (await null).createRequire(import.meta.url)("./package.json").version;
+var version = true ? "1.3.5" : (await null).createRequire(import.meta.url)("./package.json").version;
 var { server, StdioServerTransport } = await createServerRuntime({
   name: "hex-line-mcp",
   version,