lumen-plus 0.0.5 → 0.0.6

package/dist/utils/node_modules/svelte/src/compiler/phases/1-parse/acorn.js

@@ -0,0 +1,198 @@
+/** @import { Comment, Program } from 'estree' */
+/** @import { AST } from '#compiler' */
+import * as acorn from 'acorn';
+import { walk } from 'zimmerframe';
+import { tsPlugin } from '@sveltejs/acorn-typescript';
+
+const ParserWithTS = acorn.Parser.extend(tsPlugin());
+
+/**
+ * @typedef {Comment & {
+ *   start: number;
+ *   end: number;
+ * }} CommentWithLocation
+ */
+
+/**
+ * @param {string} source
+ * @param {AST.JSComment[]} comments
+ * @param {boolean} typescript
+ * @param {boolean} [is_script]
+ */
+export function parse(source, comments, typescript, is_script) {
+	const parser = typescript ? ParserWithTS : acorn.Parser;
+
+	const { onComment, add_comments } = get_comment_handlers(
+		source,
+		/** @type {CommentWithLocation[]} */ (comments)
+	);
+
+	// @ts-ignore
+	const parse_statement = parser.prototype.parseStatement;
+
+	// If we're dealing with a <script> then it might contain an export
+	// for something that doesn't exist directly inside but is inside the
+	// component instead, so we need to ensure that Acorn doesn't throw
+	// an error in these cases
+	if (is_script) {
+		// @ts-ignore
+		parser.prototype.parseStatement = function (...args) {
+			const v = parse_statement.call(this, ...args);
+			// @ts-ignore
+			this.undefinedExports = {};
+			return v;
+		};
+	}
+
+	let ast;
+
+	try {
+		ast = parser.parse(source, {
+			onComment,
+			sourceType: 'module',
+			ecmaVersion: 16,
+			locations: true
+		});
+	} finally {
+		if (is_script) {
+			// @ts-ignore
+			parser.prototype.parseStatement = parse_statement;
+		}
+	}
+
+	add_comments(ast);
+
+	return /** @type {Program} */ (ast);
+}
+
+/**
+ * @param {string} source
+ * @param {Comment[]} comments
+ * @param {boolean} typescript
+ * @param {number} index
+ * @returns {acorn.Expression & { leadingComments?: CommentWithLocation[]; trailingComments?: CommentWithLocation[]; }}
+ */
+export function parse_expression_at(source, comments, typescript, index) {
+	const parser = typescript ? ParserWithTS : acorn.Parser;
+
+	const { onComment, add_comments } = get_comment_handlers(
+		source,
+		/** @type {CommentWithLocation[]} */ (comments),
+		index
+	);
+
+	const ast = parser.parseExpressionAt(source, index, {
+		onComment,
+		sourceType: 'module',
+		ecmaVersion: 16,
+		locations: true
+	});
+
+	add_comments(ast);
+
+	return ast;
+}
+
+/**
+ * Acorn doesn't add comments to the AST by itself. This factory returns the capabilities
+ * to add them after the fact. They are needed in order to support `svelte-ignore` comments
+ * in JS code and so that `prettier-plugin-svelte` doesn't remove all comments when formatting.
+ * @param {string} source
+ * @param {CommentWithLocation[]} comments
+ * @param {number} index
+ */
+function get_comment_handlers(source, comments, index = 0) {
+	return {
+		/**
+		 * @param {boolean} block
+		 * @param {string} value
+		 * @param {number} start
+		 * @param {number} end
+		 * @param {import('acorn').Position} [start_loc]
+		 * @param {import('acorn').Position} [end_loc]
+		 */
+		onComment: (block, value, start, end, start_loc, end_loc) => {
+			if (block && /\n/.test(value)) {
+				let a = start;
+				while (a > 0 && source[a - 1] !== '\n') a -= 1;
+
+				let b = a;
+				while (/[ \t]/.test(source[b])) b += 1;
+
+				const indentation = source.slice(a, b);
+				value = value.replace(new RegExp(`^${indentation}`, 'gm'), '');
+			}
+
+			comments.push({
+				type: block ? 'Block' : 'Line',
+				value,
+				start,
+				end,
+				loc: {
+					start: /** @type {import('acorn').Position} */ (start_loc),
+					end: /** @type {import('acorn').Position} */ (end_loc)
+				}
+			});
+		},
+
+		/** @param {acorn.Node & { leadingComments?: CommentWithLocation[]; trailingComments?: CommentWithLocation[]; }} ast */
+		add_comments(ast) {
+			if (comments.length === 0) return;
+
+			comments = comments
+				.filter((comment) => comment.start >= index)
+				.map(({ type, value, start, end }) => ({ type, value, start, end }));
+
+			walk(ast, null, {
+				_(node, { next, path }) {
+					let comment;
+
+					while (comments[0] && comments[0].start < node.start) {
+						comment = /** @type {CommentWithLocation} */ (comments.shift());
+						(node.leadingComments ||= []).push(comment);
+					}
+
+					next();
+
+					if (comments[0]) {
+						const parent = /** @type {any} */ (path.at(-1));
+
+						if (parent === undefined || node.end !== parent.end) {
+							const slice = source.slice(node.end, comments[0].start);
+							const is_last_in_body =
+								((parent?.type === 'BlockStatement' || parent?.type === 'Program') &&
+									parent.body.indexOf(node) === parent.body.length - 1) ||
+								(parent?.type === 'ArrayExpression' &&
+									parent.elements.indexOf(node) === parent.elements.length - 1) ||
+								(parent?.type === 'ObjectExpression' &&
+									parent.properties.indexOf(node) === parent.properties.length - 1);
+
+							if (is_last_in_body) {
+								// Special case: There can be multiple trailing comments after the last node in a block,
+								// and they can be separated by newlines
+								let end = node.end;
+
+								while (comments.length) {
+									const comment = comments[0];
+									if (parent && comment.start >= parent.end) break;
+
+									(node.trailingComments ||= []).push(comment);
+									comments.shift();
+									end = comment.end;
+								}
+							} else if (node.end <= comments[0].start && /^[,) \t]*$/.test(slice)) {
+								node.trailingComments = [/** @type {CommentWithLocation} */ (comments.shift())];
+							}
+						}
+					}
+				}
+			});
+
+			// Special case: Trailing comments after the root node (which can only happen for expression tags or for Program nodes).
+			// Adding them ensures that we can later detect the end of the expression tag correctly.
+			if (comments.length > 0 && (comments[0].start >= ast.end || ast.type === 'Program')) {
+				(ast.trailingComments ||= []).push(...comments.splice(0));
+			}
+		}
+	};
+}

