@untangle-code/parser-registry 0.0.0-stage → 0.1.0

package/dist/text/byte-offset-table.d.ts

@@ -0,0 +1,27 @@
+/**
+ * UTF-16 code unit offset -> UTF-8 byte offset conversion.
+ *
+ * tree-sitter's native Node binding reports `startIndex`/`endIndex` as UTF-16
+ * code unit offsets into the JS source string (verified empirically: a
+ * 4-byte astral codepoint advances `endIndex` by 2, not 4). `SourceRange`
+ * (domain `types/common.ts`) is normative on byte offsets ("startByte is
+ * 0-based inclusive, endByte is 0-based exclusive", spec.md §7/§8.4 lossless
+ * byte-range coverage). Every adapter in this package MUST therefore convert
+ * through a `ByteOffsetTable` before constructing a `SourceRange` — never
+ * pass a tree-sitter index straight through.
+ *
+ * The table is a prefix-sum: `table[i]` is the number of UTF-8 bytes needed
+ * to encode `source.slice(0, i)`. Building it is O(n) once per parse;
+ * lookups are O(1). A lookup at an index that falls inside a surrogate pair
+ * (which should never happen for a tree-sitter node boundary, since the
+ * lexer never splits a surrogate pair) resolves to the byte offset of the
+ * pair's start.
+ */
+export interface ByteOffsetTable {
+    /** Convert a UTF-16 code unit offset (clamped to the source length) to a UTF-8 byte offset. */
+    toByteOffset(utf16Index: number): number;
+    /** Total UTF-8 byte length of the source. */
+    readonly totalBytes: number;
+}
+export declare function buildByteOffsetTable(source: string): ByteOffsetTable;
+//# sourceMappingURL=byte-offset-table.d.ts.map

package/dist/text/byte-offset-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"byte-offset-table.d.ts","sourceRoot":"","sources":["../../src/text/byte-offset-table.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,eAAe;IAC9B,+FAA+F;IAC/F,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC;IACzC,6CAA6C;IAC7C,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B;AASD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe,CA6BpE"}

package/dist/text/byte-offset-table.js

@@ -0,0 +1,39 @@
+function utf8LengthOfCodePoint(codePoint) {
+    if (codePoint <= 0x7f)
+        return 1;
+    if (codePoint <= 0x7ff)
+        return 2;
+    if (codePoint <= 0xffff)
+        return 3;
+    return 4;
+}
+export function buildByteOffsetTable(source) {
+    const length = source.length;
+    // prefixBytes[i] = byte offset corresponding to UTF-16 index i.
+    const prefixBytes = new Uint32Array(length + 1);
+    let byteLength = 0;
+    let i = 0;
+    while (i < length) {
+        const codePoint = source.codePointAt(i);
+        // codePointAt is only undefined past the string end, which can't happen here.
+        const cp = codePoint;
+        const utf16Width = cp > 0xffff ? 2 : 1;
+        prefixBytes[i] = byteLength;
+        if (utf16Width === 2) {
+            // The low surrogate is not a valid boundary; map it to the same byte
+            // offset as the high surrogate so any accidental lookup is still safe.
+            prefixBytes[i + 1] = byteLength;
+        }
+        byteLength += utf8LengthOfCodePoint(cp);
+        i += utf16Width;
+    }
+    prefixBytes[length] = byteLength;
+    return {
+        totalBytes: byteLength,
+        toByteOffset(utf16Index) {
+            const clamped = utf16Index < 0 ? 0 : utf16Index > length ? length : utf16Index;
+            return prefixBytes[clamped];
+        },
+    };
+}
+//# sourceMappingURL=byte-offset-table.js.map

