@devisfuture/mega-collection 2.4.7 → 2.5.0

package/dist/search/types.d.ts

@@ -1,93 +0,0 @@
-import type { CollectionItem } from "../types";
-export interface TextSearchEngineOptions<T extends CollectionItem = CollectionItem> {
-    data?: T[];
-    fields?: (keyof T & string)[];
-    nestedFields?: string[];
-    /**
-     * Minimum query length required to trigger a search. Defaults to `1`.
-     *
-     * Queries shorter than the trigram length (3) always use a linear scan even
-     * when an index is configured, because the index only stores trigrams. Set
-     * `minQueryLength` to `3` or higher to skip sub-trigram queries entirely and
-     * guarantee that every accepted query hits the index.
-     */
-    minQueryLength?: number;
-    /**
-     * When `true`, each search narrows its source to the previous result if the
-     * new query includes the previous query as a prefix/substring. Useful for
-     * search-as-you-type scenarios where the user incrementally refines the query.
-     *
-     * Call {@link TextSearchEngine.resetSearchState} to discard the saved result
-     * and force the next search to scan the full dataset.
-     */
-    filterByPreviousResult?: boolean;
-    /**
-     * Suppresses non-production fallback warnings.
-     * Diagnostic warnings also stop accumulating in {@link TextSearchEngine.getWarnings}.
-     */
-    silent?: boolean;
-}
-export interface SearchQueryOptions {
-    limit?: number;
-    offset?: number;
-}
-export interface TextSearchEngineStats {
-    totalQueries: number;
-    indexedQueries: number;
-    fallbackQueries: number;
-    fallbackRate: number;
-    fallbackFields: Record<string, number>;
-}
-export type NestedFieldDescriptor = {
-    collectionKey: string;
-    nestedKey: string;
-};
-export type SearchIndex = {
-    ngramMap: Map<string, Set<number>>;
-    normalizedValues: string[];
-    version: number;
-};
-export interface SearchNestedCollectionStorage {
-    ngramIndexes: Map<string, Map<string, Set<number>>>;
-    normalizedFieldValues: Map<string, string[]>;
-}
-export type SearchRuntime<T extends CollectionItem> = {
-    indexedFields: Set<keyof T & string>;
-    flatIndexes: Map<string, SearchIndex>;
-    nestedStorage: SearchNestedCollectionStorage;
-    deferredMutationVersion: number | null;
-    filterByPreviousResult: boolean;
-    previousResultIndices: number[] | null;
-    previousResultLookup: Uint8Array | null;
-    previousQuery: string | null;
-    stats: {
-        totalQueries: number;
-        indexedQueries: number;
-        fallbackQueries: number;
-        fallbackFields: Map<string, number>;
-    };
-};
-export type SearchResult<T extends CollectionItem> = {
-    items: T[];
-    indices: number[];
-};
-export type SearchWindow = {
-    offset: number;
-    limit: number;
-    take: number;
-    hasWindow: boolean;
-};
-export type SearchSource = {
-    indices: number[] | null;
-    lookup: Uint8Array | null;
-};
-export type IntersectPostingListsOptions = {
-    restrictionLookup?: Uint8Array | null;
-    take?: number;
-};
-export type IntersectPostingListsInCandidatesOptions = {
-    candidateIndices: readonly number[];
-    restrictionLookup?: Uint8Array | null;
-    take?: number;
-};
-//# sourceMappingURL=types.d.ts.map

package/dist/search/utils.d.ts

@@ -1,4 +0,0 @@
-import type { CollectionItem } from "../types";
-import type { SearchRuntime } from "./types";
-export declare const createSearchRuntime: <T extends CollectionItem>() => SearchRuntime<T>;
-//# sourceMappingURL=utils.d.ts.map

package/dist/search/utils.mjs

