@vigla/svelte 0.0.0-stage → 5.57.4

package/src/front/parse/expression.ts

@@ -0,0 +1,85 @@
+import type * as AST from '../ast.ts';
+import { findMatchingBracket } from './bracket.ts';
+import { isReserved } from './html.ts';
+import { identifierEnd as wordEnd } from './identifier.ts';
+import { lfLineBreaksOnly, parseExpressionAt, removeParens } from './js.ts';
+import type { Parser } from './parser.ts';
+
+export function looseIdentifier(parser: Parser, open?: string): AST.Expression | undefined {
+	const end = findMatchingBracket(parser.template, parser.index, open ?? '{');
+	if (!end) return undefined;
+	const start = parser.index;
+	parser.index = end;
+	return { type: 'Identifier', start, end, name: '' } as AST.Expression;
+}
+
+export function readExpression(parser: Parser, open?: string, strict?: boolean): AST.Expression {
+	const simple = readSimple(parser);
+	if (simple !== null) return simple;
+	try {
+		const node = parseExpressionAt(parser, parser.template, parser.index);
+		let index = node.end;
+		const last = parser.comments.at(-1);
+		if (last !== undefined && last.end > index) index = last.end;
+		parser.index = index;
+		return removeParens(node) as unknown as AST.Expression;
+	} catch (error) {
+		if (parser.loose && !strict) {
+			const expression = looseIdentifier(parser, open);
+			if (expression !== undefined) return expression;
+		}
+		throw error;
+	}
+}
+
+function readSimple(parser: Parser): AST.Expression | null {
+	if (!lfLineBreaksOnly(parser.template)) return null;
+	const template = parser.template;
+	const index = parser.index;
+	parser.allowWhitespace();
+	const start = parser.index;
+	let end = wordEnd(template, start);
+	if (end === -1 || isReserved(template.slice(start, end))) {
+		parser.index = index;
+		return null;
+	}
+	const position = (offset: number): { line: number; column: number } => {
+		const { line, column } = parser.locate(offset);
+		return { line, column };
+	};
+	const identifier = (from: number, to: number): AST.Expression =>
+		({
+			type: 'Identifier',
+			start: from,
+			end: to,
+			loc: { start: position(from), end: position(to) },
+			name: template.slice(from, to)
+		}) as AST.Expression;
+	let node = identifier(start, end);
+	while (template[end] === '.') {
+		const propertyEnd = wordEnd(template, end + 1);
+		if (propertyEnd === -1) {
+			parser.index = index;
+			return null;
+		}
+		node = {
+			type: 'MemberExpression',
+			start,
+			end: propertyEnd,
+			loc: { start: position(start), end: position(propertyEnd) },
+			object: node,
+			property: identifier(end + 1, propertyEnd),
+			computed: false,
+			optional: false
+		} as AST.Expression;
+		end = propertyEnd;
+	}
+	parser.index = end;
+	parser.allowWhitespace();
+	if (!parser.match('}')) {
+		parser.index = index;
+		return null;
+	}
+	parser.index = end;
+	return node;
+}

package/src/front/parse/html.ts

