lumen-plus 0.0.4 → 0.0.5

package/dist/utils/node_modules/svelte/src/constants.js

@@ -1,64 +0,0 @@
-export const EACH_ITEM_REACTIVE = 1;
-export const EACH_INDEX_REACTIVE = 1 << 1;
-/** See EachBlock interface metadata.is_controlled for an explanation what this is */
-export const EACH_IS_CONTROLLED = 1 << 2;
-export const EACH_IS_ANIMATED = 1 << 3;
-export const EACH_ITEM_IMMUTABLE = 1 << 4;
-
-export const PROPS_IS_IMMUTABLE = 1;
-export const PROPS_IS_RUNES = 1 << 1;
-export const PROPS_IS_UPDATED = 1 << 2;
-export const PROPS_IS_BINDABLE = 1 << 3;
-export const PROPS_IS_LAZY_INITIAL = 1 << 4;
-
-export const TRANSITION_IN = 1;
-export const TRANSITION_OUT = 1 << 1;
-export const TRANSITION_GLOBAL = 1 << 2;
-
-export const TEMPLATE_FRAGMENT = 1;
-export const TEMPLATE_USE_IMPORT_NODE = 1 << 1;
-export const TEMPLATE_USE_SVG = 1 << 2;
-export const TEMPLATE_USE_MATHML = 1 << 3;
-
-export const HYDRATION_START = '[';
-/** used to indicate that an `{:else}...` block was rendered */
-export const HYDRATION_START_ELSE = '[!';
-export const HYDRATION_END = ']';
-export const HYDRATION_ERROR = {};
-
-export const ELEMENT_IS_NAMESPACED = 1;
-export const ELEMENT_PRESERVE_ATTRIBUTE_CASE = 1 << 1;
-export const ELEMENT_IS_INPUT = 1 << 2;
-
-export const UNINITIALIZED = Symbol();
-
-// Dev-time component properties
-export const FILENAME = Symbol('filename');
-export const HMR = Symbol('hmr');
-
-export const NAMESPACE_HTML = 'http://www.w3.org/1999/xhtml';
-export const NAMESPACE_SVG = 'http://www.w3.org/2000/svg';
-export const NAMESPACE_MATHML = 'http://www.w3.org/1998/Math/MathML';
-
-// we use a list of ignorable runtime warnings because not every runtime warning
-// can be ignored and we want to keep the validation for svelte-ignore in place
-export const IGNORABLE_RUNTIME_WARNINGS = /** @type {const} */ ([
-	'await_waterfall',
-	'await_reactivity_loss',
-	'state_snapshot_uncloneable',
-	'binding_property_non_reactive',
-	'hydration_attribute_changed',
-	'hydration_html_changed',
-	'ownership_invalid_binding',
-	'ownership_invalid_mutation'
-]);
-
-/**
- * Whitespace inside one of these elements will not result in
- * a whitespace node being created in any circumstances. (This
- * list is almost certainly very incomplete)
- * TODO this is currently unused
- */
-export const ELEMENTS_WITHOUT_TEXT = ['audio', 'datalist', 'dl', 'optgroup', 'select', 'video'];
-
-export const ATTACHMENT_KEY = '@attach';

package/dist/utils/node_modules/svelte/src/easing/index.js

