freewind-ts-utils 0.18.2

package/common/deepEqual.js

@@ -0,0 +1,46 @@
+import { getEnumerableOwnDescriptors as e } from "./getEnumerableOwnDescriptors.js";
+//#region src/common/deepEqual.ts
+function t(t) {
+	return e(t).map(([e]) => e);
+}
+function n(e) {
+	return typeof e == "object" && !!e;
+}
+function r(e, t) {
+	if (e.constructor !== t.constructor || e.byteLength !== t.byteLength) return !1;
+	let n = new Uint8Array(e.buffer, e.byteOffset, e.byteLength), r = new Uint8Array(t.buffer, t.byteOffset, t.byteLength);
+	return n.every((e, t) => e === r[t]);
+}
+function i(e, t, n) {
+	let r = e.get(t);
+	return r?.has(n) ? !0 : r ? (r.add(n), !1) : (e.set(t, new WeakSet([n])), !1);
+}
+function a(e, o, s) {
+	if (Object.is(e, o)) return !0;
+	if (!n(e) || !n(o) || Object.getPrototypeOf(e) !== Object.getPrototypeOf(o)) return !1;
+	if (e instanceof Date && o instanceof Date) return Object.is(e.getTime(), o.getTime());
+	if (e instanceof RegExp && o instanceof RegExp) return e.source === o.source && e.flags === o.flags && e.lastIndex === o.lastIndex;
+	if (e instanceof Map && o instanceof Map) {
+		if (e.size !== o.size || i(s, e, o)) return e.size === o.size;
+		let t = Array.from(e.entries()), n = Array.from(o.entries());
+		return t.every(([e, t], r) => {
+			let i = n[r];
+			return i !== void 0 && a(e, i[0], s) && a(t, i[1], s);
+		});
+	}
+	if (e instanceof Set && o instanceof Set) {
+		if (e.size !== o.size || i(s, e, o)) return e.size === o.size;
+		let t = Array.from(e.values()), n = Array.from(o.values());
+		return t.every((e, t) => a(e, n[t], s));
+	}
+	if (e instanceof ArrayBuffer && o instanceof ArrayBuffer) return r(new Uint8Array(e), new Uint8Array(o));
+	if (ArrayBuffer.isView(e) && ArrayBuffer.isView(o)) return r(e, o);
+	if (Array.isArray(e) && Array.isArray(o)) return e.length !== o.length || i(s, e, o) ? e.length === o.length : e.every((e, t) => a(e, o[t], s));
+	let c = t(e), l = t(o);
+	return c.length !== l.length || i(s, e, o) ? c.length === l.length : c.every((t) => l.includes(t) && a(Reflect.get(e, t), Reflect.get(o, t), s));
+}
+function o(e, t) {
+	return a(e, t, /* @__PURE__ */ new WeakMap());
+}
+//#endregion
+export { o as deepEqual };

package/common/deepParseJsonStrings.d.ts

@@ -0,0 +1 @@
+export declare function deepParseJsonStrings(value: unknown): unknown;

package/common/deepParseJsonStrings.js

@@ -0,0 +1,22 @@
+//#region src/common/deepParseJsonStrings.ts
+function e(e) {
+	let t = e.trim();
+	if (!t || t[0] !== "{" && t[0] !== "[") return e;
+	try {
+		return JSON.parse(t);
+	} catch {
+		return e;
+	}
+}
+function t(e) {
+	return !!(e && typeof e == "object" && !Array.isArray(e));
+}
+function n(r) {
+	if (typeof r == "string") {
+		let t = e(r);
+		return t === r ? r : n(t);
+	}
+	return Array.isArray(r) ? r.map((e) => n(e)) : t(r) ? Object.fromEntries(Object.entries(r).map(([e, t]) => [e, n(t)])) : r;
+}
+//#endregion
+export { n as deepParseJsonStrings };

package/common/dependsOn.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Declares a compile-time dependency between values without changing runtime behavior.
+ *
+ * Useful when you want TypeScript to keep certain inferred relationships alive.
+ *
+ * @example
+ * ```ts
+ * const config = { mode: 'prod' as const }
+ * dependsOn(config)
+ * ```
+ */
+export declare function dependsOn(...values: unknown[]): void;

package/common/dependsOn.js

@@ -0,0 +1,4 @@
+//#region src/common/dependsOn.ts
+function e(...e) {}
+//#endregion
+export { e as dependsOn };