package/dist/text/byte-offset-table.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"byte-offset-table.js","sourceRoot":"","sources":["../../src/text/byte-offset-table.ts"],"names":[],"mappings":"AA0BA,SAAS,qBAAqB,CAAC,SAAiB;IAC9C,IAAI,SAAS,IAAI,IAAI;QAAE,OAAO,CAAC,CAAC;IAChC,IAAI,SAAS,IAAI,KAAK;QAAE,OAAO,CAAC,CAAC;IACjC,IAAI,SAAS,IAAI,MAAM;QAAE,OAAO,CAAC,CAAC;IAClC,OAAO,CAAC,CAAC;AACX,CAAC;AAED,MAAM,UAAU,oBAAoB,CAAC,MAAc;IACjD,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;IAC7B,gEAAgE;IAChE,MAAM,WAAW,GAAG,IAAI,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAChD,IAAI,UAAU,GAAG,CAAC,CAAC;IACnB,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,OAAO,CAAC,GAAG,MAAM,EAAE,CAAC;QAClB,MAAM,SAAS,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;QACxC,8EAA8E;QAC9E,MAAM,EAAE,GAAG,SAAmB,CAAC;QAC/B,MAAM,UAAU,GAAG,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QACvC,WAAW,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC;QAC5B,IAAI,UAAU,KAAK,CAAC,EAAE,CAAC;YACrB,qEAAqE;YACrE,uEAAuE;YACvE,WAAW,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,UAAU,CAAC;QAClC,CAAC;QACD,UAAU,IAAI,qBAAqB,CAAC,EAAE,CAAC,CAAC;QACxC,CAAC,IAAI,UAAU,CAAC;IAClB,CAAC;IACD,WAAW,CAAC,MAAM,CAAC,GAAG,UAAU,CAAC;IAEjC,OAAO;QACL,UAAU,EAAE,UAAU;QACtB,YAAY,CAAC,UAAkB;YAC7B,MAAM,OAAO,GAAG,UAAU,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,GAAG,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,UAAU,CAAC;YAC/E,OAAO,WAAW,CAAC,OAAO,CAAW,CAAC;QACxC,CAAC;KACF,CAAC;AACJ,CAAC"}

package/package.json

@@ -1,6 +1,128 @@
 {
   "name": "@untangle-code/parser-registry",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "description": "Untangle parser registry: lazy-loaded LanguageAdapter registry plus TypeScript/JavaScript/TSX/JSX tree-sitter adapters.",
+  "license": "AGPL-3.0-only",
+  "homepage": "https://github.com/lboel/untangle",
+  "bugs": {
+    "url": "https://github.com/lboel/untangle/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lboel/untangle.git",
+    "directory": "packages/parser-registry"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": "^22.13.0 || >=24.0.0"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.test.*",
+    "!dist/**/test-helpers.*",
+    "!dist/**/test-support.*",
+    "!dist/**/test-support/**",
+    "!dist/**/testing/**",
+    "!dist/**/__tests__/**",
+    "src",
+    "!src/**/*.test.ts",
+    "!src/**/test-helpers.ts",
+    "!src/**/test-support.ts",
+    "!src/**/test-support/**",
+    "!src/**/testing/**",
+    "LICENSE",
+    "NOTICE",
+    "README.md",
+    "THIRD_PARTY_LICENSES.md"
+  ],
+  "dependencies": {
+    "@ast-grep/lang-python": "0.0.6",
+    "@ast-grep/napi": "0.45.3",
+    "@vue/compiler-sfc": "3.5.44",
+    "tree-sitter": "0.21.1",
+    "tree-sitter-javascript": "0.23.1",
+    "tree-sitter-typescript": "0.23.2",
+    "@untangle-code/domain": "0.1.0"
+  },
+  "devDependencies": {
+    "@ast-grep/lang-bash": "0.0.8",
+    "@ast-grep/lang-c": "0.0.6",
+    "@ast-grep/lang-cpp": "0.0.6",
+    "@ast-grep/lang-csharp": "0.0.6",
+    "@ast-grep/lang-go": "0.0.6",
+    "@ast-grep/lang-java": "0.0.7",
+    "@ast-grep/lang-kotlin": "0.0.7",
+    "@ast-grep/lang-php": "0.0.7",
+    "@ast-grep/lang-ruby": "0.0.7",
+    "@ast-grep/lang-rust": "0.0.7",
+    "@ast-grep/lang-swift": "0.0.8",
+    "@types/node": "22.19.7",
+    "typescript": "5.9.3",
+    "vitest": "3.2.7",
+    "@untangle-code/testkit": "0.1.0"
+  },
+  "peerDependencies": {
+    "@ast-grep/lang-bash": "0.0.8",
+    "@ast-grep/lang-c": "0.0.6",
+    "@ast-grep/lang-cpp": "0.0.6",
+    "@ast-grep/lang-csharp": "0.0.6",
+    "@ast-grep/lang-go": "0.0.6",
+    "@ast-grep/lang-java": "0.0.7",
+    "@ast-grep/lang-kotlin": "0.0.7",
+    "@ast-grep/lang-php": "0.0.7",
+    "@ast-grep/lang-ruby": "0.0.7",
+    "@ast-grep/lang-rust": "0.0.7",
+    "@ast-grep/lang-swift": "0.0.8"
+  },
+  "peerDependenciesMeta": {
+    "@ast-grep/lang-go": {
+      "optional": true
+    },
+    "@ast-grep/lang-java": {
+      "optional": true
+    },
+    "@ast-grep/lang-rust": {
+      "optional": true
+    },
+    "@ast-grep/lang-csharp": {
+      "optional": true
+    },
+    "@ast-grep/lang-ruby": {
+      "optional": true
+    },
+    "@ast-grep/lang-php": {
+      "optional": true
+    },
+    "@ast-grep/lang-kotlin": {
+      "optional": true
+    },
+    "@ast-grep/lang-c": {
+      "optional": true
+    },
+    "@ast-grep/lang-cpp": {
+      "optional": true
+    },
+    "@ast-grep/lang-swift": {
+      "optional": true
+    },
+    "@ast-grep/lang-bash": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build": "node ../../scripts/tsc-build.mjs tsconfig.json",
+    "typecheck": "tsc -p tsconfig.typecheck.json",
+    "test": "vitest run",
+    "clean": "rm -rf dist *.tsbuildinfo"
+  }
 }

