@vigla/svelte 0.0.0-stage → 5.57.3

package/src/front/parse/attribute.ts

@@ -0,0 +1,319 @@
+import type * as AST from '../ast.ts';
+import { fail } from '../diagnostics.ts';
+import { decode } from './decode.ts';
+import { readExpression } from './expression.ts';
+import { isWhitespace } from './html.ts';
+import type { Identifier, Parser } from './parser.ts';
+
+const unquotedEnd = /(\/>|[\s"'=<>`])/y;
+const quote = /["']/y;
+const staticValue = /(?:"([^"]*)"|'([^'])*'|([^>\s]+))/y;
+
+export function isExpressionAttribute(
+	attribute: AST.Attribute
+): attribute is AST.Attribute & { value: AST.ExpressionTag | [AST.ExpressionTag] } {
+	const value = attribute.value;
+	return (
+		value !== true &&
+		(!Array.isArray(value) || (value.length === 1 && value[0]?.type === 'ExpressionTag'))
+	);
+}
+
+export function attributeExpression(attribute: AST.Attribute): AST.Expression {
+	const value = attribute.value as AST.ExpressionTag | AST.ExpressionTag[];
+	return Array.isArray(value) ? (value[0] as AST.ExpressionTag).expression : value.expression;
+}
+
+function attribute(
+	name: string,
+	loc: AST.NameLocation | null,
+	start: number,
+	end: number,
+	value: AST.AttributeValue
+): AST.Attribute {
+	return { type: 'Attribute', start, end, name, name_loc: loc, value };
+}
+
+export function readStaticAttribute(parser: Parser): AST.Attribute | null {
+	const start = parser.index;
+	const tag = readTag(parser, true);
+	if (!tag.name) return null;
+	let value: AST.AttributeValue = true;
+	if (parser.eat('=')) {
+		parser.allowWhitespace();
+		let raw = parser.matchRegex(staticValue);
+		if (!raw) fail('expected_attribute_value', parser.index);
+		parser.index += raw.length;
+		const quoted = raw[0] === '"' || raw[0] === "'";
+		if (quoted) raw = raw.slice(1, -1);
+		value = [
+			{
+				start: parser.index - raw.length - (quoted ? 1 : 0),
+				end: quoted ? parser.index - 1 : parser.index,
+				type: 'Text',
+				raw,
+				data: decode(raw, true)
+			}
+		];
+	}
+	if (parser.matchRegex(quote)) fail('expected_token', parser.index, { token: '=' });
+	return attribute(tag.name, tag.loc, start, parser.index, value);
+}
+
+function readComment(parser: Parser): AST.JSComment | null {
+	const start = parser.index;
+	if (parser.eat('//')) {
+		const value = parser.readUntil('\n');
+		const end = parser.index;
+		return { type: 'Line', start, end, value, loc: location(parser, start, end) };
+	}
+	if (parser.eat('/*')) {
+		const value = parser.readUntil('*/');
+		parser.eat('*/');
+		const end = parser.index;
+		return { type: 'Block', start, end, value, loc: location(parser, start, end) };
+	}
+	return null;
+}
+
+function location(parser: Parser, start: number, end: number): AST.NameLocation {
+	return { start: parser.locate(start), end: parser.locate(end) };
+}
+
+const directives: Readonly<Record<string, AST.DirectiveType>> = {
+	use: 'UseDirective',
+	animate: 'AnimateDirective',
+	bind: 'BindDirective',
+	class: 'ClassDirective',
+	on: 'OnDirective',
+	let: 'LetDirective',
+	in: 'TransitionDirective',
+	out: 'TransitionDirective',
+	transition: 'TransitionDirective'
+};
+
+function directiveType(prefix: string): AST.DirectiveType | 'StyleDirective' | null {
+	if (prefix === 'style') return 'StyleDirective';
+	return Object.hasOwn(directives, prefix) ? (directives[prefix] as AST.DirectiveType) : null;
+}
+
+export function readAttribute(parser: Parser): AST.AttributeLike | null {
+	for (let comment = readComment(parser); comment !== null; comment = readComment(parser)) {
+		parser.comments.push(comment);
+		parser.allowWhitespace();
+	}
+
+	const start = parser.index;
+
+	if (parser.eat('{')) {
+		parser.allowWhitespace();
+		if (parser.eat('@attach')) {
+			parser.requireWhitespace();
+			const expression = readExpression(parser);
+			parser.allowWhitespace();
+			parser.eat('}', true);
+			return { type: 'AttachTag', start, end: parser.index, expression };
+		}
+		if (parser.eat('...')) {
+			const expression = readExpression(parser);
+			parser.allowWhitespace();
+			parser.eat('}', true);
+			return { type: 'SpreadAttribute', start, end: parser.index, expression };
+		}
+		const id = parser.readIdentifier();
+		if (id.name === '') {
+			if (
+				parser.loose &&
+				(parser.match('#') || parser.match('/') || parser.match('@') || parser.match(':'))
+			) {
+				return null;
+			}
+			if (!(parser.loose && parser.match('}'))) fail('attribute_empty_shorthand', start);
+		}
+		parser.allowWhitespace();
+		parser.eat('}', true);
+		const expression: AST.ExpressionTag = {
+			type: 'ExpressionTag',
+			start: id.start,
+			end: id.end,
+			expression: id as AST.Expression
+		};
+		return attribute(id.name, id.loc, start, parser.index, expression);
+	}
+
+	const tag = readTag(parser, true);
+	if (!tag.name) return null;
+
+	let end = parser.index;
+	parser.allowWhitespace();
+
+	const colon = tag.name.indexOf(':');
+	const type = colon === -1 ? null : directiveType(tag.name.slice(0, colon));
+
+	let value: AST.AttributeValue = true;
+	if (parser.eat('=')) {
+		parser.allowWhitespace();
+		if (parser.template[parser.index] === '/' && parser.template[parser.index + 1] === '>') {
+			const at = parser.index++;
+			value = [{ start: at, end: at + 1, type: 'Text', raw: '/', data: '/' }];
+		} else {
+			value = readAttributeValue(parser);
+		}
+		end = parser.index;
+	} else if (parser.matchRegex(quote)) {
+		fail('expected_token', parser.index, { token: '=' });
+	}
+
+	if (type === null) return attribute(tag.name, tag.loc, start, end, value);
+
+	const [name = '', ...modifiers] = tag.name.slice(colon + 1).split('|');
+	if (name === '') {
+		fail('directive_missing_name', { start, end: start + colon + 1 }, { type: tag.name });
+	}
+
+	if (type === 'StyleDirective') {
+		return { start, end, type, name, name_loc: tag.loc, modifiers, value };
+	}
+
+	const first = value === true ? undefined : Array.isArray(value) ? value[0] : value;
+	let expression: AST.Expression | null = null;
+	if (first !== undefined) {
+		if ((value as unknown[]).length > 1 || first.type === 'Text') {
+			fail('directive_invalid_value', first.start);
+		}
+		expression = (first as AST.ExpressionTag).expression;
+	}
+
+	const directive: AST.Directive = {
+		start,
+		end,
+		type,
+		name,
+		name_loc: tag.loc,
+		expression,
+		modifiers
+	};
+	if (type === 'TransitionDirective') {
+		const direction = tag.name.slice(0, colon);
+		directive.intro = direction === 'in' || direction === 'transition';
+		directive.outro = direction === 'out' || direction === 'transition';
+	}
+	if ((type === 'BindDirective' || type === 'ClassDirective') && directive.expression === null) {
+		directive.expression = {
+			start: start + colon + 1,
+			end,
+			type: 'Identifier',
+			name: directive.name
+		} as AST.Expression;
+	}
+	return directive;
+}
+
+function readAttributeValue(parser: Parser): AST.ExpressionTag | (AST.Text | AST.ExpressionTag)[] {
+	const mark = parser.eat("'") ? "'" : parser.eat('"') ? '"' : null;
+	if (mark !== null && parser.eat(mark)) {
+		return [{ start: parser.index - 1, end: parser.index - 1, type: 'Text', raw: '', data: '' }];
+	}
+	let value: (AST.Text | AST.ExpressionTag)[];
+	try {
+		value = readSequence(
+			parser,
+			() => (mark !== null ? parser.match(mark) : parser.matchRegex(unquotedEnd) !== null),
+			'in attribute value'
+		);
+	} catch (error) {
+		const diagnostic = (error as { diagnostic?: { code: string; start: number } }).diagnostic;
+		if (diagnostic?.code === 'js_parse_error') {
+			const at = diagnostic.start;
+			if (parser.template.slice(at - 1, at + 1) === '/>') {
+				parser.index = at;
+				fail('expected_token', at, { token: mark ?? '}' });
+			}
+		}
+		throw error;
+	}
+	if (value.length === 0 && mark === null) fail('expected_attribute_value', parser.index);
+	if (mark !== null) parser.index += 1;
+	if (mark !== null || value.length > 1 || value[0]?.type === 'Text') return value;
+	return value[0] as AST.ExpressionTag;
+}
+
+export function readSequence(
+	parser: Parser,
+	done: () => boolean,
+	where: string
+): (AST.Text | AST.ExpressionTag)[] {
+	const chunks: (AST.Text | AST.ExpressionTag)[] = [];
+	let chunkStart = parser.index;
+	const flush = (end: number): void => {
+		if (end > chunkStart) {
+			const raw = parser.template.slice(chunkStart, end);
+			chunks.push({ start: chunkStart, end, type: 'Text', raw, data: decode(raw, true) });
+		}
+	};
+	while (parser.index < parser.template.length) {
+		const index = parser.index;
+		if (done()) {
+			flush(parser.index);
+			return chunks;
+		}
+		if (parser.eat('{')) {
+			if (parser.match('#')) {
+				const at = parser.index - 1;
+				parser.eat('#');
+				fail('block_invalid_placement', at, { name: lowercaseName(parser), location: where });
+			} else if (parser.match('@')) {
+				const at = parser.index - 1;
+				parser.eat('@');
+				fail('tag_invalid_placement', at, { name: lowercaseName(parser), location: where });
+			}
+			flush(parser.index - 1);
+			parser.allowWhitespace();
+			const expression = readExpression(parser);
+			parser.allowWhitespace();
+			parser.eat('}', true);
+			chunks.push({ type: 'ExpressionTag', start: index, end: parser.index, expression });
+			chunkStart = parser.index;
+		} else {
+			parser.index++;
+		}
+	}
+	if (parser.loose) return chunks;
+	fail('unexpected_eof', parser.template.length);
+}
+
+export function readTagName(parser: Parser, attribute = false): string {
+	const start = parser.index;
+	if (start >= parser.template.length && !parser.loose)
+		fail('unexpected_eof', parser.template.length);
+	while (parser.index < parser.template.length) {
+		const code = parser.template.charCodeAt(parser.index);
+		if (
+			isWhitespace(code) ||
+			code === 47 ||
+			code === 62 ||
+			(attribute && (code === 34 || code === 39 || code === 61))
+		) {
+			break;
+		}
+		parser.index += 1;
+	}
+	return parser.template.slice(start, parser.index);
+}
+
+export function readTag(parser: Parser, attribute = false): Identifier {
+	const start = parser.index;
+	const name = readTagName(parser, attribute);
+	const end = parser.index;
+	return { type: 'Identifier', name, start, end, loc: location(parser, start, end) };
+}
+
+function lowercaseName(parser: Parser): string {
+	const start = parser.index;
+	while (parser.index < parser.template.length) {
+		const code = parser.template.charCodeAt(parser.index);
+		if (code < 97 || code > 122) break;
+		parser.index += 1;
+	}
+	return parser.template.slice(start, parser.index);
+}

package/src/front/parse/bracket.ts

@@ -0,0 +1,99 @@
+import { fail } from '../diagnostics.ts';
+
+const pairs: Readonly<Record<string, string>> = { '{': '}', '(': ')', '[': ']' };
+
+function unescaped(text: string, from: number, char: string): number {
+	for (let index = text.indexOf(char, from); index !== -1; index = text.indexOf(char, index + 1)) {
+		let slashes = 0;
+		for (let back = index - 1; text[back] === '\\'; back--) slashes++;
+		if (slashes % 2 === 0) return index;
+	}
+	return Infinity;
+}
+
+function stringEnd(text: string, from: number, quote: string): number {
+	if (quote === '`') return unescaped(text, from, quote);
+	const line = text.indexOf('\n', from);
+	return unescaped(line === -1 ? text : text.slice(0, line), from, quote);
+}
+
+function regexEnd(text: string, from: number): number {
+	const slash = unescaped(text, from, '/');
+	return slash < unescaped(text, from, '\n') ? slash : Infinity;
+}
+
+function after(text: string, needle: string, from: number): number {
+	const found = text.indexOf(needle, from);
+	return (found === -1 ? Infinity : found) + needle.length;
+}
+
+export function findMatchingBracket(text: string, from: number, open: string): number | undefined {
+	const close = pairs[open];
+	let depth = 1;
+	let index = from;
+	while (depth > 0 && index < text.length) {
+		const char = text[index];
+		if (char === "'" || char === '"' || char === '`') {
+			index = stringEnd(text, index + 1, char) + 1;
+			continue;
+		}
+		if (char === '/') {
+			const next = text[index + 1];
+			if (next === undefined || next === '') index++;
+			else if (next === '/') index = after(text, '\n', index + 1);
+			else if (next === '*') index = after(text, '*/', index + 1);
+			else {
+				const end = regexEnd(text, index + 1) + 1;
+				index = end === Infinity ? index + 1 : end;
+			}
+			continue;
+		}
+		if (char === open) depth++;
+		else if (char === close) depth--;
+		if (depth === 0) return index;
+		index++;
+	}
+	return undefined;
+}
+
+export function matchBracket(
+	template: string,
+	start: number,
+	brackets: Readonly<Record<string, string>> = pairs
+): number {
+	const closers = new Set(Object.values(brackets));
+	const stack: string[] = [];
+	let index = start;
+	while (index < template.length) {
+		const char = template[index++] as string;
+		if (char === "'" || char === '"' || char === '`') {
+			index = matchQuote(template, index, char);
+			continue;
+		}
+		if (char in brackets) {
+			stack.push(char);
+		} else if (closers.has(char)) {
+			const expected = brackets[stack.pop() as string] as string;
+			if (char !== expected) fail('expected_token', index - 1, { token: expected });
+			if (stack.length === 0) return index;
+		}
+	}
+	fail('unexpected_eof', template.length);
+}
+
+function matchQuote(template: string, start: number, quote: string): number {
+	let escaped = false;
+	let index = start;
+	while (index < template.length) {
+		const char = template[index++];
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+		if (char === quote) return index;
+		if (char === '\\') escaped = true;
+		if (quote === '`' && char === '$' && template[index] === '{')
+			index = matchBracket(template, index);
+	}
+	fail('unterminated_string_constant', start);
+}

package/src/front/parse/characters.ts

@@ -0,0 +1,19 @@
+const lineSeparators = String.fromCharCode(0x2028, 0x2029);
+
+const bidirectionalControls = String.fromCharCode(
+	0x202a,
+	0x202b,
+	0x202c,
+	0x202d,
+	0x202e,
+	0x2066,
+	0x2067,
+	0x2068,
+	0x2069
+);
+
+export const nonLfLineBreak = new RegExp(`\\r(?!\\n)|[${lineSeparators}]`);
+
+export const bidirectionalRun = new RegExp(`[${bidirectionalControls}]+`, 'g');
+
+export const bidirectionalChar = new RegExp(`[${bidirectionalControls}]`);

package/src/front/parse/decode.ts

@@ -0,0 +1,87 @@
+import { entities } from './entities.ts';
+
+const longest = Math.max(...Object.keys(entities).map((name) => name.length));
+
+const windows1252 = [
+	8364, 129, 8218, 402, 8222, 8230, 8224, 8225, 710, 8240, 352, 8249, 338, 141, 381, 143, 144, 8216,
+	8217, 8220, 8221, 8226, 8211, 8212, 732, 8482, 353, 8250, 339, 157, 382, 376
+];
+
+function valid(code: number, attribute: boolean): number {
+	if (code === 10 && !attribute) return 32;
+	if (code < 128) return code;
+	if (code <= 159) return windows1252[code - 128] as number;
+	if (code < 55296) return code;
+	if (code <= 57343) return 0;
+	if (code <= 196607) return code;
+	if ((code >= 917504 && code <= 917631) || (code >= 917760 && code <= 917999)) return code;
+	return 0;
+}
+
+const word = /\w/;
+
+function isHex(char: string | undefined): boolean {
+	return char !== undefined && /[0-9a-fA-F]/.test(char);
+}
+
+function isDigit(char: string | undefined): boolean {
+	return char !== undefined && char >= '0' && char <= '9';
+}
+
+interface Reference {
+	readonly end: number;
+	readonly code: number;
+}
+
+function numeric(text: string, at: number): Reference | null {
+	let index = at + 1;
+	let code: number;
+	if ((text[index] === 'x' || text[index] === 'X') && isHex(text[index + 1])) {
+		const from = ++index;
+		while (isHex(text[index])) index++;
+		code = parseInt(text.slice(from, index), 16);
+	} else if (isDigit(text[index])) {
+		const from = index;
+		while (isDigit(text[index])) index++;
+		code = parseInt(text.slice(from, index), 10);
+	} else {
+		return null;
+	}
+	if (text[index] === ';') index++;
+	return { end: index, code };
+}
+
+function named(text: string, at: number, attribute: boolean): Reference | null {
+	for (let length = Math.min(longest, text.length - at); length > 0; length--) {
+		const name = text.slice(at, at + length);
+		const code = entities[name];
+		if (code === undefined) continue;
+		if (attribute && !name.endsWith(';')) {
+			const next = text[at + length];
+			if (next !== undefined && (word.test(next) || next === '=')) continue;
+		}
+		return { end: at + length, code };
+	}
+	return null;
+}
+
+export function decode(text: string, attribute: boolean): string {
+	let index = text.indexOf('&');
+	if (index === -1) return text;
+	let out = '';
+	let copied = 0;
+	while (index !== -1) {
+		const at = index + 1;
+		const reference = text[at] === '#' ? numeric(text, at) : named(text, at, attribute);
+		if (reference === null) {
+			index = text.indexOf('&', at);
+			continue;
+		}
+		if (reference.code) {
+			out += text.slice(copied, index) + String.fromCodePoint(valid(reference.code, attribute));
+			copied = reference.end;
+		}
+		index = text.indexOf('&', reference.end);
+	}
+	return out + text.slice(copied);
+}