lumen-plus 0.0.4 → 0.0.5

package/dist/utils/node_modules/svelte/src/compiler/utils/compile_diagnostic.js

@@ -1,107 +0,0 @@
-/** @import { Location } from 'locate-character' */
-import * as state from '../state.js';
-
-const regex_tabs = /^\t+/;
-
-/**
- * @param {string} str
- */
-function tabs_to_spaces(str) {
-	return str.replace(regex_tabs, (match) => match.split('\t').join('  '));
-}
-
-/**
- * @param {string} source
- * @param {number} line
- * @param {number} column
- */
-function get_code_frame(source, line, column) {
-	const lines = source.split('\n');
-	const frame_start = Math.max(0, line - 2);
-	const frame_end = Math.min(line + 3, lines.length);
-	const digits = String(frame_end + 1).length;
-	return lines
-		.slice(frame_start, frame_end)
-		.map((str, i) => {
-			const is_error_line = frame_start + i === line;
-			const line_num = String(i + frame_start + 1).padStart(digits, ' ');
-			if (is_error_line) {
-				const indicator =
-					' '.repeat(digits + 2 + tabs_to_spaces(str.slice(0, column)).length) + '^';
-				return `${line_num}: ${tabs_to_spaces(str)}\n${indicator}`;
-			}
-			return `${line_num}: ${tabs_to_spaces(str)}`;
-		})
-		.join('\n');
-}
-
-/**
- * @typedef {{
- * 	code: string;
- * 	message: string;
- *  stack?: string;
- * 	filename?: string;
- * 	start?: Location;
- * 	end?: Location;
- * 	position?: [number, number];
- * 	frame?: string;
- * }} ICompileDiagnostic
- */
-
-/** @implements {ICompileDiagnostic} */
-export class CompileDiagnostic {
-	name = 'CompileDiagnostic';
-
-	/**
-	 * @param {string} code
-	 * @param {string} message
-	 * @param {[number, number] | undefined} position
-	 */
-	constructor(code, message, position) {
-		this.code = code;
-		this.message = message;
-
-		if (state.filename !== state.UNKNOWN_FILENAME) {
-			this.filename = state.filename;
-		}
-
-		if (position) {
-			this.position = position;
-			this.start = state.locator(position[0]);
-			this.end = state.locator(position[1]);
-			if (this.start && this.end) {
-				this.frame = get_code_frame(state.source, this.start.line - 1, this.end.column);
-			}
-		}
-	}
-
-	toString() {
-		let out = `${this.code}: ${this.message}`;
-
-		if (this.filename) {
-			out += `\n${this.filename}`;
-
-			if (this.start) {
-				out += `:${this.start.line}:${this.start.column}`;
-			}
-		}
-
-		if (this.frame) {
-			out += `\n${this.frame}`;
-		}
-
-		return out;
-	}
-
-	toJSON() {
-		return {
-			code: this.code,
-			message: this.message,
-			filename: this.filename,
-			start: this.start,
-			end: this.end,
-			position: this.position,
-			frame: this.frame
-		};
-	}
-}

package/dist/utils/node_modules/svelte/src/compiler/utils/extract_svelte_ignore.js

