@letant/python 0.0.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Juun
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# @letant/python
+
+Python grammar provider plugin for letant core library.

package/dist/index.d.mts

@@ -0,0 +1,27 @@
+import * as letant from 'letant';
+
+type QueryConfig = {
+    "module.binding": {
+        required: "source";
+        optional: "alias" | "name";
+    };
+    variable: {
+        required: "node" | "name";
+        optional: never;
+    };
+    class: {
+        required: "node" | "name" | "body";
+        optional: "extends";
+    };
+    function: {
+        required: "node" | "name" | "body";
+        optional: never;
+    };
+};
+type NodeKind = letant.Head<keyof QueryConfig> | "parameter";
+type Node = letant.Node<NodeKind>;
+type Descriptor = letant.Plugin.Descriptor<QueryConfig, Node>;
+
+declare const descriptor: Descriptor;
+
+export { descriptor as default, descriptor };

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+import * as letant from 'letant';
+
+type QueryConfig = {
+    "module.binding": {
+        required: "source";
+        optional: "alias" | "name";
+    };
+    variable: {
+        required: "node" | "name";
+        optional: never;
+    };
+    class: {
+        required: "node" | "name" | "body";
+        optional: "extends";
+    };
+    function: {
+        required: "node" | "name" | "body";
+        optional: never;
+    };
+};
+type NodeKind = letant.Head<keyof QueryConfig> | "parameter";
+type Node = letant.Node<NodeKind>;
+type Descriptor = letant.Plugin.Descriptor<QueryConfig, Node>;
+
+declare const descriptor: Descriptor;
+
+export { descriptor as default, descriptor };

package/dist/index.js

