ast-search 1.0.0

package/README.md

@@ -0,0 +1,86 @@
+# ast-search
+
+A (somewhat) limited-case search tool meant to facilitate large-scale refactors.
+
+Searches files for a given function or property name, and then determines whether those functions or properties contain a given expression or value.
+
+## Example
+
+For example, say you have a large number of VueJS single-file-components with `setup` functions that might be improperly accessing the `this.` instance of the file:
+
+```
+<script>
+...
+export default {
+    setup() {
+        const store = useStore();
+        const dynamicTestValue = computed(() => {
+            return this.testValue
+        })
+    },
+    computed: {
+        testValue: 0
+    }
+}
+</script>
+```
+
+If you have hundreds of component files, this would be especially difficult (if not impossible) to find with a regular expression because it would require both searching across multiple lines and knowing the lexical scope of the `setup` function, which would vary widely across each file.
+
+## Usage
+
+`ast-search` leverages [ acornjs ](https://github.com/acornjs/acorn) to construct an Abstract Syntax Tree of each JavaScript file it parses, and then searches relevant paths for both the given top-level function or property as well as the desired search term.
+
+For example, say the above VueJS SFC is a file at `src/components/TestValue.vue`. To search this file and determine whether the `setup` function has a `this.` expression, you'd do the following:
+
+```bash
+$ ast-search -f ./src/components/TestValue.vue --fn setup -e ThisExpression
+```
+
+If it finds the expression in the function, it echoes the file path:
+
+```bash
+$ ast-search -f ./src/components/TestValue.vue --fn setup -e ThisExpression
+./src/components/TestValue.vue
+```
+
+## Arguments
+
+| Flag               | Definition                                                                                         |
+| ------------------ | -------------------------------------------------------------------------------------------------- |
+| `-f, --file`       | the file path to search, relative or absolute                                                      |
+| `--function, fn`   | the function to search; can be any variation of a function declaration or expression               |
+| `-p, --property`   | the property to search; expected to be a property on an object                                     |
+| `-m, --multiple`   | used for searching function calls, of which a single file may contain several                      |
+| `-e, --expression` | the type of expression to search for; must be a valid `acornjs` JavaScript expression (list below) |
+| `-d, --debug`      | output the full Abstract Syntax Tree to a file called `output.json`                                |
+
+### Supported Expressions
+
+| Expression Name          | Reference                                             | Common Operators              |
+| ------------------------ | ----------------------------------------------------- | ----------------------------- |
+| ArrayExpression          | begins an array expression                            | `[]`                          |
+| ArrowFunctionExpression  | begins an arrow function in any lexical context       | `() =>`                       |
+| AssignmentExpression     | equals operator                                       | `=`                           |
+| AwaitExpression          | asynchronous promise resolver                         | `await`                       |
+| BinaryExpression         | any left + right side operation                       | `1 + 1`                       |
+| CallExpression           | function calls                                        | `fn()`                        |
+| ChainExpression          | chained property or method accessors                  | `store.state.someFn()`        |
+| ConditionalExpression    | ternary expression                                    | `x ? y : z`                   |
+| FunctionExpression       | named, non-assigned functions                         | `fn() {}`                     |
+| ImportExpression         | import statements                                     | `import x from 'y'`           |
+| LogicalExpression        | evaluates to a boolean, e.g. if statement expressions | `if (x > y)`                  |
+| MemberExpression         | object member accessor                                | `this.theMember`              |
+| NewExpression            | `new` constructor declaration                         | `const x = new Item()`        |
+| ObjectExpression         | an object as referenced by its brackets               | `{}`                          |
+| ParenthesizedExpression  | an expression wrapped in parens                       | `const foo = (bar)`           |
+| SequenceExpression       | deconstructor expressions                             | `({...(a,b),c})`              |
+| TaggedTemplateExpression | backtick expressions                                  | <pre>`${test}`</pre>          |
+| ThisExpression           | this accessors                                        | `this.someItem`               |
+| UnaryExpression          | standalone statements                                 | ` return x + 1` (the `x + 1`) |
+| UpdateExpression         | increments, decrements                                | `x++` or `--y`                |
+| YieldExpression          | yield statements in iterators                         | `yield x`                     |
+
+## Support
+
+Currently only supports VueJS's Single File Components.

package/build/__tests__/dummyFiles/empty.js

@@ -0,0 +1 @@
+"use strict";

package/build/__tests__/file.test.js

@@ -0,0 +1,65 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { describe, expect, test } from "@jest/globals";
+import { getAst, getAstFromPath, parseVueSFC } from "../file";
+import { DefaultExport, defaultExport, fsMock, fullVueSFC, reactComponent, vue3SFC, } from "./setup";
+jest.mock("node:fs/promises", () => (Object.assign(Object.assign({}, jest.requireActual("node:fs/promises")), { open: jest.fn().mockImplementation((path, flags) => {
+        return fsMock.promises.open(path, flags);
+    }) })));
+describe("file", () => {
+    test("it creates an ast", () => {
+        const ast = getAst(DefaultExport);
+        expect(ast).toBeTruthy();
+    });
+    test("it parses a Vue SFC component", () => __awaiter(void 0, void 0, void 0, function* () {
+        const { open } = fsMock.promises;
+        const file = yield open(fullVueSFC);
+        const lines = yield file.readFile();
+        const contents = parseVueSFC(lines);
+        [
+            "<template>",
+            "</template>",
+            "<script>",
+            "</script>",
+            "<style>",
+            "</style>",
+        ].forEach((v) => {
+            expect(contents.indexOf(v)).toBe(-1);
+        });
+    }));
+    test("it parses a Vue 3 SFC with <script setup lang='ts'>", () => __awaiter(void 0, void 0, void 0, function* () {
+        const { open } = fsMock.promises;
+        const file = yield open(vue3SFC);
+        const lines = yield file.readFile();
+        const contents = parseVueSFC(lines);
+        ["<script setup lang=\"ts\">", "</script>", "<template>", "<style"].forEach((v) => {
+            expect(contents.indexOf(v)).toBe(-1);
+        });
+        expect(contents).toContain("greet");
+    }));
+    test("it parses a Vue 3 SFC from path", () => __awaiter(void 0, void 0, void 0, function* () {
+        const { ast, file } = yield getAstFromPath(vue3SFC);
+        expect(ast).toBeTruthy();
+        expect(file).not.toBeNull();
+        yield file.close();
+    }));
+    test("it parses a React component", () => __awaiter(void 0, void 0, void 0, function* () {
+        const { ast, file } = yield getAstFromPath(reactComponent);
+        expect(ast).toBeTruthy();
+        expect(file).not.toBeNull();
+        yield file.close();
+    }));
+    test("it opens a file from path", () => __awaiter(void 0, void 0, void 0, function* () {
+        const { ast, file } = yield getAstFromPath(defaultExport);
+        expect(ast).toBeTruthy();
+        expect(file).not.toBeNull();
+        yield file.close();
+    }));
+});

package/build/__tests__/main.test.js

@@ -0,0 +1,68 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { describe, expect, test } from "@jest/globals";
+import { fsMock, vueSFCOnlyJS, reactListNoKey } from "./setup";
+import { searchRepo } from "../main.js";
+jest.mock("node:fs/promises", () => (Object.assign(Object.assign({}, jest.requireActual("node:fs/promises")), { open: jest.fn().mockImplementation((path, flags) => fsMock.promises.open(path, flags)), readdir: jest.fn().mockImplementation((path, options) => fsMock.promises.readdir(path, options)) })));
+describe("searchRepo", () => {
+    test("type selector: finds FunctionDeclaration nodes across files", () => __awaiter(void 0, void 0, void 0, function* () {
+        const matches = yield searchRepo("FunctionDeclaration", "/");
+        expect(matches.length).toBeGreaterThan(0);
+        expect(matches.every((m) => m.file !== "")).toBe(true);
+    }));
+    test("shorthand: 'this' expands to ThisExpression", () => __awaiter(void 0, void 0, void 0, function* () {
+        const matches = yield searchRepo("ThisExpression", "/");
+        const shorthandMatches = yield searchRepo("this", "/");
+        expect(shorthandMatches.length).toBe(matches.length);
+    }));
+    test("descendant combinator: finds this inside methods", () => __awaiter(void 0, void 0, void 0, function* () {
+        const matches = yield searchRepo("ObjectMethod ThisExpression", "/");
+        expect(matches.length).toBeGreaterThan(0);
+        expect(matches.some((m) => m.file === vueSFCOnlyJS)).toBe(true);
+    }));
+    test("returns empty array when nothing matches", () => __awaiter(void 0, void 0, void 0, function* () {
+        const matches = yield searchRepo("DebuggerStatement", "/");
+        expect(matches).toHaveLength(0);
+    }));
+    test("each match has file, line, col, and source fields", () => __awaiter(void 0, void 0, void 0, function* () {
+        const matches = yield searchRepo("FunctionDeclaration", "/");
+        const m = matches[0];
+        expect(typeof m.file).toBe("string");
+        expect(typeof m.line).toBe("number");
+        expect(typeof m.col).toBe("number");
+        expect(typeof m.source).toBe("string");
+    }));
+    test("match source contains the first line of the matched node", () => __awaiter(void 0, void 0, void 0, function* () {
+        const matches = yield searchRepo("FunctionDeclaration", "/");
+        expect(matches[0].source).toBeTruthy();
+        expect(matches[0].source).not.toContain("\n");
+    }));
+    test("skips files that fail to parse without throwing", () => __awaiter(void 0, void 0, void 0, function* () {
+        const matches = yield searchRepo("ThisExpression", "/");
+        expect(Array.isArray(matches)).toBe(true);
+    }));
+    test("match file paths are limited to the given dir", () => __awaiter(void 0, void 0, void 0, function* () {
+        const matches = yield searchRepo("FunctionDeclaration", "/");
+        expect(matches.every((m) => m.file.startsWith("/"))).toBe(true);
+    }));
+    test("attribute selector: finds .map() calls", () => __awaiter(void 0, void 0, void 0, function* () {
+        const matches = yield searchRepo('CallExpression[callee.property.name="map"]', "/");
+        expect(matches.length).toBeGreaterThan(0);
+        expect(matches.some((m) => m.file === reactListNoKey)).toBe(true);
+    }));
+    test(":has() + :not(): target query finds map-without-key components", () => __awaiter(void 0, void 0, void 0, function* () {
+        const matches = yield searchRepo('VariableDeclarator:has(CallExpression[callee.property.name="map"]):not(:has(JSXAttribute[name.name="key"]))', "/");
+        expect(matches.some((m) => m.file === reactListNoKey)).toBe(true);
+        expect(matches.every((m) => !m.source.includes("ListWithKey"))).toBe(true);
+    }));
+    test("throws on invalid selector syntax", () => __awaiter(void 0, void 0, void 0, function* () {
+        yield expect(searchRepo(">>> invalid ::::", "/")).rejects.toThrow();
+    }));
+});

package/build/__tests__/output.test.js

@@ -0,0 +1,74 @@
+import { describe, it, expect } from "@jest/globals";
+import { formatMatches } from "../output.js";
+const m = { file: "src/foo.ts", line: 42, col: 7, source: "const x = () => {}" };
+describe("formatMatches — text format (default)", () => {
+    it("produces file:line:col: source prefix", () => {
+        const [out] = formatMatches([m], false);
+        expect(out).toMatch(/^src\/foo\.ts:42:7: /);
+    });
+    it("includes source text in output", () => {
+        const [out] = formatMatches([m], false);
+        expect(out).toContain("const x = () => {}");
+    });
+    it("no ANSI codes when isTTY=false", () => {
+        const [out] = formatMatches([m], false);
+        expect(out).not.toContain("\x1b");
+    });
+    it("includes ANSI codes when isTTY=true", () => {
+        const [out] = formatMatches([m], true);
+        expect(out).toContain("\x1b[");
+    });
+    it("ANSI output still contains the source text", () => {
+        const [out] = formatMatches([m], true);
+        expect(out).toContain("const x = () => {}");
+    });
+    it("ANSI output still has correct prefix", () => {
+        const [out] = formatMatches([m], true);
+        expect(out).toMatch(/src\/foo\.ts:42:7:/);
+    });
+    it("returns one line per match", () => {
+        const matches = [
+            { file: "a.ts", line: 1, col: 0, source: "foo()" },
+            { file: "b.ts", line: 2, col: 3, source: "bar()" },
+        ];
+        const lines = formatMatches(matches, false);
+        expect(lines).toHaveLength(2);
+        expect(lines[0]).toContain("a.ts:1:0:");
+        expect(lines[1]).toContain("b.ts:2:3:");
+    });
+    it("returns empty array for no matches", () => {
+        expect(formatMatches([], false)).toEqual([]);
+    });
+    it("shows only location when source is empty", () => {
+        const noSource = { file: "x.ts", line: 1, col: 0, source: "" };
+        const [out] = formatMatches([noSource], false);
+        expect(out).toBe("x.ts:1:0");
+    });
+});
+describe("formatMatches — json format", () => {
+    it("returns a single JSON string", () => {
+        const lines = formatMatches([m], false, "json");
+        expect(lines).toHaveLength(1);
+        const parsed = JSON.parse(lines[0]);
+        expect(parsed).toHaveLength(1);
+        expect(parsed[0].file).toBe("src/foo.ts");
+    });
+    it("returns empty JSON array for no matches", () => {
+        const lines = formatMatches([], false, "json");
+        expect(JSON.parse(lines[0])).toEqual([]);
+    });
+});
+describe("formatMatches — files format", () => {
+    it("returns deduplicated file paths", () => {
+        const matches = [
+            { file: "a.ts", line: 1, col: 0, source: "x" },
+            { file: "a.ts", line: 5, col: 0, source: "y" },
+            { file: "b.ts", line: 2, col: 0, source: "z" },
+        ];
+        const lines = formatMatches(matches, false, "files");
+        expect(lines).toEqual(["a.ts", "b.ts"]);
+    });
+    it("returns empty array for no matches", () => {
+        expect(formatMatches([], false, "files")).toEqual([]);
+    });
+});

package/build/__tests__/query.test.js

@@ -0,0 +1,335 @@
+import { describe, expect, test } from "@jest/globals";
+import { parseQuery, SHORTHANDS } from "../query.js";
+describe("SHORTHANDS", () => {
+    const expected = {
+        this: "ThisExpression",
+        await: "AwaitExpression",
+        yield: "YieldExpression",
+        new: "NewExpression",
+        call: "CallExpression",
+        arrow: "ArrowFunctionExpression",
+        fn: "FunctionExpression",
+        member: "MemberExpression",
+        ternary: "ConditionalExpression",
+        template: "TemplateLiteral",
+        tagged: "TaggedTemplateExpression",
+        "import()": "ImportExpression",
+        assign: "AssignmentExpression",
+        binary: "BinaryExpression",
+        logical: "LogicalExpression",
+        spread: "SpreadElement",
+    };
+    Object.entries(expected).forEach(([shorthand, babelType]) => {
+        test(`'${shorthand}' maps to '${babelType}'`, () => {
+            expect(SHORTHANDS[shorthand]).toBe(babelType);
+        });
+    });
+    test("has exactly 16 entries", () => {
+        expect(Object.keys(SHORTHANDS)).toHaveLength(16);
+    });
+});
+describe("parseQuery — bare identifier", () => {
+    test("single lowercase word → bare-ident", () => {
+        const result = parseQuery("setup");
+        expect(result).toEqual({ kind: "bare-ident", name: "setup" });
+    });
+    test("camelCase identifier → bare-ident", () => {
+        const result = parseQuery("myFunction");
+        expect(result).toEqual({ kind: "bare-ident", name: "myFunction" });
+    });
+    test("identifier with $ → bare-ident", () => {
+        const result = parseQuery("$emit");
+        expect(result).toEqual({ kind: "bare-ident", name: "$emit" });
+    });
+    test("identifier with _ → bare-ident", () => {
+        const result = parseQuery("_private");
+        expect(result).toEqual({ kind: "bare-ident", name: "_private" });
+    });
+    test("identifier with digits → bare-ident", () => {
+        const result = parseQuery("handler2");
+        expect(result).toEqual({ kind: "bare-ident", name: "handler2" });
+    });
+    test("unknown lowercase word (not a shorthand) → bare-ident", () => {
+        const result = parseQuery("foo");
+        expect(result).toEqual({ kind: "bare-ident", name: "foo" });
+    });
+});
+describe("parseQuery — bare expression (shorthand)", () => {
+    test("'this' → bare-expr with ThisExpression", () => {
+        const result = parseQuery("this");
+        expect(result).toEqual({
+            kind: "bare-expr",
+            expr: [[{ negated: false, babelType: "ThisExpression" }]],
+        });
+    });
+    test("'await' → bare-expr with AwaitExpression", () => {
+        const result = parseQuery("await");
+        expect(result).toEqual({
+            kind: "bare-expr",
+            expr: [[{ negated: false, babelType: "AwaitExpression" }]],
+        });
+    });
+    test("'import()' → bare-expr with ImportExpression", () => {
+        const result = parseQuery("import()");
+        expect(result).toEqual({
+            kind: "bare-expr",
+            expr: [[{ negated: false, babelType: "ImportExpression" }]],
+        });
+    });
+    test("known shorthands that collide with JS identifiers → bare-expr not bare-ident", () => {
+        const colliding = ["call", "fn", "arrow", "template", "member", "assign", "logical"];
+        for (const s of colliding) {
+            const result = parseQuery(s);
+            expect(result.kind).toBe("bare-expr");
+        }
+    });
+});
+describe("parseQuery — bare expression (PascalCase Babel type)", () => {
+    test("'ThisExpression' → bare-expr with ThisExpression", () => {
+        const result = parseQuery("ThisExpression");
+        expect(result).toEqual({
+            kind: "bare-expr",
+            expr: [[{ negated: false, babelType: "ThisExpression" }]],
+        });
+    });
+    test("'ArrowFunctionExpression' → bare-expr", () => {
+        const result = parseQuery("ArrowFunctionExpression");
+        expect(result).toEqual({
+            kind: "bare-expr",
+            expr: [[{ negated: false, babelType: "ArrowFunctionExpression" }]],
+        });
+    });
+});
+describe("parseQuery — bare expression with negation", () => {
+    test("'!await' → bare-expr with negated AwaitExpression", () => {
+        const result = parseQuery("!await");
+        expect(result).toEqual({
+            kind: "bare-expr",
+            expr: [[{ negated: true, babelType: "AwaitExpression" }]],
+        });
+    });
+    test("'!import()' → bare-expr with negated ImportExpression", () => {
+        const result = parseQuery("!import()");
+        expect(result).toEqual({
+            kind: "bare-expr",
+            expr: [[{ negated: true, babelType: "ImportExpression" }]],
+        });
+    });
+});
+describe("parseQuery — bare expression with boolean operators", () => {
+    test("'this && await' → bare-expr AND clause", () => {
+        const result = parseQuery("this && await");
+        expect(result).toEqual({
+            kind: "bare-expr",
+            expr: [
+                [
+                    { negated: false, babelType: "ThisExpression" },
+                    { negated: false, babelType: "AwaitExpression" },
+                ],
+            ],
+        });
+    });
+    test("'this || await' → bare-expr OR clause", () => {
+        const result = parseQuery("this || await");
+        expect(result).toEqual({
+            kind: "bare-expr",
+            expr: [
+                [{ negated: false, babelType: "ThisExpression" }],
+                [{ negated: false, babelType: "AwaitExpression" }],
+            ],
+        });
+    });
+    test("'!import() && arrow' → bare-expr AND clause with negation", () => {
+        const result = parseQuery("!import() && arrow");
+        expect(result).toEqual({
+            kind: "bare-expr",
+            expr: [
+                [
+                    { negated: true, babelType: "ImportExpression" },
+                    { negated: false, babelType: "ArrowFunctionExpression" },
+                ],
+            ],
+        });
+    });
+    test("&& binds tighter than || — 'this && await || yield'", () => {
+        const result = parseQuery("this && await || yield");
+        expect(result).toEqual({
+            kind: "bare-expr",
+            expr: [
+                [
+                    { negated: false, babelType: "ThisExpression" },
+                    { negated: false, babelType: "AwaitExpression" },
+                ],
+                [{ negated: false, babelType: "YieldExpression" }],
+            ],
+        });
+    });
+});
+describe("parseQuery — scope query", () => {
+    test("'setup > this' → scope query (example 2)", () => {
+        const result = parseQuery("setup > this");
+        expect(result).toEqual({
+            kind: "scope",
+            scope: "setup",
+            expr: [[{ negated: false, babelType: "ThisExpression" }]],
+        });
+    });
+    test("'* > this' → wildcard scope (example 3)", () => {
+        const result = parseQuery("* > this");
+        expect(result).toEqual({
+            kind: "scope",
+            scope: "*",
+            expr: [[{ negated: false, babelType: "ThisExpression" }]],
+        });
+    });
+    test("'setup > !await' → negated predicate (example 4)", () => {
+        const result = parseQuery("setup > !await");
+        expect(result).toEqual({
+            kind: "scope",
+            scope: "setup",
+            expr: [[{ negated: true, babelType: "AwaitExpression" }]],
+        });
+    });
+    test("'setup > this && await' → AND composition (example 5)", () => {
+        const result = parseQuery("setup > this && await");
+        expect(result).toEqual({
+            kind: "scope",
+            scope: "setup",
+            expr: [
+                [
+                    { negated: false, babelType: "ThisExpression" },
+                    { negated: false, babelType: "AwaitExpression" },
+                ],
+            ],
+        });
+    });
+    test("'render > member || ternary' → OR composition (example 6)", () => {
+        const result = parseQuery("render > member || ternary");
+        expect(result).toEqual({
+            kind: "scope",
+            scope: "render",
+            expr: [
+                [{ negated: false, babelType: "MemberExpression" }],
+                [{ negated: false, babelType: "ConditionalExpression" }],
+            ],
+        });
+    });
+    test("'useEffect > ArrowFunctionExpression' → PascalCase type (example 9)", () => {
+        const result = parseQuery("useEffect > ArrowFunctionExpression");
+        expect(result).toEqual({
+            kind: "scope",
+            scope: "useEffect",
+            expr: [[{ negated: false, babelType: "ArrowFunctionExpression" }]],
+        });
+    });
+    test("'* > !call' → wildcard + negation (example 10)", () => {
+        const result = parseQuery("* > !call");
+        expect(result).toEqual({
+            kind: "scope",
+            scope: "*",
+            expr: [[{ negated: true, babelType: "CallExpression" }]],
+        });
+    });
+    test("'fetchData > await || import()' → complex OR (example 11)", () => {
+        const result = parseQuery("fetchData > await || import()");
+        expect(result).toEqual({
+            kind: "scope",
+            scope: "fetchData",
+            expr: [
+                [{ negated: false, babelType: "AwaitExpression" }],
+                [{ negated: false, babelType: "ImportExpression" }],
+            ],
+        });
+    });
+    test("scope with $ in name", () => {
+        const result = parseQuery("$el > this");
+        expect(result).toEqual({
+            kind: "scope",
+            scope: "$el",
+            expr: [[{ negated: false, babelType: "ThisExpression" }]],
+        });
+    });
+    test("scope with _ in name", () => {
+        const result = parseQuery("_init > await");
+        expect(result).toEqual({
+            kind: "scope",
+            scope: "_init",
+            expr: [[{ negated: false, babelType: "AwaitExpression" }]],
+        });
+    });
+    test("'template' in scope position matches identifier named 'template'", () => {
+        const result = parseQuery("template > this");
+        expect(result).toEqual({
+            kind: "scope",
+            scope: "template",
+            expr: [[{ negated: false, babelType: "ThisExpression" }]],
+        });
+    });
+    test("'setup > this && await || yield' — complex mixed operators", () => {
+        const result = parseQuery("setup > this && await || yield");
+        expect(result).toEqual({
+            kind: "scope",
+            scope: "setup",
+            expr: [
+                [
+                    { negated: false, babelType: "ThisExpression" },
+                    { negated: false, babelType: "AwaitExpression" },
+                ],
+                [{ negated: false, babelType: "YieldExpression" }],
+            ],
+        });
+    });
+});
+describe("parseQuery — parse errors", () => {
+    test("'setup>this' — missing spaces around > → error", () => {
+        expect(() => parseQuery("setup>this")).toThrow(/whitespace required/i);
+    });
+    test("'setup >this' — missing space after > → error", () => {
+        expect(() => parseQuery("setup >this")).toThrow(/whitespace required/i);
+    });
+    test("'setup> this' — missing space before > → error", () => {
+        expect(() => parseQuery("setup> this")).toThrow(/whitespace required/i);
+    });
+    test("'setup > foo' — unknown token in expression position → error", () => {
+        expect(() => parseQuery("setup > foo")).toThrow(/unknown expression atom/i);
+    });
+    test("'setup > ' — empty expression → error", () => {
+        expect(() => parseQuery("setup > ")).toThrow();
+    });
+    test("empty string → error", () => {
+        expect(() => parseQuery("")).toThrow(/empty query/i);
+    });
+    test("'  ' — whitespace only → error", () => {
+        expect(() => parseQuery("  ")).toThrow(/empty query/i);
+    });
+});
+describe("parseQuery — type narrowing", () => {
+    test("returns ScopeQuery for scope queries", () => {
+        const result = parseQuery("setup > this");
+        if (result.kind === "scope") {
+            expect(result.scope).toBe("setup");
+            expect(result.expr).toBeDefined();
+        }
+        else {
+            throw new Error("Expected scope query");
+        }
+    });
+    test("returns BareExpr for shorthand queries", () => {
+        const result = parseQuery("this");
+        if (result.kind === "bare-expr") {
+            expect(result.expr).toBeDefined();
+        }
+        else {
+            throw new Error("Expected bare-expr");
+        }
+    });
+    test("returns BareIdent for identifier queries", () => {
+        const result = parseQuery("setup");
+        if (result.kind === "bare-ident") {
+            expect(result.name).toBe("setup");
+        }
+        else {
+            throw new Error("Expected bare-ident");
+        }
+    });
+});