@@ -1,22 +0,0 @@
-//#region src/search/utils.ts
-var e = () => ({
-	indexedFields: /* @__PURE__ */ new Set(),
-	flatIndexes: /* @__PURE__ */ new Map(),
-	nestedStorage: {
-		ngramIndexes: /* @__PURE__ */ new Map(),
-		normalizedFieldValues: /* @__PURE__ */ new Map()
-	},
-	deferredMutationVersion: null,
-	filterByPreviousResult: !1,
-	previousResultIndices: null,
-	previousResultLookup: null,
-	previousQuery: null,
-	stats: {
-		totalQueries: 0,
-		indexedQueries: 0,
-		fallbackQueries: 0,
-		fallbackFields: /* @__PURE__ */ new Map()
-	}
-});
-//#endregion
-export { e as createSearchRuntime };

package/dist/sort/errors.d.ts

@@ -1,5 +0,0 @@
-export declare class SortEngineError extends Error {
-    constructor(message: string);
-    static missingDatasetForSort(): SortEngineError;
-}
-//# sourceMappingURL=errors.d.ts.map

package/dist/sort/errors.mjs

@@ -1,11 +0,0 @@
-//#region src/sort/errors.ts
-var e = class e extends Error {
-	constructor(e) {
-		super(e), this.name = "SortEngineError";
-	}
-	static missingDatasetForSort() {
-		return new e("SortEngine: no dataset in memory.");
-	}
-};
-//#endregion
-export { e as SortEngineError };

package/dist/sort/sorter.d.ts

@@ -1,47 +0,0 @@
-import { State } from "../State";
-import { CollectionItem, SortDescriptor, type UpdateDescriptor } from "../types";
-import type { SortEngineOptions } from "./types";
-export declare class SortEngine<T extends CollectionItem> {
-    private readonly state;
-    private readonly namespace;
-    constructor(options?: SortEngineOptions<T> & {
-        state?: State<T>;
-    });
-    private get dataset();
-    private get runtime();
-    private get cache();
-    private get indexedFields();
-    private shouldDeferMutationCacheUpdates;
-    private invalidateCachedIndexes;
-    private rebuildConfiguredIndexes;
-    private buildIndexForDataset;
-    private buildIndexFromData;
-    clearIndexes(): this;
-    clearData(): this;
-    data(data: T[]): this;
-    add(items: T[]): this;
-    update(descriptor: UpdateDescriptor<T>): this;
-    private applyAddedItems;
-    getOriginData(): T[];
-    private handleStateMutation;
-    sort(descriptors: SortDescriptor<T>[]): T[];
-    sort(data: T[], descriptors: SortDescriptor<T>[], inPlace?: boolean): T[];
-    private sortNumericFastPath;
-    private sortMultiField;
-    private sortTieGroups;
-    private materializeItemsFromIndexes;
-    private getCachedSortedItems;
-    private shouldMaintainIncrementally;
-    private hasDuplicateValuesForIndexes;
-    private compareIndexesByField;
-    private applyUpdatedItem;
-    private updateCachedIndexForUpdatedItem;
-    private updateCachedIndexForAddedItems;
-    private applyRemovedItem;
-    private applyRemovedItemsBatch;
-    private updateCachedIndexForRemovedItem;
-    private updateUniqueCachedIndexForRemovedItem;
-    private updateUniqueCachedIndexForRemovedItems;
-    private buildComparator;
-}
-//# sourceMappingURL=sorter.d.ts.map

package/dist/sort/sorter.mjs

