vigla 0.0.0 → 0.2.0

package/dist/shared/nesting.js

@@ -0,0 +1,143 @@
+const headings = ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'];
+const blocks = [
+    'address',
+    'article',
+    'aside',
+    'blockquote',
+    'div',
+    'dl',
+    'fieldset',
+    'footer',
+    'form',
+    'h1',
+    'h2',
+    'h3',
+    'h4',
+    'h5',
+    'h6',
+    'header',
+    'hgroup',
+    'hr',
+    'main',
+    'menu',
+    'nav',
+    'ol',
+    'p',
+    'pre',
+    'section',
+    'table',
+    'ul'
+];
+const sections = ['tr', 'style', 'script', 'template'];
+const rules = {
+    li: { direct: ['li'] },
+    dt: { descendant: ['dt', 'dd'], resetBy: ['dl'] },
+    dd: { descendant: ['dt', 'dd'], resetBy: ['dl'] },
+    p: { descendant: blocks },
+    rt: { descendant: ['rt', 'rp'] },
+    rp: { descendant: ['rt', 'rp'] },
+    optgroup: { descendant: ['optgroup'] },
+    option: { descendant: ['option', 'optgroup'] },
+    thead: { only: sections },
+    tbody: { only: sections },
+    tfoot: { only: sections },
+    tr: { only: ['th', 'td', 'style', 'script', 'template'] },
+    td: { direct: ['td', 'th', 'tr'] },
+    th: { direct: ['td', 'th', 'tr'] },
+    form: { descendant: ['form'] },
+    a: { descendant: ['a'] },
+    button: { descendant: ['button'] },
+    h1: { descendant: headings },
+    h2: { descendant: headings },
+    h3: { descendant: headings },
+    h4: { descendant: headings },
+    h5: { descendant: headings },
+    h6: { descendant: headings },
+    colgroup: { only: ['col', 'template'] },
+    table: {
+        only: ['caption', 'colgroup', 'tbody', 'thead', 'tfoot', 'style', 'script', 'template']
+    },
+    head: {
+        only: [
+            'base',
+            'basefont',
+            'bgsound',
+            'link',
+            'meta',
+            'title',
+            'noscript',
+            'noframes',
+            'style',
+            'script',
+            'template'
+        ]
+    },
+    html: { only: ['head', 'body', 'frameset'] },
+    frameset: { only: ['frame'] },
+    '#document': { only: ['html'] }
+};
+function tag(name, at) {
+    return at === undefined ? `\`<${name}>\`` : `\`<${name}>\` (${at})`;
+}
+export function invalidUnder(child, ancestors, childAt, ancestorAt) {
+    if (child.includes('-'))
+        return null;
+    const ancestor = ancestors[ancestors.length - 1];
+    const rule = rules[ancestor];
+    if (rule === undefined)
+        return null;
+    if (rule.resetBy !== undefined) {
+        for (let index = ancestors.length - 2; index >= 0; index--) {
+            const name = ancestors[index];
+            if (name.includes('-'))
+                return null;
+            if (rule.resetBy.includes(name))
+                return null;
+        }
+    }
+    if (rule.descendant?.includes(child))
+        return `${tag(child, childAt)} cannot be a descendant of ${tag(ancestor, ancestorAt)}`;
+    return null;
+}
+export function invalidIn(child, parent, childAt, parentAt) {
+    if (child.includes('-') || parent.includes('-'))
+        return null;
+    if (parent === 'template')
+        return null;
+    const rule = rules[parent];
+    const own = tag(child, childAt);
+    const outer = tag(parent, parentAt);
+    if (rule !== undefined) {
+        if (rule.direct?.includes(child))
+            return `${own} cannot be a direct child of ${outer}`;
+        if (rule.descendant?.includes(child))
+            return `${own} cannot be a child of ${outer}`;
+        if (rule.only !== undefined) {
+            if (rule.only.includes(child))
+                return null;
+            return `${own} cannot be a child of ${outer}. ${tag(parent)} only allows these children: ${rule.only.map((name) => tag(name)).join(', ')}`;
+        }
+    }
+    switch (child) {
+        case 'body':
+        case 'caption':
+        case 'col':
+        case 'colgroup':
+        case 'frameset':
+        case 'frame':
+        case 'head':
+        case 'html':
+            return `${own} cannot be a child of ${outer}`;
+        case 'thead':
+        case 'tbody':
+        case 'tfoot':
+            return `${own} must be the child of a \`<table>\`, not a ${outer}`;
+        case 'td':
+        case 'th':
+            return `${own} must be the child of a \`<tr>\`, not a ${outer}`;
+        case 'tr':
+            return `\`<tr>\` must be the child of a \`<thead>\`, \`<tbody>\`, or \`<tfoot>\`, not a ${outer}`;
+    }
+    return null;
+}
+//# sourceMappingURL=nesting.js.map

