lumen-plus 0.0.4 → 0.0.5

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

@@ -1,198 +0,0 @@
-/** @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

@@ -1,326 +0,0 @@
-/** @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

@@ -1,116 +0,0 @@
-/** @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
-	};
-}