@@ -1,104 +0,0 @@
-import { IGNORABLE_RUNTIME_WARNINGS } from '../../constants.js';
-import fuzzymatch from '../phases/1-parse/utils/fuzzymatch.js';
-import * as w from '../warnings.js';
-
-const regex_svelte_ignore = /^\s*svelte-ignore\s/;
-
-/** @type {Record<string, string>} Map of legacy code -> new code */
-const replacements = {
-	'non-top-level-reactive-declaration': 'reactive_declaration_invalid_placement',
-	'module-script-reactive-declaration': 'reactive_declaration_module_script',
-	'empty-block': 'block_empty',
-	'avoid-is': 'attribute_avoid_is',
-	'invalid-html-attribute': 'attribute_invalid_property_name',
-	'a11y-structure': 'a11y_figcaption_parent',
-	'illegal-attribute-character': 'attribute_illegal_colon',
-	'invalid-rest-eachblock-binding': 'bind_invalid_each_rest',
-	'unused-export-let': 'export_let_unused'
-};
-
-const codes = w.codes.concat(IGNORABLE_RUNTIME_WARNINGS);
-
-/**
- * @param {number} offset
- * @param {string} text
- * @param {boolean} runes
- * @returns {string[]}
- */
-export function extract_svelte_ignore(offset, text, runes) {
-	const match = regex_svelte_ignore.exec(text);
-	if (!match) return [];
-
-	let length = match[0].length;
-	offset += length;
-
-	/** @type {string[]} */
-	const ignores = [];
-
-	if (runes) {
-		// Warnings have to be separated by commas, everything after is interpreted as prose
-		for (const match of text.slice(length).matchAll(/([\w$-]+)(,)?/gm)) {
-			const code = match[1];
-
-			if (codes.includes(code)) {
-				ignores.push(code);
-			} else {
-				const replacement = replacements[code] ?? code.replace(/-/g, '_');
-
-				// The type cast is for some reason necessary to pass the type check in CI
-				const start = offset + /** @type {number} */ (match.index);
-				const end = start + code.length;
-
-				if (codes.includes(replacement)) {
-					w.legacy_code({ start, end }, code, replacement);
-				} else {
-					const suggestion = fuzzymatch(code, codes);
-					w.unknown_code({ start, end }, code, suggestion);
-				}
-			}
-
-			if (!match[2]) {
-				break;
-			}
-		}
-	} else {
-		// Non-runes mode: lax parsing, backwards compat with old codes
-		for (const match of text.slice(length).matchAll(/[\w$-]+/gm)) {
-			const code = match[0];
-
-			ignores.push(code);
-
-			if (!codes.includes(code)) {
-				const replacement = replacements[code] ?? code.replace(/-/g, '_');
-
-				if (codes.includes(replacement)) {
-					ignores.push(replacement);
-				}
-			}
-		}
-	}
-
-	return ignores;
-}
-
-/**
- * Replaces legacy svelte-ignore codes with new codes.
- * @param {string} text
- * @returns {string}
- */
-export function migrate_svelte_ignore(text) {
-	const match = regex_svelte_ignore.exec(text);
-	if (!match) return text;
-
-	const length = match[0].length;
-	return (
-		text.substring(0, length) +
-		text.substring(length).replace(/\w+-\w+(-\w+)*/g, (code, _, idx) => {
-			let replacement = replacements[code] ?? code.replace(/-/g, '_');
-			if (/\w+-\w+/.test(text.substring(length + idx + code.length))) {
-				replacement += ',';
-			}
-			return replacement;
-		})
-	);
-}

package/dist/utils/node_modules/svelte/src/compiler/utils/mapped_code.js