package/common/doExpr.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Evaluates a callback immediately and returns its result.
+ *
+ * Useful when you want a small local scope inside an expression.
+ *
+ * @example
+ * ```ts
+ * const message = doExpr(() => {
+ *   const name = 'Ada'
+ *   return `Hello, ${name}`
+ * })
+ * ```
+ */
+export declare function doExpr<T>(fn: () => T): T;

package/common/doExpr.js

@@ -0,0 +1,6 @@
+//#region src/common/doExpr.ts
+function e(e) {
+	return e();
+}
+//#endregion
+export { e as doExpr };

package/common/flatChildren.d.ts

@@ -0,0 +1 @@
+export declare function flatChildren<T>(items: T[], childrenFn: (item: T) => T[] | undefined): T[];

package/common/flatChildren.js

@@ -0,0 +1,14 @@
+//#region src/common/flatChildren.ts
+function e(e, t) {
+	let n = [];
+	function r(e) {
+		for (let i of e) {
+			n.push(i);
+			let e = t(i);
+			e && e.length > 0 && r(e);
+		}
+	}
+	return r(e), n;
+}
+//#endregion
+export { e as flatChildren };

package/common/formatDecimal.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Formats a number with rounding to `fractionDigits`, then trims trailing zeros.
+ *
+ * Returns `NaN`, `Infinity`, or `-Infinity` unchanged as strings.
+ *
+ * @example
+ * ```ts
+ * formatDecimal(12.3, 2) // '12.3'
+ * formatDecimal(12.345, 2) // '12.35'
+ * ```
+ */
+export declare function formatDecimal(value: number, fractionDigits: number): string;

package/common/formatDecimal.js

@@ -0,0 +1,11 @@
+//#region src/common/formatDecimal.ts
+function e(e, t) {
+	if (!Number.isInteger(t) || t < 0) throw Error("fractionDigits must be a non-negative integer.");
+	return Number.isFinite(e) ? new Intl.NumberFormat("en-US", {
+		maximumFractionDigits: t,
+		minimumFractionDigits: 0,
+		useGrouping: !1
+	}).format(e) : String(e);
+}
+//#endregion
+export { e as formatDecimal };

package/common/formatFriendlyTime.d.ts

@@ -0,0 +1 @@
+export declare function formatFriendlyTime(input: string | number | Date, nowInput?: string | number | Date): string;

package/common/formatFriendlyTime.js

@@ -0,0 +1,10 @@
+//#region src/common/formatFriendlyTime.ts
+var e = 1e3, t = 60 * e, n = 60 * t, r = 24 * n, i = 7 * r, a = 30 * r, o = 365 * r;
+function s(s, c = Date.now()) {
+	let l = new Date(s).getTime(), u = new Date(c).getTime();
+	if (!Number.isFinite(l) || !Number.isFinite(u)) return "";
+	let d = u - l, f = Math.abs(d);
+	return f < 5 * e ? "刚刚" : f < t ? `${Math.max(1, Math.floor(f / e))}秒${d >= 0 ? "前" : "后"}` : f < n ? `${Math.floor(f / t)}分钟${d >= 0 ? "前" : "后"}` : f < r ? `${Math.floor(f / n)}小时${d >= 0 ? "前" : "后"}` : f < i ? `${Math.floor(f / r)}天${d >= 0 ? "前" : "后"}` : f < a ? `${Math.floor(f / i)}周${d >= 0 ? "前" : "后"}` : f < o ? `${Math.floor(f / a)}个月${d >= 0 ? "前" : "后"}` : `${Math.floor(f / o)}年${d >= 0 ? "前" : "后"}`;
+}
+//#endregion
+export { s as formatFriendlyTime };

package/common/formatSize.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Formats a byte count into a compact size string based on UTF-8 byte totals.
+ *
+ * The returned value does not include `B` and has no trailing space, so it can
+ * be reused in broader count displays.
+ *
+ * @example
+ * ```ts
+ * const bytes = new TextEncoder().encode('你好').length
+ * formatSize(bytes) // '6'
+ * ```
+ */
+export declare function formatSize(bytes: number): string;

package/common/formatSize.js

@@ -0,0 +1,19 @@
+//#region src/common/formatSize.ts
+var e = [
+	"",
+	"K",
+	"M",
+	"G",
+	"T",
+	"P",
+	"E"
+], t = 102.4;
+function n(n) {
+	if (!Number.isFinite(n)) return "0";
+	let r = n < 0 ? "-" : "", i = Math.abs(n), a = i < t ? 0 : 1;
+	for (a === 1 && (i /= 1024); i >= 1024 && a < e.length - 1;) i /= 1024, a += 1;
+	let o = i >= 100 || a === 0 ? 0 : 1;
+	return `${r}${i.toFixed(o).replace(/\.0$/, "")}${e[a]}`;
+}
+//#endregion
+export { n as formatSize };

