lumen-plus 0.0.4 → 0.0.5

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

@@ -1,93 +0,0 @@
-/** @import { Expression } from 'estree' */
-/** @import { Parser } from '../index.js' */
-import { parse_expression_at } from '../acorn.js';
-import { regex_whitespace } from '../../patterns.js';
-import * as e from '../../../errors.js';
-import { find_matching_bracket } from '../utils/bracket.js';
-
-/**
- * @param {Parser} parser
- * @param {string} [opening_token]
- * @returns {Expression | undefined}
- */
-export function get_loose_identifier(parser, opening_token) {
-	// Find the next } and treat it as the end of the expression
-	const end = find_matching_bracket(parser.template, parser.index, opening_token ?? '{');
-	if (end) {
-		const start = parser.index;
-		parser.index = end;
-		// We don't know what the expression is and signal this by returning an empty identifier
-		return {
-			type: 'Identifier',
-			start,
-			end,
-			name: ''
-		};
-	}
-}
-
-/**
- * @param {Parser} parser
- * @param {string} [opening_token]
- * @param {boolean} [disallow_loose]
- * @returns {Expression}
- */
-export default function read_expression(parser, opening_token, disallow_loose) {
-	try {
-		let comment_index = parser.root.comments.length;
-
-		const node = parse_expression_at(
-			parser.template,
-			parser.root.comments,
-			parser.ts,
-			parser.index
-		);
-
-		let num_parens = 0;
-
-		let i = parser.root.comments.length;
-		while (i-- > comment_index) {
-			const comment = parser.root.comments[i];
-			if (comment.end < node.start) {
-				parser.index = comment.end;
-				break;
-			}
-		}
-
-		for (let i = parser.index; i < /** @type {number} */ (node.start); i += 1) {
-			if (parser.template[i] === '(') num_parens += 1;
-		}
-
-		let index = /** @type {number} */ (node.end);
-
-		const last_comment = parser.root.comments.at(-1);
-		if (last_comment && last_comment.end > index) index = last_comment.end;
-
-		while (num_parens > 0) {
-			const char = parser.template[index];
-
-			if (char === ')') {
-				num_parens -= 1;
-			} else if (!regex_whitespace.test(char)) {
-				e.expected_token(index, ')');
-			}
-
-			index += 1;
-		}
-
-		parser.index = index;
-
-		return /** @type {Expression} */ (node);
-	} catch (err) {
-		// If we are in an each loop we need the error to be thrown in cases like
-		// `as { y = z }` so we still throw and handle the error there
-		if (parser.loose && !disallow_loose) {
-			const expression = get_loose_identifier(parser, opening_token);
-			if (expression) {
-				return expression;
-			}
-		}
-
-		parser.acorn_error(err);
-	}
-}

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

