lumen-plus 0.0.3 → 0.0.4

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

@@ -0,0 +1,280 @@
+/**
+ * @param {string} name
+ * @param {string[]} names
+ * @returns {string | null}
+ */
+export default function fuzzymatch(name, names) {
+	if (names.length === 0) return null;
+
+	const set = new FuzzySet(names);
+	const matches = set.get(name);
+
+	return matches && matches[0][0] > 0.7 ? matches[0][1] : null;
+}
+
+// adapted from https://github.com/Glench/fuzzyset.js/blob/master/lib/fuzzyset.js in 2016
+// BSD Licensed (see https://github.com/Glench/fuzzyset.js/issues/10)
+
+const GRAM_SIZE_LOWER = 2;
+const GRAM_SIZE_UPPER = 3;
+
+// return an edit distance from 0 to 1
+
+/**
+ * @param {string} str1
+ * @param {string} str2
+ */
+function _distance(str1, str2) {
+	if (str1 === null && str2 === null) {
+		throw 'Trying to compare two null values';
+	}
+	if (str1 === null || str2 === null) return 0;
+	str1 = String(str1);
+	str2 = String(str2);
+
+	const distance = levenshtein(str1, str2);
+	return 1 - distance / Math.max(str1.length, str2.length);
+}
+
+// helper functions
+
+/**
+ * @param {string} str1
+ * @param {string} str2
+ */
+function levenshtein(str1, str2) {
+	/** @type {number[]} */
+	const current = [];
+	let prev = 0;
+	let value = 0;
+
+	for (let i = 0; i <= str2.length; i++) {
+		for (let j = 0; j <= str1.length; j++) {
+			if (i && j) {
+				if (str1.charAt(j - 1) === str2.charAt(i - 1)) {
+					value = prev;
+				} else {
+					value = Math.min(current[j], current[j - 1], prev) + 1;
+				}
+			} else {
+				value = i + j;
+			}
+
+			prev = current[j];
+			current[j] = value;
+		}
+	}
+
+	return /** @type {number} */ (current.pop());
+}
+
+const non_word_regex = /[^\w, ]+/;
+
+/**
+ * @param {string} value
+ * @param {any} gram_size
+ */
+function iterate_grams(value, gram_size = 2) {
+	const simplified = '-' + value.toLowerCase().replace(non_word_regex, '') + '-';
+	const len_diff = gram_size - simplified.length;
+	const results = [];
+
+	if (len_diff > 0) {
+		for (let i = 0; i < len_diff; ++i) {
+			value += '-';
+		}
+	}
+	for (let i = 0; i < simplified.length - gram_size + 1; ++i) {
+		results.push(simplified.slice(i, i + gram_size));
+	}
+	return results;
+}
+
+/**
+ * @param {string} value
+ * @param {any} gram_size
+ */
+function gram_counter(value, gram_size = 2) {
+	// return an object where key=gram, value=number of occurrences
+
+	/** @type {Record<string, number>} */
+	const result = {};
+	const grams = iterate_grams(value, gram_size);
+	let i = 0;
+
+	for (i; i < grams.length; ++i) {
+		if (grams[i] in result) {
+			result[grams[i]] += 1;
+		} else {
+			result[grams[i]] = 1;
+		}
+	}
+	return result;
+}
+
+/**
+ * @param {MatchTuple} a
+ * @param {MatchTuple} b
+ */
+function sort_descending(a, b) {
+	return b[0] - a[0];
+}
+
+class FuzzySet {
+	/** @type {Record<string, string>} */
+	exact_set = {};
+
+	/** @type {Record<string, [number, number][]>} */
+	match_dict = {};
+
+	/** @type {Record<string, number[]>} */
+	items = {};
+
+	/** @param {string[]} arr */
+	constructor(arr) {
+		// initialisation
+		for (let i = GRAM_SIZE_LOWER; i < GRAM_SIZE_UPPER + 1; ++i) {
+			this.items[i] = [];
+		}
+
+		// add all the items to the set
+		for (let i = 0; i < arr.length; ++i) {
+			this.add(arr[i]);
+		}
+	}
+
+	/** @param {string} value */
+	add(value) {
+		const normalized_value = value.toLowerCase();
+		if (normalized_value in this.exact_set) {
+			return false;
+		}
+
+		let i = GRAM_SIZE_LOWER;
+		for (i; i < GRAM_SIZE_UPPER + 1; ++i) {
+			this._add(value, i);
+		}
+	}
+
+	/**
+	 * @param {string} value
+	 * @param {number} gram_size
+	 */
+	_add(value, gram_size) {
+		const normalized_value = value.toLowerCase();
+		const items = this.items[gram_size] || [];
+		const index = items.length;
+
+		items.push(0);
+		const gram_counts = gram_counter(normalized_value, gram_size);
+		let sum_of_square_gram_counts = 0;
+		let gram;
+		let gram_count;
+
+		for (gram in gram_counts) {
+			gram_count = gram_counts[gram];
+			sum_of_square_gram_counts += Math.pow(gram_count, 2);
+			if (gram in this.match_dict) {
+				this.match_dict[gram].push([index, gram_count]);
+			} else {
+				this.match_dict[gram] = [[index, gram_count]];
+			}
+		}
+		const vector_normal = Math.sqrt(sum_of_square_gram_counts);
+		// @ts-ignore no idea what this code is doing
+		items[index] = [vector_normal, normalized_value];
+		this.items[gram_size] = items;
+		this.exact_set[normalized_value] = value;
+	}
+
+	/** @param {string} value */
+	get(value) {
+		const normalized_value = value.toLowerCase();
+		const result = this.exact_set[normalized_value];
+
+		if (result) {
+			return /** @type {MatchTuple[]} */ ([[1, result]]);
+		}
+
+		// start with high gram size and if there are no results, go to lower gram sizes
+		for (let gram_size = GRAM_SIZE_UPPER; gram_size >= GRAM_SIZE_LOWER; --gram_size) {
+			const results = this.__get(value, gram_size);
+			if (results.length > 0) return results;
+		}
+		return null;
+	}
+
+	/**
+	 * @param {string} value
+	 * @param {number} gram_size
+	 * @returns {MatchTuple[]}
+	 */
+	__get(value, gram_size) {
+		const normalized_value = value.toLowerCase();
+
+		/** @type {Record<string, number>} */
+		const matches = {};
+		const gram_counts = gram_counter(normalized_value, gram_size);
+		const items = this.items[gram_size];
+		let sum_of_square_gram_counts = 0;
+		let gram;
+		let gram_count;
+		let i;
+		let index;
+		let other_gram_count;
+
+		for (gram in gram_counts) {
+			gram_count = gram_counts[gram];
+			sum_of_square_gram_counts += Math.pow(gram_count, 2);
+			if (gram in this.match_dict) {
+				for (i = 0; i < this.match_dict[gram].length; ++i) {
+					index = this.match_dict[gram][i][0];
+					other_gram_count = this.match_dict[gram][i][1];
+					if (index in matches) {
+						matches[index] += gram_count * other_gram_count;
+					} else {
+						matches[index] = gram_count * other_gram_count;
+					}
+				}
+			}
+		}
+
+		const vector_normal = Math.sqrt(sum_of_square_gram_counts);
+
+		/** @type {MatchTuple[]} */
+		let results = [];
+		let match_score;
+
+		// build a results list of [score, str]
+		for (const match_index in matches) {
+			match_score = matches[match_index];
+			// @ts-ignore no idea what this code is doing
+			results.push([match_score / (vector_normal * items[match_index][0]), items[match_index][1]]);
+		}
+
+		results.sort(sort_descending);
+
+		/** @type {MatchTuple[]} */
+		let new_results = [];
+		const end_index = Math.min(50, results.length);
+		// truncate somewhat arbitrarily to 50
+		for (let i = 0; i < end_index; ++i) {
+			// @ts-ignore no idea what this code is doing
+			new_results.push([_distance(results[i][1], normalized_value), results[i][1]]);
+		}
+		results = new_results;
+		results.sort(sort_descending);
+
+		new_results = [];
+		for (let i = 0; i < results.length; ++i) {
+			if (results[i][0] === results[0][0]) {
+				// @ts-ignore no idea what this code is doing
+				new_results.push([results[i][0], this.exact_set[results[i][1]]]);
+			}
+		}
+
+		return new_results;
+	}
+}
+
+/** @typedef {[score: number, match: string]} MatchTuple */

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