package/common/fuzzy/fuzzyMatch.d.ts

@@ -0,0 +1,25 @@
+export interface FuzzyMatchPart {
+    text: string;
+    matched: boolean;
+}
+export interface FuzzyMatchHit {
+    value: string;
+    score: number;
+    ranges: Array<[number, number]>;
+    parts: FuzzyMatchPart[];
+}
+/**
+ * Fuzzy-matches a query against candidate strings, sorts best hits first, and can
+ * optionally return highlight-ready metadata.
+ *
+ * Matching is case-insensitive and rewards exact, prefix, word-boundary, camel-case,
+ * and contiguous matches.
+ *
+ * @example
+ * ```ts
+ * fuzzyMatch('fm', ['fuzzyMatch', 'formatDecimal'])
+ * // ['fuzzyMatch', 'formatDecimal']
+ * ```
+ */
+export declare function fuzzyMatch(query: string, candidates: string[], highlight?: false): string[];
+export declare function fuzzyMatch(query: string, candidates: string[], highlight: true): FuzzyMatchHit[];

package/common/fuzzy/fuzzyMatch.js

@@ -0,0 +1,19 @@
+import { buildHighlightRanges as e } from "./utils/buildHighlightRanges.js";
+import { buildHighlightParts as t } from "./utils/buildHighlightParts.js";
+import { rankFuzzyCandidates as n } from "./utils/rankFuzzyCandidates.js";
+import { scoreLooseFuzzyMatch as r } from "./utils/scoreLooseFuzzyMatch.js";
+//#region src/common/fuzzy/fuzzyMatch.ts
+function i(i, a, o = !1) {
+	let s = n(i, a, r);
+	return o ? s.map(({ value: n, score: r, indexes: i }) => {
+		let a = e(i);
+		return {
+			value: n,
+			score: r,
+			ranges: a,
+			parts: t(n, a)
+		};
+	}) : s.map(({ value: e }) => e);
+}
+//#endregion
+export { i as fuzzyMatch };

package/common/fuzzy/fuzzyMatchPath.d.ts

@@ -0,0 +1,23 @@
+import { FuzzyMatchHit } from './fuzzyMatch.js';
+/**
+ * Fuzzy-matches a query against path-like candidates, sorts best hits first, and can
+ * optionally return highlight-ready metadata for file-picker style search.
+ *
+ * Query separators `/`, `\`, and whitespace split the query into ordered parts that
+ * match different path segments in order. A continuous query matches within one path
+ * segment only and never spans `/`.
+ *
+ * Basename matches are preferred over directory-only matches. Both `/` and `\` in
+ * candidates and queries are normalized before matching.
+ *
+ * @example
+ * ```ts
+ * fuzzyMatchPath('common/fm', ['src/common/fuzzy/fuzzyMatch.ts'])
+ * // ['src/common/fuzzy/fuzzyMatch.ts']
+ *
+ * fuzzyMatchPath('abc', ['aaa/bbbc.ts', 'src/abc.ts'])
+ * // ['src/abc.ts']
+ * ```
+ */
+export declare function fuzzyMatchPath(query: string, candidates: string[], highlight?: false): string[];
+export declare function fuzzyMatchPath(query: string, candidates: string[], highlight: true): FuzzyMatchHit[];

package/common/fuzzy/fuzzyMatchPath.js