@@ -0,0 +1,158 @@
+const voids = new Set([
+	'area',
+	'base',
+	'br',
+	'col',
+	'command',
+	'embed',
+	'hr',
+	'img',
+	'input',
+	'keygen',
+	'link',
+	'meta',
+	'param',
+	'source',
+	'track',
+	'wbr'
+]);
+
+export function isVoid(name: string): boolean {
+	return voids.has(name) || name.toLowerCase() === '!doctype';
+}
+
+const reservedWords = new Set([
+	'arguments',
+	'await',
+	'break',
+	'case',
+	'catch',
+	'class',
+	'const',
+	'continue',
+	'debugger',
+	'default',
+	'delete',
+	'do',
+	'else',
+	'enum',
+	'eval',
+	'export',
+	'extends',
+	'false',
+	'finally',
+	'for',
+	'function',
+	'if',
+	'implements',
+	'import',
+	'in',
+	'instanceof',
+	'interface',
+	'let',
+	'new',
+	'null',
+	'package',
+	'private',
+	'protected',
+	'public',
+	'return',
+	'static',
+	'super',
+	'switch',
+	'this',
+	'throw',
+	'true',
+	'try',
+	'typeof',
+	'var',
+	'void',
+	'while',
+	'with',
+	'yield'
+]);
+
+export function isReserved(word: string): boolean {
+	return reservedWords.has(word);
+}
+
+const blockStarters = [
+	'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 closers: Readonly<Record<string, readonly string[]>> = {
+	li: ['li'],
+	dt: ['dt', 'dd'],
+	dd: ['dt', 'dd'],
+	p: blockStarters,
+	rt: ['rt', 'rp'],
+	rp: ['rt', 'rp'],
+	optgroup: ['optgroup'],
+	option: ['option', 'optgroup'],
+	thead: ['tbody', 'tfoot'],
+	tbody: ['tbody', 'tfoot'],
+	tfoot: ['tbody'],
+	tr: ['tr', 'tbody'],
+	td: ['td', 'th', 'tr'],
+	th: ['td', 'th', 'tr']
+};
+
+export function closingTagOmitted(current: string, next?: string): boolean {
+	const closing = closers[current];
+	return closing !== undefined && (next === undefined || closing.includes(next));
+}
+
+export const validTagName =
+	/^[a-zA-Z][a-zA-Z0-9]*(-[a-zA-Z0-9.\-_\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u{10000}-\u{EFFFF}]*)?$/u;
+
+export const validComponentName =
+	/^(?:\p{Lu}[$\u200C\u200D\p{ID_Continue}.]*|\p{ID_Start}[$\u200C\u200D\p{ID_Continue}]*(?:\.[$\u200C\u200D\p{ID_Continue}]+)+)$/u;
+
+const doctype = /^![a-zA-Z]+$/;
+const namespaced = /^[a-zA-Z][a-zA-Z0-9]*:[a-zA-Z][a-zA-Z0-9-]*[a-zA-Z0-9]$/;
+
+export function validElementName(name: string): boolean {
+	return doctype.test(name) || namespaced.test(name) || validTagName.test(name);
+}
+
+export function isWhitespace(code: number): boolean {
+	if (code === 32 || (code <= 13 && code >= 9)) return true;
+	if (code < 160) return false;
+	return (
+		code === 160 ||
+		code === 5760 ||
+		(code >= 8192 && code <= 8202) ||
+		code === 8232 ||
+		code === 8233 ||
+		code === 8239 ||
+		code === 8287 ||
+		code === 12288 ||
+		code === 65279
+	);
+}

package/src/front/parse/identifier.ts

@@ -0,0 +1,29 @@
+import * as acorn from 'acorn';
+
+interface Classes {
+	isIdentifierStart(code: number, astral: boolean): boolean;
+	isIdentifierChar(code: number, astral: boolean): boolean;
+}
+
+const classes = acorn as unknown as Classes;
+
+export function identifierStart(code: number): boolean {
+	return classes.isIdentifierStart(code, true);
+}
+
+export function identifierChar(code: number): boolean {
+	return classes.isIdentifierChar(code, true);
+}
+
+export function identifierEnd(text: string, start: number): number {
+	if (start >= text.length) return -1;
+	const code = text.codePointAt(start) as number;
+	if (!identifierStart(code)) return -1;
+	let end = start + (code <= 0xffff ? 1 : 2);
+	while (end < text.length) {
+		const next = text.codePointAt(end) as number;
+		if (!identifierChar(next)) break;
+		end += next <= 0xffff ? 1 : 2;
+	}
+	return end;
+}

package/src/front/parse/index.ts