@@ -0,0 +1,127 @@
+import entities from './entities.js';
+
+const windows_1252 = [
+	8364, 129, 8218, 402, 8222, 8230, 8224, 8225, 710, 8240, 352, 8249, 338, 141, 381, 143, 144, 8216,
+	8217, 8220, 8221, 8226, 8211, 8212, 732, 8482, 353, 8250, 339, 157, 382, 376
+];
+
+/**
+ * @param {string} entity_name
+ * @param {boolean} is_attribute_value
+ */
+function reg_exp_entity(entity_name, is_attribute_value) {
+	// https://html.spec.whatwg.org/multipage/parsing.html#named-character-reference-state
+	// doesn't decode the html entity which not ends with ; and next character is =, number or alphabet in attribute value.
+	if (is_attribute_value && !entity_name.endsWith(';')) {
+		return `${entity_name}\\b(?!=)`;
+	}
+	return entity_name;
+}
+
+/** @param {boolean} is_attribute_value */
+function get_entity_pattern(is_attribute_value) {
+	const reg_exp_num = '#(?:x[a-fA-F\\d]+|\\d+)(?:;)?';
+	const reg_exp_entities = Object.keys(entities).map(
+		/** @param {any} entity_name */ (entity_name) => reg_exp_entity(entity_name, is_attribute_value)
+	);
+
+	const entity_pattern = new RegExp(`&(${reg_exp_num}|${reg_exp_entities.join('|')})`, 'g');
+
+	return entity_pattern;
+}
+
+const entity_pattern_content = get_entity_pattern(false);
+const entity_pattern_attr_value = get_entity_pattern(true);
+
+/**
+ * @param {string} html
+ * @param {boolean} is_attribute_value
+ */
+export function decode_character_references(html, is_attribute_value) {
+	const entity_pattern = is_attribute_value ? entity_pattern_attr_value : entity_pattern_content;
+	return html.replace(
+		entity_pattern,
+		/**
+		 * @param {any} match
+		 * @param {keyof typeof entities} entity
+		 */ (match, entity) => {
+			let code;
+
+			// Handle named entities
+			if (entity[0] !== '#') {
+				code = entities[entity];
+			} else if (entity[1] === 'x') {
+				code = parseInt(entity.substring(2), 16);
+			} else {
+				code = parseInt(entity.substring(1), 10);
+			}
+
+			if (!code) {
+				return match;
+			}
+
+			return String.fromCodePoint(validate_code(code));
+		}
+	);
+}
+
+const NUL = 0;
+
+// some code points are verboten. If we were inserting HTML, the browser would replace the illegal
+// code points with alternatives in some cases - since we're bypassing that mechanism, we need
+// to replace them ourselves
+//
+// Source: http://en.wikipedia.org/wiki/Character_encodings_in_HTML#Illegal_characters
+// Also see: https://en.wikipedia.org/wiki/Plane_(Unicode)
+// Also see: https://html.spec.whatwg.org/multipage/parsing.html#preprocessing-the-input-stream
+
+/** @param {number} code */
+function validate_code(code) {
+	// line feed becomes generic whitespace
+	if (code === 10) {
+		return 32;
+	}
+
+	// ASCII range. (Why someone would use HTML entities for ASCII characters I don't know, but...)
+	if (code < 128) {
+		return code;
+	}
+
+	// code points 128-159 are dealt with leniently by browsers, but they're incorrect. We need
+	// to correct the mistake or we'll end up with missing € signs and so on
+	if (code <= 159) {
+		return windows_1252[code - 128];
+	}
+
+	// basic multilingual plane
+	if (code < 55296) {
+		return code;
+	}
+
+	// UTF-16 surrogate halves
+	if (code <= 57343) {
+		return NUL;
+	}
+
+	// rest of the basic multilingual plane
+	if (code <= 65535) {
+		return code;
+	}
+
+	// supplementary multilingual plane 0x10000 - 0x1ffff
+	if (code >= 65536 && code <= 131071) {
+		return code;
+	}
+
+	// supplementary ideographic plane 0x20000 - 0x2ffff
+	if (code >= 131072 && code <= 196607) {
+		return code;
+	}
+
+	// supplementary special-purpose plane 0xe0000 - 0xe07f and 0xe0100 - 0xe01ef
+	if ((code >= 917504 && code <= 917631) || (code >= 917760 && code <= 917999)) {
+		return code;
+	}
+
+	return NUL;
+}