@teasel/parser 0.0.5 → 0.0.7

package/README.md

@@ -127,9 +127,9 @@ teasel --typescript --scopes file.ts
 ```
 cargo build --release
 cd package
-bun run build          # the Node addon
-bun run build:wasm     # the WebAssembly module
-bun test.js
+npm run build          # the Node addon; tsc 7 on the PATH for the plan types
+npm run build:wasm     # the WebAssembly module
+node test.js
 ```
 
 Node resolves `@teasel/parser` to the addon and everything else to the WebAssembly module, with the same API.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@teasel/parser",
-	"version": "0.0.5",
+	"version": "0.0.7",
 	"description": "A JavaScript and TypeScript parser in Rust. It answers in ESTree.",
 	"license": "MIT",
 	"repository": {
@@ -17,46 +17,52 @@
 				"default": "./index.js"
 			},
 			"default": {
-				"types": "./wasm.d.ts",
+				"types": "./index.d.ts",
 				"default": "./wasm.js"
 			}
 		},
 		"./wasm": {
-			"types": "./wasm.d.ts",
+			"types": "./index.d.ts",
 			"default": "./wasm.js"
 		},
-		"./teasel.wasm": "./teasel.wasm"
+		"./teasel.wasm": "./teasel.wasm",
+		"./plan": {
+			"types": "./plan.d.ts",
+			"default": "./plan.js"
+		}
 	},
 	"files": [
 		"index.js",
 		"index.d.ts",
 		"wasm.js",
-		"wasm.d.ts",
 		"native.js",
 		"api.js",
 		"decode.js",
 		"identifier.js",
+		"plan.js",
+		"plan.d.ts",
 		"teasel.wasm"
 	],
 	"scripts": {
-		"build": "bun addon.js",
+		"build": "npm run build:plan && node addon.js",
+		"build:plan": "tsc --ignoreConfig plan.ts --declaration --strict --target es2022 --module esnext --moduleResolution bundler --skipLibCheck",
 		"build:wasm": "cargo build --release -p teasel-wasm --target wasm32-unknown-unknown && cp ../target/wasm32-unknown-unknown/release/teasel_wasm.wasm teasel.wasm",
-		"test": "bun test.js && bun test.js interpret",
+		"test": "node test.js && node test.js interpret",
+		"types": "tsc -p tsconfig.json",
 		"check": "node check.js",
-		"changeset:version": "changeset version && bun versions.js && git add --all"
+		"prepublishOnly": "npm run build:plan"
 	},
 	"dependencies": {
 		"@types/estree": "^1.0.6"
 	},
 	"devDependencies": {
-		"@changesets/changelog-github": "^1.0.0",
-		"@changesets/cli": "^3.0.1"
+		"@types/node": "^26.0.0"
 	},
 	"optionalDependencies": {
-		"@teasel/parser-linux-x64-gnu": "0.0.5",
-		"@teasel/parser-linux-arm64-gnu": "0.0.5",
-		"@teasel/parser-darwin-x64": "0.0.5",
-		"@teasel/parser-darwin-arm64": "0.0.5",
-		"@teasel/parser-win32-x64-msvc": "0.0.5"
+		"@teasel/parser-linux-x64-gnu": "0.0.7",
+		"@teasel/parser-linux-arm64-gnu": "0.0.7",
+		"@teasel/parser-darwin-x64": "0.0.7",
+		"@teasel/parser-darwin-arm64": "0.0.7",
+		"@teasel/parser-win32-x64-msvc": "0.0.7"
 	}
 }

package/plan.d.ts