@@ -1,261 +0,0 @@
-/** @import { ObjectExpression } from 'estree' */
-/** @import { AST } from '#compiler' */
-import { NAMESPACE_MATHML, NAMESPACE_SVG } from '../../../../constants.js';
-import * as e from '../../../errors.js';
-
-/**
- * @param {AST.SvelteOptionsRaw} node
- * @returns {AST.Root['options']}
- */
-export default function read_options(node) {
-	/** @type {AST.SvelteOptions} */
-	const component_options = {
-		start: node.start,
-		end: node.end,
-		// @ts-ignore
-		attributes: node.attributes
-	};
-
-	if (!node) {
-		return component_options;
-	}
-
-	for (const attribute of node.attributes) {
-		if (attribute.type !== 'Attribute') {
-			e.svelte_options_invalid_attribute(attribute);
-		}
-
-		const { name } = attribute;
-
-		switch (name) {
-			case 'runes': {
-				component_options.runes = get_boolean_value(attribute);
-				break;
-			}
-			case 'tag': {
-				e.svelte_options_deprecated_tag(attribute);
-				break; // eslint doesn't know this is unnecessary
-			}
-			case 'customElement': {
-				/** @type {AST.SvelteOptions['customElement']} */
-				const ce = {};
-				const { value: v } = attribute;
-				const value = v === true || Array.isArray(v) ? v : [v];
-
-				if (value === true) {
-					e.svelte_options_invalid_customelement(attribute);
-				} else if (value[0].type === 'Text') {
-					const tag = get_static_value(attribute);
-					validate_tag(attribute, tag);
-					ce.tag = tag;
-					component_options.customElement = ce;
-					break;
-				} else if (value[0].expression.type !== 'ObjectExpression') {
-					// Before Svelte 4 it was necessary to explicitly set customElement to null or else you'd get a warning.
-					// This is no longer necessary, but for backwards compat just skip in this case now.
-					if (value[0].expression.type === 'Literal' && value[0].expression.value === null) {
-						break;
-					}
-					e.svelte_options_invalid_customelement(attribute);
-				}
-
-				/** @type {Array<[string, any]>} */
-				const properties = [];
-				for (const property of value[0].expression.properties) {
-					if (
-						property.type !== 'Property' ||
-						property.computed ||
-						property.key.type !== 'Identifier'
-					) {
-						e.svelte_options_invalid_customelement(attribute);
-					}
-					properties.push([property.key.name, property.value]);
-				}
-
-				const tag = properties.find(([name]) => name === 'tag');
-				if (tag) {
-					const tag_value = tag[1]?.value;
-					validate_tag(tag, tag_value);
-					ce.tag = tag_value;
-				}
-
-				const props = properties.find(([name]) => name === 'props')?.[1];
-				if (props) {
-					if (props.type !== 'ObjectExpression') {
-						e.svelte_options_invalid_customelement_props(attribute);
-					}
-					ce.props = {};
-					for (const property of /** @type {ObjectExpression} */ (props).properties) {
-						if (
-							property.type !== 'Property' ||
-							property.computed ||
-							property.key.type !== 'Identifier' ||
-							property.value.type !== 'ObjectExpression'
-						) {
-							e.svelte_options_invalid_customelement_props(attribute);
-						}
-						ce.props[property.key.name] = {};
-						for (const prop of property.value.properties) {
-							if (
-								prop.type !== 'Property' ||
-								prop.computed ||
-								prop.key.type !== 'Identifier' ||
-								prop.value.type !== 'Literal'
-							) {
-								e.svelte_options_invalid_customelement_props(attribute);
-							}
-
-							if (prop.key.name === 'type') {
-								if (
-									['String', 'Number', 'Boolean', 'Array', 'Object'].indexOf(
-										/** @type {string} */ (prop.value.value)
-									) === -1
-								) {
-									e.svelte_options_invalid_customelement_props(attribute);
-								}
-								ce.props[property.key.name].type = /** @type {any} */ (prop.value.value);
-							} else if (prop.key.name === 'reflect') {
-								if (typeof prop.value.value !== 'boolean') {
-									e.svelte_options_invalid_customelement_props(attribute);
-								}
-								ce.props[property.key.name].reflect = prop.value.value;
-							} else if (prop.key.name === 'attribute') {
-								if (typeof prop.value.value !== 'string') {
-									e.svelte_options_invalid_customelement_props(attribute);
-								}
-								ce.props[property.key.name].attribute = prop.value.value;
-							} else {
-								e.svelte_options_invalid_customelement_props(attribute);
-							}
-						}
-					}
-				}
-
-				const shadow = properties.find(([name]) => name === 'shadow')?.[1];
-				if (shadow) {
-					const shadowdom = shadow?.value;
-					if (shadowdom !== 'open' && shadowdom !== 'none') {
-						e.svelte_options_invalid_customelement_shadow(shadow);
-					}
-					ce.shadow = shadowdom;
-				}
-
-				const extend = properties.find(([name]) => name === 'extend')?.[1];
-				if (extend) {
-					ce.extend = extend;
-				}
-
-				component_options.customElement = ce;
-				break;
-			}
-			case 'namespace': {
-				const value = get_static_value(attribute);
-
-				if (value === NAMESPACE_SVG) {
-					component_options.namespace = 'svg';
-				} else if (value === NAMESPACE_MATHML) {
-					component_options.namespace = 'mathml';
-				} else if (value === 'html' || value === 'mathml' || value === 'svg') {
-					component_options.namespace = value;
-				} else {
-					e.svelte_options_invalid_attribute_value(attribute, `"html", "mathml" or "svg"`);
-				}
-
-				break;
-			}
-			case 'css': {
-				const value = get_static_value(attribute);
-
-				if (value === 'injected') {
-					component_options.css = value;
-				} else {
-					e.svelte_options_invalid_attribute_value(attribute, `"injected"`);
-				}
-
-				break;
-			}
-			case 'immutable': {
-				component_options.immutable = get_boolean_value(attribute);
-				break;
-			}
-			case 'preserveWhitespace': {
-				component_options.preserveWhitespace = get_boolean_value(attribute);
-				break;
-			}
-			case 'accessors': {
-				component_options.accessors = get_boolean_value(attribute);
-				break;
-			}
-			default:
-				e.svelte_options_unknown_attribute(attribute, name);
-		}
-	}
-
-	return component_options;
-}
-
-/**
- * @param {any} attribute
- */
-function get_static_value(attribute) {
-	const { value } = attribute;
-
-	if (value === true) return true;
-
-	const chunk = Array.isArray(value) ? value[0] : value;
-
-	if (!chunk) return true;
-	if (value.length > 1) {
-		return null;
-	}
-	if (chunk.type === 'Text') return chunk.data;
-	if (chunk.expression.type !== 'Literal') {
-		return null;
-	}
-
-	return chunk.expression.value;
-}
-
-/**
- * @param {any} attribute
- */
-function get_boolean_value(attribute) {
-	const value = get_static_value(attribute);
-	if (typeof value !== 'boolean') {
-		e.svelte_options_invalid_attribute_value(attribute, 'true or false');
-	}
-	return value;
-}
-
-// https://html.spec.whatwg.org/multipage/custom-elements.html#valid-custom-element-name
-const tag_name_char =
-	'[a-z0-9_.\xB7\xC0-\xD6\xD8-\xF6\xF8-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u{10000}-\u{EFFFF}-]';
-const regex_valid_tag_name = new RegExp(`^[a-z]${tag_name_char}*-${tag_name_char}*$`, 'u');
-const reserved_tag_names = [
-	'annotation-xml',
-	'color-profile',
-	'font-face',
-	'font-face-src',
-	'font-face-uri',
-	'font-face-format',
-	'font-face-name',
-	'missing-glyph'
-];
-
-/**
- * @param {any} attribute
- * @param {string | null} tag
- * @returns {asserts tag is string}
- */
-function validate_tag(attribute, tag) {
-	if (typeof tag !== 'string') {
-		e.svelte_options_invalid_tagname(attribute);
-	}
-	if (tag) {
-		if (!regex_valid_tag_name.test(tag)) {
-			e.svelte_options_invalid_tagname(attribute);
-		} else if (reserved_tag_names.includes(tag)) {
-			e.svelte_options_reserved_tagname(attribute);
-		}
-	}
-}

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

