@colbymchenry/codegraph-darwin-arm64 0.9.0

package/lib/node_modules/web-tree-sitter/lib/wasm_store.h

@@ -0,0 +1,31 @@
+#ifndef TREE_SITTER_WASM_H_
+#define TREE_SITTER_WASM_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "tree_sitter/api.h"
+#include "./parser.h"
+
+bool ts_wasm_store_start(TSWasmStore *self, TSLexer *lexer, const TSLanguage *language);
+void ts_wasm_store_reset(TSWasmStore *self);
+bool ts_wasm_store_has_error(const TSWasmStore *self);
+
+bool ts_wasm_store_call_lex_main(TSWasmStore *self, TSStateId state);
+bool ts_wasm_store_call_lex_keyword(TSWasmStore *self, TSStateId state);
+
+uint32_t ts_wasm_store_call_scanner_create(TSWasmStore *self);
+void ts_wasm_store_call_scanner_destroy(TSWasmStore *self, uint32_t scanner_address);
+bool ts_wasm_store_call_scanner_scan(TSWasmStore *self, uint32_t scanner_address, uint32_t valid_tokens_ix);
+uint32_t ts_wasm_store_call_scanner_serialize(TSWasmStore *self, uint32_t scanner_address, char *buffer);
+void ts_wasm_store_call_scanner_deserialize(TSWasmStore *self, uint32_t scanner, const char *buffer, unsigned length);
+
+void ts_wasm_language_retain(const TSLanguage *self);
+void ts_wasm_language_release(const TSLanguage *self);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TREE_SITTER_WASM_H_

package/lib/node_modules/web-tree-sitter/package.json

@@ -0,0 +1,98 @@
+{
+  "name": "web-tree-sitter",
+  "version": "0.25.10",
+  "description": "Tree-sitter bindings for the web",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tree-sitter/tree-sitter.git",
+    "directory": "lib/binding_web"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Max Brunsfeld",
+    "email": "maxbrunsfeld@gmail.com"
+  },
+  "maintainers": [
+    {
+      "name": "Amaan Qureshi",
+      "email": "amaanq12@gmail.com"
+    }
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./tree-sitter.js",
+      "require": "./tree-sitter.cjs",
+      "types": "./web-tree-sitter.d.ts"
+    },
+    "./tree-sitter.wasm": "./tree-sitter.wasm",
+    "./debug": {
+      "import": "./debug/tree-sitter.js",
+      "require": "./debug/tree-sitter.cjs",
+      "types": "./web-tree-sitter.d.ts"
+    },
+    "./debug/tree-sitter.wasm": "./debug/tree-sitter.wasm"
+  },
+  "types": "web-tree-sitter.d.ts",
+  "keywords": [
+    "incremental",
+    "parsing",
+    "tree-sitter",
+    "wasm"
+  ],
+  "files": [
+    "README.md",
+    "tree-sitter.cjs",
+    "tree-sitter.cjs.map",
+    "tree-sitter.js",
+    "tree-sitter.js.map",
+    "tree-sitter.wasm",
+    "tree-sitter.wasm.map",
+    "debug/tree-sitter.cjs",
+    "debug/tree-sitter.cjs.map",
+    "debug/tree-sitter.js",
+    "debug/tree-sitter.js.map",
+    "debug/tree-sitter.wasm",
+    "debug/tree-sitter.wasm.map",
+    "web-tree-sitter.d.ts",
+    "web-tree-sitter.d.ts.map",
+    "src/**/*.ts",
+    "lib/*.c",
+    "lib/*.h"
+  ],
+  "devDependencies": {
+    "@eslint/js": "^9.20.0",
+    "@types/node": "^22.13.1",
+    "@vitest/coverage-v8": "^3.0.5",
+    "dts-buddy": "^0.5.4",
+    "esbuild": "^0.24.2",
+    "eslint": "^9.19.0",
+    "source-map": "^0.7.4",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.3",
+    "typescript-eslint": "^8.22.0",
+    "vitest": "^3.0.4"
+  },
+  "peerDependencies": {
+    "@types/emscripten": "^1.40.0"
+  },
+  "peerDependenciesMeta": {
+    "@types/emscripten": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build:ts": "tsc -b . && node script/build.js",
+    "build:wasm": "cd ../../ && cargo xtask build-wasm",
+    "build:wasm:debug": "cd ../../ && cargo xtask build-wasm --debug",
+    "build": "npm run build:wasm && npm run build:ts",
+    "build:debug": "npm run build:wasm:debug && npm run build:ts -- --debug",
+    "build:dts": "node script/generate-dts.js",
+    "lint": "eslint src/*.ts script/*.ts test/*.ts",
+    "lint:fix": "eslint src/*.ts script/*.ts test/*.ts --fix",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepack": "cp ../../LICENSE .",
+    "prepublishOnly": "tsx script/check-artifacts-fresh.ts"
+  }
+}