package/dist/utils/node_modules/svelte/src/compiler/phases/1-parse/index.js

@@ -0,0 +1,326 @@
+/** @import { AST } from '#compiler' */
+/** @import { Location } from 'locate-character' */
+/** @import * as ESTree from 'estree' */
+// @ts-expect-error acorn type definitions are borked in the release we use
+import { isIdentifierStart, isIdentifierChar } from 'acorn';
+import fragment from './state/fragment.js';
+import { regex_whitespace } from '../patterns.js';
+import * as e from '../../errors.js';
+import { create_fragment } from './utils/create.js';
+import read_options from './read/options.js';
+import { is_reserved } from '../../../utils.js';
+import { disallow_children } from '../2-analyze/visitors/shared/special-element.js';
+import * as state from '../../state.js';
+
+const regex_position_indicator = / \(\d+:\d+\)$/;
+
+const regex_lang_attribute =
+	/<!--[^]*?-->|<script\s+(?:[^>]*|(?:[^=>'"/]+=(?:"[^"]*"|'[^']*'|[^>\s]+)\s+)*)lang=(["'])?([^"' >]+)\1[^>]*>/g;
+
+export class Parser {
+	/**
+	 * @readonly
+	 * @type {string}
+	 */
+	template;
+
+	/**
+	 * Whether or not we're in loose parsing mode, in which
+	 * case we try to continue parsing as much as possible
+	 * @type {boolean}
+	 */
+	loose;
+
+	/** */
+	index = 0;
+
+	/**
+	 * Creates a minimal parser instance for CSS-only parsing.
+	 * Skips Svelte component parsing setup.
+	 * @param {string} source
+	 * @returns {Parser}
+	 */
+	static forCss(source) {
+		const parser = Object.create(Parser.prototype);
+		parser.template = source;
+		parser.index = 0;
+		parser.loose = false;
+		return parser;
+	}
+
+	/** Whether we're parsing in TypeScript mode */
+	ts = false;
+
+	/** @type {AST.TemplateNode[]} */
+	stack = [];
+
+	/** @type {AST.Fragment[]} */
+	fragments = [];
+
+	/** @type {AST.Root} */
+	root;
+
+	/** @type {Record<string, boolean>} */
+	meta_tags = {};
+
+	/** @type {LastAutoClosedTag | undefined} */
+	last_auto_closed_tag;
+
+	/**
+	 * @param {string} template
+	 * @param {boolean} loose
+	 */
+	constructor(template, loose) {
+		if (typeof template !== 'string') {
+			throw new TypeError('Template must be a string');
+		}
+
+		this.loose = loose;
+		this.template = template.trimEnd();
+
+		let match_lang;
+
+		do match_lang = regex_lang_attribute.exec(template);
+		while (match_lang && match_lang[0][1] !== 's'); // ensure it starts with '<s' to match script tags
+
+		regex_lang_attribute.lastIndex = 0; // reset matched index to pass tests - otherwise declare the regex inside the constructor
+
+		this.ts = match_lang?.[2] === 'ts';
+
+		this.root = {
+			css: null,
+			js: [],
+			// @ts-ignore
+			start: null,
+			// @ts-ignore
+			end: null,
+			type: 'Root',
+			fragment: create_fragment(),
+			options: null,
+			comments: [],
+			metadata: {
+				ts: this.ts
+			}
+		};
+
+		this.stack.push(this.root);
+		this.fragments.push(this.root.fragment);
+
+		/** @type {ParserState} */
+		let state = fragment;
+
+		while (this.index < this.template.length) {
+			state = state(this) || fragment;
+		}
+
+		if (this.stack.length > 1) {
+			const current = this.current();
+
+			if (this.loose) {
+				current.end = this.template.length;
+			} else if (current.type === 'RegularElement') {
+				current.end = current.start + 1;
+				e.element_unclosed(current, current.name);
+			} else {
+				current.end = current.start + 1;
+				e.block_unclosed(current);
+			}
+		}
+
+		if (state !== fragment) {
+			e.unexpected_eof(this.index);
+		}
+
+		this.root.start = 0;
+		this.root.end = template.length;
+
+		const options_index = this.root.fragment.nodes.findIndex(
+			/** @param {any} thing */
+			(thing) => thing.type === 'SvelteOptions'
+		);
+		if (options_index !== -1) {
+			const options = /** @type {AST.SvelteOptionsRaw} */ (this.root.fragment.nodes[options_index]);
+			this.root.fragment.nodes.splice(options_index, 1);
+			this.root.options = read_options(options);
+
+			disallow_children(options);
+
+			// We need this for the old AST format
+			Object.defineProperty(this.root.options, '__raw__', {
+				value: options,
+				enumerable: false
+			});
+		}
+	}
+
+	current() {
+		return this.stack[this.stack.length - 1];
+	}
+
+	/**
+	 * @param {any} err
+	 * @returns {never}
+	 */
+	acorn_error(err) {
+		e.js_parse_error(err.pos, err.message.replace(regex_position_indicator, ''));
+	}
+
+	/**
+	 * @param {string} str
+	 * @param {boolean} required
+	 * @param {boolean} required_in_loose
+	 */
+	eat(str, required = false, required_in_loose = true) {
+		if (this.match(str)) {
+			this.index += str.length;
+			return true;
+		}
+
+		if (required && (!this.loose || required_in_loose)) {
+			e.expected_token(this.index, str);
+		}
+
+		return false;
+	}
+
+	/** @param {string} str */
+	match(str) {
+		const length = str.length;
+		if (length === 1) {
+			// more performant than slicing
+			return this.template[this.index] === str;
+		}
+
+		return this.template.slice(this.index, this.index + length) === str;
+	}
+
+	/**
+	 * Match a regex at the current index
+	 * @param {RegExp} pattern  Should have a ^ anchor at the start so the regex doesn't search past the beginning, resulting in worse performance
+	 */
+	match_regex(pattern) {
+		const match = pattern.exec(this.template.slice(this.index));
+		if (!match || match.index !== 0) return null;
+
+		return match[0];
+	}
+
+	allow_whitespace() {
+		while (this.index < this.template.length && regex_whitespace.test(this.template[this.index])) {
+			this.index++;
+		}
+	}
+
+	/**
+	 * Search for a regex starting at the current index and return the result if it matches
+	 * @param {RegExp} pattern  Should have a ^ anchor at the start so the regex doesn't search past the beginning, resulting in worse performance
+	 */
+	read(pattern) {
+		const result = this.match_regex(pattern);
+		if (result) this.index += result.length;
+		return result;
+	}
+
+	/**
+	 * @returns {ESTree.Identifier & { start: number, end: number, loc: { start: Location, end: Location } }}
+	 */
+	read_identifier() {
+		const start = this.index;
+		let end = start;
+		let name = '';
+
+		const code = /** @type {number} */ (this.template.codePointAt(this.index));
+
+		if (isIdentifierStart(code, true)) {
+			let i = this.index;
+			end += code <= 0xffff ? 1 : 2;
+
+			while (end < this.template.length) {
+				const code = /** @type {number} */ (this.template.codePointAt(end));
+
+				if (!isIdentifierChar(code, true)) break;
+				end += code <= 0xffff ? 1 : 2;
+			}
+
+			name = this.template.slice(start, end);
+			this.index = end;
+
+			if (is_reserved(name)) {
+				e.unexpected_reserved_word(start, name);
+			}
+		}
+
+		return {
+			type: 'Identifier',
+			name,
+			start,
+			end,
+			loc: {
+				start: state.locator(start),
+				end: state.locator(end)
+			}
+		};
+	}
+
+	/** @param {RegExp} pattern */
+	read_until(pattern) {
+		if (this.index >= this.template.length) {
+			if (this.loose) return '';
+			e.unexpected_eof(this.template.length);
+		}
+
+		const start = this.index;
+		const match = pattern.exec(this.template.slice(start));
+
+		if (match) {
+			this.index = start + match.index;
+			return this.template.slice(start, this.index);
+		}
+
+		this.index = this.template.length;
+		return this.template.slice(start);
+	}
+
+	require_whitespace() {
+		if (!regex_whitespace.test(this.template[this.index])) {
+			e.expected_whitespace(this.index);
+		}
+
+		this.allow_whitespace();
+	}
+
+	pop() {
+		this.fragments.pop();
+		return this.stack.pop();
+	}
+
+	/**
+	 * @template {AST.Fragment['nodes'][number]} T
+	 * @param {T} node
+	 * @returns {T}
+	 */
+	append(node) {
+		this.fragments.at(-1)?.nodes.push(node);
+		return node;
+	}
+}
+
+/**
+ * @param {string} template
+ * @param {boolean} [loose]
+ * @returns {AST.Root}
+ */
+export function parse(template, loose = false) {
+	state.set_source(template);
+
+	const parser = new Parser(template, loose);
+	return parser.root;
+}
+
+/** @typedef {(parser: Parser) => ParserState | void} ParserState */
+
+/** @typedef {Object} LastAutoClosedTag
+ * @property {string} tag
+ * @property {string} reason
+ * @property {number} depth
+ */

package/dist/utils/node_modules/svelte/src/compiler/phases/1-parse/read/context.js

@@ -0,0 +1,116 @@
+/** @import { Pattern } from 'estree' */
+/** @import { Parser } from '../index.js' */
+import { match_bracket } from '../utils/bracket.js';
+import { parse_expression_at } from '../acorn.js';
+import { regex_not_newline_characters } from '../../patterns.js';
+import * as e from '../../../errors.js';
+
+/**
+ * @param {Parser} parser
+ * @returns {Pattern}
+ */
+export default function read_pattern(parser) {
+	const start = parser.index;
+	let i = parser.index;
+
+	const id = parser.read_identifier();
+
+	if (id.name !== '') {
+		const annotation = read_type_annotation(parser);
+
+		return {
+			...id,
+			typeAnnotation: annotation
+		};
+	}
+
+	const char = parser.template[i];
+
+	if (char !== '{' && char !== '[') {
+		e.expected_pattern(i);
+	}
+
+	i = match_bracket(parser, start);
+	parser.index = i;
+
+	const pattern_string = parser.template.slice(start, i);
+
+	try {
+		// the length of the `space_with_newline` has to be start - 1
+		// because we added a `(` in front of the pattern_string,
+		// which shifted the entire string to right by 1
+		// so we offset it by removing 1 character in the `space_with_newline`
+		// to achieve that, we remove the 1st space encountered,
+		// so it will not affect the `column` of the node
+		let space_with_newline = parser.template
+			.slice(0, start)
+			.replace(regex_not_newline_characters, ' ');
+		const first_space = space_with_newline.indexOf(' ');
+		space_with_newline =
+			space_with_newline.slice(0, first_space) + space_with_newline.slice(first_space + 1);
+
+		const expression = /** @type {any} */ (
+			parse_expression_at(
+				`${space_with_newline}(${pattern_string} = 1)`,
+				parser.root.comments,
+				parser.ts,
+				start - 1
+			)
+		).left;
+
+		expression.typeAnnotation = read_type_annotation(parser);
+		if (expression.typeAnnotation) {
+			expression.end = expression.typeAnnotation.end;
+		}
+
+		return expression;
+	} catch (error) {
+		parser.acorn_error(error);
+	}
+}
+
+/**
+ * @param {Parser} parser
+ * @returns {any}
+ */
+function read_type_annotation(parser) {
+	const start = parser.index;
+	parser.allow_whitespace();
+
+	if (!parser.eat(':')) {
+		parser.index = start;
+		return undefined;
+	}
+
+	// we need to trick Acorn into parsing the type annotation
+	const insert = '_ as ';
+	let a = parser.index - insert.length;
+	const template =
+		parser.template.slice(0, a).replace(/[^\n]/g, ' ') +
+		insert +
+		// If this is a type annotation for a function parameter, Acorn-TS will treat subsequent
+		// parameters as part of a sequence expression instead, and will then error on optional
+		// parameters (`?:`). Therefore replace that sequence with something that will not error.
+		parser.template.slice(parser.index).replace(/\?\s*:/g, ':');
+	let expression = parse_expression_at(template, parser.root.comments, parser.ts, a);
+
+	// `foo: bar = baz` gets mangled — fix it
+	if (expression.type === 'AssignmentExpression') {
+		let b = expression.right.start;
+		while (template[b] !== '=') b -= 1;
+		expression = parse_expression_at(template.slice(0, b), parser.root.comments, parser.ts, a);
+	}
+
+	// `array as item: string, index` becomes `string, index`, which is mistaken as a sequence expression - fix that
+	if (expression.type === 'SequenceExpression') {
+		expression = expression.expressions[0];
+	}
+
+	parser.index = /** @type {number} */ (expression.end);
+	return {
+		type: 'TSTypeAnnotation',
+		start,
+		end: parser.index,
+		typeAnnotation: /** @type {any} */ (expression).typeAnnotation
+	};
+}