package/src/boundaries/expression.ts

@@ -0,0 +1,95 @@
+import type { HttpExpressionV1 } from "@untangle-code/domain";
+
+import type { SyntaxNode } from "../languages/shared/syntax.js";
+
+export function namedChildren(node: SyntaxNode): SyntaxNode[] {
+  return node.children.filter((child) => child.isNamed && child.type !== "comment");
+}
+
+export function field(node: SyntaxNode, name: string): SyntaxNode | null {
+  return node.childForFieldName(name);
+}
+
+export function unknown(detail: string): HttpExpressionV1 {
+  return { kind: "unknown", detail };
+}
+
+/** Only unescaped literals are accepted. Unsupported escapes remain explicit unknowns. */
+export function stringValue(node: SyntaxNode | null): string | null {
+  if (node === null || (node.type !== "string" && node.type !== "string_literal")) return null;
+  const raw = node.text;
+  const quote = raw[0];
+  if ((quote !== "'" && quote !== '"') || raw.at(-1) !== quote || raw.includes("\\")) return null;
+  if (raw.startsWith(quote.repeat(3))) return null;
+  return raw.slice(1, -1);
+}
+
+/** Interpret syntax, never execute source expressions or scan comments/string contents as code. */
+export function expression(node: SyntaxNode | null, depth = 0): HttpExpressionV1 {
+  if (node === null) return unknown("missing expression");
+  if (depth > 40) return unknown("expression depth budget exceeded");
+  const next = (child: SyntaxNode | null) => expression(child, depth + 1);
+  const string = stringValue(node);
+  if (string !== null) return { kind: "string", value: string };
+  if (node.type === "identifier" || node.type === "shorthand_property_identifier") {
+    return node.text === "undefined" ? { kind: "undefined" } : { kind: "name", name: node.text };
+  }
+  if (
+    ["parenthesized_expression", "as_expression", "type_assertion", "await_expression"].includes(
+      node.type,
+    )
+  ) {
+    return next(namedChildren(node)[0] ?? null);
+  }
+  if (node.type === "member_expression" || node.type === "attribute") {
+    const property = field(node, "property") ?? field(node, "attribute");
+    return property === null
+      ? unknown("computed member")
+      : {
+          kind: "member",
+          object: next(field(node, "object")),
+          property: property.text,
+        };
+  }
+  if (node.type === "call_expression" || node.type === "call") {
+    return {
+      kind: "call",
+      callee: next(field(node, "function")),
+      arguments: namedChildren(field(node, "arguments") ?? node).map(next),
+    };
+  }
+  if (node.type === "template_string") {
+    const parts: (string | HttpExpressionV1)[] = [];
+    for (const child of namedChildren(node)) {
+      if (child.type === "string_fragment") parts.push(child.text);
+      else if (child.type === "template_substitution")
+        parts.push(next(namedChildren(child)[0] ?? null));
+      else return unknown("escaped or unsupported template segment");
+    }
+    return { kind: "template", parts };
+  }
+  if (
+    node.type === "binary_expression" &&
+    node.children.some((child) => child.text === "+" && !child.isNamed)
+  ) {
+    return { kind: "template", parts: [next(field(node, "left")), next(field(node, "right"))] };
+  }
+  if (node.type === "object") {
+    const entries: Extract<HttpExpressionV1, { kind: "object" }>["entries"] = [];
+    for (const child of namedChildren(node)) {
+      if (child.type === "spread_element")
+        entries.push({ spread: next(namedChildren(child)[0] ?? null) });
+      else if (child.type === "pair") {
+        const key = field(child, "key");
+        const literalKey = stringValue(key);
+        if (key === null || (literalKey === null && key.type !== "property_identifier")) {
+          entries.push({ spread: unknown("computed object key") });
+        } else entries.push({ key: literalKey ?? key.text, value: next(field(child, "value")) });
+      } else if (child.type === "shorthand_property_identifier") {
+        entries.push({ key: child.text, value: next(child) });
+      } else entries.push({ spread: unknown("unsupported object entry") });
+    }
+    return { kind: "object", entries };
+  }
+  return unknown(`unsupported ${node.type}`);
+}