package/lib/node_modules/web-tree-sitter/src/bindings.ts

@@ -0,0 +1,26 @@
+import createModule, { type MainModule } from '../lib/tree-sitter';
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import { type Parser } from './parser';
+
+export let Module: MainModule | null = null;
+
+/**
+ * @internal
+ *
+ * Initialize the Tree-sitter WASM module. This should only be called by the {@link Parser} class via {@link Parser.init}.
+ */
+export async function initializeBinding(moduleOptions?: EmscriptenModule): Promise<MainModule> {
+  if (!Module) {
+    Module = await createModule(moduleOptions);
+  }
+  return Module;
+}
+
+/**
+ * @internal
+ *
+ * Checks if the Tree-sitter WASM module has been initialized.
+ */
+export function checkModule(): boolean {
+  return !!Module;
+}

package/lib/node_modules/web-tree-sitter/src/constants.ts

@@ -0,0 +1,133 @@
+import { type MainModule } from '../lib/tree-sitter';
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import { ParseState, type Parser } from './parser';
+
+/**
+ * A position in a multi-line text document, in terms of rows and columns.
+ *
+ * Rows and columns are zero-based.
+ */
+export interface Point {
+  /** The zero-based row number. */
+  row: number;
+
+  /** The zero-based column number. */
+  column: number;
+}
+
+/**
+ *  A range of positions in a multi-line text document, both in terms of bytes
+ *  and of rows and columns.
+ */
+export interface Range {
+  /** The start position of the range. */
+  startPosition: Point;
+
+  /** The end position of the range. */
+  endPosition: Point;
+
+  /** The start index of the range. */
+  startIndex: number;
+
+  /** The end index of the range. */
+  endIndex: number;
+}
+
+/**
+ * A summary of a change to a text document.
+ */
+export interface Edit {
+  /** The start position of the change. */
+  startPosition: Point;
+
+  /** The end position of the change before the edit. */
+  oldEndPosition: Point;
+
+  /** The end position of the change after the edit. */
+  newEndPosition: Point;
+
+  /** The start index of the change. */
+  startIndex: number;
+
+  /** The end index of the change before the edit. */
+  oldEndIndex: number;
+
+  /** The end index of the change after the edit. */
+  newEndIndex: number;
+}
+
+/** @internal */
+export const SIZE_OF_SHORT = 2;
+
+/** @internal */
+export const SIZE_OF_INT = 4;
+
+/** @internal */
+export const SIZE_OF_CURSOR = 4 * SIZE_OF_INT;
+
+/** @internal */
+export const SIZE_OF_NODE = 5 * SIZE_OF_INT;
+
+/** @internal */
+export const SIZE_OF_POINT = 2 * SIZE_OF_INT;
+
+/** @internal */
+export const SIZE_OF_RANGE = 2 * SIZE_OF_INT + 2 * SIZE_OF_POINT;
+
+/** @internal */
+export const ZERO_POINT: Point = { row: 0, column: 0 };
+
+/**
+ * A callback for parsing that takes an index and point, and should return a string.
+ */
+export type ParseCallback = (index: number, position: Point) => string | undefined;
+
+/**
+  * A callback that receives the parse state during parsing.
+  */
+export type ProgressCallback = (progress: ParseState) => boolean;
+
+/**
+ * A callback for logging messages.
+ *
+ * If `isLex` is `true`, the message is from the lexer, otherwise it's from the parser.
+ */
+export type LogCallback = (message: string, isLex: boolean) => void;
+
+// Helper type for internal use
+/** @internal */
+export const INTERNAL = Symbol('INTERNAL');
+/** @internal */
+export type Internal = typeof INTERNAL;
+
+// Helper functions for type checking
+/** @internal */
+export function assertInternal(x: unknown): asserts x is Internal {
+  if (x !== INTERNAL) throw new Error('Illegal constructor');
+}
+
+/** @internal */
+export function isPoint(point?: Point): point is Point {
+  return (
+    !!point &&
+    typeof (point).row === 'number' &&
+    typeof (point).column === 'number'
+  );
+}
+
+/**
+ * @internal
+ *
+ * Sets the Tree-sitter WASM module. This should only be called by the {@link Parser} class via {@link Parser.init}.
+ */
+export function setModule(module: MainModule) {
+  C = module;
+}
+
+/**
+ * @internal
+ *
+ * `C` is a convenient shorthand for the Tree-sitter WASM module,
+ * which allows us to call all of the exported functions.
+ */
+export let C: MainModule;