@@ -1,286 +0,0 @@
-/*
-Adapted from https://github.com/mattdesl
-Distributed under MIT License https://github.com/mattdesl/eases/blob/master/LICENSE.md
-*/
-
-/**
- * @param {number} t
- * @returns {number}
- */
-export function linear(t) {
-	return t;
-}
-
-/**
- * @param {number} t
- * @returns {number}
- */
-export function backInOut(t) {
-	const s = 1.70158 * 1.525;
-	if ((t *= 2) < 1) return 0.5 * (t * t * ((s + 1) * t - s));
-	return 0.5 * ((t -= 2) * t * ((s + 1) * t + s) + 2);
-}
-
-/**
- * @param {number} t
- * @returns {number}
- */
-export function backIn(t) {
-	const s = 1.70158;
-	return t * t * ((s + 1) * t - s);
-}
-
-/**
- * @param {number} t
- * @returns {number}
- */
-export function backOut(t) {
-	const s = 1.70158;
-	return --t * t * ((s + 1) * t + s) + 1;
-}
-
-/**
- * @param {number} t
- * @returns {number}
- */
-export function bounceOut(t) {
-	const a = 4.0 / 11.0;
-	const b = 8.0 / 11.0;
-	const c = 9.0 / 10.0;
-	const ca = 4356.0 / 361.0;
-	const cb = 35442.0 / 1805.0;
-	const cc = 16061.0 / 1805.0;
-	const t2 = t * t;
-	return t < a
-		? 7.5625 * t2
-		: t < b
-			? 9.075 * t2 - 9.9 * t + 3.4
-			: t < c
-				? ca * t2 - cb * t + cc
-				: 10.8 * t * t - 20.52 * t + 10.72;
-}
-
-/**
- * @param {number} t
- * @returns {number}
- */
-export function bounceInOut(t) {
-	return t < 0.5 ? 0.5 * (1.0 - bounceOut(1.0 - t * 2.0)) : 0.5 * bounceOut(t * 2.0 - 1.0) + 0.5;
-}
-
-/**
- * @param {number} t
- * @returns {number}
- */
-export function bounceIn(t) {
-	return 1.0 - bounceOut(1.0 - t);
-}
-
-/**
- * @param {number} t
- * @returns {number}
- */
-export function circInOut(t) {
-	if ((t *= 2) < 1) return -0.5 * (Math.sqrt(1 - t * t) - 1);
-	return 0.5 * (Math.sqrt(1 - (t -= 2) * t) + 1);
-}
-
-/**
- * @param {number} t
- * @returns {number}
- */
-export function circIn(t) {
-	return 1.0 - Math.sqrt(1.0 - t * t);
-}
-
-/**
- * @param {number} t
- * @returns {number}
- */
-export function circOut(t) {
-	return Math.sqrt(1 - --t * t);
-}
-
-/**
- * @param {number} t
- * @returns {number}
- */
-export function cubicInOut(t) {
-	return t < 0.5 ? 4.0 * t * t * t : 0.5 * Math.pow(2.0 * t - 2.0, 3.0) + 1.0;
-}
-
-/**
- * @param {number} t
- * @returns {number}
- */
-export function cubicIn(t) {
-	return t * t * t;
-}
-
-/**
- * @param {number} t
- * @returns {number}
- */
-export function cubicOut(t) {
-	const f = t - 1.0;
-	return f * f * f + 1.0;
-}
-
-/**
- * @param {number} t
- * @returns {number}
- */
-export function elasticInOut(t) {
-	return t < 0.5
-		? 0.5 * Math.sin(((+13.0 * Math.PI) / 2) * 2.0 * t) * Math.pow(2.0, 10.0 * (2.0 * t - 1.0))
-		: 0.5 *
-				Math.sin(((-13.0 * Math.PI) / 2) * (2.0 * t - 1.0 + 1.0)) *
-				Math.pow(2.0, -10.0 * (2.0 * t - 1.0)) +
-				1.0;
-}
-
-/**
- * @param {number} t
- * @returns {number}
- */
-export function elasticIn(t) {
-	return Math.sin((13.0 * t * Math.PI) / 2) * Math.pow(2.0, 10.0 * (t - 1.0));
-}
-
-/**
- * @param {number} t
- * @returns {number}
- */
-export function elasticOut(t) {
-	return Math.sin((-13.0 * (t + 1.0) * Math.PI) / 2) * Math.pow(2.0, -10.0 * t) + 1.0;
-}
-
-/**
- * @param {number} t
- * @returns {number}
- */
-export function expoInOut(t) {
-	return t === 0.0 || t === 1.0
-		? t
-		: t < 0.5
-			? +0.5 * Math.pow(2.0, 20.0 * t - 10.0)
-			: -0.5 * Math.pow(2.0, 10.0 - t * 20.0) + 1.0;
-}
-
-/**
- * @param {number} t
- * @returns {number}
- */
-export function expoIn(t) {
-	return t === 0.0 ? t : Math.pow(2.0, 10.0 * (t - 1.0));
-}
-
-/**
- * @param {number} t
- * @returns {number}
- */
-export function expoOut(t) {
-	return t === 1.0 ? t : 1.0 - Math.pow(2.0, -10.0 * t);
-}
-
-/**
- * @param {number} t
- * @returns {number}
- */
-export function quadInOut(t) {
-	t /= 0.5;
-	if (t < 1) return 0.5 * t * t;
-	t--;
-	return -0.5 * (t * (t - 2) - 1);
-}
-
-/**
- * @param {number} t
- * @returns {number}
- */
-export function quadIn(t) {
-	return t * t;
-}
-
-/**
- * @param {number} t
- * @returns {number}
- */
-export function quadOut(t) {
-	return -t * (t - 2.0);
-}
-
-/**
- * @param {number} t
- * @returns {number}
- */
-export function quartInOut(t) {
-	return t < 0.5 ? +8.0 * Math.pow(t, 4.0) : -8.0 * Math.pow(t - 1.0, 4.0) + 1.0;
-}
-
-/**
- * @param {number} t
- * @returns {number}
- */
-export function quartIn(t) {
-	return Math.pow(t, 4.0);
-}
-
-/**
- * @param {number} t
- * @returns {number}
- */
-export function quartOut(t) {
-	return Math.pow(t - 1.0, 3.0) * (1.0 - t) + 1.0;
-}
-
-/**
- * @param {number} t
- * @returns {number}
- */
-export function quintInOut(t) {
-	if ((t *= 2) < 1) return 0.5 * t * t * t * t * t;
-	return 0.5 * ((t -= 2) * t * t * t * t + 2);
-}
-
-/**
- * @param {number} t
- * @returns {number}
- */
-export function quintIn(t) {
-	return t * t * t * t * t;
-}
-
-/**
- * @param {number} t
- * @returns {number}
- */
-export function quintOut(t) {
-	return --t * t * t * t * t + 1;
-}
-
-/**
- * @param {number} t
- * @returns {number}
- */
-export function sineInOut(t) {
-	return -0.5 * (Math.cos(Math.PI * t) - 1);
-}
-
-/**
- * @param {number} t
- * @returns {number}
- */
-export function sineIn(t) {
-	const v = Math.cos(t * Math.PI * 0.5);
-	if (Math.abs(v) < 1e-14) return 1;
-	else return 1 - v;
-}
-
-/**
- * @param {number} t
- * @returns {number}
- */
-export function sineOut(t) {
-	return Math.sin((t * Math.PI) / 2);
-}