@@ -0,0 +1,88 @@
+import type { Diagnostic } from 'vigla/compiler';
+import type * as AST from '../ast.ts';
+import { fail } from '../diagnostics.ts';
+import { locator, type Locator } from '../locate.ts';
+import { element } from './element.ts';
+import { readOptions } from './options.ts';
+import { Parser, Scanner } from './parser.ts';
+import { readStylesheet } from './style.ts';
+import { tag } from './tag.ts';
+import { decode } from './decode.ts';
+
+export interface Parsed {
+	readonly root: AST.Root;
+	readonly ts: boolean;
+	readonly options: AST.ElementLike | null;
+	readonly warnings: readonly Diagnostic[];
+	readonly locate: Locator;
+}
+
+function text(parser: Parser): void {
+	const start = parser.index;
+	const template = parser.template;
+	let index = start;
+	while (index < template.length) {
+		const char = template[index];
+		if (char === '<' || char === '{') break;
+		index++;
+	}
+	parser.index = index;
+	const data = template.slice(start, index);
+	parser.append({ type: 'Text', start, end: index, raw: data, data: decode(data, false) });
+}
+
+export function parseComponent(source: string, loose = false): Parsed {
+	const locate = locator(source);
+	const parser = new Parser(source, loose, locate);
+	while (parser.index < parser.template.length) {
+		if (parser.match('<')) element(parser);
+		else if (parser.match('{')) tag(parser);
+		else text(parser);
+	}
+
+	if (parser.stack.length > 1) {
+		const current = parser.current() as AST.ElementLike | AST.Block;
+		if (parser.loose) {
+			current.end = parser.template.length;
+		} else {
+			current.end = current.start + 1;
+			if (current.type === 'RegularElement')
+				fail('element_unclosed', current, { name: current.name });
+			fail('block_unclosed', current);
+		}
+	}
+
+	const root = parser.root;
+	const nodes = root.fragment.nodes;
+	const at = nodes.findIndex((node) => node.type === 'SvelteOptions');
+	let options: AST.ElementLike | null = null;
+	if (at !== -1) {
+		options = nodes.splice(at, 1)[0] as AST.ElementLike;
+		root.options = readOptions(options);
+		const children = options.fragment.nodes;
+		if (children.length > 0) {
+			fail(
+				'svelte_meta_invalid_content',
+				{
+					start: (children[0] as AST.TemplateNode).start,
+					end: (children.at(-1) as AST.TemplateNode).end
+				},
+				{ name: options.name }
+			);
+		}
+	}
+
+	return { root, ts: parser.ts, options, warnings: parser.warnings, locate };
+}
+
+export function parseStylesheet(source: string): AST.Css.StyleSheetFile {
+	const scanner = new Scanner(source, false);
+	const children = readStylesheet(scanner);
+	return {
+		type: 'StyleSheetFile',
+		start: 0,
+		end: source.length,
+		children,
+		comments: scanner.cssComments
+	};
+}

package/src/front/parse/js.ts