@@ -1,375 +0,0 @@
-import { State as e } from "../State.mjs";
-import { DEFER_SORT_MUTATION_CACHE_UPDATES_KEY as t, MERGE_SHARED_SCOPE as n } from "../constants.mjs";
-import { SortEngineError as r } from "./errors.mjs";
-import { canUseUint32Radix as i, createSortRuntime as a, radixSortUint32 as o } from "./utils.mjs";
-//#region src/sort/sorter.ts
-var s = class {
-	constructor(t = {}) {
-		if (this.state = t.state ?? new e(t.data ?? []), this.namespace = this.state.createNamespace("sort"), this.state.subscribe((e) => this.handleStateMutation(e)), t.fields?.length) {
-			for (let e of t.fields) this.indexedFields.add(e);
-			this.dataset.length > 0 && this.rebuildConfiguredIndexes();
-		}
-	}
-	get dataset() {
-		return this.state.getOriginData();
-	}
-	get runtime() {
-		return this.state.getOrCreateScopedValue(this.namespace, "runtime", a);
-	}
-	get cache() {
-		return this.runtime.cache;
-	}
-	get indexedFields() {
-		return this.runtime.indexedFields;
-	}
-	shouldDeferMutationCacheUpdates() {
-		return this.state.getScopedValue(n, t) === !0;
-	}
-	invalidateCachedIndexes() {
-		for (let e of this.indexedFields) this.cache.delete(e);
-	}
-	rebuildConfiguredIndexes() {
-		this.cache.clear();
-		for (let e of this.indexedFields) this.buildIndexForDataset(e);
-	}
-	buildIndexForDataset(e) {
-		this.dataset.length && this.buildIndexFromData(this.dataset, e);
-	}
-	buildIndexFromData(e, t) {
-		let n = e.length, r = new Uint32Array(n);
-		for (let e = 0; e < n; e++) r[e] = e;
-		let a = 0;
-		for (; a < n && e[a][t] == null;) a++;
-		if (a < n && typeof e[a][t] == "number") {
-			let a = new Float64Array(n);
-			for (let r = 0; r < n; r++) a[r] = e[r][t];
-			i(a, n) ? o(r, a, n) : r.sort((e, t) => a[e] - a[t]);
-		} else {
-			let i = Array(n);
-			for (let r = 0; r < n; r++) i[r] = e[r][t];
-			r.sort((e, t) => {
-				let n = i[e], r = i[t];
-				return n < r ? -1 : n > r ? 1 : 0;
-			});
-		}
-		let s = new Uint32Array(n);
-		for (let e = 0; e < n; e++) s[r[e]] = e;
-		this.cache.set(t, {
-			indexes: r,
-			reverseIndex: s,
-			ascItems: null,
-			descItems: null,
-			hasDuplicateValues: this.hasDuplicateValuesForIndexes(e, r, t),
-			version: this.state.getMutationVersion()
-		});
-	}
-	clearIndexes() {
-		return this.cache.clear(), this;
-	}
-	clearData() {
-		return this.state.clearData(), this;
-	}
-	data(e) {
-		return this.state.data(e), this;
-	}
-	add(e) {
-		return this.state.add(e), this;
-	}
-	update(e) {
-		return this.state.update(e), this;
-	}
-	applyAddedItems(e, t) {
-		if (t === 0) return this;
-		if (this.shouldDeferMutationCacheUpdates()) return this.invalidateCachedIndexes(), this;
-		for (let n of this.indexedFields) {
-			let r = this.cache.get(n);
-			if (r) {
-				if (!this.shouldMaintainIncrementally(r)) {
-					this.cache.delete(n);
-					continue;
-				}
-				this.updateCachedIndexForAddedItems(n, e, t);
-			}
-		}
-		return this;
-	}
-	getOriginData() {
-		return this.state.getOriginData();
-	}
-	handleStateMutation(e) {
-		switch (e.type) {
-			case "add":
-				this.applyAddedItems(e.startIndex, e.items.length);
-				return;
-			case "update":
-				this.applyUpdatedItem(e.index, e.previousItem, e.nextItem);
-				return;
-			case "data":
-				this.rebuildConfiguredIndexes();
-				return;
-			case "clearData":
-				this.cache.clear();
-				return;
-			case "remove":
-				this.applyRemovedItem(e.removedIndex, e.movedFromIndex);
-				return;
-			case "removeMany":
-				this.applyRemovedItemsBatch(e.entries);
-				return;
-		}
-	}
-	sort(e, t, n = !1) {
-		let i = t === void 0, a, o;
-		if (i) {
-			if (!this.dataset.length) throw r.missingDatasetForSort();
-			a = this.dataset, o = e;
-		} else a = e, o = t;
-		if (o.length === 0 || a.length === 0) return a;
-		if (o.length === 1) {
-			let { field: e, direction: t } = o[0];
-			if (i && this.indexedFields.has(e)) {
-				let n = this.cache.get(e), r = this.state.getMutationVersion();
-				return (!n || n.version !== r) && (this.buildIndexForDataset(e), n = this.cache.get(e)), this.getCachedSortedItems(n, t);
-			}
-			return this.sortNumericFastPath(a, e, t, n);
-		}
-		return this.sortMultiField(a, o, n, i);
-	}
-	sortNumericFastPath(e, t, n, r) {
-		if (e.length === 0 || typeof e[0][t] != "number") {
-			let i = r ? e : e.slice();
-			return i.sort((e, r) => {
-				let i = e[t], a = r[t], o = i < a ? -1 : i > a ? 1 : 0;
-				return n === "asc" ? o : -o;
-			}), i;
-		}
-		let a = e.length, s = new Float64Array(a);
-		for (let n = 0; n < a; n++) s[n] = e[n][t];
-		let c = new Uint32Array(a);
-		for (let e = 0; e < a; e++) c[e] = e;
-		return i(s, a) ? o(c, s, a) : c.sort((e, t) => s[e] - s[t]), this.materializeItemsFromIndexes(e, c, n);
-	}
-	sortMultiField(e, t, n, r) {
-		let [i, ...a] = t;
-		if (r && this.indexedFields.has(i.field)) {
-			let e = this.cache.get(i.field), t = this.state.getMutationVersion();
-			(!e || e.version !== t) && (this.buildIndexForDataset(i.field), e = this.cache.get(i.field));
-			let n = e.hasDuplicateValues ? this.getCachedSortedItems(e, i.direction).slice() : this.getCachedSortedItems(e, i.direction);
-			return e.hasDuplicateValues ? this.sortTieGroups(n, i.field, a) : n;
-		}
-		let o = n ? e : e.slice(), s = this.buildComparator(t);
-		return o.sort(s), o;
-	}
-	sortTieGroups(e, t, n) {
-		if (n.length === 0) return e;
-		let r = this.buildComparator(n), i = e.length, a = 0;
-		for (; a < i;) {
-			let n = a + 1, o = e[a][t];
-			for (; n < i && e[n][t] === o;) n++;
-			if (n - a > 1) {
-				let t = e.slice(a, n);
-				t.sort(r);
-				for (let r = a; r < n; r++) e[r] = t[r - a];
-			}
-			a = n;
-		}
-		return e;
-	}
-	materializeItemsFromIndexes(e, t, n) {
-		let r = t.length, i = Array(r);
-		if (n === "asc") {
-			for (let n = 0; n < r; n++) i[n] = e[t[n]];
-			return i;
-		}
-		for (let n = 0; n < r; n++) i[n] = e[t[r - 1 - n]];
-		return i;
-	}
-	getCachedSortedItems(e, t) {
-		return t === "asc" ? (e.ascItems === null && (e.ascItems = this.materializeItemsFromIndexes(this.dataset, e.indexes, "asc")), e.ascItems) : (e.descItems === null && (e.descItems = this.getCachedSortedItems(e, "asc").slice().reverse()), e.descItems);
-	}
-	shouldMaintainIncrementally(e) {
-		return e.ascItems !== null || e.descItems !== null;
-	}
-	hasDuplicateValuesForIndexes(e, t, n) {
-		for (let r = 1; r < t.length; r++) if (e[t[r - 1]][n] === e[t[r]][n]) return !0;
-		return !1;
-	}
-	compareIndexesByField(e, t, n) {
-		let r = this.dataset[t][e], i = this.dataset[n][e];
-		if (typeof r == "number" && typeof i == "number") {
-			let e = r - i;
-			if (e !== 0) return e;
-		} else {
-			if (r < i) return -1;
-			if (r > i) return 1;
-		}
-		return t - n;
-	}
-	applyUpdatedItem(e, t, n) {
-		if (this.shouldDeferMutationCacheUpdates()) {
-			this.invalidateCachedIndexes();
-			return;
-		}
-		for (let r of this.indexedFields) {
-			if (t[r] === n[r]) continue;
-			let i = this.cache.get(r);
-			if (i) {
-				if (!this.shouldMaintainIncrementally(i)) {
-					this.cache.delete(r);
-					continue;
-				}
-				this.updateCachedIndexForUpdatedItem(r, e);
-			}
-		}
-	}
-	updateCachedIndexForUpdatedItem(e, t) {
-		let n = this.cache.get(e);
-		if (!n) return;
-		let { indexes: r, reverseIndex: i } = n, a = r.length, o = i[t];
-		if (o >= a || r[o] !== t) {
-			this.cache.delete(e);
-			return;
-		}
-		r.copyWithin(o, o + 1);
-		let s = a - 1, c = 0, l = s;
-		for (; c < l;) {
-			let n = c + l >> 1;
-			this.compareIndexesByField(e, r[n], t) <= 0 ? c = n + 1 : l = n;
-		}
-		let u = c;
-		r.copyWithin(u + 1, u, s), r[u] = t, n.ascItems !== null && (n.ascItems.copyWithin(o, o + 1), n.ascItems.copyWithin(u + 1, u, s), n.ascItems[u] = this.dataset[t]);
-		let d = Math.min(o, u), f = Math.max(o, u);
-		for (let e = d; e <= f; e++) i[r[e]] = e;
-		if (n.descItems = null, !n.hasDuplicateValues) {
-			let i = u > 0 ? r[u - 1] : -1, o = u + 1 < a ? r[u + 1] : -1;
-			n.hasDuplicateValues = i !== -1 && this.dataset[i][e] === this.dataset[t][e] || o !== -1 && this.dataset[o][e] === this.dataset[t][e];
-		}
-		n.version = this.state.getMutationVersion();
-	}
-	updateCachedIndexForAddedItems(e, t, n) {
-		let r = this.cache.get(e);
-		if (!r) return;
-		let i = Array(n);
-		for (let e = 0; e < n; e++) i[e] = t + e;
-		i.sort((t, n) => this.compareIndexesByField(e, t, n));
-		let a = new Uint32Array(r.indexes.length + n), o = -1, s = r.hasDuplicateValues, c = 0, l = 0, u = 0;
-		for (; c < r.indexes.length && l < i.length;) {
-			let t = this.compareIndexesByField(e, r.indexes[c], i[l]) <= 0 ? r.indexes[c++] : i[l++];
-			a[u] = t, !s && o !== -1 && this.dataset[o][e] === this.dataset[t][e] && (s = !0), o = t, u += 1;
-		}
-		for (; c < r.indexes.length;) {
-			let t = r.indexes[c++];
-			a[u] = t, !s && o !== -1 && this.dataset[o][e] === this.dataset[t][e] && (s = !0), o = t, u += 1;
-		}
-		for (; l < i.length;) {
-			let t = i[l++];
-			a[u] = t, !s && o !== -1 && this.dataset[o][e] === this.dataset[t][e] && (s = !0), o = t, u += 1;
-		}
-		let d = new Uint32Array(a.length);
-		for (let e = 0; e < a.length; e++) d[a[e]] = e;
-		r.indexes = a, r.reverseIndex = d, r.ascItems = r.ascItems ? this.materializeItemsFromIndexes(this.dataset, a, "asc") : null, r.descItems = null, r.hasDuplicateValues = s, r.version = this.state.getMutationVersion();
-	}
-	applyRemovedItem(e, t) {
-		if (this.shouldDeferMutationCacheUpdates()) {
-			this.invalidateCachedIndexes();
-			return;
-		}
-		for (let n of this.indexedFields) {
-			let r = this.cache.get(n);
-			if (r) {
-				if (!this.shouldMaintainIncrementally(r)) {
-					this.cache.delete(n);
-					continue;
-				}
-				this.updateCachedIndexForRemovedItem(n, e, t);
-			}
-		}
-	}
-	applyRemovedItemsBatch(e) {
-		if (this.shouldDeferMutationCacheUpdates()) {
-			this.invalidateCachedIndexes();
-			return;
-		}
-		for (let t of this.indexedFields) {
-			let n = this.cache.get(t);
-			if (n) {
-				if (!this.shouldMaintainIncrementally(n)) {
-					this.cache.delete(t);
-					continue;
-				}
-				if (!n.hasDuplicateValues) {
-					this.updateUniqueCachedIndexForRemovedItems(n, e), n.version = this.state.getMutationVersion();
-					continue;
-				}
-				this.cache.delete(t);
-			}
-		}
-	}
-	updateCachedIndexForRemovedItem(e, t, n) {
-		let r = this.cache.get(e);
-		if (!r) return;
-		if (!r.hasDuplicateValues) {
-			this.updateUniqueCachedIndexForRemovedItem(r, t, n), r.version = this.state.getMutationVersion();
-			return;
-		}
-		let i = [];
-		for (let e = 0; e < r.indexes.length; e++) {
-			let a = r.indexes[e];
-			a === t || a === n || i.push(a);
-		}
-		if (n !== null && n !== t) {
-			let n = 0, r = i.length;
-			for (; n < r;) {
-				let a = n + r >> 1;
-				this.compareIndexesByField(e, i[a], t) <= 0 ? n = a + 1 : r = a;
-			}
-			i.splice(n, 0, t);
-		}
-		let a = Uint32Array.from(i), o = new Uint32Array(this.dataset.length);
-		for (let e = 0; e < a.length; e++) {
-			let t = a[e];
-			o[t] = e;
-		}
-		r.indexes = a, r.reverseIndex = o, r.ascItems = r.ascItems ? this.materializeItemsFromIndexes(this.dataset, a, "asc") : null, r.descItems = null, r.hasDuplicateValues = r.hasDuplicateValues ? this.hasDuplicateValuesForIndexes(this.dataset, a, e) : !1, r.version = this.state.getMutationVersion();
-	}
-	updateUniqueCachedIndexForRemovedItem(e, t, n) {
-		let r = e.indexes.length - 1, i = new Uint32Array(r), a = new Uint32Array(this.dataset.length), o = e.ascItems === null ? null : Array(r), s = 0;
-		for (let r = 0; r < e.indexes.length; r++) {
-			let c = e.indexes[r];
-			if (c === t) continue;
-			let l = n !== null && c === n ? t : c;
-			i[s] = l, a[l] = s, o !== null && (o[s] = this.dataset[l]), s += 1;
-		}
-		e.indexes = i, e.reverseIndex = a, e.ascItems = o, e.descItems = null;
-	}
-	updateUniqueCachedIndexForRemovedItems(e, t) {
-		let n = e.indexes.length, r = new Uint32Array(n), i = new Int32Array(n);
-		for (let e = 0; e < n; e++) r[e] = e, i[e] = -1;
-		let a = n;
-		for (let e = 0; e < t.length; e++) {
-			let n = t[e];
-			n.movedFromIndex !== null && (r[n.removedIndex] = r[n.movedFromIndex]), --a;
-		}
-		let o = new Uint32Array(a), s = new Uint32Array(a), c = e.ascItems === null ? null : Array(a);
-		for (let e = 0; e < a; e++) i[r[e]] = e;
-		let l = 0;
-		for (let t = 0; t < e.indexes.length; t++) {
-			let n = i[e.indexes[t]];
-			n !== -1 && (o[l] = n, s[n] = l, c !== null && (c[l] = this.dataset[n]), l += 1);
-		}
-		e.indexes = o, e.reverseIndex = s, e.ascItems = c, e.descItems = null;
-	}
-	buildComparator(e) {
-		let t = e.map(({ field: e }) => e), n = e.map(({ direction: e }) => e === "asc" ? 1 : -1), r = t.length;
-		return (e, i) => {
-			for (let a = 0; a < r; a++) {
-				let r = t[a], o = e[r], s = i[r];
-				if (o < s) return -n[a];
-				if (o > s) return n[a];
-			}
-			return 0;
-		};
-	}
-};
-//#endregion
-export { s as SortEngine };