@@ -1,454 +0,0 @@
-/** @import { ValidatedCompileOptions } from '#compiler' */
-/** @import { Processed } from '../preprocess/public.js' */
-/** @import { SourceMap } from 'magic-string' */
-/** @import { Source } from '../preprocess/private.js' */
-/** @import { DecodedSourceMap, SourceMapSegment, RawSourceMap } from '@jridgewell/remapping' */
-import remapping from '@jridgewell/remapping';
-import { push_array } from './push_array.js';
-
-/**
- * @param {string} s
- */
-function last_line_length(s) {
-	return s.length - s.lastIndexOf('\n') - 1;
-}
-// mutate map in-place
-
-/**
- * @param {DecodedSourceMap} map
- * @param {{ line: number; column: number; }} offset
- * @param {number} source_index
- */
-export function sourcemap_add_offset(map, offset, source_index) {
-	if (map.mappings.length == 0) return;
-	for (let line = 0; line < map.mappings.length; line++) {
-		const segment_list = map.mappings[line];
-		for (let segment = 0; segment < segment_list.length; segment++) {
-			const seg = segment_list[segment];
-			// shift only segments that belong to component source file
-			if (seg[1] === source_index) {
-				// also ensures that seg.length >= 4
-				// shift column if it points at the first line
-				if (seg[2] === 0) {
-					/** @type {any} */ (seg[3]) += offset.column;
-				}
-				// shift line
-				/** @type {any} */ (seg[2]) += offset.line;
-			}
-		}
-	}
-}
-
-/**
- * @template T
- * @param {T[]} this_table
- * @param {T[]} other_table
- * @returns {[T[], number[], boolean, boolean]}
- */
-function merge_tables(this_table, other_table) {
-	const new_table = this_table.slice();
-	const idx_map = [];
-	other_table = other_table || [];
-	let val_changed = false;
-	for (const [other_idx, other_val] of other_table.entries()) {
-		const this_idx = this_table.indexOf(other_val);
-		if (this_idx >= 0) {
-			idx_map[other_idx] = this_idx;
-		} else {
-			const new_idx = new_table.length;
-			new_table[new_idx] = other_val;
-			idx_map[other_idx] = new_idx;
-			val_changed = true;
-		}
-	}
-	let idx_changed = val_changed;
-	if (val_changed) {
-		if (idx_map.find((val, idx) => val != idx) === undefined) {
-			// idx_map is identity map [0, 1, 2, 3, 4, ....]
-			idx_changed = false;
-		}
-	}
-	return [new_table, idx_map, val_changed, idx_changed];
-}
-const regex_line_token = /([^\w\s]|\s+)/g;
-/** */
-export class MappedCode {
-	/**
-	 * @type {string}
-	 */
-	string = /** @type {any} */ (undefined);
-
-	/**
-	 * @type {DecodedSourceMap}
-	 */
-	map = /** @type {any} */ (undefined);
-
-	/**
-	 * @param {string} string
-	 * @param {DecodedSourceMap | null} map
-	 */
-	constructor(string = '', map = null) {
-		this.string = string;
-		if (map) {
-			this.map = map;
-		} else {
-			this.map = {
-				version: 3,
-				mappings: [],
-				sources: [],
-				names: []
-			};
-		}
-	}
-	/**
-	 * concat in-place (mutable), return this (chainable)
-	 * will also mutate the `other` object
-	 * @param {MappedCode} other
-	 * @returns {MappedCode}
-	 */
-	concat(other) {
-		// noop: if one is empty, return the other
-		if (other.string == '') return this;
-		if (this.string == '') {
-			this.string = other.string;
-			this.map = other.map;
-			return this;
-		}
-		// compute last line length before mutating
-		const column_offset = last_line_length(this.string);
-		this.string += other.string;
-		const m1 = this.map;
-		const m2 = other.map;
-		if (m2.mappings.length == 0) return this;
-		// combine sources and names
-		const [sources, new_source_idx, sources_changed, sources_idx_changed] = merge_tables(
-			m1.sources,
-			m2.sources
-		);
-		const [names, new_name_idx, names_changed, names_idx_changed] = merge_tables(
-			m1.names,
-			m2.names
-		);
-		if (sources_changed) m1.sources = sources;
-		if (names_changed) m1.names = names;
-		// unswitched loops are faster
-		if (sources_idx_changed && names_idx_changed) {
-			for (let line = 0; line < m2.mappings.length; line++) {
-				const segment_list = m2.mappings[line];
-				for (let segment = 0; segment < segment_list.length; segment++) {
-					const seg = segment_list[segment];
-					// @ts-ignore
-					if (seg[1] >= 0) seg[1] = new_source_idx[seg[1]];
-					// @ts-ignore
-					if (seg[4] >= 0) seg[4] = new_name_idx[seg[4]];
-				}
-			}
-		} else if (sources_idx_changed) {
-			for (let line = 0; line < m2.mappings.length; line++) {
-				const segment_list = m2.mappings[line];
-				for (let segment = 0; segment < segment_list.length; segment++) {
-					const seg = segment_list[segment];
-					// @ts-ignore
-					if (seg[1] >= 0) seg[1] = new_source_idx[seg[1]];
-				}
-			}
-		} else if (names_idx_changed) {
-			for (let line = 0; line < m2.mappings.length; line++) {
-				const segment_list = m2.mappings[line];
-				for (let segment = 0; segment < segment_list.length; segment++) {
-					const seg = segment_list[segment];
-					// @ts-ignore
-					if (seg[4] >= 0) seg[4] = new_name_idx[seg[4]];
-				}
-			}
-		}
-		// combine the mappings
-		// combine
-		// 1. last line of first map
-		// 2. first line of second map
-		// columns of 2 must be shifted
-		if (m2.mappings.length > 0 && column_offset > 0) {
-			const first_line = m2.mappings[0];
-			for (let i = 0; i < first_line.length; i++) {
-				first_line[i][0] += column_offset;
-			}
-		}
-		// combine last line + first line
-		push_array(
-			m1.mappings[m1.mappings.length - 1],
-			/** @type {SourceMapSegment[]} */ (m2.mappings.shift())
-		);
-		// append other lines
-		push_array(m1.mappings, m2.mappings);
-		return this;
-	}
-
-	/**
-	 * @static
-	 * @param {string} string
-	 * @param {DecodedSourceMap} [map]
-	 * @returns {MappedCode}
-	 */
-	static from_processed(string, map) {
-		const line_count = string.split('\n').length;
-		if (map) {
-			// ensure that count of source map mappings lines
-			// is equal to count of generated code lines
-			// (some tools may produce less)
-			const missing_lines = line_count - map.mappings.length;
-			for (let i = 0; i < missing_lines; i++) {
-				map.mappings.push([]);
-			}
-			return new MappedCode(string, map);
-		}
-		if (string == '') return new MappedCode();
-		map = { version: 3, names: [], sources: [], mappings: [] };
-		// add empty SourceMapSegment[] for every line
-		for (let i = 0; i < line_count; i++) map.mappings.push([]);
-		return new MappedCode(string, map);
-	}
-
-	/**
-	 * @static
-	 * @param {Source} opts
-	 * @returns {MappedCode}
-	 */
-	static from_source({ source, file_basename, get_location }) {
-		/**
-		 * @type {{ line: number; column: number; }}
-		 */
-		let offset = get_location(0);
-		if (!offset) offset = { line: 0, column: 0 };
-
-		/**
-		 * @type {DecodedSourceMap}
-		 */
-		const map = { version: 3, names: [], sources: [file_basename], mappings: [] };
-		if (source == '') return new MappedCode(source, map);
-		// we create a high resolution identity map here,
-		// we know that it will eventually be merged with svelte's map,
-		// at which stage the resolution will decrease.
-		const line_list = source.split('\n');
-		for (let line = 0; line < line_list.length; line++) {
-			map.mappings.push([]);
-			const token_list = line_list[line].split(regex_line_token);
-			for (let token = 0, column = 0; token < token_list.length; token++) {
-				if (token_list[token] == '') continue;
-				map.mappings[line].push([column, 0, offset.line + line, column]);
-				column += token_list[token].length;
-			}
-		}
-		// shift columns in first line
-		const segment_list = map.mappings[0];
-		for (let segment = 0; segment < segment_list.length; segment++) {
-			// @ts-ignore
-			segment_list[segment][3] += offset.column;
-		}
-		return new MappedCode(source, map);
-	}
-}
-
-// browser vs node.js
-const b64enc =
-	typeof window !== 'undefined' && typeof btoa === 'function'
-		? /** @param {string} str */ (str) => btoa(unescape(encodeURIComponent(str)))
-		: /** @param {string} str */ (str) => Buffer.from(str).toString('base64');
-const b64dec =
-	typeof window !== 'undefined' && typeof atob === 'function'
-		? atob
-		: /** @param {any} a */ (a) => Buffer.from(a, 'base64').toString();
-
-/**
- * @param {string} filename Basename of the input file
- * @param {Array<DecodedSourceMap | RawSourceMap>} sourcemap_list
- */
-export function combine_sourcemaps(filename, sourcemap_list) {
-	if (sourcemap_list.length == 0) return null;
-	let map_idx = 1;
-	const map =
-		sourcemap_list.slice(0, -1).find((m) => m.sources.length !== 1) === undefined
-			? remapping(
-					// use array interface
-					// only the oldest sourcemap can have multiple sources
-					sourcemap_list,
-					() => null,
-					true // skip optional field `sourcesContent`
-				)
-			: remapping(
-					// use loader interface
-					sourcemap_list[0], // last map
-					(sourcefile) => {
-						// TODO the equality check assumes that the preprocessor map has the input file as a relative path in sources,
-						// e.g. when the input file is `src/foo/bar.svelte`, then sources is expected to contain just `bar.svelte`.
-						// Therefore filename also needs to be the basename of the path. This feels brittle, investigate how we can
-						// harden this (without breaking other tooling that assumes this behavior).
-						if (sourcefile === filename && sourcemap_list[map_idx]) {
-							return sourcemap_list[map_idx++]; // idx 1, 2, ...
-							// bundle file = branch node
-						} else {
-							return null; // source file = leaf node
-						}
-					},
-					true
-				);
-	if (!map.file) delete map.file; // skip optional field `file`
-	// When source maps are combined and the leading map is empty, sources is not set.
-	// Add the filename to the empty array in this case.
-	// Further improvements to remapping may help address this as well https://github.com/ampproject/remapping/issues/116
-	if (!map.sources.length) map.sources = [filename];
-	return map;
-}
-
-/**
- * @param {string} filename
- * @param {SourceMap} svelte_map
- * @param {string | DecodedSourceMap | RawSourceMap} preprocessor_map_input
- * @returns {SourceMap}
- */
-function apply_preprocessor_sourcemap(filename, svelte_map, preprocessor_map_input) {
-	if (!svelte_map || !preprocessor_map_input) return svelte_map;
-	const preprocessor_map =
-		typeof preprocessor_map_input === 'string'
-			? JSON.parse(preprocessor_map_input)
-			: preprocessor_map_input;
-	const result_map = combine_sourcemaps(filename, [svelte_map, preprocessor_map]);
-	// Svelte expects a SourceMap which includes toUrl and toString. Instead of wrapping our output in a class,
-	// we just tack on the extra properties.
-	Object.defineProperties(result_map, {
-		toString: {
-			enumerable: false,
-			value: function toString() {
-				return JSON.stringify(this);
-			}
-		},
-		toUrl: {
-			enumerable: false,
-			value: function toUrl() {
-				return 'data:application/json;charset=utf-8;base64,' + b64enc(this.toString());
-			}
-		}
-	});
-	return /** @type {any} */ (result_map);
-}
-const regex_data_uri = /data:(?:application|text)\/json;(?:charset[:=]\S+?;)?base64,(\S*)/;
-// parse attached sourcemap in processed.code
-
-/**
- * @param {Processed} processed
- * @param {'script' | 'style'} tag_name
- * @returns {void}
- */
-export function parse_attached_sourcemap(processed, tag_name) {
-	const r_in = '[#@]\\s*sourceMappingURL\\s*=\\s*(\\S*)';
-	const regex =
-		tag_name == 'script'
-			? new RegExp('(?://' + r_in + ')|(?:/\\*' + r_in + '\\s*\\*/)$')
-			: new RegExp('/\\*' + r_in + '\\s*\\*/$');
-
-	/**
-	 * @param {any} message
-	 */
-	function log_warning(message) {
-		// code_start: help to find preprocessor
-		const code_start =
-			processed.code.length < 100 ? processed.code : processed.code.slice(0, 100) + ' [...]';
-		// eslint-disable-next-line no-console
-		console.warn(`warning: ${message}. processed.code = ${JSON.stringify(code_start)}`);
-	}
-	processed.code = processed.code.replace(regex, (_, match1, match2) => {
-		const map_url = tag_name == 'script' ? match1 || match2 : match1;
-		const map_data = (map_url.match(regex_data_uri) || [])[1];
-		if (map_data) {
-			// sourceMappingURL is data URL
-			if (processed.map) {
-				log_warning(
-					'Not implemented. ' +
-						'Found sourcemap in both processed.code and processed.map. ' +
-						'Please update your preprocessor to return only one sourcemap.'
-				);
-				// ignore attached sourcemap
-				return '';
-			}
-			processed.map = b64dec(map_data); // use attached sourcemap
-			return ''; // remove from processed.code
-		}
-		// sourceMappingURL is path or URL
-		if (!processed.map) {
-			log_warning(
-				`Found sourcemap path ${JSON.stringify(
-					map_url
-				)} in processed.code, but no sourcemap data. ` +
-					'Please update your preprocessor to return sourcemap data directly.'
-			);
-		}
-		// ignore sourcemap path
-		return ''; // remove from processed.code
-	});
-}
-
-/**
- * @param {{ code: string, map: SourceMap}} result
- * @param {ValidatedCompileOptions} options
- * @param {string} source_name
- */
-export function merge_with_preprocessor_map(result, options, source_name) {
-	if (options.sourcemap) {
-		const file_basename = get_basename(options.filename);
-		// The preprocessor map is expected to contain `sources: [basename_of_filename]`, but our own
-		// map may contain a different file name. Patch our map beforehand to align sources so merging
-		// with the preprocessor map works correctly.
-		result.map.sources = [file_basename];
-		Object.assign(
-			result.map,
-			apply_preprocessor_sourcemap(
-				file_basename,
-				result.map,
-				/** @type {any} */ (options.sourcemap)
-			)
-		);
-		// After applying the preprocessor map, we need to do the inverse and make the sources
-		// relative to the input file again in case the output code is in a different directory.
-		if (file_basename !== source_name) {
-			result.map.sources = result.map.sources.map(
-				/** @param {string} source */ (source) => get_relative_path(source_name, source)
-			);
-		}
-	}
-}
-
-/**
- * @param {string} from
- * @param {string} to
- */
-function get_relative_path(from, to) {
-	// Don't use node's utils here to ensure the compiler is usable in a browser environment
-	const from_parts = from.split(/[/\\]/);
-	const to_parts = to.split(/[/\\]/);
-	from_parts.pop(); // get dirname
-	while (from_parts[0] === to_parts[0]) {
-		from_parts.shift();
-		to_parts.shift();
-	}
-	if (from_parts.length) {
-		let i = from_parts.length;
-		while (i--) from_parts[i] = '..';
-	}
-	return from_parts.concat(to_parts).join('/');
-}
-
-/**
- * Like node's `basename`, but doesn't use it to ensure the compiler is usable in a browser environment
- * @param {string} filename
- */
-export function get_basename(filename) {
-	return /** @type {string} */ (filename.split(/[/\\]/).pop());
-}
-
-/**
- * @param {string} filename
- * @param {string | undefined} output_filename
- * @param {string} fallback
- */
-export function get_source_name(filename, output_filename, fallback) {
-	return output_filename ? get_relative_path(output_filename, filename) : get_basename(filename);
-}

