@jigs.design/compiler 0.0.0-stage → 0.1.1

package/dist/script.js

@@ -0,0 +1,695 @@
+import { parse } from "acorn";
+//#region src/script.ts
+const OPTIONS = {
+	ecmaVersion: "latest",
+	preserveParens: true,
+	sourceType: "script",
+	strict: true
+};
+/** `.constructor` and friends reach the realm's internals. */
+const FORBIDDEN_MEMBERS = /* @__PURE__ */ new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+/** Calls whose result changes on every render. */
+const UNSTABLE_CALLS = /* @__PURE__ */ new Map([
+	["Date", /* @__PURE__ */ new Set(["now"])],
+	["Math", /* @__PURE__ */ new Set(["random"])],
+	["performance", /* @__PURE__ */ new Set(["now"])]
+]);
+/** Calls that read the clock, which rounding can make stable. */
+const CLOCK_CALLS = /* @__PURE__ */ new Set(["Date.now", "performance.now"]);
+/** `Math` functions that round a number, as in `Math.floor(Date.now() / DAY)`. */
+const ROUNDING = /* @__PURE__ */ new Set([
+	"ceil",
+	"floor",
+	"round",
+	"trunc"
+]);
+/**
+* Reads of `new Date()` that give the time to the second or finer. Others,
+* such as `.getMonth()` or `.toISOString().slice(0, 10)`, can be stable, so
+* they are left to the runtime, which stops a query whose input keeps changing.
+*/
+const FINE_DATE_READS = /* @__PURE__ */ new Set([
+	"getMilliseconds",
+	"getSeconds",
+	"getTime",
+	"getUTCMilliseconds",
+	"getUTCSeconds",
+	"valueOf"
+]);
+/** `new Date()` with no arguments: the current time. */
+const isNewDate = (node) => node.type === "NewExpression" && node.callee.type === "Identifier" && node.callee.name === "Date" && node.arguments.length === 0;
+/** `Math.floor(… / …)` and the like: a quotient rounded to a whole number. */
+function roundsQuotient(node) {
+	const [argument] = node.arguments;
+	const inner = argument?.type === "ParenthesizedExpression" ? argument.expression : argument;
+	return node.callee.type === "MemberExpression" && !node.callee.computed && node.callee.object.type === "Identifier" && node.callee.object.name === "Math" && node.callee.property.type === "Identifier" && ROUNDING.has(node.callee.property.name) && inner?.type === "BinaryExpression" && inner.operator === "/";
+}
+const LOOPS = {
+	DoWhileStatement: "do…while",
+	ForInStatement: "for…in",
+	ForOfStatement: "for…of",
+	ForStatement: "for",
+	WhileStatement: "while"
+};
+const unsupported = (syntax, advice) => `${syntax} isn't part of Pickle's JavaScript: ${advice}`;
+const MESSAGES = {
+	class: unsupported("`class`", "use plain objects and arrow functions"),
+	fetch: "There is no `fetch` in Pickle: read data with `useQuery` and a query the prompt lists",
+	function: (name) => unsupported(`\`function ${name}()\``, `write \`const ${name} = (…) => …\` instead`),
+	getter: unsupported("A getter or setter", "compute the value in a {@body} line instead"),
+	import: unsupported("`import()`", "everything a spec can use is built in"),
+	label: unsupported("A label", "use array methods instead of loops"),
+	loop: (keyword) => unsupported(`A \`${keyword}\` loop`, "repeat markup with <each>, and compute values with .map, .filter or .reduce"),
+	member: (name) => unsupported(`\`${name}\``, "read the fields you need directly"),
+	queryOption: (key) => `\`useQuery\` takes only \`{ enabled }\` as its third argument; "${key}" does nothing`,
+	regex: unsupported("A regular expression literal", "use string methods such as .includes, .startsWith, .split or .replaceAll"),
+	this: unsupported("`this`", "it is undefined in a spec"),
+	try: unsupported("`try`", "an error a line throws is reported on that line, and the rest of the page still renders"),
+	unstable: (call) => `\`${call}\` in a useQuery input changes on every render, so the query starts again each time and never shows data. Keep the value in state, e.g. \`{@body const [now] = useState(${call})}\`, and build the input from it`,
+	variable: (kind) => unsupported(`\`${kind}\``, "declare values with `const`, and keep values that change in useState")
+};
+/** The parser's message without its `(line:column)` suffix. */
+function syntaxMessage(error) {
+	if (typeof error === "object" && error !== null && "message" in error && typeof error.message === "string") {
+		const offset = "pos" in error && typeof error.pos === "number" ? error.pos : 0;
+		return {
+			message: error.message.replace(/\s*\(\d+:\d+\)$/, ""),
+			offset
+		};
+	}
+	return {
+		message: String(error),
+		offset: 0
+	};
+}
+const isNode = (value) => typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+/** Child nodes in source order, for node types with no scoping of their own. */
+function childNodes(node) {
+	const out = [];
+	for (const [key, value] of Object.entries(node)) {
+		if (key === "type" || key === "start" || key === "end") continue;
+		if (Array.isArray(value)) {
+			for (const item of value) if (isNode(item)) out.push(item);
+		} else if (isNode(value)) out.push(value);
+	}
+	return out;
+}
+function patternNames(pattern, out) {
+	if (pattern === null || pattern === void 0) return;
+	switch (pattern.type) {
+		case "Identifier":
+			out.push(pattern.name);
+			return;
+		case "ObjectPattern":
+			for (const property of pattern.properties) patternNames(property.type === "RestElement" ? property.argument : property.value, out);
+			return;
+		case "ArrayPattern":
+			for (const element of pattern.elements) patternNames(element, out);
+			return;
+		case "RestElement":
+			patternNames(pattern.argument, out);
+			return;
+		case "AssignmentPattern":
+			patternNames(pattern.left, out);
+			return;
+		case "MemberExpression": return;
+	}
+}
+/** `let`, `const`, `class` and `function` declared directly in `body`. */
+function lexicalNames(body) {
+	const names = [];
+	for (const statement of body) if (statement.type === "VariableDeclaration" && statement.kind !== "var") for (const declarator of statement.declarations) patternNames(declarator.id, names);
+	else if ((statement.type === "FunctionDeclaration" || statement.type === "ClassDeclaration") && statement.id !== null) names.push(statement.id.name);
+	return names;
+}
+const isFunction = (node) => node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
+/** `var` declarations anywhere in `node`, not counting nested functions. */
+function varNames(node, out) {
+	if (node.type === "VariableDeclaration" && node.kind === "var") for (const declarator of node.declarations) patternNames(declarator.id, out);
+	for (const child of childNodes(node)) if (!isFunction(child)) varNames(child, out);
+}
+/** The name a callee is written as, bare or as `Pickle.name`. */
+function calleeName(node) {
+	return node.type === "Identifier" ? node.name : node.type === "MemberExpression" && !node.computed && node.object.type === "Identifier" && node.object.name === "Pickle" && node.property.type === "Identifier" ? node.property.name : null;
+}
+/** `useQuery`, bare or as `Pickle.useQuery`. */
+function hookCallee(node) {
+	const name = calleeName(node);
+	return name === "useMutation" || name === "useQuery" || name === "useState" ? name : null;
+}
+/** A procedure call's callee: a query or mutation hook, or `useAction`, which models sometimes guess. */
+function procedureCallee(node) {
+	const name = calleeName(node);
+	return name === "useAction" || name === "useMutation" || name === "useQuery" ? name : null;
+}
+/** An object literal's key written out as a name, string or number. */
+function keyName(node) {
+	if (node.type === "Identifier") return node.name;
+	return node.type === "Literal" && node.value !== null ? String(node.value) : null;
+}
+/** The text of a string argument: a quoted literal or a template with no `${}`. */
+function stringArgument(node) {
+	if (node?.type === "Literal" && node.raw !== void 0 && /^["']/.test(node.raw)) return String(node.value);
+	if (node?.type === "TemplateLiteral" && node.expressions.length === 0) return node.quasis[0]?.value.cooked ?? null;
+	return null;
+}
+function resolves(scope, name) {
+	for (let current = scope; current !== null; current = current.parent) if (current.names.has(name)) return true;
+	return false;
+}
+function propertyName(node) {
+	if (!node.computed && node.property.type === "Identifier") return node.property.name;
+	if (node.computed && node.property.type === "Literal" && typeof node.property.value === "string") return node.property.value;
+	return null;
+}
+/** Array methods that return undefined when nothing is there. */
+const MAYBE_UNDEFINED_CALLS = /* @__PURE__ */ new Set([
+	"at",
+	"find",
+	"findLast"
+]);
+/**
+* Whether `node` may evaluate to undefined though it reads as a value: a
+* `find`, `findLast` or `at` call, an index such as `items[0]`, or a
+* condition, `&&`, `||` or `??` one of whose results is one.
+*/
+function mayBeUndefined(node) {
+	switch (node.type) {
+		case "ParenthesizedExpression": return mayBeUndefined(node.expression);
+		case "ChainExpression": return mayBeUndefined(node.expression);
+		case "CallExpression": {
+			const name = node.callee.type === "MemberExpression" ? propertyName(node.callee) : null;
+			return name !== null && MAYBE_UNDEFINED_CALLS.has(name);
+		}
+		case "MemberExpression": return node.computed && propertyName(node) === null;
+		case "ConditionalExpression": return mayBeUndefined(node.consequent) || mayBeUndefined(node.alternate);
+		case "LogicalExpression": return mayBeUndefined(node.right) || node.operator === "&&" && mayBeUndefined(node.left);
+		default: return false;
+	}
+}
+const isNullLiteral = (node) => node.type === "Literal" && node.raw === "null";
+/** `text` is what was parsed, less the `shift` an expression's wrapping adds. */
+function collectFacts(program, shift, text) {
+	const facts = {
+		calls: [],
+		chains: [],
+		declared: [],
+		hookCalls: [],
+		hooks: [],
+		hookValues: [],
+		issues: [],
+		keyed: [],
+		maybeUndefined: [],
+		members: [],
+		nullCompares: [],
+		procedures: [],
+		references: []
+	};
+	const at = (node) => Math.max(0, node.start - shift);
+	const until = (node) => Math.max(0, node.end - shift);
+	/**
+	* The calls a top-level declaration's initializer evaluates first and
+	* unconditionally: the initializer itself, or what it reads a member of,
+	* compares, or tests with `||`, `??` or `&&`, as in
+	* `useQuery("a").data ?? []`. A hook call there is at the top; one
+	* anywhere else is not.
+	*/
+	const topCalls = /* @__PURE__ */ new Set();
+	for (const statement of program.body) {
+		if (statement.type !== "VariableDeclaration") continue;
+		for (const declarator of statement.declarations) {
+			let root = declarator.init;
+			while (root !== null && root !== void 0) {
+				if (root.type === "CallExpression") {
+					topCalls.add(root);
+					break;
+				}
+				root = root.type === "MemberExpression" ? root.object : root.type === "LogicalExpression" || root.type === "BinaryExpression" ? root.left : root.type === "ParenthesizedExpression" || root.type === "ChainExpression" ? root.expression : null;
+			}
+		}
+	}
+	const issue = (node, message, code = "unsupported_syntax") => {
+		facts.issues.push({
+			code,
+			end: until(node),
+			message,
+			offset: at(node)
+		});
+	};
+	let queryInput = 0;
+	/** Inside a rounded quotient, where reading the clock gives a stable value. */
+	let rounded = 0;
+	const unstable = (node, call, clock) => {
+		if (queryInput > 0 && !(clock && rounded > 0)) issue(node, MESSAGES.unstable(call), "unstable_input");
+	};
+	const reference = (name, node, scope, deferred) => {
+		if (!resolves(scope, name)) facts.references.push({
+			deferred,
+			end: until(node),
+			name,
+			offset: at(node)
+		});
+	};
+	/** Records `node` when it compares a free name strictly with null. */
+	const nullCompare = (node, scope) => {
+		if (node.operator !== "!==" && node.operator !== "===") return;
+		const named = isNullLiteral(node.right) ? node.left : isNullLiteral(node.left) ? node.right : null;
+		if (named?.type !== "Identifier" || resolves(scope, named.name)) return;
+		const operatorOffset = text.indexOf(node.operator, until(node.left));
+		if (operatorOffset === -1) return;
+		facts.nullCompares.push({
+			end: until(node),
+			name: named.name,
+			offset: at(node),
+			operator: node.operator,
+			operatorEnd: operatorOffset + node.operator.length,
+			operatorOffset
+		});
+	};
+	/** Members that are the object of another, whose chain the outer one records. */
+	const nested = /* @__PURE__ */ new WeakSet();
+	/** Records the chain `node` ends, when it starts at a free name. */
+	const chain = (node, scope) => {
+		const members = [];
+		let current = node;
+		while (current.type === "MemberExpression") {
+			members.unshift(current);
+			current = current.object;
+		}
+		if (current.type !== "Identifier" || resolves(scope, current.name)) return;
+		const path = [];
+		const ends = [];
+		for (const member of members) {
+			const name = propertyName(member);
+			if (name === null) break;
+			path.push(name);
+			ends.push(until(member));
+		}
+		if (path.length > 0) facts.chains.push({
+			ends,
+			object: current.name,
+			offset: at(current),
+			path
+		});
+	};
+	const visitMember = (node, scope, deferred, called) => {
+		const property = propertyName(node);
+		if (property !== null && FORBIDDEN_MEMBERS.has(property)) issue(node, MESSAGES.member(`.${property}`));
+		if (!nested.has(node)) chain(node, scope);
+		if (node.object.type === "MemberExpression") nested.add(node.object);
+		if (property !== null && !node.computed && node.object.type === "Identifier" && !resolves(scope, node.object.name)) facts.members.push({
+			called,
+			deferred,
+			end: until(node),
+			object: node.object.name,
+			offset: at(node),
+			property
+		});
+		if (called && property !== null && node.object.type === "Identifier" && UNSTABLE_CALLS.get(node.object.name)?.has(property) === true) {
+			const call = `${node.object.name}.${property}`;
+			unstable(node, `${call}()`, CLOCK_CALLS.has(call));
+		}
+		if (called && property !== null && FINE_DATE_READS.has(property) && isNewDate(node.object)) unstable(node, `new Date().${property}()`, true);
+		visit(node.object, scope, deferred);
+		if (node.computed) visit(node.property, scope, deferred);
+	};
+	/** Default values and computed keys in a binding pattern; the names themselves are declared elsewhere. */
+	const visitPattern = (pattern, scope, deferred) => {
+		if (pattern === null || pattern === void 0) return;
+		switch (pattern.type) {
+			case "Identifier": return;
+			case "ObjectPattern":
+				for (const property of pattern.properties) {
+					if (property.type === "RestElement") {
+						visitPattern(property.argument, scope, deferred);
+						continue;
+					}
+					if (property.computed) visit(property.key, scope, deferred);
+					visitPattern(property.value, scope, deferred);
+				}
+				return;
+			case "ArrayPattern":
+				for (const element of pattern.elements) visitPattern(element, scope, deferred);
+				return;
+			case "RestElement":
+				visitPattern(pattern.argument, scope, deferred);
+				return;
+			case "AssignmentPattern":
+				visitPattern(pattern.left, scope, deferred);
+				visit(pattern.right, scope, deferred);
+				return;
+			case "MemberExpression":
+				visitMember(pattern, scope, deferred, false);
+				return;
+		}
+	};
+	/** The left of `=`: a name written to is read from scope like any other. */
+	const visitTarget = (target, scope, deferred) => {
+		const names = [];
+		patternNames(target, names);
+		for (const name of names) reference(name, target, scope, deferred);
+		visitPattern(target, scope, deferred);
+	};
+	const visitFunction = (node, scope) => {
+		const names = [];
+		if (node.type === "FunctionExpression" && node.id) names.push(node.id.name);
+		for (const param of node.params) patternNames(param, names);
+		if (node.body.type === "BlockStatement") {
+			varNames(node.body, names);
+			names.push(...lexicalNames(node.body.body));
+		}
+		const inner = {
+			names: new Set(names),
+			parent: scope
+		};
+		for (const param of node.params) visitPattern(param, inner, true);
+		if (node.body.type === "BlockStatement") for (const statement of node.body.body) visit(statement, inner, true);
+		else visit(node.body, inner, true);
+	};
+	const visitCall = (node, scope, deferred) => {
+		const callee = node.callee;
+		const hook = hookCallee(callee);
+		if (callee.type === "Identifier") {
+			if (!resolves(scope, callee.name)) {
+				facts.calls.push({
+					callee: callee.name,
+					deferred,
+					end: until(node),
+					offset: at(node)
+				});
+				if (callee.name === "fetch") issue(node, MESSAGES.fetch);
+			}
+			if (hook === null || resolves(scope, callee.name)) visit(callee, scope, deferred);
+			else reference(callee.name, callee, scope, deferred);
+		} else if (callee.type === "MemberExpression") visitMember(callee, scope, deferred, true);
+		else visit(callee, scope, deferred);
+		const free = hook !== null && (callee.type !== "Identifier" || !resolves(scope, callee.name));
+		if (free) facts.hookCalls.push({
+			end: until(node),
+			hook,
+			offset: at(node),
+			place: deferred ? "handler" : topCalls.has(node) ? "top" : "nested",
+			prefixed: callee.type === "MemberExpression"
+		});
+		const procedure = procedureCallee(callee);
+		if (procedure !== null) {
+			const [first] = node.arguments;
+			facts.procedures.push({
+				end: until(node),
+				hook: procedure,
+				name: stringArgument(first),
+				offset: at(node),
+				tanstack: first?.type === "ObjectExpression"
+			});
+		}
+		if (hook === "useMutation" || hook === "useState") {
+			const last = node.arguments.at(-1);
+			facts.keyed.push({
+				arguments: node.arguments.length,
+				hook,
+				insertAt: (last === void 0 ? node.end - 1 : last.end) - shift,
+				start: at(node)
+			});
+		}
+		const isQuery = hook === "useQuery";
+		const options = node.arguments[2];
+		if (free && isQuery && options?.type === "ObjectExpression") for (const property of options.properties) {
+			const key = property.type === "Property" && !property.computed ? keyName(property.key) : null;
+			if (key !== null && key !== "enabled") issue(property, MESSAGES.queryOption(key), "query_options");
+		}
+		const rounds = roundsQuotient(node) ? 1 : 0;
+		rounded += rounds;
+		for (const [index, argument] of node.arguments.entries()) {
+			const input = isQuery && index === 1;
+			queryInput += input ? 1 : 0;
+			visit(argument, scope, deferred);
+			queryInput -= input ? 1 : 0;
+		}
+		rounded -= rounds;
+	};
+	const visitBlock = (body, scope, deferred) => {
+		const inner = {
+			names: new Set(lexicalNames(body)),
+			parent: scope
+		};
+		for (const statement of body) visit(statement, inner, deferred);
+	};
+	function visit(node, scope, deferred) {
+		switch (node.type) {
+			case "Identifier": {
+				const hook = hookCallee(node);
+				if (hook !== null && !resolves(scope, node.name)) facts.hookValues.push({
+					end: until(node),
+					hook,
+					offset: at(node)
+				});
+				reference(node.name, node, scope, deferred);
+				return;
+			}
+			case "MemberExpression":
+				visitMember(node, scope, deferred, false);
+				return;
+			case "CallExpression":
+				visitCall(node, scope, deferred);
+				return;
+			case "ThisExpression":
+				issue(node, MESSAGES.this);
+				return;
+			case "Literal":
+				if (node.regex !== void 0) issue(node, MESSAGES.regex);
+				return;
+			case "FunctionDeclaration":
+				issue(node, MESSAGES.function(node.id?.name ?? "name"));
+				visitFunction(node, scope);
+				return;
+			case "FunctionExpression":
+			case "ArrowFunctionExpression":
+				visitFunction(node, scope);
+				return;
+			case "ClassDeclaration":
+			case "ClassExpression": {
+				issue(node, MESSAGES.class);
+				const names = node.id ? [node.id.name] : [];
+				const inner = {
+					names: new Set(names),
+					parent: scope
+				};
+				if (node.superClass) visit(node.superClass, scope, deferred);
+				for (const member of node.body.body) {
+					if (member.type === "StaticBlock") {
+						visitBlock(member.body, inner, true);
+						continue;
+					}
+					if (member.computed) visit(member.key, inner, deferred);
+					if (member.value) visit(member.value, inner, true);
+				}
+				return;
+			}
+			case "BinaryExpression":
+				nullCompare(node, scope);
+				visit(node.left, scope, deferred);
+				visit(node.right, scope, deferred);
+				return;
+			case "VariableDeclaration":
+				if (node.kind === "var" || node.kind === "let") issue(node, MESSAGES.variable(node.kind));
+				for (const declarator of node.declarations) {
+					visitPattern(declarator.id, scope, deferred);
+					if (declarator.init) visit(declarator.init, scope, deferred);
+				}
+				return;
+			case "Property":
+				if (node.kind !== "init") issue(node, MESSAGES.getter);
+				if (!node.computed && (node.key.type === "Identifier" && node.key.name === "__proto__" || node.key.type === "Literal" && node.key.value === "__proto__")) issue(node, MESSAGES.member("__proto__"));
+				if (node.computed) visit(node.key, scope, deferred);
+				visit(node.value, scope, deferred);
+				return;
+			case "AssignmentExpression":
+				if (node.left.type === "MemberExpression") visitMember(node.left, scope, deferred, false);
+				else visitTarget(node.left, scope, deferred);
+				visit(node.right, scope, deferred);
+				return;
+			case "BlockStatement":
+			case "StaticBlock":
+				visitBlock(node.body, scope, deferred);
+				return;
+			case "SwitchStatement": {
+				visit(node.discriminant, scope, deferred);
+				const inner = {
+					names: new Set(lexicalNames(node.cases.flatMap((entry) => entry.consequent))),
+					parent: scope
+				};
+				for (const entry of node.cases) {
+					if (entry.test) visit(entry.test, inner, deferred);
+					for (const statement of entry.consequent) visit(statement, inner, deferred);
+				}
+				return;
+			}
+			case "TryStatement":
+				issue(node, MESSAGES.try);
+				visit(node.block, scope, deferred);
+				if (node.handler) {
+					const names = [];
+					patternNames(node.handler.param, names);
+					const inner = {
+						names: new Set(names),
+						parent: scope
+					};
+					visitPattern(node.handler.param, inner, deferred);
+					visit(node.handler.body, inner, deferred);
+				}
+				if (node.finalizer) visit(node.finalizer, scope, deferred);
+				return;
+			case "ForStatement":
+			case "ForInStatement":
+			case "ForOfStatement":
+			case "WhileStatement":
+			case "DoWhileStatement": {
+				issue(node, MESSAGES.loop(LOOPS[node.type]));
+				const head = node.type === "ForStatement" ? node.init : node.type === "ForInStatement" || node.type === "ForOfStatement" ? node.left : null;
+				const inner = {
+					names: new Set(head?.type === "VariableDeclaration" ? lexicalNames([head]) : []),
+					parent: scope
+				};
+				const target = (node.type === "ForInStatement" || node.type === "ForOfStatement") && node.left.type !== "VariableDeclaration" ? node.left : null;
+				for (const child of childNodes(node)) {
+					if (target !== null && child === target) {
+						visitTarget(target, inner, deferred);
+						continue;
+					}
+					visit(child, inner, deferred);
+				}
+				return;
+			}
+			case "LabeledStatement":
+				issue(node, MESSAGES.label);
+				visit(node.body, scope, deferred);
+				return;
+			case "ImportExpression":
+				issue(node, MESSAGES.import);
+				visit(node.source, scope, deferred);
+				return;
+			case "BreakStatement":
+			case "ContinueStatement":
+			case "MetaProperty":
+			case "PrivateIdentifier":
+			case "Super":
+			case "TemplateElement": return;
+			default: for (const child of childNodes(node)) visit(child, scope, deferred);
+		}
+	}
+	const top = [...lexicalNames(program.body)];
+	varNames(program, top);
+	facts.declared = [...new Set(top)];
+	const root = {
+		names: new Set(top),
+		parent: null
+	};
+	for (const statement of program.body) {
+		visit(statement, root, false);
+		if (statement.type !== "VariableDeclaration") continue;
+		for (const declarator of statement.declarations) {
+			if (declarator.id.type === "Identifier" && declarator.init !== null && declarator.init !== void 0 && mayBeUndefined(declarator.init)) facts.maybeUndefined.push(declarator.id.name);
+			const init = declarator.init?.type === "CallExpression" ? declarator.init : null;
+			const hook = init === null ? null : hookCallee(init.callee);
+			if (hook === null) continue;
+			const procedure = stringArgument(init?.arguments[0]);
+			if (declarator.id.type === "Identifier") {
+				facts.hooks.push({
+					hook,
+					name: declarator.id.name,
+					procedure,
+					property: null
+				});
+				continue;
+			}
+			if (declarator.id.type !== "ObjectPattern") continue;
+			for (const property of declarator.id.properties) {
+				if (property.type === "RestElement" || property.computed) continue;
+				const key = property.key.type === "Identifier" ? property.key.name : null;
+				const local = property.value.type === "Identifier" ? property.value.name : property.value.type === "AssignmentPattern" && property.value.left.type === "Identifier" ? property.value.left.name : null;
+				if (key !== null && local !== null) facts.hooks.push({
+					hook,
+					name: local,
+					procedure,
+					property: key
+				});
+			}
+		}
+	}
+	return facts;
+}
+/** Whether `source` would parse outside strict mode, for a clearer message. */
+function sloppyParses(source) {
+	try {
+		parse(source, {
+			...OPTIONS,
+			strict: false
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+function parseCode(code, kind) {
+	const source = kind === "expression" ? `(${code}\n)` : code;
+	const shift = kind === "expression" ? 1 : 0;
+	let program;
+	try {
+		program = parse(source, OPTIONS);
+	} catch (error) {
+		const found = syntaxMessage(error);
+		return {
+			message: sloppyParses(source) ? `${found.message}${found.message.endsWith(" in strict mode") ? "" : " in strict mode"}, which specs run in` : found.message,
+			offset: Math.max(0, found.offset - shift)
+		};
+	}
+	if (kind === "statement") return {
+		program,
+		shift
+	};
+	const [only] = program.body;
+	if (program.body.length !== 1 || only?.type !== "ExpressionStatement" || only.expression.type !== "ParenthesizedExpression" || only.expression.start !== 0 || only.expression.end !== source.length) return {
+		message: "This is more than one expression",
+		offset: 0
+	};
+	return {
+		program,
+		shift
+	};
+}
+const MAX_CACHED = 4e3;
+const cache = /* @__PURE__ */ new Map();
+/** Parses `code` in strict mode and reads what it declares, reads and calls. Cached. */
+function analyze(code, kind) {
+	const key = `${kind}\u0000${code}`;
+	const cached = cache.get(key);
+	if (cached !== void 0) return cached;
+	const parsed = parseCode(code, kind);
+	const result = "program" in parsed ? {
+		ok: true,
+		...collectFacts(parsed.program, parsed.shift, code)
+	} : {
+		message: parsed.message,
+		offset: parsed.offset,
+		ok: false
+	};
+	if (cache.size >= MAX_CACHED) cache.clear();
+	cache.set(key, result);
+	return result;
+}
+/** Whether `name` can be bound as a variable in strict mode. */
+function isValidBinding(name) {
+	return /^[A-Za-z_$][\w$]*$/.test(name) && analyze(`(${name}) => 0`, "expression").ok;
+}
+/** The 1-based line of `offset` in `code`, which starts on `line`. */
+function lineOf(code, line, offset) {
+	let result = line;
+	for (let index = 0; index < offset && index < code.length; index++) if (code.charAt(index) === "\n") result++;
+	return result;
+}
+//#endregion
+export { analyze, isValidBinding, lineOf };

package/dist/signature.d.ts

@@ -0,0 +1,5 @@
+import { Recipe } from "./compile.js";
+//#region src/signature.d.ts
+/** `<statCard label value delta={0} note="">…</statCard>` when the define has a slot. */
+export declare function recipeSignature(recipe: Recipe): string;
+//#endregion