package/dist/sort/types.d.ts

@@ -1,18 +0,0 @@
-import type { CollectionItem } from "../types";
-export interface SortIndex<T extends CollectionItem = CollectionItem> {
-    indexes: Uint32Array;
-    reverseIndex: Uint32Array;
-    ascItems: T[] | null;
-    descItems: T[] | null;
-    hasDuplicateValues: boolean;
-    version: number;
-}
-export interface SortEngineOptions<T extends CollectionItem = CollectionItem> {
-    data?: T[];
-    fields?: (keyof T & string)[];
-}
-export type SortRuntime<T extends CollectionItem> = {
-    indexedFields: Set<keyof T & string>;
-    cache: Map<string, SortIndex<T>>;
-};
-//# sourceMappingURL=types.d.ts.map

package/dist/sort/utils.d.ts

@@ -1,17 +0,0 @@
-import type { CollectionItem } from "../types";
-import type { SortRuntime } from "./types";
-/**
- * Returns true if every value in `values` is a non-negative 32-bit integer,
- * i.e. it can be treated as a Uint32 without precision loss.
- */
-export declare function canUseUint32Radix(values: Float64Array, length: number): boolean;
-/**
- * 2-pass LSD radix sort — sorts `indexes` so that `values[indexes[i]]` is
- * non-decreasing.  Requires all values to be in [0, 2^32-1] integers.
- *
- * Time  O(2n + 2·65536)  ≈ O(n)
- * Space O(n + 65536)     for temp buffer + count array
- */
-export declare function radixSortUint32(indexes: Uint32Array, values: Float64Array, length: number): void;
-export declare const createSortRuntime: <T extends CollectionItem>() => SortRuntime<T>;
-//# sourceMappingURL=utils.d.ts.map