package/dist/utils/node_modules/svelte/src/escaping.js

@@ -1,26 +0,0 @@
-const ATTR_REGEX = /[&"<]/g;
-const CONTENT_REGEX = /[&<]/g;
-
-/**
- * @template V
- * @param {V} value
- * @param {boolean} [is_attr]
- */
-export function escape_html(value, is_attr) {
-	const str = String(value ?? '');
-
-	const pattern = is_attr ? ATTR_REGEX : CONTENT_REGEX;
-	pattern.lastIndex = 0;
-
-	let escaped = '';
-	let last = 0;
-
-	while (pattern.test(str)) {
-		const i = pattern.lastIndex - 1;
-		const ch = str[i];
-		escaped += str.substring(last, i) + (ch === '&' ? '&amp;' : ch === '"' ? '&quot;' : '&lt;');
-		last = i + 1;
-	}
-
-	return escaped + str.substring(last);
-}

package/dist/utils/node_modules/svelte/src/events/index.js

@@ -1 +0,0 @@
-export { on } from '../internal/client/dom/elements/events.js';

package/dist/utils/node_modules/svelte/src/html-tree-validation.js

@@ -1,238 +0,0 @@
-/**
- * Map of elements that have certain elements that are not allowed inside them, in the sense that they will auto-close the parent/ancestor element.
- * Theoretically one could take advantage of it but most of the time it will just result in confusing behavior and break when SSR'd.
- * There are more elements that are invalid inside other elements, but they're not auto-closed and so don't break SSR and are therefore not listed here.
- * @type {Record<string, { direct: string[]} | { descendant: string[]; reset_by?: string[] }>}
- */
-const autoclosing_children = {
-	// based on http://developers.whatwg.org/syntax.html#syntax-tag-omission
-	li: { direct: ['li'] },
-	// https://developer.mozilla.org/en-US/docs/Web/HTML/Element/dt#technical_summary
-	dt: { descendant: ['dt', 'dd'], reset_by: ['dl'] },
-	dd: { descendant: ['dt', 'dd'], reset_by: ['dl'] },
-	p: {
-		descendant: [
-			'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'
-		]
-	},
-	rt: { descendant: ['rt', 'rp'] },
-	rp: { descendant: ['rt', 'rp'] },
-	optgroup: { descendant: ['optgroup'] },
-	option: { descendant: ['option', 'optgroup'] },
-	thead: { direct: ['tbody', 'tfoot'] },
-	tbody: { direct: ['tbody', 'tfoot'] },
-	tfoot: { direct: ['tbody'] },
-	tr: { direct: ['tr', 'tbody'] },
-	td: { direct: ['td', 'th', 'tr'] },
-	th: { direct: ['td', 'th', 'tr'] }
-};
-
-/**
- * Returns true if the tag is either the last in the list of siblings and will be autoclosed,
- * or not allowed inside the parent tag such that it will auto-close it. The latter results
- * in the browser repairing the HTML, which will likely result in an error during hydration.
- * @param {string} current
- * @param {string} [next]
- */
-export function closing_tag_omitted(current, next) {
-	const disallowed = autoclosing_children[current];
-	if (disallowed) {
-		if (
-			!next ||
-			('direct' in disallowed ? disallowed.direct : disallowed.descendant).includes(next)
-		) {
-			return true;
-		}
-	}
-	return false;
-}
-
-/**
- * Map of elements that have certain elements that are not allowed inside them, in the sense that the browser will somehow repair the HTML.
- * There are more elements that are invalid inside other elements, but they're not repaired and so don't break SSR and are therefore not listed here.
- * @type {Record<string, { direct: string[]} | { descendant: string[]; reset_by?: string[]; only?: string[] } | { only: string[] }>}
- */
-const disallowed_children = {
-	...autoclosing_children,
-	// Strictly speaking, seeing an <option> doesn't mean we're in a <select>, but we assume it here
-	// option or optgroup does not have an `only` restriction because newer browsers support rich HTML content
-	// inside option elements. For older browsers, hydration will handle the mismatch.
-	form: { descendant: ['form'] },
-	a: { descendant: ['a'] },
-	button: { descendant: ['button'] },
-	h1: { descendant: ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'] },
-	h2: { descendant: ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'] },
-	h3: { descendant: ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'] },
-	h4: { descendant: ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'] },
-	h5: { descendant: ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'] },
-	h6: { descendant: ['h1', 'h2', 'h3', 'h4', 'h5', 'h6'] },
-
-	// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intd
-	// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-incaption
-	// No special behavior since these rules fall back to "in body" mode for
-	// all except special table nodes which cause bad parsing behavior anyway.
-
-	// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intd
-	tr: { only: ['th', 'td', 'style', 'script', 'template'] },
-	// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intbody
-	tbody: { only: ['tr', 'style', 'script', 'template'] },
-	thead: { only: ['tr', 'style', 'script', 'template'] },
-	tfoot: { only: ['tr', 'style', 'script', 'template'] },
-	// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-incolgroup
-	colgroup: { only: ['col', 'template'] },
-	// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intable
-	table: {
-		only: ['caption', 'colgroup', 'tbody', 'thead', 'tfoot', 'style', 'script', 'template']
-	},
-	// https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inhead
-	head: {
-		only: [
-			'base',
-			'basefont',
-			'bgsound',
-			'link',
-			'meta',
-			'title',
-			'noscript',
-			'noframes',
-			'style',
-			'script',
-			'template'
-		]
-	},
-	// https://html.spec.whatwg.org/multipage/semantics.html#the-html-element
-	html: { only: ['head', 'body', 'frameset'] },
-	frameset: { only: ['frame'] },
-	'#document': { only: ['html'] }
-};
-
-/**
- * Returns an error message if the tag is not allowed inside the ancestor tag (which is grandparent and above) such that it will result
- * in the browser repairing the HTML, which will likely result in an error during hydration.
- * @param {string} child_tag
- * @param {string[]} ancestors All nodes starting with the parent, up until the ancestor, which means two entries minimum
- * @param {string} [child_loc]
- * @param {string} [ancestor_loc]
- * @returns {string | null}
- */
-export function is_tag_valid_with_ancestor(child_tag, ancestors, child_loc, ancestor_loc) {
-	if (child_tag.includes('-')) return null; // custom elements can be anything
-
-	const ancestor_tag = ancestors[ancestors.length - 1];
-	const disallowed = disallowed_children[ancestor_tag];
-	if (!disallowed) return null;
-
-	if ('reset_by' in disallowed && disallowed.reset_by) {
-		for (let i = ancestors.length - 2; i >= 0; i--) {
-			const ancestor = ancestors[i];
-			if (ancestor.includes('-')) return null; // custom elements can be anything
-
-			// A reset means that forbidden descendants are allowed again
-			if (disallowed.reset_by.includes(ancestors[i])) {
-				return null;
-			}
-		}
-	}
-
-	if ('descendant' in disallowed && disallowed.descendant.includes(child_tag)) {
-		const child = child_loc ? `\`<${child_tag}>\` (${child_loc})` : `\`<${child_tag}>\``;
-		const ancestor = ancestor_loc
-			? `\`<${ancestor_tag}>\` (${ancestor_loc})`
-			: `\`<${ancestor_tag}>\``;
-
-		return `${child} cannot be a descendant of ${ancestor}`;
-	}
-
-	return null;
-}
-
-/**
- * Returns an error message if the tag is not allowed inside the parent tag such that it will result
- * in the browser repairing the HTML, which will likely result in an error during hydration.
- * @param {string} child_tag
- * @param {string} parent_tag
- * @param {string} [child_loc]
- * @param {string} [parent_loc]
- * @returns {string | null}
- */
-export function is_tag_valid_with_parent(child_tag, parent_tag, child_loc, parent_loc) {
-	if (child_tag.includes('-') || parent_tag?.includes('-')) return null; // custom elements can be anything
-
-	if (parent_tag === 'template') return null; // no errors or warning should be thrown in immediate children of template tags
-
-	const disallowed = disallowed_children[parent_tag];
-
-	const child = child_loc ? `\`<${child_tag}>\` (${child_loc})` : `\`<${child_tag}>\``;
-	const parent = parent_loc ? `\`<${parent_tag}>\` (${parent_loc})` : `\`<${parent_tag}>\``;
-
-	if (disallowed) {
-		if ('direct' in disallowed && disallowed.direct.includes(child_tag)) {
-			return `${child} cannot be a direct child of ${parent}`;
-		}
-
-		if ('descendant' in disallowed && disallowed.descendant.includes(child_tag)) {
-			return `${child} cannot be a child of ${parent}`;
-		}
-
-		if ('only' in disallowed && disallowed.only) {
-			if (disallowed.only.includes(child_tag)) {
-				return null;
-			} else {
-				return `${child} cannot be a child of ${parent}. \`<${parent_tag}>\` only allows these children: ${disallowed.only.map((d) => `\`<${d}>\``).join(', ')}`;
-			}
-		}
-	}
-
-	// These tags are only valid with a few parents that have special child
-	// parsing rules - if we're down here, then none of those matched and
-	// so we allow it only if we don't know what the parent is, as all other
-	// cases are invalid (and we only get into this function if we know the parent).
-	switch (child_tag) {
-		case 'body':
-		case 'caption':
-		case 'col':
-		case 'colgroup':
-		case 'frameset':
-		case 'frame':
-		case 'head':
-		case 'html':
-			return `${child} cannot be a child of ${parent}`;
-		case 'thead':
-		case 'tbody':
-		case 'tfoot':
-			return `${child} must be the child of a \`<table>\`, not a ${parent}`;
-		case 'td':
-		case 'th':
-			return `${child} must be the child of a \`<tr>\`, not a ${parent}`;
-		case 'tr':
-			return `\`<tr>\` must be the child of a \`<thead>\`, \`<tbody>\`, or \`<tfoot>\`, not a ${parent}`;
-	}
-
-	return null;
-}