package/lib/node_modules/web-tree-sitter/src/index.ts

@@ -0,0 +1,31 @@
+export type {
+  Point,
+  Range,
+  Edit,
+  ParseCallback,
+  ProgressCallback,
+  LogCallback,
+} from './constants';
+export {
+  type ParseOptions,
+  type ParseState,
+  LANGUAGE_VERSION,
+  MIN_COMPATIBLE_VERSION,
+  Parser,
+} from './parser';
+export { Language } from './language';
+export { Tree } from './tree';
+export { Node } from './node';
+export { TreeCursor } from './tree_cursor';
+export {
+  type QueryOptions,
+  type QueryState,
+  type QueryProperties,
+  type QueryPredicate,
+  type QueryCapture,
+  type QueryMatch,
+  CaptureQuantifier,
+  type PredicateStep,
+  Query,
+} from './query';
+export { LookaheadIterator } from './lookahead_iterator';

package/lib/node_modules/web-tree-sitter/src/language.ts

@@ -0,0 +1,291 @@
+import { C, INTERNAL, Internal, assertInternal, SIZE_OF_INT, SIZE_OF_SHORT } from './constants';
+import { LookaheadIterator } from './lookahead_iterator';
+import { unmarshalLanguageMetadata } from './marshal';
+import { TRANSFER_BUFFER } from './parser';
+import { Query } from './query';
+
+const LANGUAGE_FUNCTION_REGEX = /^tree_sitter_\w+$/;
+
+export interface LanguageMetadata {
+  readonly major_version: number;
+  readonly minor_version: number;
+  readonly patch_version: number;
+}
+
+/**
+ * An opaque object that defines how to parse a particular language.
+ * The code for each `Language` is generated by the Tree-sitter CLI.
+ */
+export class Language {
+  /** @internal */
+  private [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: string[];
+
+  /**
+   * A list of all field names in the language. The index of each field name in
+   * this array is its field id.
+   */
+  fields: (string | null)[];
+
+  /** @internal */
+  constructor(internal: Internal, address: number) {
+    assertInternal(internal);
+    this[0] = address;
+    this.types = new Array<string>(C._ts_language_symbol_count(this[0]));
+    for (let i = 0, n = this.types.length; i < n; i++) {
+      if (C._ts_language_symbol_type(this[0], i) < 2) {
+        this.types[i] = C.UTF8ToString(C._ts_language_symbol_name(this[0], i));
+      }
+    }
+    this.fields = new Array<string>(C._ts_language_field_count(this[0]) + 1);
+    for (let i = 0, n = this.fields.length; i < n; i++) {
+      const fieldName = C._ts_language_field_name_for_id(this[0], i);
+      if (fieldName !== 0) {
+        this.fields[i] = C.UTF8ToString(fieldName);
+      } else {
+        this.fields[i] = null;
+      }
+    }
+  }
+
+
+  /**
+   * Gets the name of the language.
+   */
+  get name(): string | null {
+    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(): number {
+    return C._ts_language_version(this[0]);
+  }
+
+  /**
+   * Gets the ABI version of the language.
+   */
+  get abiVersion(): number {
+    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(): LanguageMetadata | null {
+    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(): number {
+    return this.fields.length - 1;
+  }
+
+  /**
+   * Gets the number of states in the language.
+   */
+  get stateCount(): number {
+    return C._ts_language_state_count(this[0]);
+  }
+
+  /**
+   * Get the field id for a field name.
+   */
+  fieldIdForName(fieldName: string): number | null {
+    const result = this.fields.indexOf(fieldName);
+    return result !== -1 ? result : null;
+  }
+
+  /**
+   * Get the field name for a field id.
+   */
+  fieldNameForId(fieldId: number): string | null {
+    return this.fields[fieldId] ?? null;
+  }
+
+  /**
+   * Get the node type id for a node type name.
+   */
+  idForNodeType(type: string, named: boolean): number | null {
+    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(): number {
+    return C._ts_language_symbol_count(this[0]);
+  }
+
+  /**
+   * Get the node type name for a node type id.
+   */
+  nodeTypeForId(typeId: number): string | null {
+    const name = C._ts_language_symbol_name(this[0], typeId);
+    return name ? C.UTF8ToString(name) : 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: number): boolean {
+    return C._ts_language_type_is_named_wasm(this[0], typeId) ? true : false;
+  }
+
+  /**
+   * Check if a node type is visible.
+   */
+  nodeTypeIsVisible(typeId: number): boolean {
+    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(): number[] {
+    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<number>(count);
+
+    if (count > 0) {
+      let address = buffer;
+      for (let i = 0; i < count; i++) {
+        result[i] = C.getValue(address, 'i16');
+        address += SIZE_OF_SHORT;
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Get the subtype ids for a given supertype node id.
+   */
+  subtypes(supertype: number): number[] {
+    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<number>(count);
+
+    if (count > 0) {
+      let address = buffer;
+      for (let i = 0; i < count; i++) {
+        result[i] = 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: number, typeId: number): number {
+    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: number): LookaheadIterator | null {
+    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: string): Query {
+    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: string | Uint8Array): Promise<Language> {
+    let bytes: Promise<Uint8Array>;
+    if (input instanceof Uint8Array) {
+      bytes = Promise.resolve(input);
+    } else {
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      if (globalThis.process?.versions.node) {
+        const fs: typeof import('fs/promises') = await import('fs/promises');
+        bytes = fs.readFile(input);
+      } else {
+        bytes = fetch(input)
+          .then((response) => response.arrayBuffer()
+            .then((buffer) => {
+              if (response.ok) {
+                return new Uint8Array(buffer);
+              } else {
+                const body = new TextDecoder('utf-8').decode(buffer);
+                throw new Error(`Language.load failed with status ${response.status}.\n\n${body}`);
+              }
+            }));
+      }
+    }
+
+    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:\n${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);
+  }
+}

package/lib/node_modules/web-tree-sitter/src/lookahead_iterator.ts

@@ -0,0 +1,75 @@
+import { C, Internal, assertInternal } from './constants';
+import { Language } from './language';
+
+export class LookaheadIterator implements Iterable<string> {
+  /** @internal */
+  private [0] = 0; // Internal handle for WASM
+
+  /** @internal */
+  private language: Language;
+
+  /** @internal */
+  constructor(internal: Internal, address: number, language: Language) {
+    assertInternal(internal);
+    this[0] = address;
+    this.language = language;
+  }
+
+  /** Get the current symbol of the lookahead iterator. */
+  get currentTypeId(): number {
+    return C._ts_lookahead_iterator_current_symbol(this[0]);
+  }
+
+  /** Get the current symbol name of the lookahead iterator. */
+  get currentType(): string {
+    return this.language.types[this.currentTypeId] || 'ERROR';
+  }
+
+  /** Delete the lookahead iterator, freeing its resources. */
+  delete(): void {
+    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: Language, stateId: number): boolean {
+    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: number): boolean {
+    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](): Iterator<string> {
+    return {
+      next: (): IteratorResult<string> => {
+        if (C._ts_lookahead_iterator_next(this[0])) {
+          return { done: false, value: this.currentType };
+        }
+        return { done: true, value: '' };
+      }
+    };
+  }
+}