package/dist/sort/utils.mjs

@@ -1,38 +0,0 @@
-//#region src/sort/utils.ts
-function e(e, t) {
-	for (let n = 0; n < t; n++) {
-		let t = e[n];
-		if (t !== t >>> 0) return !1;
-	}
-	return !0;
-}
-function t(e, t, n) {
-	let r = new Uint32Array(n), i = new Uint32Array(65536);
-	for (let r = 0; r < n; r++) i[t[e[r]] & 65535]++;
-	let a = 0;
-	for (let e = 0; e < 65536; e++) {
-		let t = i[e];
-		i[e] = a, a += t;
-	}
-	for (let a = 0; a < n; a++) {
-		let n = t[e[a]] & 65535;
-		r[i[n]++] = e[a];
-	}
-	i.fill(0);
-	for (let e = 0; e < n; e++) i[t[r[e]] >>> 16 & 65535]++;
-	a = 0;
-	for (let e = 0; e < 65536; e++) {
-		let t = i[e];
-		i[e] = a, a += t;
-	}
-	for (let a = 0; a < n; a++) {
-		let n = t[r[a]] >>> 16 & 65535;
-		e[i[n]++] = r[a];
-	}
-}
-var n = () => ({
-	indexedFields: /* @__PURE__ */ new Set(),
-	cache: /* @__PURE__ */ new Map()
-});
-//#endregion
-export { e as canUseUint32Radix, n as createSortRuntime, t as radixSortUint32 };