@@ -0,0 +1,284 @@
+import * as acorn from 'acorn';
+import { tsPlugin } from '@sveltejs/acorn-typescript';
+import type { JSComment, Located } from '../ast.ts';
+import { fail } from '../diagnostics.ts';
+import type { Locator } from '../locate.ts';
+import { nonLfLineBreak } from './characters.ts';
+
+interface Internals {
+	undefinedExports: Record<string, unknown>;
+	parseStatement(context: null, topLevel: boolean, exports: object): unknown;
+	nextToken(): void;
+}
+
+type Constructor = typeof acorn.Parser;
+
+function scripted(base: Constructor): Constructor {
+	return class extends (base as unknown as new (...args: never[]) => Internals) {
+		override parseStatement(context: null, topLevel: boolean, exports: object): unknown {
+			const statement = super.parseStatement(context, topLevel, exports);
+			this.undefinedExports = {};
+			return statement;
+		}
+	} as unknown as Constructor;
+}
+
+const plain = acorn.Parser;
+const typed = plain.extend(tsPlugin());
+const plainScript = scripted(plain);
+const typedScript = scripted(typed);
+
+export interface Node extends Located {
+	type: string;
+	leadingComments?: Attached[];
+	trailingComments?: Attached[];
+	[key: string]: unknown;
+}
+
+interface Attached {
+	type: 'Line' | 'Block';
+	value: string;
+	start: number;
+	end: number;
+}
+
+export interface Context {
+	readonly template: string;
+	readonly ts: boolean;
+	readonly comments: JSComment[];
+	readonly locate: Locator;
+}
+
+const nonLf = nonLfLineBreak;
+let lastTemplate = '';
+let lfOnly = true;
+
+export function lfLineBreaksOnly(template: string): boolean {
+	if (template !== lastTemplate) {
+		lastTemplate = template;
+		lfOnly = !nonLf.test(template);
+	}
+	return lfOnly;
+}
+
+const positionSuffix = / \(\d+:\d+\)$/;
+
+function rethrow(error: unknown): never {
+	if (!(error instanceof SyntaxError)) throw error;
+	const position = (error as SyntaxError & { pos: number }).pos;
+	fail('js_parse_error', position, { message: error.message.replace(positionSuffix, '') });
+}
+
+function leading(source: string, start: number): string {
+	let lineStart = start;
+	while (lineStart > 0 && source[lineStart - 1] !== '\n') lineStart -= 1;
+	let end = lineStart;
+	while (source[end] === ' ' || source[end] === '\t') end += 1;
+	return source.slice(lineStart, end);
+}
+
+const trailingGap = /^[,) \t]*$/;
+
+class Comments {
+	readonly source: string;
+	readonly into: JSComment[];
+	readonly from: number;
+
+	constructor(source: string, into: JSComment[], from = 0) {
+		this.source = source;
+		this.into = into;
+		this.from = from;
+	}
+
+	readonly onComment = (
+		block: boolean,
+		text: string,
+		start: number,
+		end: number,
+		startLoc?: acorn.Position,
+		endLoc?: acorn.Position
+	): void => {
+		let value = text;
+		if (block && value.includes('\n')) {
+			const indentation = leading(this.source, start);
+			value = value.replace(new RegExp(`^${indentation}`, 'gm'), '');
+		}
+		this.into.push({
+			type: block ? 'Block' : 'Line',
+			value,
+			start,
+			end,
+			loc: {
+				start: startLoc as acorn.Position,
+				end: endLoc as acorn.Position
+			}
+		});
+	};
+
+	attach(ast: Node): void {
+		if (this.into.length === 0) return;
+		let first = this.into.length;
+		while (first > 0 && (this.into[first - 1] as JSComment).start >= this.from) first--;
+		const queue: Attached[] = [];
+		for (let index = first; index < this.into.length; index++) {
+			const comment = this.into[index] as JSComment;
+			queue.push({
+				type: comment.type,
+				value: comment.value,
+				start: comment.start,
+				end: comment.end
+			});
+		}
+		let head = 0;
+		const source = this.source;
+		const path: Node[] = [];
+
+		const visit = (node: Node, final: boolean): void => {
+			while (head < queue.length && (queue[head] as Attached).start < node.start) {
+				(node.leadingComments ??= []).push(queue[head++] as Attached);
+			}
+			path.push(node);
+			const listed = lists[node.type];
+			for (const key in node) {
+				if (key === 'type') continue;
+				const child = node[key];
+				if (child === null || typeof child !== 'object') continue;
+				if (Array.isArray(child)) {
+					const tracked = key === listed;
+					for (let index = 0; index < child.length; index++) {
+						const item = child[index] as Node | null;
+						if (item !== null && typeof item === 'object' && item.type) {
+							visit(item, tracked && index === child.length - 1);
+						}
+					}
+				} else if ((child as Node).type) {
+					visit(child as Node, false);
+				}
+			}
+			path.pop();
+			const next = queue[head];
+			if (next === undefined) return;
+			const parent = path.at(-1) as (Node & Record<string, unknown>) | undefined;
+			if (parent !== undefined && node.end === parent.end) return;
+			const gap = source.slice(node.end, next.start);
+			if (final) {
+				while (head < queue.length) {
+					const comment = queue[head] as Attached;
+					if (parent !== undefined && comment.start >= parent.end) break;
+					(node.trailingComments ??= []).push(comment);
+					head++;
+				}
+			} else if (node.end <= next.start && trailingGap.test(gap)) {
+				node.trailingComments = [next];
+				head++;
+			}
+		};
+
+		visit(ast, false);
+		if (head < queue.length) {
+			const rest = queue[head] as Attached;
+			if (rest.start >= ast.end || ast.type === 'Program') {
+				(ast.trailingComments ??= []).push(...queue.slice(head));
+			}
+		}
+	}
+}
+
+const lists: Readonly<Record<string, string>> = {
+	BlockStatement: 'body',
+	Program: 'body',
+	ArrayExpression: 'elements',
+	ObjectExpression: 'properties'
+};
+
+function startLocation(context: Context, index: number): acorn.Position | undefined {
+	if (!lfLineBreaksOnly(context.template)) return undefined;
+	const { line, column } = context.locate(index);
+	return { line, column, offset: index } as acorn.Position;
+}
+
+export function parseScript(source: string, comments: JSComment[], ts: boolean): Node {
+	const parser = ts ? typedScript : plainScript;
+	const handler = new Comments(source, comments);
+	try {
+		const ast = parser.parse(source, {
+			onComment: handler.onComment,
+			sourceType: 'module',
+			ecmaVersion: 16,
+			locations: true
+		}) as unknown as Node;
+		handler.attach(ast);
+		return ast;
+	} catch (error) {
+		rethrow(error);
+	}
+}
+
+export function parseExpressionAt(context: Context, source: string, index: number): Node {
+	const parser = context.ts ? typed : plain;
+	const handler = new Comments(source, context.comments, index);
+	try {
+		const ast = parser.parseExpressionAt(source, index, {
+			onComment: handler.onComment,
+			sourceType: 'module',
+			ecmaVersion: 16,
+			locations: true,
+			preserveParens: true,
+			startLocation: startLocation(context, index)
+		} as acorn.Options) as unknown as Node;
+		handler.attach(ast);
+		return ast;
+	} catch (error) {
+		rethrow(error);
+	}
+}
+
+export function parseStatementAt(context: Context, source: string, index: number): Node {
+	const Parser = (context.ts ? typed : plain) as unknown as new (
+		options: acorn.Options,
+		input: string,
+		start: number
+	) => Internals;
+	const handler = new Comments(source, context.comments, index);
+	try {
+		const parser = new Parser(
+			{
+				onComment: handler.onComment,
+				sourceType: 'module',
+				ecmaVersion: 16,
+				locations: true,
+				startLocation: startLocation(context, index)
+			} as acorn.Options,
+			source,
+			index
+		);
+		parser.nextToken();
+		const statement = parser.parseStatement(null, true, Object.create(null)) as Node;
+		handler.attach(statement);
+		return statement;
+	} catch (error) {
+		if ((error as { pos?: number }).pos === source.length) fail('unexpected_eof', source.length);
+		rethrow(error);
+	}
+}
+
+export function removeParens<T>(node: T): T {
+	if (node === null || typeof node !== 'object') return node;
+	let current = node as unknown as Node;
+	while (current.type === 'ParenthesizedExpression') current = current.expression as Node;
+	for (const key in current) {
+		if (key === 'type') continue;
+		const child = current[key];
+		if (child === null || typeof child !== 'object') continue;
+		if (Array.isArray(child)) {
+			for (let index = 0; index < child.length; index++) {
+				const item = child[index] as Node | null;
+				if (item !== null && typeof item === 'object' && item.type)
+					child[index] = removeParens(item);
+			}
+		} else if ((child as Node).type) {
+			current[key] = removeParens(child);
+		}
+	}
+	return current as unknown as T;
+}