@@ -0,0 +1,102 @@
+import { buildHighlightRanges as e } from "./utils/buildHighlightRanges.js";
+import { buildHighlightParts as t } from "./utils/buildHighlightParts.js";
+import { normalizePathSeparators as n } from "./utils/normalizePathSeparators.js";
+import { rankFuzzyCandidates as r } from "./utils/rankFuzzyCandidates.js";
+import { scoreLooseFuzzyMatch as i } from "./utils/scoreLooseFuzzyMatch.js";
+//#region src/common/fuzzy/fuzzyMatchPath.ts
+function a(n, i, a = !1) {
+	let s = r(n, i, o);
+	return a ? s.map(({ value: n, score: r, indexes: i }) => {
+		let a = e(i);
+		return {
+			value: n,
+			score: r,
+			ranges: a,
+			parts: t(n, a)
+		};
+	}) : s.map(({ value: e }) => e);
+}
+function o(e, t) {
+	let r = n(e), i = n(t);
+	return s(i) ? u(r, i) : l(r, i);
+}
+function s(e) {
+	return /[\s/]/.test(e);
+}
+function c(e) {
+	return n(e).split(/[\s/]+/).filter(Boolean);
+}
+function l(e, t) {
+	let n = d(e), r = [];
+	for (let e = 0; e < n.length; e += 1) {
+		let a = n[e];
+		if (!a) continue;
+		let o = i(a.value, t);
+		if (!o) continue;
+		let s = e === n.length - 1;
+		r.push({
+			score: o.score + e * 12 + (s ? 900 : -1200),
+			indexes: o.indexes.map((e) => e + a.start),
+			spread: o.spread
+		});
+	}
+	return p(r);
+}
+function u(e, t) {
+	let n = d(e), r = c(t);
+	if (r.length <= 1 || r.length > n.length) return;
+	let a = [], o = n.length - 1;
+	for (let e = r.length - 1; e >= 0; --e) {
+		let t = r[e];
+		if (!t) return;
+		let s;
+		for (let r = o; r >= e; --r) {
+			let e = n[r];
+			if (!e) continue;
+			let a = i(e.value, t);
+			if (!a) continue;
+			let o = {
+				score: a.score + r * 12,
+				indexes: a.indexes.map((t) => t + e.start),
+				spread: a.spread
+			};
+			(!s || o.score > s.score || o.score === s.score && (o.indexes[0] ?? -1) > (s.indexes[0] ?? -1)) && (s = o);
+		}
+		if (!s) return;
+		a.unshift(s);
+		let c = s.indexes[0];
+		if (c === void 0 || (o = f(n, c), o < e - 1)) return;
+	}
+	let s = Array.from(new Set(a.flatMap((e) => e.indexes))).sort((e, t) => e - t), l = s[0], u = s[s.length - 1];
+	if (!(l === void 0 || u === void 0)) return {
+		score: a.reduce((e, t, n) => e + t.score + (n === a.length - 1 ? 500 : 0), 0),
+		indexes: s,
+		spread: u - l
+	};
+}
+function d(e) {
+	let t = [], n = 0;
+	for (let r = 0; r <= e.length; r += 1) {
+		if (r < e.length && e[r] !== "/") continue;
+		let i = e.slice(n, r);
+		i && t.push({
+			value: i,
+			start: n
+		}), n = r + 1;
+	}
+	return t;
+}
+function f(e, t) {
+	for (let n = e.length - 1; n >= 0; --n) {
+		let r = e[n];
+		if (r && r.start < t) return n;
+	}
+	return -1;
+}
+function p(e) {
+	let t;
+	for (let n of e) (!t || n.score > t.score || n.score === t.score && n.spread < t.spread) && (t = n);
+	return t;
+}
+//#endregion
+export { a as fuzzyMatchPath };

package/common/fuzzy/types.d.ts

@@ -0,0 +1,10 @@
+export interface InternalFuzzyMatchResult {
+    score: number;
+    indexes: number[];
+    spread: number;
+}
+export interface FuzzyRankedCandidate {
+    value: string;
+    score: number;
+    indexes: number[];
+}

package/common/fuzzy/utils/buildHighlightParts.d.ts

@@ -0,0 +1,4 @@
+export declare function buildHighlightParts(value: string, ranges: Array<[number, number]>): Array<{
+    text: string;
+    matched: boolean;
+}>;

package/common/fuzzy/utils/buildHighlightParts.js

@@ -0,0 +1,21 @@
+//#region src/common/fuzzy/utils/buildHighlightParts.ts
+function e(e, t) {
+	if (t.length === 0) return e ? [{
+		text: e,
+		matched: !1
+	}] : [];
+	let n = [], r = 0;
+	for (let [i, a] of t) r < i && n.push({
+		text: e.slice(r, i),
+		matched: !1
+	}), n.push({
+		text: e.slice(i, a),
+		matched: !0
+	}), r = a;
+	return r < e.length && n.push({
+		text: e.slice(r),
+		matched: !1
+	}), n;
+}
+//#endregion
+export { e as buildHighlightParts };

package/common/fuzzy/utils/buildHighlightRanges.d.ts

@@ -0,0 +1 @@
+export declare function buildHighlightRanges(indexes: number[]): Array<[number, number]>;

package/common/fuzzy/utils/buildHighlightRanges.js