package/dist/utils/node_modules/svelte/src/compiler/utils/push_array.js

@@ -1,13 +0,0 @@
-/**
- * Pushes all `items` into `array` using `push`, therefore mutating the array.
- * We do this for memory and perf reasons, and because `array.push(...items)` would
- * run into a "max call stack size exceeded" error with too many items (~65k).
- * @template T
- * @param {T[]} array
- * @param {T[]} items
- */
-export function push_array(array, items) {
-	for (let i = 0; i < items.length; i++) {
-		array.push(items[i]);
-	}
-}

package/dist/utils/node_modules/svelte/src/compiler/utils/sanitize_template_string.js

@@ -1,7 +0,0 @@
-/**
- * @param {string} str
- * @returns {string}
- */
-export function sanitize_template_string(str) {
-	return str.replace(/(`|\${|\\)/g, '\\$1');
-}

package/dist/utils/node_modules/svelte/src/compiler/utils/slot.js

@@ -1,20 +0,0 @@
-/** @import { AST } from '#compiler' */
-import { is_element_node } from '../phases/nodes.js';
-import { is_text_attribute } from './ast.js';
-
-/**
- * @param {AST.SvelteNode} node
- */
-export function determine_slot(node) {
-	if (!is_element_node(node)) return null;
-
-	for (const attribute of node.attributes) {
-		if (attribute.type !== 'Attribute') continue;
-		if (attribute.name !== 'slot') continue;
-		if (!is_text_attribute(attribute)) continue;
-
-		return /** @type {string} */ (attribute.value[0].data);
-	}
-
-	return null;
-}