package/dist/shared/nesting.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nesting.js","sourceRoot":"","sources":["../../src/shared/nesting.ts"],"names":[],"mappings":"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"}

package/dist/shared/slots.d.ts

@@ -0,0 +1,8 @@
+export type SlotNames = Readonly<Record<string, boolean>>;
+interface Slotted {
+    readonly children?: unknown;
+}
+export declare function slotProps<P extends object>(props: P, slots: SlotNames): P;
+export declare function slots(props: Slotted): SlotNames;
+export {};
+//# sourceMappingURL=slots.d.ts.map

package/dist/shared/slots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slots.d.ts","sourceRoot":"","sources":["../../src/shared/slots.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAI1D,UAAU,OAAO;IAChB,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,SAAS,GAAG,CAAC,CAGzE;AAED,wBAAgB,KAAK,CAAC,KAAK,EAAE,OAAO,GAAG,SAAS,CAE/C"}

package/dist/shared/slots.js

@@ -0,0 +1,9 @@
+const names = new WeakMap();
+export function slotProps(props, slots) {
+    names.set(props, slots);
+    return props;
+}
+export function slots(props) {
+    return names.get(props) ?? (props.children === undefined ? {} : { default: true });
+}
+//# sourceMappingURL=slots.js.map

package/dist/shared/slots.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slots.js","sourceRoot":"","sources":["../../src/shared/slots.ts"],"names":[],"mappings":"AAEA,MAAM,KAAK,GAAG,IAAI,OAAO,EAAqB,CAAC;AAM/C,MAAM,UAAU,SAAS,CAAmB,KAAQ,EAAE,KAAgB;IACrE,KAAK,CAAC,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACxB,OAAO,KAAK,CAAC;AACd,CAAC;AAED,MAAM,UAAU,KAAK,CAAC,KAAc;IACnC,OAAO,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC,CAAC;AACpF,CAAC"}

package/dist/shared/snippet.d.ts

@@ -0,0 +1,11 @@
+export declare function invalidArgs(): never;
+export declare function snippet<T extends (...args: never[]) => unknown>(fn: T): T;
+export interface RawSnippet {
+    render(): string;
+    setup?(element: Element): void | (() => void);
+}
+export type SnippetArgs<Values extends unknown[]> = {
+    [Key in keyof Values]: () => Values[Key];
+};
+export type RawFactory<Values extends unknown[]> = (...args: SnippetArgs<Values>) => RawSnippet;
+//# sourceMappingURL=snippet.d.ts.map

package/dist/shared/snippet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"snippet.d.ts","sourceRoot":"","sources":["../../src/shared/snippet.ts"],"names":[],"mappings":"AAEA,wBAAgB,WAAW,IAAI,KAAK,CAKnC;AAED,wBAAgB,OAAO,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,KAAK,EAAE,KAAK,OAAO,EAAE,EAAE,EAAE,CAAC,GAAG,CAAC,CAQzE;AAED,MAAM,WAAW,UAAU;IAC1B,MAAM,IAAI,MAAM,CAAC;IACjB,KAAK,CAAC,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,GAAG,CAAC,MAAM,IAAI,CAAC,CAAC;CAC9C;AAED,MAAM,MAAM,WAAW,CAAC,MAAM,SAAS,OAAO,EAAE,IAAI;KAClD,GAAG,IAAI,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,GAAG,CAAC;CACxC,CAAC;AAEF,MAAM,MAAM,UAAU,CAAC,MAAM,SAAS,OAAO,EAAE,IAAI,CAAC,GAAG,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,KAAK,UAAU,CAAC"}