@@ -0,0 +1,20 @@
+//#region src/common/fuzzy/utils/buildHighlightRanges.ts
+function e(e) {
+	if (e.length === 0) return [];
+	let t = [], n = e[0];
+	if (n === void 0) return [];
+	let r = n, i = n + 1;
+	for (let n = 1; n < e.length; n += 1) {
+		let a = e[n];
+		if (a !== void 0) {
+			if (a === i) {
+				i += 1;
+				continue;
+			}
+			t.push([r, i]), r = a, i = a + 1;
+		}
+	}
+	return t.push([r, i]), t;
+}
+//#endregion
+export { e as buildHighlightRanges };

package/common/fuzzy/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from './buildHighlightRanges.js';
+export * from './buildHighlightParts.js';
+export * from './normalizePathSeparators.js';
+export * from './rankFuzzyCandidates.js';
+export * from './scoreLooseFuzzyMatch.js';

package/common/fuzzy/utils/index.js

@@ -0,0 +1,6 @@
+import { buildHighlightRanges as e } from "./buildHighlightRanges.js";
+import { buildHighlightParts as t } from "./buildHighlightParts.js";
+import { normalizePathSeparators as n } from "./normalizePathSeparators.js";
+import { rankFuzzyCandidates as r } from "./rankFuzzyCandidates.js";
+import { scoreLooseFuzzyMatch as i } from "./scoreLooseFuzzyMatch.js";
+export { t as buildHighlightParts, e as buildHighlightRanges, n as normalizePathSeparators, r as rankFuzzyCandidates, i as scoreLooseFuzzyMatch };

package/common/fuzzy/utils/normalizePathSeparators.d.ts

@@ -0,0 +1 @@
+export declare function normalizePathSeparators(value: string): string;

package/common/fuzzy/utils/normalizePathSeparators.js

@@ -0,0 +1,7 @@
+//#region src/common/fuzzy/utils/normalizePathSeparators.ts
+var e = /[\\/]+/g;
+function t(t) {
+	return t.replace(e, "/");
+}
+//#endregion
+export { t as normalizePathSeparators };

package/common/fuzzy/utils/rankFuzzyCandidates.d.ts

@@ -0,0 +1,2 @@
+import { FuzzyRankedCandidate, InternalFuzzyMatchResult } from '../types.js';
+export declare function rankFuzzyCandidates(query: string, candidates: string[], scorer: (value: string, query: string) => InternalFuzzyMatchResult | undefined): FuzzyRankedCandidate[];

package/common/fuzzy/utils/rankFuzzyCandidates.js

@@ -0,0 +1,26 @@
+//#region src/common/fuzzy/utils/rankFuzzyCandidates.ts
+function e(e, t, n) {
+	let r = e.trim();
+	if (!r) return t.map((e) => ({
+		value: e,
+		score: 0,
+		indexes: []
+	}));
+	let i = t.map((e, t) => {
+		let i = n(e, r);
+		if (i) return {
+			index: t,
+			value: e,
+			score: i.score,
+			indexes: i.indexes,
+			spread: i.spread
+		};
+	}).filter((e) => e !== void 0);
+	return i.sort((e, t) => t.score - e.score || e.spread - t.spread || e.value.length - t.value.length || e.index - t.index), i.map(({ value: e, score: t, indexes: n }) => ({
+		value: e,
+		score: t,
+		indexes: n
+	}));
+}
+//#endregion
+export { e as rankFuzzyCandidates };

package/common/fuzzy/utils/scoreLooseFuzzyMatch.d.ts

@@ -0,0 +1,2 @@
+import { InternalFuzzyMatchResult } from '../types.js';
+export declare function scoreLooseFuzzyMatch(rawTarget: string, rawQuery: string): InternalFuzzyMatchResult | undefined;

package/common/fuzzy/utils/scoreLooseFuzzyMatch.js