@@ -0,0 +1,335 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => index_default,
+  descriptor: () => descriptor
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/query.ts
+var import_query = require("letant/query");
+var import_tree_sitter_python = __toESM(require("tree-sitter-python"));
+
+// src/queries/binding/module.scm
+var module_default = "(import_statement name: (dotted_name) @source @name) (import_statement name: (aliased_import name: (dotted_name) @source alias: (identifier) @alias)) (import_from_statement module_name: [ (dotted_name) (relative_import) ] @source name: (dotted_name) @name) (import_from_statement module_name: [ (dotted_name) (relative_import) ] @source name: (aliased_import name: (dotted_name) @name alias: (identifier) @alias))";
+
+// src/queries/binding/variable.scm
+var variable_default = "(expression_statement (assignment left: [ (identifier) (pattern_list) (tuple_pattern) ] @name) ) @node (for_statement left: [ (identifier) (pattern_list) (tuple_pattern) ] @name ) @node";
+
+// src/queries/scope/class.scm
+var class_default = "(class_definition name: (identifier) @name superclasses: (argument_list)? @extends body: (block) @body ) @node";
+
+// src/queries/scope/function.scm
+var function_default = "(function_definition name: (identifier) @name body: (block) @body ) @node";
+
+// src/queries/utility/reference.scm
+var reference_default = "(identifier) @reference";
+
+// src/query.ts
+var language = import_tree_sitter_python.default;
+var query = new import_query.QueryMap(language).set("module.binding", module_default).set("variable", variable_default).set("class", class_default).set("function", function_default);
+var utility = new import_query.QueryMap(language).set(
+  "reference",
+  reference_default
+);
+
+// src/handlers/bypass/compound.ts
+var COMPOUND = /* @__PURE__ */ new Set([
+  "if_statement",
+  "elif_clause",
+  "else_clause",
+  "for_statement",
+  "while_statement",
+  "try_statement",
+  "except_clause",
+  "finally_clause",
+  "with_statement",
+  "match_statement",
+  "case_clause"
+]);
+function bypassCompound(queryKey) {
+  const blocks = (node) => node.namedChildren.flatMap((child) => {
+    if (child.type === "block") return [child];
+    if (COMPOUND.has(child.type)) return blocks(child);
+    return [];
+  });
+  const run = (node) => {
+    const matches = [];
+    for (const child of node.namedChildren) {
+      if (child.type === "decorated_definition") {
+        const definition = child.childForFieldName("definition");
+        if (definition) {
+          matches.push(
+            ...query.match(queryKey, definition, { maxStartDepth: 0 })
+          );
+        }
+        continue;
+      }
+      if (!COMPOUND.has(child.type)) continue;
+      for (const block of blocks(child)) {
+        matches.push(...query.match(queryKey, block, { maxStartDepth: 1 }));
+        matches.push(...run(block));
+      }
+    }
+    return matches;
+  };
+  return run;
+}
+var compound_default = bypassCompound;
+
+// src/capture.ts
+var captureConfig = {
+  "module.binding": {
+    bypass: compound_default("module.binding")
+  },
+  variable: {
+    bypass: compound_default("variable")
+  },
+  class: {
+    bypass: compound_default("class")
+  },
+  function: {
+    bypass: compound_default("function")
+  }
+};
+
+// src/handlers/binding/module.ts
+var import_utils = require("letant/utils");
+var import_utils2 = require("letant/utils");
+
+// src/handlers/utility/module-path.ts
+function toModulePath(source) {
+  if (!source.startsWith(".")) return source;
+  const dots = /^\.+/.exec(source)[0].length;
+  const rest = source.slice(dots).replace(/\./g, "/");
+  const prefix = dots === 1 ? "./" : "../".repeat(dots - 1);
+  return rest ? prefix + rest : prefix;
+}
+var module_path_default = toModulePath;
+
+// src/handlers/binding/module.ts
+var moduleBindingHandler = (captures, parent) => {
+  const result = (0, import_utils2.createConvertResult)();
+  for (const c of captures) {
+    const { source, name, alias } = c;
+    const plain = !!name && !alias && source.text === name.text;
+    const representative = alias?.text ?? (plain ? source.text.split(".")[0] : name?.text);
+    if (!representative) continue;
+    let modulePath = module_path_default(plain ? representative : source.text);
+    if (modulePath.endsWith("/") && name) {
+      modulePath += name.text;
+    }
+    result.nodes.push({
+      path: (0, import_utils2.createChildPath)(parent, representative),
+      type: "binding",
+      kind: "module",
+      at: (0, import_utils.NodeSource)(modulePath),
+      props: alias ? { alias_of: (name ?? source).text } : void 0
+    });
+  }
+  return result;
+};
+var module_default2 = moduleBindingHandler;
+
+// src/handlers/binding/variable.ts
+var import_utils3 = require("letant/utils");
+
+// src/handlers/utility/pattern.ts
+var dispatcher = {
+  // terminate condition of recursion
+  identifier: (node) => [{ name: node.text, node }],
+  // recurse over single element
+  list_splat_pattern: (node) => flatPattern(node.firstNamedChild),
+  // recurse over multiple elements
+  pattern_list: (node) => node.namedChildren.flatMap((c) => flatPattern(c)),
+  tuple_pattern: (node) => node.namedChildren.flatMap((c) => flatPattern(c)),
+  list_pattern: (node) => node.namedChildren.flatMap((c) => flatPattern(c))
+};
+function flatPattern(node) {
+  if (!dispatcher[node.type]) {
+    return [];
+  }
+  return dispatcher[node.type](node);
+}
+var pattern_default = flatPattern;
+
+// src/handlers/binding/variable.ts
+var variableHandler = (captures, parent) => {
+  const result = (0, import_utils3.createConvertResult)();
+  for (const c of captures) {
+    const { node, name } = c;
+    for (const { name: nm, node: n } of pattern_default(name)) {
+      const path = (0, import_utils3.createChildPath)(parent, nm);
+      result.nodes.push({
+        path,
+        type: "binding",
+        kind: "variable",
+        at: (0, import_utils3.getRange)(name.type === "identifier" ? node : n)
+      });
+    }
+  }
+  return result;
+};
+var variable_default2 = variableHandler;
+
+// src/handlers/scope/class.ts
+var import_utils4 = require("letant/utils");
+var classHandler = (captures, parent, { capture, convert }) => {
+  const result = (0, import_utils4.createConvertResult)();
+  for (const c of captures) {
+    const { node, name, extends: ext, body } = c;
+    const path = (0, import_utils4.createChildPath)(parent, name.text);
+    result.nodes.push({
+      path,
+      type: "scope",
+      kind: "class",
+      at: (0, import_utils4.getRange)(node),
+      blockStartIndex: body.startIndex,
+      props: {
+        extends: ext?.text
+      }
+    });
+    result.push(convert(capture(body), path));
+  }
+  return result;
+};
+var class_default2 = classHandler;
+
+// src/handlers/scope/function.ts
+var import_utils5 = require("letant/utils");
+
+// src/handlers/utility/parameter.ts
+function flatParameters(parameters) {
+  const result = [];
+  for (const child of parameters.namedChildren) {
+    switch (child.type) {
+      case "identifier":
+        result.push({ name: child.text, node: child, has_default: false });
+        break;
+      case "typed_parameter": {
+        const inner = child.firstNamedChild;
+        if (inner?.type === "identifier") {
+          result.push({ name: inner.text, node: child, has_default: false });
+        }
+        break;
+      }
+      case "default_parameter":
+      case "typed_default_parameter": {
+        const name = child.childForFieldName("name");
+        if (name?.type === "identifier") {
+          result.push({ name: name.text, node: child, has_default: true });
+        }
+        break;
+      }
+      case "list_splat_pattern":
+      case "dictionary_splat_pattern": {
+        const inner = child.firstNamedChild;
+        if (inner?.type === "identifier") {
+          result.push({ name: inner.text, node: child, has_default: false });
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return result;
+}
+var parameter_default = flatParameters;
+
+// src/handlers/scope/function.ts
+var functionHandler = (captures, parent, { capture, convert }) => {
+  const result = (0, import_utils5.createConvertResult)();
+  for (const c of captures) {
+    const { node, name, body } = c;
+    const path = (0, import_utils5.createChildPath)(parent, name.text);
+    result.nodes.push({
+      path,
+      type: "scope",
+      kind: "function",
+      at: (0, import_utils5.getRange)(node),
+      blockStartIndex: body.startIndex,
+      props: {
+        is_async: node.children.some((child) => child.type === "async")
+      }
+    });
+    const parameters = node.childForFieldName("parameters");
+    if (parameters) {
+      for (const { name: nm, node: n, has_default } of parameter_default(
+        parameters
+      )) {
+        result.nodes.push({
+          path: (0, import_utils5.createChildPath)(path, nm),
+          type: "binding",
+          kind: "parameter",
+          at: (0, import_utils5.getRange)(n),
+          props: { has_default }
+        });
+      }
+    }
+    result.push(convert(capture(body), path));
+  }
+  return result;
+};
+var function_default2 = functionHandler;
+
+// src/convert.ts
+var convertConfig = {
+  // binding
+  "module.binding": module_default2,
+  variable: variable_default2,
+  // scope
+  class: class_default2,
+  function: function_default2
+};
+
+// src/handlers/utility/reference.ts
+function referenceHandler(node) {
+  const captured = utility.get("reference").captures(node, { startIndex: node.startIndex, endIndex: node.endIndex }).flatMap((c) => c.node);
+  return captured;
+}
+var reference_default2 = referenceHandler;
+
+// src/index.ts
+var descriptor = {
+  language,
+  extensions: [".py", "/__init__.py"],
+  query,
+  captureConfig,
+  convertConfig,
+  references: reference_default2
+};
+var index_default = descriptor;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  descriptor
+});

package/dist/index.mjs

@@ -0,0 +1,298 @@
+// src/query.ts
+import { QueryMap } from "letant/query";
+import Python from "tree-sitter-python";
+
+// src/queries/binding/module.scm
+var module_default = "(import_statement name: (dotted_name) @source @name) (import_statement name: (aliased_import name: (dotted_name) @source alias: (identifier) @alias)) (import_from_statement module_name: [ (dotted_name) (relative_import) ] @source name: (dotted_name) @name) (import_from_statement module_name: [ (dotted_name) (relative_import) ] @source name: (aliased_import name: (dotted_name) @name alias: (identifier) @alias))";
+
+// src/queries/binding/variable.scm
+var variable_default = "(expression_statement (assignment left: [ (identifier) (pattern_list) (tuple_pattern) ] @name) ) @node (for_statement left: [ (identifier) (pattern_list) (tuple_pattern) ] @name ) @node";
+
+// src/queries/scope/class.scm
+var class_default = "(class_definition name: (identifier) @name superclasses: (argument_list)? @extends body: (block) @body ) @node";
+
+// src/queries/scope/function.scm
+var function_default = "(function_definition name: (identifier) @name body: (block) @body ) @node";
+
+// src/queries/utility/reference.scm
+var reference_default = "(identifier) @reference";
+
+// src/query.ts
+var language = Python;
+var query = new QueryMap(language).set("module.binding", module_default).set("variable", variable_default).set("class", class_default).set("function", function_default);
+var utility = new QueryMap(language).set(
+  "reference",
+  reference_default
+);
+
+// src/handlers/bypass/compound.ts
+var COMPOUND = /* @__PURE__ */ new Set([
+  "if_statement",
+  "elif_clause",
+  "else_clause",
+  "for_statement",
+  "while_statement",
+  "try_statement",
+  "except_clause",
+  "finally_clause",
+  "with_statement",
+  "match_statement",
+  "case_clause"
+]);
+function bypassCompound(queryKey) {
+  const blocks = (node) => node.namedChildren.flatMap((child) => {
+    if (child.type === "block") return [child];
+    if (COMPOUND.has(child.type)) return blocks(child);
+    return [];
+  });
+  const run = (node) => {
+    const matches = [];
+    for (const child of node.namedChildren) {
+      if (child.type === "decorated_definition") {
+        const definition = child.childForFieldName("definition");
+        if (definition) {
+          matches.push(
+            ...query.match(queryKey, definition, { maxStartDepth: 0 })
+          );
+        }
+        continue;
+      }
+      if (!COMPOUND.has(child.type)) continue;
+      for (const block of blocks(child)) {
+        matches.push(...query.match(queryKey, block, { maxStartDepth: 1 }));
+        matches.push(...run(block));
+      }
+    }
+    return matches;
+  };
+  return run;
+}
+var compound_default = bypassCompound;
+
+// src/capture.ts
+var captureConfig = {
+  "module.binding": {
+    bypass: compound_default("module.binding")
+  },
+  variable: {
+    bypass: compound_default("variable")
+  },
+  class: {
+    bypass: compound_default("class")
+  },
+  function: {
+    bypass: compound_default("function")
+  }
+};
+
+// src/handlers/binding/module.ts
+import { NodeSource } from "letant/utils";
+import { createChildPath, createConvertResult } from "letant/utils";
+
+// src/handlers/utility/module-path.ts
+function toModulePath(source) {
+  if (!source.startsWith(".")) return source;
+  const dots = /^\.+/.exec(source)[0].length;
+  const rest = source.slice(dots).replace(/\./g, "/");
+  const prefix = dots === 1 ? "./" : "../".repeat(dots - 1);
+  return rest ? prefix + rest : prefix;
+}
+var module_path_default = toModulePath;
+
+// src/handlers/binding/module.ts
+var moduleBindingHandler = (captures, parent) => {
+  const result = createConvertResult();
+  for (const c of captures) {
+    const { source, name, alias } = c;
+    const plain = !!name && !alias && source.text === name.text;
+    const representative = alias?.text ?? (plain ? source.text.split(".")[0] : name?.text);
+    if (!representative) continue;
+    let modulePath = module_path_default(plain ? representative : source.text);
+    if (modulePath.endsWith("/") && name) {
+      modulePath += name.text;
+    }
+    result.nodes.push({
+      path: createChildPath(parent, representative),
+      type: "binding",
+      kind: "module",
+      at: NodeSource(modulePath),
+      props: alias ? { alias_of: (name ?? source).text } : void 0
+    });
+  }
+  return result;
+};
+var module_default2 = moduleBindingHandler;
+
+// src/handlers/binding/variable.ts
+import { createChildPath as createChildPath2, createConvertResult as createConvertResult2, getRange } from "letant/utils";
+
+// src/handlers/utility/pattern.ts
+var dispatcher = {
+  // terminate condition of recursion
+  identifier: (node) => [{ name: node.text, node }],
+  // recurse over single element
+  list_splat_pattern: (node) => flatPattern(node.firstNamedChild),
+  // recurse over multiple elements
+  pattern_list: (node) => node.namedChildren.flatMap((c) => flatPattern(c)),
+  tuple_pattern: (node) => node.namedChildren.flatMap((c) => flatPattern(c)),
+  list_pattern: (node) => node.namedChildren.flatMap((c) => flatPattern(c))
+};
+function flatPattern(node) {
+  if (!dispatcher[node.type]) {
+    return [];
+  }
+  return dispatcher[node.type](node);
+}
+var pattern_default = flatPattern;
+
+// src/handlers/binding/variable.ts
+var variableHandler = (captures, parent) => {
+  const result = createConvertResult2();
+  for (const c of captures) {
+    const { node, name } = c;
+    for (const { name: nm, node: n } of pattern_default(name)) {
+      const path = createChildPath2(parent, nm);
+      result.nodes.push({
+        path,
+        type: "binding",
+        kind: "variable",
+        at: getRange(name.type === "identifier" ? node : n)
+      });
+    }
+  }
+  return result;
+};
+var variable_default2 = variableHandler;
+
+// src/handlers/scope/class.ts
+import { createChildPath as createChildPath3, createConvertResult as createConvertResult3, getRange as getRange2 } from "letant/utils";
+var classHandler = (captures, parent, { capture, convert }) => {
+  const result = createConvertResult3();
+  for (const c of captures) {
+    const { node, name, extends: ext, body } = c;
+    const path = createChildPath3(parent, name.text);
+    result.nodes.push({
+      path,
+      type: "scope",
+      kind: "class",
+      at: getRange2(node),
+      blockStartIndex: body.startIndex,
+      props: {
+        extends: ext?.text
+      }
+    });
+    result.push(convert(capture(body), path));
+  }
+  return result;
+};
+var class_default2 = classHandler;
+
+// src/handlers/scope/function.ts
+import { createChildPath as createChildPath4, createConvertResult as createConvertResult4, getRange as getRange3 } from "letant/utils";
+
+// src/handlers/utility/parameter.ts
+function flatParameters(parameters) {
+  const result = [];
+  for (const child of parameters.namedChildren) {
+    switch (child.type) {
+      case "identifier":
+        result.push({ name: child.text, node: child, has_default: false });
+        break;
+      case "typed_parameter": {
+        const inner = child.firstNamedChild;
+        if (inner?.type === "identifier") {
+          result.push({ name: inner.text, node: child, has_default: false });
+        }
+        break;
+      }
+      case "default_parameter":
+      case "typed_default_parameter": {
+        const name = child.childForFieldName("name");
+        if (name?.type === "identifier") {
+          result.push({ name: name.text, node: child, has_default: true });
+        }
+        break;
+      }
+      case "list_splat_pattern":
+      case "dictionary_splat_pattern": {
+        const inner = child.firstNamedChild;
+        if (inner?.type === "identifier") {
+          result.push({ name: inner.text, node: child, has_default: false });
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return result;
+}
+var parameter_default = flatParameters;
+
+// src/handlers/scope/function.ts
+var functionHandler = (captures, parent, { capture, convert }) => {
+  const result = createConvertResult4();
+  for (const c of captures) {
+    const { node, name, body } = c;
+    const path = createChildPath4(parent, name.text);
+    result.nodes.push({
+      path,
+      type: "scope",
+      kind: "function",
+      at: getRange3(node),
+      blockStartIndex: body.startIndex,
+      props: {
+        is_async: node.children.some((child) => child.type === "async")
+      }
+    });
+    const parameters = node.childForFieldName("parameters");
+    if (parameters) {
+      for (const { name: nm, node: n, has_default } of parameter_default(
+        parameters
+      )) {
+        result.nodes.push({
+          path: createChildPath4(path, nm),
+          type: "binding",
+          kind: "parameter",
+          at: getRange3(n),
+          props: { has_default }
+        });
+      }
+    }
+    result.push(convert(capture(body), path));
+  }
+  return result;
+};
+var function_default2 = functionHandler;
+
+// src/convert.ts
+var convertConfig = {
+  // binding
+  "module.binding": module_default2,
+  variable: variable_default2,
+  // scope
+  class: class_default2,
+  function: function_default2
+};
+
+// src/handlers/utility/reference.ts
+function referenceHandler(node) {
+  const captured = utility.get("reference").captures(node, { startIndex: node.startIndex, endIndex: node.endIndex }).flatMap((c) => c.node);
+  return captured;
+}
+var reference_default2 = referenceHandler;
+
+// src/index.ts
+var descriptor = {
+  language,
+  extensions: [".py", "/__init__.py"],
+  query,
+  captureConfig,
+  convertConfig,
+  references: reference_default2
+};
+var index_default = descriptor;
+export {
+  index_default as default,
+  descriptor
+};

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@letant/python",
+  "version": "0.0.3",
+  "description": "Python plugin for letant",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    }
+  },
+  "keywords": [],
+  "author": "Juun",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": "^22.13.0 || >=24"
+  },
+  "peerDependencies": {
+    "letant": "^0.0.5",
+    "tree-sitter-python": "^0.25.0"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.5",
+    "@types/node": "^26.1.1",
+    "letant": "0.0.5",
+    "tree-sitter-python": "^0.25.0",
+    "tsup": "^8.5.1",
+    "typescript": "^6.0.3"
+  },
+  "scripts": {
+    "attw": "attw --pack --ignore-rules 'no-resolution'",
+    "attw:quiet": "attw --pack --quiet --ignore-rules 'no-resolution'",
+    "build": "tsup",
+    "check-types": "tsc -p ./tsconfig.json --noEmit",
+    "dev": "tsup --watch",
+    "dev:query": "pnpm letant query --grammar tree-sitter-python"
+  }
+}