package/dist/shared/snippet.js

@@ -0,0 +1,11 @@
+import { failure } from './diagnostics.js';
+export function invalidArgs() {
+    throw failure('invalid_snippet_arguments', 'A snippet function was passed invalid arguments. Snippets should only be instantiated via `{@render ...}`');
+}
+export function snippet(fn) {
+    fn.toString = () => {
+        throw failure('snippet_without_render_tag', 'Attempted to render a snippet without a `{@render}` block. This would cause the snippet code to be stringified instead of its content being rendered to the DOM. To fix this, change `{snippet}` to `{@render snippet()}`.');
+    };
+    return fn;
+}
+//# sourceMappingURL=snippet.js.map

package/dist/shared/snippet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snippet.js","sourceRoot":"","sources":["../../src/shared/snippet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAE3C,MAAM,UAAU,WAAW;IAC1B,MAAM,OAAO,CACZ,2BAA2B,EAC3B,2GAA2G,CAC3G,CAAC;AACH,CAAC;AAED,MAAM,UAAU,OAAO,CAA0C,EAAK;IACrE,EAAE,CAAC,QAAQ,GAAG,GAAG,EAAE;QAClB,MAAM,OAAO,CACZ,4BAA4B,EAC5B,4NAA4N,CAC5N,CAAC;IACH,CAAC,CAAC;IACF,OAAO,EAAE,CAAC;AACX,CAAC"}

package/package.json

@@ -1,6 +1,62 @@
 {
 	"name": "vigla",
-	"version": "0.0.0",
-	"description": "Reserved.",
-	"files": []
+	"version": "0.2.0",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/runlith/vigla.git",
+		"directory": "packages/vigla"
+	},
+	"type": "module",
+	"files": [
+		"dist",
+		"src"
+	],
+	"exports": {
+		".": {
+			"browser": "./dist/entries/index.js",
+			"default": "./dist/entries/index-server.js"
+		},
+		"./server": "./dist/entries/server.js",
+		"./attachments": "./dist/entries/attachments.js",
+		"./action": "./dist/entries/action.js",
+		"./events": "./dist/entries/events.js",
+		"./reactivity": {
+			"browser": "./dist/entries/reactivity.js",
+			"default": "./dist/entries/reactivity-server.js"
+		},
+		"./reactivity/window": {
+			"browser": "./dist/entries/window.js",
+			"default": "./dist/entries/window-server.js"
+		},
+		"./motion": {
+			"browser": "./dist/entries/motion.js",
+			"default": "./dist/entries/motion-server.js"
+		},
+		"./transition": "./dist/entries/transition.js",
+		"./animate": "./dist/entries/animate.js",
+		"./easing": "./dist/entries/easing.js",
+		"./compiler": "./dist/entries/compiler.js",
+		"./internal/index-client": "./dist/entries/index.js",
+		"./internal/index-server": "./dist/entries/index-server.js",
+		"./internal/reactivity-client": "./dist/entries/reactivity.js",
+		"./internal/reactivity-server": "./dist/entries/reactivity-server.js",
+		"./internal/window-client": "./dist/entries/window.js",
+		"./internal/window-server": "./dist/entries/window-server.js",
+		"./internal/motion-client": "./dist/entries/motion.js",
+		"./internal/motion-server": "./dist/entries/motion-server.js",
+		"./internal/client": "./dist/entries/internal/client.js",
+		"./internal/server": "./dist/entries/internal/server.js"
+	},
+	"dependencies": {
+		"@jridgewell/remapping": "^2.3.5",
+		"@types/estree": "^1.0.9",
+		"acorn": "^8.18.0",
+		"aria-query": "5.3.1",
+		"axobject-query": "^4.1.0",
+		"clsx": "^2.1.1",
+		"devalue": "^5.9.4",
+		"esm-env": "^1.2.1",
+		"esrap": "^2.3.6",
+		"magic-string": "^0.30.21"
+	}
 }