@@ -0,0 +1,238 @@
+declare const out: unique symbol;
+export type JSONValue = null | boolean | number | string | JSONValue[] | {
+    [key: string]: JSONValue;
+};
+export type JS = 'expression' | 'assignmentExpression' | 'pattern' | 'bindingIdentifier' | 'identifierReference' | 'params' | 'typeParameters' | 'statement' | 'program';
+export type Mode = 'normal' | 'raw' | 'rcdata' | 'verbatim';
+export type Stop = {
+    prefixes: string[];
+} | {
+    matchingElement: true;
+} | {
+    documentEnd: true;
+};
+export type Reader = {
+    kind: 'token';
+    text: string;
+    gap: 'space*' | 'none';
+    word: boolean;
+} | {
+    kind: 'space';
+    min: number;
+} | {
+    kind: 'test';
+    value: V<boolean>;
+} | {
+    kind: 'rule';
+    name: string;
+} | {
+    kind: 'javascript';
+    entry: JS;
+    boundary?: 'last-shared-word';
+} | {
+    kind: 'html-single';
+    entry: JS;
+} | {
+    kind: 'html-attributes';
+    mode: 'normal' | 'static';
+} | {
+    kind: 'html-attribute-parts';
+} | {
+    kind: 'html-children';
+    mode: Mode;
+    stop: Stop;
+} | {
+    kind: 'css-stylesheet';
+};
+export interface V<out T = unknown> {
+    readonly [out]: T;
+}
+export type Expr = V & {
+    readonly name?: never;
+};
+export interface Slot<out N extends string> extends V<any> {
+    readonly name: N;
+}
+export type Schema = Record<string, 'null' | 'omit'>;
+type Names<S extends Schema, L extends readonly string[]> = (keyof S & string) | L[number];
+type Slots<S extends Schema, L extends readonly string[]> = {
+    readonly [N in Names<S, L>]: Slot<N>;
+};
+export interface Form<out W = unknown> {
+    readonly [out]: W;
+}
+export type Write<N extends string, K extends string> = {
+    into: N;
+    kind: K;
+};
+type Wrote<Fs extends readonly Form[]> = Form<Fs[number][typeof out]>;
+type Kind<R extends Reader> = R extends {
+    kind: 'javascript' | 'html-single';
+    entry: infer E;
+} ? E : R['kind'];
+type Bindable<W> = W extends Write<infer N, 'pattern' | 'bindingIdentifier' | 'params' | 'value'> ? N : never;
+export interface Region<out Id extends string, out F extends string> {
+    readonly id: Id;
+    readonly parent: V;
+    readonly kind: 'module' | 'script' | 'fragment' | 'block' | 'function';
+    readonly covers: V;
+    readonly when?: V<boolean>;
+    readonly each?: {
+        list: V;
+        as: string;
+    };
+    readonly [out]: F;
+}
+export interface Declare<out N extends string, out R extends string | Expr> {
+    readonly patterns: V;
+    readonly into: V;
+    readonly kind: 'pattern' | 'param';
+    readonly [out]: [N, R];
+}
+export interface RuleData {
+    readonly type: string;
+    readonly fields: Schema;
+    readonly locals?: readonly string[];
+    form: Form;
+    regions?: readonly Region<string, string>[];
+    declares?: readonly Declare<string, string | Expr>[];
+    span?: 'none' | 'through-next-token-start';
+}
+export type Dispatch = {
+    when: V<boolean>;
+    rule: string;
+    type?: string;
+    attributes?: 'static';
+    content?: Mode;
+};
+export type Plan = {
+    version: 1;
+    document: string;
+    rules: Record<string, {
+        toJSON(): RuleData;
+    }>;
+    html: {
+        delimiters: [string, string];
+        attributeInterpolations: boolean;
+        attributeComments: 'javascript' | 'none';
+        autoclose: boolean;
+        trimEnd: boolean;
+        void: string[];
+        text: string;
+        comment: string;
+        content: {
+            prefix: string;
+            rule: string;
+        }[];
+        attribute: {
+            prefix: string;
+            rule: string;
+        }[];
+        plainAttribute: {
+            type: string;
+            name: string;
+            value: string;
+            text: string;
+            expression: string;
+        };
+        elements: Dispatch[];
+        directiveNames: {
+            prefix: string;
+            argument: string;
+            modifier: string;
+            requireArgument: boolean;
+            dynamic: [string, string] | null;
+            unknown: 'plain-attribute' | 'wildcard-rule';
+        };
+        directives: {
+            name: string;
+            rule: string;
+        }[];
+    };
+};
+export declare const constant: <const T extends JSONValue>(value: T) => V<T>;
+export declare const get: (base: string | V, ...path: (string | number)[]) => V<any>;
+export declare const equal: (left: V, right: V) => V<boolean>;
+export declare const less: (left: V, right: V) => V<boolean>;
+export declare const present: (left: V) => V<boolean>;
+export declare const choose: <A, B>(condition: V<boolean>, yes: V<A>, no: V<B>) => V<A | B>;
+export declare const flatMap: (list: V, as: string, body: V) => V<unknown[]>;
+export declare const length: (list: V) => V<number>;
+export declare const at: (list: V, index: number) => V<any>;
+export declare const array: (...items: V[]) => V<unknown[]>;
+export declare const record: (type: string | null, fields: Record<string, V>, span?: V) => V;
+export declare const not: (p: V<boolean>) => V<boolean>;
+export declare const and: (a: V<boolean>, b: V<boolean>) => V<boolean>;
+export declare const or: (a: V<boolean>, b: V<boolean>) => V<boolean>;
+export declare const filter: (list: V, as: string, predicate: V<boolean>) => V<unknown[]>;
+export declare const map: (list: V, as: string, value: V) => V<unknown[]>;
+export declare const any: (list: V) => V<boolean>;
+export declare const member: (value: V, literals: JSONValue[]) => V<boolean>;
+export declare const concat: (...lists: V[]) => V<unknown[]>;
+export declare const scope: (name: string) => V<any>;
+export declare const incoming: V<any>;
+export declare const isType: (value: V, ...types: string[]) => V<boolean>;
+export declare const attributes: (node: V) => V<unknown[]>;
+export declare const attr: (node: V, name: string) => V<unknown[]>;
+export declare const hasAttribute: (node: V, name: string) => V<boolean>;
+export declare const staticAttribute: (node: V, name: string) => V<any>;
+export declare const seq: <Fs extends readonly Form[]>(...items: Fs) => Wrote<Fs>;
+export declare const choice: <Fs extends readonly Form[]>(...alternatives: Fs) => Wrote<Fs>;
+export declare const optional: <F extends Form>(form: F) => F;
+export declare const read: <R extends Reader, N extends string = never>(reader: R, into?: Slot<N>, input?: V) => Form<Write<N, Kind<R>>>;
+export declare const emit: <N extends string>(into: Slot<N>, value: V) => Form<Write<N, 'value'>>;
+export declare const token: (text: string, tight?: boolean) => Form<Write<never, "token">>;
+export declare const space: () => Form<Write<never, "space">>;
+export declare const test: (value: V<boolean>) => Form<Write<never, "test">>;
+export declare const call: <N extends string = never>(name: string, into?: Slot<N>) => Form<Write<N, "rule">>;
+export declare const js: <E extends JS, N extends string = never>(entry: E, into?: Slot<N>, input?: V, boundary?: 'last-shared-word') => Form<Write<N, E>>;
+export declare const repeat: <N extends string>(build: (r: {
+    readonly item: Slot<'item'>;
+}) => Form, into: Slot<N>, value?: V, min?: number, max?: number | null) => Form<Write<N, 'repeat'>>;
+export declare const many: <N extends string>(name: string, into: Slot<N>, min: number, max: number | null) => Form<Write<N, "repeat">>;
+export declare const region: <const Id extends string, F extends string>(id: Id, parent: V, covers: readonly (Slot<F> | Expr)[] | Expr, kind?: Region<Id, F>['kind'], when?: V<boolean>) => Region<Id, F>;
+export declare const declare: <N extends string, const R extends string | Expr>(patterns: readonly Slot<N>[] | Expr, into: R, kind?: 'pattern' | 'param') => Declare<N, R>;
+export declare class Rule<Type extends string, S extends Schema, L extends readonly string[], W, R extends string> {
+    #private;
+    readonly [out]: {
+        type: Type;
+        fields: S;
+        writes: W;
+    };
+    constructor(type: Type, fields: S, locals: L);
+    form<W2 extends Write<Names<S, L>, string>>(build: (f: Slots<S, L>) => Form<W2>): Rule<Type, S, L, W2, R>;
+    regions<const Rs extends readonly Region<string, Names<S, L>>[]>(build: (f: Slots<S, L>) => Rs): Rule<Type, S, L, W, R | Rs[number]['id']>;
+    declares(build: (f: Slots<S, L>) => readonly Declare<Bindable<W>, R | 'incoming' | Expr>[]): this;
+    span(policy: RuleData['span']): this;
+    toJSON(): RuleData;
+}
+export declare const rule: <const Type extends string, const S extends Schema, const L extends readonly string[] = []>(type: Type, fields: S, locals?: L) => Rule<Type, S, L, never, never>;
+interface Nodes {
+    expression: import('estree').Expression;
+    assignmentExpression: import('estree').Expression;
+    pattern: import('estree').Pattern;
+    bindingIdentifier: import('estree').Identifier;
+    identifierReference: import('estree').Identifier;
+    params: import('estree').Pattern[];
+    statement: import('estree').Statement;
+    program: import('estree').Program;
+}
+type Kinds<W, N> = W extends Write<infer M, infer K> ? ([M] extends [never] ? never : M extends N ? K : never) : never;
+type Node<W, N> = Kinds<W, N> extends infer K ? (K extends keyof Nodes ? Nodes[K] : unknown) : never;
+/** The node a rule produces: `null` fields are required and nullable, `omit` fields optional. */
+export type Infer<Rl extends {
+    readonly [out]: {
+        type: string;
+        fields: Schema;
+        writes: unknown;
+    };
+}> = {
+    type: Rl[typeof out]['type'];
+    start: number;
+    end: number;
+} & {
+    [N in keyof Rl[typeof out]['fields'] as Rl[typeof out]['fields'][N] extends 'null' ? N : never]: Node<Rl[typeof out]['writes'], N> | null;
+} & {
+    [N in keyof Rl[typeof out]['fields'] as Rl[typeof out]['fields'][N] extends 'omit' ? N : never]?: Node<Rl[typeof out]['writes'], N>;
+};
+export {};