package/src/boundaries/extract.ts

@@ -0,0 +1,307 @@
+/** AST projections for HTTP boundaries. Backend-specific ASTs stay inside the parser package. */
+import type {
+  HttpBoundaryFileFactsV1,
+  HttpFunctionFactV1,
+  LanguageAdapter,
+  ParsedAst,
+  SourceFile,
+} from "@untangle-code/domain";
+import { sha256Hex } from "@untangle-code/domain";
+
+import type { FileTextContext } from "../languages/shared/node-utils.js";
+import { rangeOf } from "../languages/shared/node-utils.js";
+import type { SyntaxNode } from "../languages/shared/syntax.js";
+import { shiftVueRange } from "../languages/vue/index.js";
+import type { VueAstRoot } from "../languages/vue/index.js";
+
+import { expression, field, namedChildren } from "./expression.js";
+import { extractPythonHttpFacts } from "./python.js";
+
+const FUNCTIONS = new Set([
+  "function_declaration",
+  "function_expression",
+  "arrow_function",
+  "method_definition",
+  "function_definition",
+]);
+
+interface NativePayload {
+  tree?: { rootNode: SyntaxNode };
+  root?: SyntaxNode;
+  ctx: FileTextContext;
+}
+
+/** Provenance keys are source locations, never graph identifiers. */
+export function functionScope(node: SyntaxNode): string {
+  return `function@${String(node.startIndex)}`;
+}
+
+export function enclosingFunction(node: SyntaxNode): SyntaxNode | null {
+  let current = node.parent;
+  while (current !== null) {
+    if (FUNCTIONS.has(current.type)) return current;
+    current = current.parent;
+  }
+  return null;
+}
+
+export function scopeOf(node: SyntaxNode): string {
+  const owner = enclosingFunction(node);
+  return owner === null ? "module" : functionScope(owner);
+}
+
+function boundNames(pattern: SyntaxNode): string[] {
+  return walkSyntax(pattern)
+    .filter(
+      (node) => node.type === "identifier" || node.type === "shorthand_property_identifier_pattern",
+    )
+    .map((node) => node.text);
+}
+
+export function functionFact(node: SyntaxNode, ctx: FileTextContext): HttpFunctionFactV1 {
+  const nameNode = field(node, "name");
+  const assignedName =
+    node.parent?.type === "variable_declarator" ? field(node.parent, "name") : null;
+  const params = field(node, "parameters");
+  const patternParameters =
+    params === null
+      ? []
+      : namedChildren(params).flatMap((param) => {
+          const pattern = field(param, "pattern") ?? param;
+          return ["object_pattern", "array_pattern", "rest_pattern"].includes(pattern.type)
+            ? boundNames(pattern).map((name) => ({ name }))
+            : [];
+        });
+  return {
+    scope: functionScope(node),
+    parentScope: scopeOf(node),
+    name: nameNode?.text ?? assignedName?.text ?? `<anonymous@${String(node.startIndex)}>`,
+    range: rangeOf(node, ctx),
+    parameters: [
+      ...(params === null
+        ? []
+        : namedChildren(params).map((param) => {
+            const name =
+              field(param, "pattern") ??
+              field(param, "name") ??
+              namedChildren(param).find((child) => child.type === "identifier") ??
+              param;
+            const value = field(param, "value");
+            const annotation = field(param, "type");
+            return {
+              name: name.text,
+              ...(value === null ? {} : { defaultValue: expression(value) }),
+              ...(annotation?.text.replaceAll(/\s+/g, " ").trim() === ": typeof fetch"
+                ? { fetchTransport: true }
+                : {}),
+            };
+          })),
+      ...patternParameters,
+    ],
+  };
+}
+
+export function walkSyntax(root: SyntaxNode): SyntaxNode[] {
+  const result: SyntaxNode[] = [];
+  const stack = [root];
+  while (stack.length > 0) {
+    const node = stack.pop() as SyntaxNode;
+    result.push(node);
+    const children = namedChildren(node);
+    for (let index = children.length - 1; index >= 0; index -= 1)
+      stack.push(children[index] as SyntaxNode);
+  }
+  return result;
+}
+
+export function extractHttpBoundaryFacts(
+  source: SourceFile,
+  ast: ParsedAst,
+  adapter?: LanguageAdapter,
+): HttpBoundaryFileFactsV1 {
+  const facts: HttpBoundaryFileFactsV1 = {
+    path: source.path,
+    contentHash: source.contentHash,
+    languageId: ast.languageId,
+    parseQuality: ast.parseQuality,
+    imports: adapter?.extractImports(ast) ?? [],
+    calls: [],
+    functions: [],
+    bindings: [],
+    routers: [],
+    routes: [],
+    includes: [],
+    pythonImports: [],
+    limitations: [],
+  };
+  if (sha256Hex(source.content) !== source.contentHash) {
+    facts.limitations.push("Source content does not match its declared hash");
+    return facts;
+  }
+  if (ast.languageId === "vue") {
+    if (ast.parseQuality !== "complete") {
+      facts.limitations.push("HTTP boundary extraction requires a complete Vue parse");
+      return facts;
+    }
+    const root = ast.root as VueAstRoot;
+    for (const script of root.scripts) {
+      const part = extractHttpBoundaryFacts(script.source, script.ast, script.adapter);
+      const prefix = `${script.context}:`;
+      const scope = (value: string) => `${prefix}${value}`;
+      const shift = (range: HttpFunctionFactV1["range"]) => shiftVueRange(script, range);
+      facts.functions.push({
+        scope: scope("module"),
+        parentScope: "module",
+        name: `<${script.context}>`,
+        range: script.range,
+        parameters: [],
+      });
+      facts.calls.push(
+        ...part.calls.map((call) => ({
+          ...call,
+          scope: scope(call.scope),
+          range: shift(call.range),
+        })),
+      );
+      facts.functions.push(
+        ...part.functions.map((fn) => ({
+          ...fn,
+          scope: scope(fn.scope),
+          parentScope: scope(fn.parentScope),
+          range: shift(fn.range),
+        })),
+      );
+      facts.bindings.push(
+        ...part.bindings.map((binding) => ({
+          ...binding,
+          scope: scope(binding.scope),
+          range: shift(binding.range),
+        })),
+      );
+      facts.limitations.push(...part.limitations);
+    }
+    return facts;
+  }
+  if (!["typescript", "javascript", "tsx", "jsx", "python"].includes(ast.languageId)) {
+    facts.limitations.push(`HTTP boundary extraction is unsupported for ${ast.languageId}`);
+    return facts;
+  }
+  if (ast.parseQuality !== "complete") {
+    facts.limitations.push("HTTP boundary extraction requires a complete parse");
+    return facts;
+  }
+  const payload = ast.root as NativePayload;
+  const root = payload.tree?.rootNode ?? payload.root;
+  if (
+    root === undefined ||
+    payload.ctx === undefined ||
+    payload.ctx.sourceText !== source.content
+  ) {
+    facts.limitations.push("Unsupported parser AST payload");
+    return facts;
+  }
+  const nodes = walkSyntax(root);
+  for (const node of nodes) {
+    if (FUNCTIONS.has(node.type)) facts.functions.push(functionFact(node, payload.ctx));
+    if (node.type === "variable_declarator" || node.type === "assignment") {
+      const name = field(node, "name") ?? field(node, "left");
+      const value = field(node, "value") ?? field(node, "right");
+      if (name !== null && ["object_pattern", "array_pattern"].includes(name.type)) {
+        for (const bound of boundNames(name))
+          facts.bindings.push({
+            scope: scopeOf(node),
+            name: bound,
+            value: { kind: "unknown", detail: "destructured binding" },
+            range: rangeOf(node, payload.ctx),
+          });
+      }
+      if (name?.type === "identifier" && value !== null)
+        facts.bindings.push({
+          scope: scopeOf(node),
+          name: name.text,
+          value:
+            node.type === "variable_declarator" &&
+            !node.parent?.children.some((child) => child.text === "const" && !child.isNamed)
+              ? { kind: "unknown", detail: "mutable variable binding" }
+              : expression(value),
+          range: rangeOf(node, payload.ctx),
+        });
+    }
+    if (node.type === "catch_clause") {
+      const parameter = field(node, "parameter");
+      if (parameter !== null)
+        for (const name of boundNames(parameter))
+          facts.bindings.push({
+            scope: scopeOf(node),
+            name,
+            value: { kind: "unknown", detail: "catch parameter binding" },
+            range: rangeOf(node, payload.ctx),
+          });
+    }
+    if (
+      node.type === "assignment_expression" ||
+      node.type === "augmented_assignment_expression" ||
+      node.type === "update_expression" ||
+      (node.type === "unary_expression" &&
+        node.children.some((child) => !child.isNamed && child.text === "delete"))
+    ) {
+      let target = field(node, "left") ?? field(node, "argument");
+      while (target?.type === "member_expression" || target?.type === "subscript_expression")
+        target = field(target, "object");
+      if (target !== null && ["object_pattern", "array_pattern"].includes(target.type)) {
+        for (const part of walkSyntax(target)) {
+          if (
+            part.type !== "member_expression" &&
+            part.type !== "subscript_expression" &&
+            part.type !== "shorthand_property_identifier_pattern"
+          )
+            continue;
+          let object = part;
+          while (object.type === "member_expression" || object.type === "subscript_expression") {
+            const parent = field(object, "object");
+            if (parent === null) break;
+            object = parent;
+          }
+          if (
+            object.type === "identifier" ||
+            object.type === "shorthand_property_identifier_pattern"
+          )
+            facts.bindings.push({
+              scope: scopeOf(node),
+              name: object.text,
+              value: { kind: "unknown", detail: "reassigned binding" },
+              range: rangeOf(node, payload.ctx),
+            });
+        }
+      }
+      if (target?.type === "identifier")
+        facts.bindings.push({
+          scope: scopeOf(node),
+          name: target.text,
+          value: { kind: "unknown", detail: "reassigned binding" },
+          range: rangeOf(node, payload.ctx),
+        });
+    }
+    if (node.type === "call_expression" || node.type === "call") {
+      const owner = enclosingFunction(node);
+      const parameter = owner?.parent;
+      if (
+        owner?.type === "arrow_function" &&
+        parameter !== null &&
+        parameter !== undefined &&
+        ["required_parameter", "optional_parameter"].includes(parameter.type) &&
+        field(parameter, "type")?.text.replaceAll(/\s+/g, " ").trim() === ": typeof fetch"
+      )
+        continue;
+      const args = field(node, "arguments");
+      facts.calls.push({
+        callee: expression(field(node, "function")),
+        arguments: args === null ? [] : namedChildren(args).map((arg) => expression(arg)),
+        range: rangeOf(node, payload.ctx),
+        scope: scopeOf(node),
+      });
+    }
+  }
+  if (ast.languageId === "python") extractPythonHttpFacts(nodes, payload.ctx, facts);
+  return facts;
+}