package/src/compiler/analysis/asynchronous.ts

@@ -0,0 +1,206 @@
+import type * as ES from 'estree';
+import { walk } from '../ir/estree.ts';
+import type { Node, Value } from '../ir/nodes.ts';
+
+export interface Settled {
+	has(node: ES.Node): boolean;
+}
+
+export function awaits(node: ES.Node): ES.AwaitExpression[] {
+	const found: ES.AwaitExpression[] = [];
+	walk(node, (child) => {
+		if (
+			child.type === 'FunctionDeclaration' ||
+			child.type === 'FunctionExpression' ||
+			child.type === 'ArrowFunctionExpression' ||
+			child.type === 'ClassBody'
+		)
+			return false;
+		if (child.type === 'AwaitExpression') {
+			found.push(child);
+			return false;
+		}
+	});
+	return found;
+}
+
+function evaluatedLast(node: ES.Node, parents: ReadonlyMap<ES.Node, ES.Node>): boolean {
+	let child = node;
+	for (let parent = parents.get(child); parent !== undefined; parent = parents.get(child)) {
+		switch (parent.type) {
+			case 'ArrayExpression':
+				if (child !== parent.elements.at(-1)) return false;
+				break;
+			case 'AssignmentExpression':
+			case 'BinaryExpression':
+			case 'LogicalExpression':
+				if (child === parent.left) return false;
+				break;
+			case 'CallExpression':
+			case 'NewExpression':
+				if (child !== parent.arguments.at(-1)) return false;
+				break;
+			case 'ConditionalExpression':
+				if (child === parent.test) return false;
+				break;
+			case 'ObjectExpression':
+				if (child !== parent.properties.at(-1)) return false;
+				break;
+			case 'Property':
+				if (child === parent.key) return false;
+				break;
+			case 'SequenceExpression':
+			case 'TemplateLiteral':
+				if (child !== parent.expressions.at(-1)) return false;
+				break;
+			default:
+				return false;
+		}
+		child = parent;
+	}
+	return true;
+}
+
+export function resuming(expression: ES.Node): ES.AwaitExpression[] {
+	const parents = new Map<ES.Node, ES.Node>();
+	const found: ES.AwaitExpression[] = [];
+	walk(expression, (child, parent) => {
+		if (parent !== null) parents.set(child, parent);
+		if (
+			child.type === 'FunctionDeclaration' ||
+			child.type === 'FunctionExpression' ||
+			child.type === 'ArrowFunctionExpression' ||
+			child.type === 'ClassBody'
+		)
+			return false;
+		if (child.type === 'AwaitExpression' && (found.length > 0 || !evaluatedLast(child, parents)))
+			found.push(child);
+	});
+	return found;
+}
+
+export function hasAwait(node: ES.Node, settled?: Settled): boolean {
+	let found = false;
+	walk(node, (child) => {
+		if (found || settled?.has(child)) return false;
+		if (
+			child.type === 'FunctionDeclaration' ||
+			child.type === 'FunctionExpression' ||
+			child.type === 'ArrowFunctionExpression' ||
+			child.type === 'ClassBody'
+		)
+			return false;
+		if (child.type === 'AwaitExpression' || (child.type === 'ForOfStatement' && child.await)) {
+			found = true;
+			return false;
+		}
+	});
+	return found;
+}
+
+export function ownExpressions(node: Node): ES.Expression[] {
+	const found: ES.Expression[] = [];
+	const value = (given: Value): void => {
+		if (given.kind === 'expression') found.push(given.expression);
+		else if (given.kind === 'text') {
+			for (const part of given.parts) if (part.kind === 'expression') found.push(part.expression);
+		}
+	};
+	switch (node.kind) {
+		case 'expression':
+		case 'raw-html':
+			found.push(node.expression);
+			break;
+		case 'element':
+		case 'component':
+		case 'dynamic-element':
+		case 'boundary':
+		case 'slot':
+			if (node.kind === 'component') found.push(node.reference);
+			if (node.kind === 'dynamic-element') found.push(node.tag);
+			for (const attribute of node.attributes) {
+				switch (attribute.kind) {
+					case 'attribute':
+					case 'style':
+						value(attribute.value);
+						break;
+					case 'spread':
+					case 'class':
+					case 'attachment':
+						found.push(attribute.expression);
+						break;
+					case 'action':
+						found.push(attribute.action);
+						if (attribute.argument !== null) found.push(attribute.argument);
+						break;
+					default:
+						break;
+				}
+			}
+			break;
+		case 'branch':
+			for (const arm of node.arms) found.push(arm.test);
+			break;
+		case 'keyed-list':
+		case 'unkeyed-list':
+			found.push(node.collection);
+			break;
+		case 'keyed-block':
+			found.push(node.key);
+			break;
+		case 'async-block':
+			found.push(node.promise);
+			break;
+		case 'render': {
+			const call = (
+				node.call.type === 'ChainExpression' ? node.call.expression : node.call
+			) as ES.SimpleCallExpression;
+			found.push(call.callee as ES.Expression);
+			for (const argument of call.arguments) {
+				if (argument.type !== 'SpreadElement') found.push(argument);
+			}
+			break;
+		}
+		default:
+			break;
+	}
+	return found;
+}
+
+export function declaring(node: Node): boolean {
+	return node.kind === 'constant' || node.kind === 'declaration';
+}
+
+export function pendingAwaits(node: Node, settled: Settled | undefined): ES.AwaitExpression[] {
+	const inits =
+		node.kind === 'constant'
+			? [node.declarator.init]
+			: node.kind === 'declaration'
+				? node.declaration.declarations.map((declarator) => declarator.init)
+				: [];
+	return inits.flatMap((init) =>
+		init == null ? [] : awaits(init).filter((found) => settled?.has(found) !== true)
+	);
+}
+
+export interface AsyncStep {
+	readonly before: readonly Node[];
+	readonly rest: readonly Node[];
+	readonly pending: readonly ES.AwaitExpression[];
+}
+
+export function asyncStep(nodes: readonly Node[], settled: Settled | undefined): AsyncStep | null {
+	for (let index = 0; index < nodes.length; index++) {
+		const node = nodes[index] as Node;
+		if (!declaring(node)) continue;
+		const pending = pendingAwaits(node, settled);
+		if (pending.length === 0) continue;
+		const earlier = nodes.slice(0, index);
+		return {
+			before: earlier.filter(declaring),
+			rest: [...earlier.filter((other) => !declaring(other)), ...nodes.slice(index)],
+			pending
+		};
+	}
+	return null;
+}