@@ -1,97 +0,0 @@
-/** @import { Program } from 'estree' */
-/** @import { AST } from '#compiler' */
-/** @import { Parser } from '../index.js' */
-import * as acorn from '../acorn.js';
-import { regex_not_newline_characters } from '../../patterns.js';
-import * as e from '../../../errors.js';
-import * as w from '../../../warnings.js';
-import { is_text_attribute } from '../../../utils/ast.js';
-import { locator } from '../../../state.js';
-
-const regex_closing_script_tag = /<\/script\s*>/;
-const regex_starts_with_closing_script_tag = /^<\/script\s*>/;
-
-const RESERVED_ATTRIBUTES = ['server', 'client', 'worker', 'test', 'default'];
-const ALLOWED_ATTRIBUTES = ['context', 'generics', 'lang', 'module'];
-
-/**
- * @param {Parser} parser
- * @param {number} start
- * @param {Array<AST.Attribute | AST.SpreadAttribute | AST.Directive | AST.AttachTag>} attributes
- * @returns {AST.Script}
- */
-export function read_script(parser, start, attributes) {
-	const script_start = parser.index;
-	const data = parser.read_until(regex_closing_script_tag);
-	if (parser.index >= parser.template.length) {
-		e.element_unclosed(parser.template.length, 'script');
-	}
-
-	const source =
-		parser.template.slice(0, script_start).replace(regex_not_newline_characters, ' ') + data;
-	parser.read(regex_starts_with_closing_script_tag);
-
-	/** @type {Program} */
-	let ast;
-
-	try {
-		ast = acorn.parse(source, parser.root.comments, parser.ts, true);
-	} catch (err) {
-		parser.acorn_error(err);
-	}
-
-	ast.start = script_start;
-
-	if (ast.loc) {
-		// Acorn always uses `0` as the start of a `Program`, but for sourcemap purposes
-		// we need it to be the start of the `<script>` contents
-		({ line: ast.loc.start.line, column: ast.loc.start.column } = locator(start));
-		({ line: ast.loc.end.line, column: ast.loc.end.column } = locator(parser.index));
-	}
-
-	/** @type {'default' | 'module'} */
-	let context = 'default';
-
-	for (const attribute of /** @type {AST.Attribute[]} */ (attributes)) {
-		if (RESERVED_ATTRIBUTES.includes(attribute.name)) {
-			e.script_reserved_attribute(attribute, attribute.name);
-		}
-
-		if (!ALLOWED_ATTRIBUTES.includes(attribute.name)) {
-			w.script_unknown_attribute(attribute);
-		}
-
-		if (attribute.name === 'module') {
-			if (attribute.value !== true) {
-				// Deliberately a generic code to future-proof for potential other attributes
-				e.script_invalid_attribute_value(attribute, attribute.name);
-			}
-
-			context = 'module';
-		}
-
-		if (attribute.name === 'context') {
-			if (attribute.value === true || !is_text_attribute(attribute)) {
-				e.script_invalid_context(attribute);
-			}
-
-			const value = attribute.value[0].data;
-
-			if (value !== 'module') {
-				e.script_invalid_context(attribute);
-			}
-
-			context = 'module';
-		}
-	}
-
-	return {
-		type: 'Script',
-		start,
-		end: parser.index,
-		context,
-		content: ast,
-		// @ts-ignore
-		attributes
-	};
-}