@@ -0,0 +1,126 @@
+//#region src/common/fuzzy/utils/scoreLooseFuzzyMatch.ts
+var e = new Set([
+	"/",
+	"\\",
+	"-",
+	"_",
+	".",
+	" "
+]);
+function t(e) {
+	return e.trim().split(/\s+/).filter(Boolean);
+}
+function n(e, t) {
+	if (!t) return {
+		score: 0,
+		indexes: [],
+		spread: 0
+	};
+	if (t.length > e.length) return;
+	let n = e.toLowerCase(), r = t.toLowerCase(), i = Array.from({ length: t.length }, () => Array.from({ length: e.length }, () => void 0)), s = r[0];
+	if (s === void 0) return;
+	for (let r = 0; r < e.length; r += 1) {
+		let o = n[r];
+		if (o === void 0 || o !== s) continue;
+		let c = i[0];
+		if (!c) return;
+		c[r] = {
+			score: a(e, t, r, 0, !0),
+			previousIndex: -1
+		};
+	}
+	for (let s = 1; s < t.length; s += 1) for (let c = s; c < e.length; c += 1) {
+		let l = n[c], u = r[s];
+		if (l === void 0 || u === void 0 || l !== u) continue;
+		let d;
+		for (let n = s - 1; n < c; n += 1) {
+			let r = i[s - 1]?.[n];
+			if (!r) continue;
+			let l = r.score + a(e, t, c, s, !1) + o(c - n);
+			(!d || l > d.score) && (d = {
+				score: l,
+				previousIndex: n
+			});
+		}
+		let f = i[s];
+		if (!f) return;
+		f[c] = d;
+	}
+	let c, l = -1;
+	for (let n = t.length - 1; n < e.length; n += 1) {
+		let e = i[t.length - 1]?.[n];
+		e && (!c || e.score > c.score || e.score === c.score && n < l) && (c = e, l = n);
+	}
+	if (!c) return;
+	let u = Array(t.length), d = t.length - 1, f = l;
+	for (; d >= 0;) {
+		u[d] = f;
+		let e = i[d]?.[f];
+		if (!e) return;
+		f = e.previousIndex, --d;
+	}
+	let p = u[0], m = u[u.length - 1];
+	if (p === void 0 || m === void 0) return;
+	let h = m - p, g = c.score;
+	if (n === r) g += 2e3;
+	else if (n.startsWith(r)) g += 600 + Math.round(t.length / e.length * 120);
+	else {
+		let e = n.indexOf(r);
+		e >= 0 && (g += 320 - Math.min(160, e * 8));
+	}
+	return g += Math.round(t.length / e.length * 100), g -= h * 4, g -= Math.max(0, e.length - t.length), {
+		score: g,
+		indexes: u,
+		spread: h
+	};
+}
+function r(e) {
+	return Array.from(new Set(e)).sort((e, t) => e - t);
+}
+function i(e, i) {
+	let a = t(i);
+	if (a.length === 0) return {
+		score: 0,
+		indexes: [],
+		spread: 0
+	};
+	let o = 0, s = [];
+	for (let t of a) {
+		let r = n(e, t);
+		if (!r) return;
+		o += r.score, s.push(...r.indexes);
+	}
+	let c = r(s), l = c[0], u = c[c.length - 1];
+	return l === void 0 || u === void 0 ? {
+		score: o,
+		indexes: [],
+		spread: 0
+	} : {
+		score: o,
+		indexes: c,
+		spread: u - l
+	};
+}
+function a(e, t, n, r, i) {
+	let a = e[n], o = t[r], c = 10;
+	return a !== void 0 && o !== void 0 && a === o && (c += 2), s(e, n) && (c += 28), i && n === 0 && (c += 16), c;
+}
+function o(e) {
+	return e === 1 ? 30 : Math.max(-20, 12 - (e - 1) * 5);
+}
+function s(t, n) {
+	if (n === 0) return !0;
+	let r = t[n], i = t[n - 1];
+	return r === void 0 || i === void 0 ? !1 : !!(e.has(i) || c(i) && l(r) || u(i) !== u(r));
+}
+function c(e) {
+	return e >= "a" && e <= "z";
+}
+function l(e) {
+	return e >= "A" && e <= "Z";
+}
+function u(e) {
+	return e >= "0" && e <= "9";
+}
+//#endregion
+export { i as scoreLooseFuzzyMatch };

package/common/getEnumerableOwnDescriptors.d.ts

@@ -0,0 +1 @@
+export declare function getEnumerableOwnDescriptors(value: object): Array<[key: string | symbol, descriptor: PropertyDescriptor]>;

package/common/getEnumerableOwnDescriptors.js

@@ -0,0 +1,11 @@
+//#region src/common/getEnumerableOwnDescriptors.ts
+function e(e) {
+	let t = [];
+	for (let n of Reflect.ownKeys(e)) {
+		let r = Object.getOwnPropertyDescriptor(e, n);
+		r?.enumerable && t.push([n, r]);
+	}
+	return t;
+}
+//#endregion
+export { e as getEnumerableOwnDescriptors };