package/src/compiler/analysis/classes.ts

@@ -0,0 +1,110 @@
+import type * as ES from 'estree';
+import { walk } from '../ir/estree.ts';
+import type { Rune, Runes } from '../ir/port.ts';
+import { spanOf, unsupported } from './scope.ts';
+
+export type FieldRune = '$state' | '$state.raw' | '$derived' | '$derived.by';
+
+const fieldRunes = new Set<Rune>(['$state', '$state.raw', '$derived', '$derived.by']);
+
+export interface StateField {
+	readonly rune: FieldRune;
+	readonly node: ES.PropertyDefinition | ES.AssignmentExpression;
+	readonly value: ES.CallExpression;
+	readonly key: ES.PrivateIdentifier;
+}
+
+export type ClassFields = ReadonlyMap<ES.ClassBody, ReadonlyMap<string, StateField>>;
+
+export function fieldName(key: ES.Node, computed: boolean): string | null {
+	if (key.type === 'Literal') return String(key.value);
+	if (computed) return null;
+	if (key.type === 'Identifier') return key.name;
+	if (key.type === 'PrivateIdentifier') return `#${key.name}`;
+	return null;
+}
+
+function runeOf(runes: Runes, node: ES.Node | null | undefined): FieldRune | null {
+	if (node?.type !== 'CallExpression') return null;
+	const rune = runes.get(node.callee);
+	return rune !== undefined && fieldRunes.has(rune) ? (rune as FieldRune) : null;
+}
+
+function constructorAssignments(body: ES.ClassBody): ES.AssignmentExpression[] {
+	const found: ES.AssignmentExpression[] = [];
+	for (const member of body.body) {
+		if (member.type !== 'MethodDefinition' || member.kind !== 'constructor') continue;
+		for (const statement of member.value.body.body) {
+			if (statement.type !== 'ExpressionStatement') continue;
+			const expression = statement.expression;
+			if (
+				expression.type === 'AssignmentExpression' &&
+				expression.operator === '=' &&
+				expression.left.type === 'MemberExpression' &&
+				expression.left.object.type === 'ThisExpression'
+			) {
+				found.push(expression);
+			}
+		}
+	}
+	return found;
+}
+
+function fieldsOf(runes: Runes, body: ES.ClassBody, placed: Set<ES.Node>): Map<string, StateField> {
+	const fields = new Map<string, StateField>();
+	const privates = new Set<string>();
+	for (const member of body.body) {
+		if (
+			(member.type === 'PropertyDefinition' || member.type === 'MethodDefinition') &&
+			member.key.type === 'PrivateIdentifier'
+		) {
+			privates.add(member.key.name);
+		}
+	}
+	const backing = (name: string): ES.PrivateIdentifier => {
+		if (name.startsWith('#')) return { type: 'PrivateIdentifier', name: name.slice(1) };
+		let candidate = name.replace(/[^A-Za-z0-9_$]/g, '_') || '_';
+		if (/^[0-9]/.test(candidate) || candidate === 'constructor') candidate = `_${candidate}`;
+		while (privates.has(candidate)) candidate = `_${candidate}`;
+		privates.add(candidate);
+		return { type: 'PrivateIdentifier', name: candidate };
+	};
+	const add = (
+		name: string | null,
+		node: StateField['node'],
+		value: ES.Expression | null | undefined
+	): void => {
+		const rune = runeOf(runes, value);
+		if (rune === null) return;
+		if (name === null) throw unsupported(spanOf(node), 'A rune in a computed class field');
+		if (fields.has(name))
+			throw unsupported(spanOf(node), 'A class field declared twice with a rune');
+		const call = value as ES.CallExpression;
+		placed.add(call.callee);
+		fields.set(name, { rune, node, value: call, key: backing(name) });
+	};
+	for (const member of body.body) {
+		if (member.type !== 'PropertyDefinition' || member.static) continue;
+		add(fieldName(member.key, member.computed), member, member.value);
+	}
+	for (const assignment of constructorAssignments(body)) {
+		const left = assignment.left as ES.MemberExpression;
+		add(fieldName(left.property, left.computed), assignment, assignment.right);
+	}
+	return fields;
+}
+
+export function classFields(
+	runes: Runes,
+	program: ES.Program | null,
+	placed: Set<ES.Node>
+): ClassFields {
+	const classes = new Map<ES.ClassBody, ReadonlyMap<string, StateField>>();
+	if (program === null) return classes;
+	walk(program, (node) => {
+		if (node.type !== 'ClassBody') return;
+		const fields = fieldsOf(runes, node, placed);
+		if (fields.size > 0) classes.set(node, fields);
+	});
+	return classes;
+}

package/src/compiler/analysis/ignoring.ts

@@ -0,0 +1,25 @@
+import type * as ES from 'estree';
+import type { Span } from '../ir/nodes.ts';
+import type { Ignores } from '../ir/port.ts';
+import { spanOf } from './scope.ts';
+
+export type Ignoring = (node: ES.Node, code: string) => boolean;
+
+export function ignoring(...sources: Ignores[]): Ignoring {
+	const spans = new Map<string, Span[]>();
+	for (const ignores of sources)
+		for (const [node, codes] of ignores) {
+			const span = spanOf(node as ES.Node);
+			for (const code of codes) {
+				const found = spans.get(code);
+				if (found === undefined) spans.set(code, [span]);
+				else found.push(span);
+			}
+		}
+	return (node, code) => {
+		const found = spans.get(code);
+		if (found === undefined) return false;
+		const span = spanOf(node);
+		return found.some((at) => at.start <= span.start && at.end >= span.end);
+	};
+}