package/plan.js

@@ -0,0 +1,83 @@
+// Authoring a host plan: data for `Plan::read` in Rust, typed so that a misuse fails to compile.
+// `plan.js` and `plan.d.ts` are emitted from this file.
+const data = (value) => value;
+// the name rides along for `into`, hidden from JSON because Rust's reader knows only op/base/path
+const slot = (base, name) => data(Object.defineProperty({ op: 'get', base, path: [name] }, 'name', { value: name }));
+const list = (value) => (Array.isArray(value) ? array(...value) : value);
+export const constant = (value) => data({ op: 'constant', value });
+export const get = (base, ...path) => data({ op: 'get', base, path });
+export const equal = (left, right) => data({ op: 'compare', relation: 'equal', left, right });
+export const less = (left, right) => data({ op: 'compare', relation: 'less', left, right });
+export const present = (left) => data({ op: 'compare', relation: 'present', left });
+export const choose = (condition, yes, no) => data({ op: 'choose', condition, yes, no });
+export const flatMap = (list, as, body) => data({ op: 'flatMap', list, as, body });
+export const length = (list) => data({ op: 'length', list });
+export const at = (list, index) => data({ op: 'at', list, index: constant(index) });
+export const array = (...items) => data({ op: 'construct', shape: 'array', items });
+export const record = (type, fields, span = constant(null)) => data({ op: 'construct', shape: 'record', type, fields, span });
+export const not = (p) => choose(p, constant(false), constant(true));
+export const and = (a, b) => choose(a, b, constant(false));
+export const or = (a, b) => choose(a, constant(true), b);
+export const filter = (list, as, predicate) => flatMap(list, as, choose(predicate, array(get(as)), array()));
+export const map = (list, as, value) => flatMap(list, as, array(value));
+export const any = (list) => less(constant(0), length(list));
+export const member = (value, literals) => any(filter(constant(literals), '$candidate', equal(get('$candidate'), value)));
+export const concat = (...lists) => flatMap(array(...lists), '$list', get('$list'));
+export const scope = (name) => get('scopes', name);
+export const incoming = get('incoming');
+export const isType = (value, ...types) => member(get(value, 'type'), types);
+export const attributes = (node) => choose(present(get(node, 'header', 'attributes')), get(node, 'header', 'attributes'), array());
+export const attr = (node, name) => filter(attributes(node), '$attribute', and(equal(get('$attribute', 'kind'), constant('ordinary')), equal(get('$attribute', 'name'), constant(name))));
+export const hasAttribute = (node, name) => any(attr(node, name));
+export const staticAttribute = (node, name) => get(at(attr(node, name), 0), 'staticText');
+export const seq = (...items) => data({ op: 'seq', items });
+export const choice = (...alternatives) => data({ op: 'choice', alternatives });
+export const optional = (form) => data(choice(form, seq()));
+export const read = (reader, into, input) => data({ op: 'read', reader, ...(into && { into: into.name }), ...(input && { input }) });
+export const emit = (into, value) => data({ op: 'emit', into: into.name, value });
+export const token = (text, tight = false) => read({ kind: 'token', text, gap: tight ? 'none' : 'space*', word: /[A-Za-z0-9_]$/.test(text) });
+export const space = () => read({ kind: 'space', min: 1 });
+export const test = (value) => read({ kind: 'test', value });
+export const call = (name, into) => read({ kind: 'rule', name }, into);
+export const js = (entry, into, input, boundary) => read({ kind: 'javascript', entry, ...(boundary && { boundary }) }, into, input);
+const item = slot('iteration', 'item');
+export const repeat = (build, into, value = item, min = 0, max = null) => data({ op: 'repeat', body: build({ item }), min, max, locals: ['item'], yield: value, into: into.name });
+export const many = (name, into, min, max) => repeat((r) => call(name, r.item), into, item, min, max);
+export const region = (id, parent, covers, kind = 'fragment', when) => data({ id, parent, kind, covers: list(covers), ...(when && { when }) });
+export const declare = (patterns, into, kind = 'pattern') => data({
+    patterns: list(patterns),
+    into: typeof into === 'string' ? (into === 'incoming' ? incoming : scope(into)) : into,
+    kind,
+});
+// a chain, not one call with an options object: TypeScript fixes W before a deferred form callback runs
+export class Rule {
+    #data;
+    #slots;
+    constructor(type, fields, locals) {
+        this.#data = { type, fields, ...(locals.length && { locals: [...locals] }), form: seq() };
+        this.#slots = data(Object.fromEntries([
+            ...Object.keys(fields).map((name) => [name, slot('record', name)]),
+            ...locals.map((name) => [name, slot('locals', name)]),
+        ]));
+    }
+    form(build) {
+        this.#data.form = build(this.#slots);
+        return data(this);
+    }
+    regions(build) {
+        this.#data.regions = [...(this.#data.regions ?? []), ...build(this.#slots)];
+        return data(this);
+    }
+    declares(build) {
+        this.#data.declares = [...(this.#data.declares ?? []), ...build(this.#slots)];
+        return this;
+    }
+    span(policy) {
+        this.#data.span = policy;
+        return this;
+    }
+    toJSON() {
+        return this.#data;
+    }
+}
+export const rule = (type, fields, locals) => new Rule(type, fields, locals ?? data([]));

package/wasm.d.ts

@@ -1 +0,0 @@
-export * from './index.js';