@hf-chimera/store 0.0.15 → 0.2.0

package/dist/src-TJG6k3Nr.cjs

@@ -1,1771 +0,0 @@
-const require_defaults = require('./defaults-Bg1kIemd.cjs');
-
-//#region src/filter/errors.ts
-var ChimeraFilterError = class extends require_defaults.ChimeraError {};
-var ChimeraFilterOperatorError = class extends ChimeraFilterError {
-	constructor(operator, message) {
-		super(`Operator "${operator}" ${message}`);
-	}
-};
-var ChimeraFilterOperatorNotFoundError = class extends ChimeraFilterOperatorError {
-	constructor(operator) {
-		super(operator, "not found");
-	}
-};
-
-//#endregion
-//#region src/shared/shared.ts
-const deepObjectAssign = (dst, srcObj, visited = /* @__PURE__ */ new WeakSet()) => {
-	for (const { 0: key, 1: srcVal } of Object.entries(srcObj)) {
-		if (srcVal === null || typeof srcVal !== "object" || Array.isArray(srcVal)) {
-			dst[key] = srcVal;
-			continue;
-		}
-		if (visited.has(srcVal)) {
-			dst[key] = srcVal;
-			continue;
-		}
-		visited.add(srcVal);
-		const destVal = dst[key];
-		dst[key] = destVal === null || typeof destVal !== "object" || Array.isArray(destVal) ? {} : destVal;
-		deepObjectAssign(dst[key], srcVal, visited);
-		visited.delete(srcVal);
-	}
-	return dst;
-};
-const deepObjectFreeze = (obj, frozenObjects = /* @__PURE__ */ new WeakSet()) => {
-	if (obj === null || typeof obj !== "object" || Object.isFrozen(obj) || frozenObjects.has(obj)) return obj;
-	frozenObjects.add(obj);
-	for (const value of Object.values(obj)) if (value && typeof value === "object") deepObjectFreeze(value, frozenObjects);
-	return Object.freeze(obj);
-};
-const TypedArray = Object.getPrototypeOf(Int8Array);
-const deepObjectClone = (value, refs) => {
-	if (value === null) return null;
-	if (value === void 0) return void 0;
-	if (typeof value !== "object") return value;
-	if (refs) {
-		const ref = refs.get(value);
-		if (ref !== void 0) return ref;
-	}
-	if (value.constructor === Object) {
-		const keys$1 = Object.keys(value).concat(Object.getOwnPropertySymbols(value));
-		const length$1 = keys$1.length;
-		const clone$1 = {};
-		refs ??= /* @__PURE__ */ new Map();
-		refs.set(value, clone$1);
-		for (let i = 0; i < length$1; i++) clone$1[keys$1[i]] = deepObjectClone(value[keys$1[i]], refs);
-		return clone$1;
-	}
-	if (Array.isArray(value)) {
-		const length$1 = value.length;
-		const clone$1 = new Array(length$1);
-		refs ??= /* @__PURE__ */ new Map();
-		refs.set(value, clone$1);
-		for (let i = 0; i < length$1; i++) clone$1[i] = deepObjectClone(value[i], refs);
-		return clone$1;
-	}
-	if (value instanceof Date) return new value.constructor(value.valueOf());
-	if (value instanceof RegExp) return value.constructor;
-	if (value instanceof Map) {
-		const clone$1 = new value.constructor();
-		refs ??= /* @__PURE__ */ new Map();
-		refs.set(value, clone$1);
-		for (const entry of value.entries()) clone$1.set(entry[0], deepObjectClone(entry[1], refs));
-		return clone$1;
-	}
-	if (value instanceof Set) {
-		const clone$1 = new value.constructor();
-		refs ??= /* @__PURE__ */ new Map();
-		refs.set(value, clone$1);
-		for (const entry of value.values()) clone$1.add(deepObjectClone(entry, refs));
-		return clone$1;
-	}
-	if (value instanceof Error) {
-		const clone$1 = new value.constructor(value.message);
-		const keys$1 = Object.keys(value).concat(Object.getOwnPropertySymbols(value));
-		const length$1 = keys$1.length;
-		refs ??= /* @__PURE__ */ new Map();
-		refs.set(value, clone$1);
-		for (let i = 0; i < length$1; i++) clone$1[keys$1[i]] = deepObjectClone(value[keys$1[i]], refs);
-		return clone$1;
-	}
-	if (value instanceof ArrayBuffer) return value.slice();
-	if (value instanceof TypedArray) return value.slice();
-	if (value instanceof DataView) return new DataView(value.buffer.slice());
-	if (value instanceof WeakMap) return value;
-	if (value instanceof WeakSet) return value;
-	const clone = Object.create(value.constructor.prototype);
-	const keys = Object.keys(value).concat(Object.getOwnPropertySymbols(value));
-	const length = keys.length;
-	refs ??= /* @__PURE__ */ new Map();
-	refs.set(value, clone);
-	for (let i = 0; i < length; i++) clone[keys[i]] = deepObjectClone(value[keys[i]], refs);
-	return clone;
-};
-const compilePropertyGetter = ({ get }) => typeof get === "function" ? get : (e) => e[get];
-const simplifyPropertyGetter = ({ key }) => key;
-const makeCancellablePromise = (promise, controller = new AbortController()) => {
-	const signal = controller.signal;
-	const newPromise = promise.then((v) => signal.aborted ? new Promise(() => null) : v, (err) => {
-		return signal.aborted ? new Promise(() => null) : Promise.reject(err);
-	});
-	newPromise.cancel = () => controller.abort();
-	newPromise.cancelled = (cb) => signal.aborted ? queueMicrotask(cb) : signal.addEventListener("abort", cb);
-	if ("cancelled" in promise) {
-		promise.cancelled(() => newPromise.cancel());
-		controller.signal.addEventListener("abort", () => promise.cancel());
-	}
-	return newPromise;
-};
-
-//#endregion
-//#region src/filter/constants.ts
-const ChimeraOperatorSymbol = Symbol("ChimeraOperatorSymbol");
-const ChimeraConjunctionSymbol = Symbol("ChimeraConjunctionSymbol");
-
-//#endregion
-//#region src/filter/filter.ts
-const filterConjunctions = {
-	and: (operations) => operations.every((op) => op()),
-	not: (operations) => !operations.every((op) => op()),
-	or: (operations) => operations.some((op) => op())
-};
-const compileOperator = (config, { op, value, test }) => {
-	const operatorFunc = config.operators[op];
-	if (!operatorFunc) throw new ChimeraFilterOperatorNotFoundError(op);
-	const getter = compilePropertyGetter(value);
-	return (entity) => operatorFunc(getter(entity), test);
-};
-const compileConjunction = (config, { kind, operations }) => {
-	const conjunction = filterConjunctions[kind];
-	const compiledOperations = operations.map((operation) => {
-		switch (operation.type) {
-			case ChimeraOperatorSymbol: return compileOperator(config, operation);
-			case ChimeraConjunctionSymbol: return compileConjunction(config, operation);
-			default: throw new require_defaults.ChimeraInternalError(`Invalid filter operation ${operation.type}`);
-		}
-	}).filter(Boolean);
-	return (entity) => conjunction(compiledOperations.map((op) => () => op(entity)));
-};
-const simplifyOperator = ({ op, value, test }) => ({
-	key: simplifyPropertyGetter(value),
-	op,
-	test,
-	type: ChimeraOperatorSymbol
-});
-const compareSimplifiedOperator = (a, b) => a.key.localeCompare(b.key) || a.op.localeCompare(b.op) || JSON.stringify(a.test).localeCompare(JSON.stringify(b.test));
-const compareSimplifiedOperation = (a, b) => {
-	if (a.type !== b.type) return a.type === ChimeraOperatorSymbol ? -1 : 1;
-	if (a.type === ChimeraOperatorSymbol && b.type === ChimeraOperatorSymbol) return compareSimplifiedOperator(a, b);
-	if (a.type === ChimeraConjunctionSymbol && b.type === ChimeraConjunctionSymbol) return compareSimplifiedConjunction(a, b);
-	return 0;
-};
-const compareSimplifiedConjunction = (a, b) => {
-	const kindCompare = a.kind.localeCompare(b.kind);
-	if (kindCompare !== 0) return kindCompare;
-	const aOps = a.operations;
-	const bOps = b.operations;
-	const minLength = Math.min(aOps.length, bOps.length);
-	for (let i = 0; i < minLength; i++) {
-		const aOp = aOps[i];
-		const bOp = bOps[i];
-		if (aOp && bOp) {
-			const compare = compareSimplifiedOperation(aOp, bOp);
-			if (compare !== 0) return compare;
-		}
-	}
-	return aOps.length - bOps.length;
-};
-const simplifyConjunction = ({ kind, operations }) => {
-	return {
-		kind,
-		operations: operations.map((op) => {
-			switch (op.type) {
-				case ChimeraOperatorSymbol: return simplifyOperator(op);
-				case ChimeraConjunctionSymbol: return simplifyConjunction(op);
-				default: throw new require_defaults.ChimeraInternalError(`Invalid filter operation ${op.type}`);
-			}
-		}).filter(Boolean).sort((a, b) => compareSimplifiedOperation(a, b)),
-		type: ChimeraConjunctionSymbol
-	};
-};
-const chimeraCreateOperator = (op, value, test) => ({
-	op,
-	test,
-	type: ChimeraOperatorSymbol,
-	value: typeof value === "string" ? {
-		get: value,
-		key: value
-	} : value
-});
-const chimeraCreateConjunction = (kind, operations) => ({
-	kind,
-	operations,
-	type: ChimeraConjunctionSymbol
-});
-const chimeraCreateNot = (operation) => ({
-	kind: "not",
-	operations: [operation],
-	type: ChimeraConjunctionSymbol
-});
-function chimeraIsConjunction(item) {
-	return item.type === ChimeraConjunctionSymbol;
-}
-function chimeraIsOperator(item) {
-	return item.type === ChimeraOperatorSymbol;
-}
-const compileFilter = (config, descriptor) => descriptor ? compileConjunction(config, descriptor) : () => true;
-const simplifyFilter = (descriptor) => descriptor ? simplifyConjunction(descriptor) : null;
-const isOperationSubset = (candidateOp, targetOp, getOperatorKey) => {
-	if (candidateOp.type !== targetOp.type) return false;
-	if (candidateOp.type === ChimeraOperatorSymbol && targetOp.type === ChimeraOperatorSymbol) return candidateOp.key === targetOp.key && candidateOp.op === targetOp.op && getOperatorKey(candidateOp) === getOperatorKey(targetOp);
-	if (candidateOp.type === ChimeraConjunctionSymbol && targetOp.type === ChimeraConjunctionSymbol) return isConjunctionSubset(candidateOp, targetOp, getOperatorKey);
-	return false;
-};
-const isConjunctionSubset = (candidate, target, getOperatorKey) => {
-	if (candidate.kind !== target.kind) return false;
-	switch (candidate.kind) {
-		case "and":
-		case "not": return candidate.operations.every((candidateOp) => target.operations.some((targetOp) => isOperationSubset(candidateOp, targetOp, getOperatorKey)));
-		case "or": return target.operations.every((targetOp) => candidate.operations.some((candidateOp) => isOperationSubset(candidateOp, targetOp, getOperatorKey)));
-	}
-};
-const isFilterSubset = (candidate, target, getOperatorKey) => {
-	if (candidate === null) return true;
-	if (target === null) return false;
-	return isConjunctionSubset(candidate, target, getOperatorKey);
-};
-
-//#endregion
-//#region src/order/types.ts
-let ChimeraOrderNulls = /* @__PURE__ */ function(ChimeraOrderNulls$1) {
-	ChimeraOrderNulls$1["First"] = "first";
-	ChimeraOrderNulls$1["Last"] = "last";
-	return ChimeraOrderNulls$1;
-}({});
-
-//#endregion
-//#region src/order/order.ts
-const compileOrderDescriptor = ({ key, desc, nulls }) => ({
-	desc,
-	get: compilePropertyGetter(key),
-	nulls
-});
-const chimeraCreateOrderBy = (key, desc = false, nulls = ChimeraOrderNulls.Last) => ({
-	desc,
-	key: typeof key === "string" ? {
-		get: key,
-		key
-	} : key,
-	nulls
-});
-const nullsComparator = (a, b, nulls) => {
-	return a == b ? 0 : (a == null ? -1 : 1) * (nulls === ChimeraOrderNulls.First ? 1 : -1);
-};
-const buildComparator = (comparator, orderBy) => {
-	if (!orderBy) return () => 0;
-	const compiledPriority = orderBy.map((ob) => compileOrderDescriptor(ob));
-	return (a, b) => {
-		let result = 0;
-		for (const descriptor of compiledPriority) {
-			const vA = descriptor.get(a);
-			const vB = descriptor.get(b);
-			if (vA == null || vB == null) {
-				result = nullsComparator(vA, vB, descriptor.nulls);
-				if (result) break;
-				continue;
-			}
-			result = comparator(descriptor.get(a), descriptor.get(b));
-			descriptor.desc && (result *= -1);
-			if (result) break;
-		}
-		return result;
-	};
-};
-const simplifyOrderBy = (orderBy) => orderBy ? orderBy.map((ob) => ({
-	desc: ob.desc,
-	field: ob.key.key,
-	nulls: ob.nulls
-})) : null;
-
-//#endregion
-//#region src/shared/ChimeraEventEmitter/ChimeraEventEmitter.ts
-var Events = function Events$1() {};
-Events.prototype = Object.create(null);
-var ChimeraEventEmitter = class {
-	_events;
-	_eventsCount;
-	constructor() {
-		this._events = new Events();
-		this._eventsCount = 0;
-	}
-	#addListener(event, fn, once) {
-		var listener = {
-			fn,
-			once
-		};
-		if (!this._events[event]) {
-			this._events[event] = listener;
-			this._eventsCount++;
-		} else if (!this._events[event].fn) this._events[event].push(listener);
-		else this._events[event] = [this._events[event], listener];
-		return this;
-	}
-	#clearEvent(event) {
-		if (--this._eventsCount === 0) this._events = new Events();
-		else delete this._events[event];
-	}
-	eventNames() {
-		return Object.keys(this._events);
-	}
-	listeners(event) {
-		var handlers = this._events[event];
-		if (!handlers) return [];
-		if (handlers.fn) return [handlers.fn];
-		for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) ee[i] = handlers[i].fn;
-		return ee;
-	}
-	listenerCount(event) {
-		var listeners = this._events[event];
-		if (!listeners) return 0;
-		if (listeners.fn) return 1;
-		return listeners.length;
-	}
-	removeListener(event, fn, once) {
-		if (!this._events[event]) return this;
-		if (!fn) {
-			this.#clearEvent(event);
-			return this;
-		}
-		var listeners = this._events[event];
-		if (listeners.fn) {
-			if (listeners.fn === fn && (!once || listeners.once)) this.#clearEvent(event);
-		} else {
-			for (var i = 0, events = [], length = listeners.length; i < length; i++) if (listeners[i].fn !== fn || once && !listeners[i].once) events.push(listeners[i]);
-			if (events.length) this._events[event] = events.length === 1 ? events[0] : events;
-			else this.#clearEvent(event);
-		}
-		return this;
-	}
-	emit(event, arg) {
-		if (!this._events[event]) return false;
-		var listeners = this._events[event];
-		if (listeners.fn) {
-			if (listeners.once) this.removeListener(event, listeners.fn, true);
-			listeners.fn.call(this, arg);
-		} else for (var i = 0, length = listeners.length; i < length; i++) {
-			if (listeners[i].once) this.removeListener(event, listeners[i].fn, true);
-			listeners[i].fn.call(this, arg);
-		}
-		return true;
-	}
-	on(event, fn) {
-		return this.#addListener(event, fn, false);
-	}
-	once(event, fn) {
-		return this.#addListener(event, fn, true);
-	}
-	removeAllListeners(event) {
-		if (event) {
-			if (this._events[event]) this.#clearEvent(event);
-		} else {
-			this._events = new Events();
-			this._eventsCount = 0;
-		}
-		return this;
-	}
-	off = this.removeListener;
-	addListener = this.on;
-};
-
-//#endregion
-//#region src/query/types.ts
-let ChimeraQueryFetchingState = /* @__PURE__ */ function(ChimeraQueryFetchingState$1) {
-	/** Query just initialized. */
-	ChimeraQueryFetchingState$1["Initialized"] = "initialized";
-	/** Not used yet. */
-	ChimeraQueryFetchingState$1["Scheduled"] = "scheduled";
-	/** Fetching in progress. */
-	ChimeraQueryFetchingState$1["Fetching"] = "fetching";
-	/** Creating in progress */
-	ChimeraQueryFetchingState$1["Creating"] = "creating";
-	/** Updating in progress. */
-	ChimeraQueryFetchingState$1["Updating"] = "updating";
-	/** Deleting in progress. */
-	ChimeraQueryFetchingState$1["Deleting"] = "deleting";
-	/** Fetch requested after reaching the Fetched, Errored, or Prefetched states. */
-	ChimeraQueryFetchingState$1["Refetching"] = "refetching";
-	/** Data retrieved from existing queries without initiating a fetch. */
-	ChimeraQueryFetchingState$1["Prefetched"] = "prefetched";
-	/** Fetch ended successfully; data is ready for use. */
-	ChimeraQueryFetchingState$1["Fetched"] = "fetched";
-	/** Fetch ended with an error; no data is available. */
-	ChimeraQueryFetchingState$1["Errored"] = "errored";
-	/** Refetch ended with an error, but old data is still available. */
-	ChimeraQueryFetchingState$1["ReErrored"] = "reErrored";
-	/**
-	* Only for the item query, data is deleted, but the local value is still present,
-	* no longer allows updates, but `refetch` still works (in case of strange errors, allows recovering state)
-	*/
-	ChimeraQueryFetchingState$1["Deleted"] = "deleted";
-	/** Only for the item query, data was actualized from an external event */
-	ChimeraQueryFetchingState$1["Actualized"] = "actualized";
-	return ChimeraQueryFetchingState$1;
-}({});
-
-//#endregion
-//#region src/query/constants.ts
-const ChimeraGetParamsSym = Symbol("ChimeraGetParamsSym");
-const ChimeraSetOneSym = Symbol("ChimeraSetOneSym");
-const ChimeraSetManySym = Symbol("ChimeraSetManySym");
-const ChimeraDeleteOneSym = Symbol("ChimeraDeleteOneSym");
-const ChimeraDeleteManySym = Symbol("ChimeraDeleteManySym");
-const ChimeraUpdateMixedSym = Symbol("ChimeraUpdateMixedSym");
-const IN_PROGRESS_STATES = [
-	ChimeraQueryFetchingState.Scheduled,
-	ChimeraQueryFetchingState.Creating,
-	ChimeraQueryFetchingState.Fetching,
-	ChimeraQueryFetchingState.Refetching,
-	ChimeraQueryFetchingState.Updating,
-	ChimeraQueryFetchingState.Deleting
-];
-
-//#endregion
-//#region src/query/ChimeraCollectionQuery.ts
-var ChimeraCollectionQuery = class extends ChimeraEventEmitter {
-	#state;
-	#promise;
-	#lastError;
-	#items;
-	#config;
-	#idGetter;
-	#params;
-	#order;
-	#filter;
-	#emit(event, arg) {
-		queueMicrotask(() => super.emit(event, arg));
-	}
-	emit() {
-		throw new require_defaults.ChimeraInternalError("External events dispatching is not supported.");
-	}
-	#prepareRequestParams() {
-		return { controller: new AbortController() };
-	}
-	#readyItems(internalMessage) {
-		if (this.#items) return this.#items;
-		throw internalMessage ? new require_defaults.ChimeraInternalError(internalMessage) : new require_defaults.ChimeraQueryNotReadyError(this.#config.name);
-	}
-	#addItem(item) {
-		const items = this.#readyItems("Trying to update not ready collection");
-		const foundIndex = items.findIndex((el) => this.#order(el, item) > 0);
-		items.splice(foundIndex !== -1 ? foundIndex : items.length, 0, item);
-		this.#emit("itemAdded", {
-			instance: this,
-			item
-		});
-	}
-	#setItems(items) {
-		!this.#items && this.#emit("ready", { instance: this });
-		const oldItems = this.#items;
-		this.#items = items;
-		this.#emit("updated", {
-			instance: this,
-			items,
-			oldItems
-		});
-	}
-	#setNewItems(items) {
-		items.forEach((i) => void deepObjectFreeze(i));
-		this.#emit("selfUpdated", {
-			instance: this,
-			items,
-			oldItems: this.#items
-		});
-		this.#setItems(items);
-	}
-	#setPromise(promise) {
-		this.#promise?.cancel();
-		this.#promise = promise;
-		return promise;
-	}
-	#deleteAtIndex(index) {
-		if (index === -1) return;
-		const { 0: old } = this.#readyItems("Trying to update not ready collection").splice(index, 1);
-		this.#emit("itemDeleted", {
-			instance: this,
-			item: old
-		});
-	}
-	#deleteItem(item) {
-		this.#deleteAtIndex(this.#readyItems("Trying to update not ready collection").indexOf(item));
-	}
-	#deleteById(id) {
-		this.#deleteAtIndex(this.#readyItems("Trying to update not ready collection").findIndex((item) => this.#idGetter(item) === id));
-	}
-	#replaceItem(oldItem, newItem) {
-		const items = this.#readyItems("Trying to update not ready collection");
-		const index = items.indexOf(oldItem);
-		const old = items[index];
-		items[index] = newItem;
-		this.#emit("itemUpdated", {
-			instance: this,
-			newItem,
-			oldItem: old
-		});
-	}
-	#getById(id) {
-		return this.#readyItems("Trying to update not ready collection").find((item) => this.#idGetter(item) === id);
-	}
-	#setOne(item) {
-		const existingItem = this.#getById(this.#idGetter(item));
-		const nowMatches = this.#filter(item);
-		if (!(nowMatches || existingItem)) return;
-		if (existingItem) {
-			if (this.#order(existingItem, item) === 0) {
-				this.#replaceItem(existingItem, item);
-				return;
-			}
-			this.#deleteItem(existingItem);
-		}
-		nowMatches && this.#addItem(item);
-	}
-	#setNewOne(item) {
-		deepObjectFreeze(item);
-		this.#setOne(item);
-	}
-	#apply(input) {
-		return input.filter((item) => this.#filter(item)).sort((a, b) => this.#order(a, b));
-	}
-	#validate(input) {
-		if (this.#config.trustQuery && !this.#config.devMode) return input;
-		const prepared = this.#apply(input);
-		if (!this.#config.trustQuery) return prepared;
-		if (this.#config.devMode) {
-			for (let i = 0; i < input.length; i++) if (input[i] !== prepared[i]) {
-				console.warn(new require_defaults.ChimeraQueryTrustFetchedCollectionError(this.#config.name, input, prepared));
-				break;
-			}
-		}
-		return input;
-	}
-	#setError(error, source) {
-		this.#state = this.#items ? ChimeraQueryFetchingState.ReErrored : ChimeraQueryFetchingState.Errored;
-		this.#lastError = error;
-		this.#emit("error", {
-			error,
-			instance: this
-		});
-		throw source;
-	}
-	#watchPromise(promise, controller) {
-		return makeCancellablePromise(promise.then((response) => {
-			this.#setNewItems(this.#validate(response.data));
-			this.#state = ChimeraQueryFetchingState.Fetched;
-			return response;
-		}).catch((error) => this.#setError(error, new require_defaults.ChimeraQueryFetchingError(this.#config.name, error))), controller);
-	}
-	constructor(config, params, existingItems, order, filter, alreadyValid) {
-		super();
-		this.#config = config;
-		this.#params = params;
-		this.#promise = null;
-		this.#items = null;
-		this.#state = ChimeraQueryFetchingState.Initialized;
-		this.#idGetter = config.idGetter;
-		this.#filter = filter;
-		this.#order = order;
-		if (existingItems) {
-			const input = Array.from(existingItems);
-			this.#setItems(alreadyValid ? this.#validate(input) : this.#apply(input));
-			this.#state = ChimeraQueryFetchingState.Prefetched;
-		} else {
-			this.#state = ChimeraQueryFetchingState.Fetching;
-			const { controller } = this.#prepareRequestParams();
-			this.#setPromise(this.#watchPromise(makeCancellablePromise(config.collectionFetcher(params, { signal: controller.signal }), controller), controller));
-		}
-		this.#emit("initialized", { instance: this });
-	}
-	get [ChimeraGetParamsSym]() {
-		return this.#params;
-	}
-	[ChimeraSetOneSym](item) {
-		this.#items && this.#setOne(item);
-	}
-	[ChimeraDeleteOneSym](id) {
-		this.#items && this.#deleteById(id);
-	}
-	[ChimeraSetManySym](items) {
-		if (this.#items) for (const item of items) this.#setOne(item);
-	}
-	[ChimeraDeleteManySym](ids) {
-		if (this.#items) for (const id of ids) this.#deleteById(id);
-	}
-	[ChimeraUpdateMixedSym](toAdd, toDelete) {
-		if (this.#items) {
-			for (const id of toDelete) this.#deleteById(id);
-			for (const item of toAdd) this.#setOne(item);
-		}
-	}
-	get state() {
-		return this.#state;
-	}
-	get inProgress() {
-		return IN_PROGRESS_STATES.includes(this.#state);
-	}
-	get ready() {
-		return this.#items !== null;
-	}
-	get lastError() {
-		return this.#lastError;
-	}
-	/**
-	* Wait for the current progress process to complete (both success or error)
-	*/
-	get progress() {
-		return new Promise((res) => {
-			const resolve = () => queueMicrotask(() => res());
-			if (this.#promise) {
-				this.#promise.then(resolve, resolve);
-				this.#promise.cancelled(() => this.progress.then(resolve, resolve));
-			} else resolve();
-		});
-	}
-	/**
-	* Wait for the current progress process to complete, throw an error if it fails
-	*/
-	get result() {
-		return new Promise((res, rej) => {
-			const resolve = () => queueMicrotask(() => res());
-			if (this.#promise) {
-				this.#promise.then(resolve, rej);
-				this.#promise.cancelled(() => this.#promise ? this.result.then(res, rej) : rej("cancelled"));
-			} else resolve();
-		});
-	}
-	/** Return an item if it is ready, throw error otherwise */
-	getById(id) {
-		return this.#readyItems().find((item) => this.#idGetter(item) === id);
-	}
-	/** Return mutable ref to item by idx if it is ready, throw error otherwise */
-	mutableAt(idx) {
-		return deepObjectClone(this.#readyItems().at(idx));
-	}
-	/** Return mutable ref to item by [id] if it is ready, throw error otherwise */
-	mutableGetById(id) {
-		return deepObjectClone(this.#readyItems().find((item) => this.#idGetter(item) === id));
-	}
-	/**
-	*  Trigger refetch, return existing refetch promise if already running
-	*  @param force If true cancels any running process and starts a new one
-	*  @throws {ChimeraQueryAlreadyRunningError} If deleting or updating already in progress
-	*/
-	refetch(force = false) {
-		if (!force && this.#promise && [ChimeraQueryFetchingState.Fetching, ChimeraQueryFetchingState.Refetching].includes(this.#state)) return this.#promise;
-		if (!force && [ChimeraQueryFetchingState.Updating, ChimeraQueryFetchingState.Deleting].includes(this.#state)) throw new require_defaults.ChimeraQueryAlreadyRunningError(this.#config.name, this.#state);
-		this.#state = ChimeraQueryFetchingState.Refetching;
-		const { controller } = this.#prepareRequestParams();
-		return this.#setPromise(this.#watchPromise(makeCancellablePromise(this.#config.collectionFetcher(this.#params, { signal: controller.signal }), controller), controller));
-	}
-	/**
-	* Update item using updated copy
-	* @param newItem new item to update
-	*/
-	update(newItem) {
-		const { controller } = this.#prepareRequestParams();
-		return this.#config.itemUpdater(newItem, { signal: controller.signal }).then((response) => {
-			const { data } = response;
-			this.#items && this.#setNewOne(data);
-			this.#emit("selfItemUpdated", {
-				instance: this,
-				item: data
-			});
-			return response;
-		});
-	}
-	/**
-	* Update item using updated copy
-	* @param newItems array of items to update
-	*/
-	batchedUpdate(newItems) {
-		const { controller } = this.#prepareRequestParams();
-		return this.#config.batchedUpdater(Array.from(newItems), { signal: controller.signal }).then((response) => {
-			const ready = this.ready;
-			response.data.forEach((item) => {
-				ready && this.#setNewOne(item);
-				this.#emit("selfItemUpdated", {
-					instance: this,
-					item
-				});
-			});
-			return response;
-		});
-	}
-	/**
-	* Delete item using its [id]
-	* @param id id of item to delete
-	*/
-	delete(id) {
-		const { controller } = this.#prepareRequestParams();
-		return this.#config.itemDeleter(id, { signal: controller.signal }).then((response) => {
-			const { result: { id: newId, success } } = response;
-			if (!this.#items) {
-				success && this.#emit("selfItemDeleted", {
-					id: newId,
-					instance: this
-				});
-				return response;
-			}
-			if (this.#config.trustQuery && !this.#config.devMode && success) {
-				this.#deleteById(newId);
-				this.#emit("selfItemDeleted", {
-					id: newId,
-					instance: this
-				});
-				return response;
-			}
-			if (id !== newId) {
-				this.#config.devMode && this.#config.trustQuery && console.warn(new require_defaults.ChimeraQueryTrustIdMismatchError(this.#config.name, id, newId));
-				if (!this.#config.trustQuery) {
-					success && this.#emit("selfItemDeleted", {
-						id: newId,
-						instance: this
-					});
-					throw new require_defaults.ChimeraQueryTrustIdMismatchError(this.#config.name, id, newId);
-				}
-			}
-			if (success) {
-				this.#deleteById(newId);
-				this.#emit("selfItemDeleted", {
-					id: newId,
-					instance: this
-				});
-				return response;
-			}
-			const error = new require_defaults.ChimeraQueryUnsuccessfulDeletionError(this.#config.name, id);
-			this.#state = ChimeraQueryFetchingState.ReErrored;
-			this.#lastError = error;
-			throw error;
-		}, (error) => this.#setError(error, new require_defaults.ChimeraQueryDeletingError(this.#config.name, error)));
-	}
-	/**
-	* Delete a list of items by their [id]s
-	* @param ids array of items to delete
-	*/
-	batchedDelete(ids) {
-		const { controller } = this.#prepareRequestParams();
-		return this.#config.batchedDeleter(Array.from(ids), { signal: controller.signal }).then((response) => {
-			this.#items && response.result.forEach(({ id: newId, success }) => {
-				if (success) {
-					this.#deleteById(newId);
-					this.#emit("selfItemDeleted", {
-						id: newId,
-						instance: this
-					});
-				} else {
-					const error = new require_defaults.ChimeraQueryUnsuccessfulDeletionError(this.#config.name, newId);
-					this.#state = ChimeraQueryFetchingState.ReErrored;
-					this.#lastError = error;
-					throw error;
-				}
-			});
-			return response;
-		}, (error) => this.#setError(error, new require_defaults.ChimeraQueryDeletingError(this.#config.name, error)));
-	}
-	/**
-	* Create new item using partial data
-	* @param item partial item data to create new item
-	*/
-	create(item) {
-		const { controller } = this.#prepareRequestParams();
-		return this.#config.itemCreator(item, { signal: controller.signal }).then((response) => {
-			const { data } = response;
-			this.#items && this.#setNewOne(data);
-			this.#emit("selfItemCreated", {
-				instance: this,
-				item: data
-			});
-			return response;
-		}, (error) => this.#setError(error, new require_defaults.ChimeraQueryFetchingError(this.#config.name, error)));
-	}
-	/**
-	* Create multiple items using partial data
-	* @param items array of partial item data to create new items
-	*/
-	batchedCreate(items) {
-		const { controller } = this.#prepareRequestParams();
-		return this.#config.batchedCreator(Array.from(items), { signal: controller.signal }).then((response) => {
-			this.#items && response.data.forEach((item) => {
-				this.#setNewOne(item);
-				this.#emit("selfItemCreated", {
-					instance: this,
-					item
-				});
-			});
-			return response;
-		}, (error) => this.#setError(error, new require_defaults.ChimeraQueryFetchingError(this.#config.name, error)));
-	}
-	/**
-	* Standard Array API without mutations
-	*/
-	get length() {
-		return this.#readyItems().length;
-	}
-	[Symbol.iterator]() {
-		return this.#readyItems()[Symbol.iterator]();
-	}
-	at(idx) {
-		return this.#readyItems().at(idx);
-	}
-	entries() {
-		return this.#readyItems().entries();
-	}
-	values() {
-		return this.#readyItems().values();
-	}
-	keys() {
-		return this.#readyItems().keys();
-	}
-	every(predicate) {
-		return this.#readyItems().every((item, idx) => predicate(item, idx, this));
-	}
-	some(predicate) {
-		return this.#readyItems().some((item, idx) => predicate(item, idx, this));
-	}
-	filter(predicate) {
-		return this.#readyItems().filter((item, idx) => predicate(item, idx, this));
-	}
-	find(predicate) {
-		return this.#readyItems().find((item, idx) => predicate(item, idx, this));
-	}
-	findIndex(predicate) {
-		return this.#readyItems().findIndex((item, idx) => predicate(item, idx, this));
-	}
-	findLast(predicate) {
-		return this.#readyItems().findLast((item, idx) => predicate(item, idx, this));
-	}
-	findLastIndex(predicate) {
-		return this.#readyItems().findLastIndex((item, idx) => predicate(item, idx, this));
-	}
-	forEach(cb) {
-		this.#readyItems().forEach((item, idx) => void cb(item, idx, this));
-	}
-	includes(item) {
-		return this.#readyItems().includes(item);
-	}
-	indexOf(item) {
-		return this.#readyItems().indexOf(item);
-	}
-	map(cb) {
-		return this.#readyItems().map((item, idx) => cb(item, idx, this));
-	}
-	reduce(cb, initialValue) {
-		return this.#readyItems().reduce((prev, cur, idx) => cb(prev, cur, idx, this), initialValue);
-	}
-	reduceRight(cb, initialValue) {
-		return this.#readyItems().reduceRight((prev, cur, idx) => cb(prev, cur, idx, this), initialValue);
-	}
-	slice(start, end) {
-		return this.#readyItems().slice(start, end);
-	}
-	toSorted(compareFn) {
-		return this.#readyItems().toSorted(compareFn);
-	}
-	toSpliced(start, deleteCount, ...items) {
-		return this.#readyItems().toSpliced(start, deleteCount, ...items);
-	}
-	toJSON() {
-		return Array.from(this.#readyItems());
-	}
-	toString() {
-		return this.#readyItems().toString();
-	}
-};
-
-//#endregion
-//#region src/query/ChimeraItemQuery.ts
-var ChimeraItemQuery = class extends ChimeraEventEmitter {
-	#item;
-	#mutable;
-	#state;
-	#promise;
-	#lastError;
-	#params;
-	#config;
-	#idGetter;
-	#emit(event, arg) {
-		queueMicrotask(() => super.emit(event, arg));
-	}
-	emit() {
-		throw new require_defaults.ChimeraInternalError("External events dispatching is not supported.");
-	}
-	#prepareRequestParams() {
-		return { controller: new AbortController() };
-	}
-	#setPromise(promise) {
-		this.#promise?.cancel();
-		this.#promise = promise;
-		return promise;
-	}
-	#readyItem(internalMessage) {
-		if (this.#item) return this.#item;
-		throw internalMessage ? new require_defaults.ChimeraInternalError(internalMessage) : new require_defaults.ChimeraQueryNotReadyError(this.#config.name);
-	}
-	#mutableItem(internalMessage) {
-		if (this.#state === ChimeraQueryFetchingState.Deleted) throw internalMessage ? new require_defaults.ChimeraInternalError(internalMessage) : new require_defaults.ChimeraQueryDeletedItemError(this.#config.name, this.#params.id);
-		return this.#readyItem(internalMessage);
-	}
-	#setMutable(item) {
-		if (item != null) if (this.#mutable) deepObjectAssign(this.#mutable, item);
-		else this.#mutable = deepObjectClone(item);
-		else this.#mutable = item;
-	}
-	#resetMutable() {
-		this.#setMutable(this.#readyItem(`Trying to reset mutable ref for empty item (${this.#config.name}[${this.#params.id}])`));
-	}
-	#setItem(item) {
-		!this.#item && this.#emit("ready", { instance: this });
-		const oldItem = this.#item;
-		this.#item = item;
-		this.#resetMutable();
-		this.#emit("updated", {
-			instance: this,
-			item,
-			oldItem
-		});
-	}
-	#setNewItem(item) {
-		deepObjectFreeze(item);
-		const oldItem = this.#item;
-		this.#setItem(item);
-		this.#emit("selfUpdated", {
-			instance: this,
-			item,
-			oldItem
-		});
-	}
-	#deleteItem() {
-		this.#state = ChimeraQueryFetchingState.Deleted;
-		this.#emit("deleted", {
-			id: this.#params.id,
-			instance: this
-		});
-	}
-	#setError(error, source) {
-		this.#state = this.#item ? ChimeraQueryFetchingState.ReErrored : ChimeraQueryFetchingState.Errored;
-		this.#lastError = error;
-		this.#emit("error", {
-			error,
-			instance: this
-		});
-		throw source;
-	}
-	#watchPromise(promise, controller) {
-		return makeCancellablePromise(promise.then(({ data }) => {
-			if (this.#config.trustQuery && !this.#config.devMode) {
-				this.#setNewItem(data);
-				this.#state = ChimeraQueryFetchingState.Fetched;
-				return { data };
-			}
-			const localId = this.#params.id;
-			const newId = this.#idGetter(data);
-			if (localId === newId || this.#state === ChimeraQueryFetchingState.Creating) {
-				this.#setNewItem(data);
-				if (this.#state === ChimeraQueryFetchingState.Creating) this.#emit("selfCreated", {
-					instance: this,
-					item: data
-				});
-				this.#state = ChimeraQueryFetchingState.Fetched;
-			} else {
-				this.#config.devMode && this.#config.trustQuery && console.warn(new require_defaults.ChimeraQueryTrustIdMismatchError(this.#config.name, localId, newId));
-				if (!this.#config.trustQuery) throw new require_defaults.ChimeraQueryTrustIdMismatchError(this.#config.name, localId, newId);
-				this.#setNewItem(data);
-				this.#params.id = newId;
-				this.#state = ChimeraQueryFetchingState.Fetched;
-			}
-			return { data };
-		}).catch((error) => this.#setError(error, new require_defaults.ChimeraQueryFetchingError(this.#config.name, error))), controller);
-	}
-	#updateItem(newItem) {
-		const newId = this.#idGetter(newItem);
-		const oldId = this.#idGetter(this.#readyItem(`Trying to update not ready item (${this.#config.name}[${this.#params.id}])`));
-		if (newId !== oldId && !this.#config.trustQuery) {
-			this.#resetMutable();
-			throw new require_defaults.ChimeraQueryIdMismatchError(this.#config.name, oldId, newId);
-		}
-		this.#state = ChimeraQueryFetchingState.Updating;
-		const { controller } = this.#prepareRequestParams();
-		return this.#setPromise(this.#watchPromise(makeCancellablePromise(this.#config.itemUpdater(newItem, { signal: controller.signal }), controller), controller));
-	}
-	#requestDelete() {
-		this.#state = ChimeraQueryFetchingState.Deleting;
-		const { controller } = this.#prepareRequestParams();
-		return this.#setPromise(makeCancellablePromise(makeCancellablePromise(this.#config.itemDeleter(this.#params.id, { signal: controller.signal }), controller).then(({ result }) => {
-			const { id, success } = result;
-			if (this.#config.trustQuery && !this.#config.devMode && success) {
-				this.#deleteItem();
-				return { result };
-			}
-			const localId = this.#params.id;
-			if (localId !== id) {
-				this.#config.devMode && this.#config.trustQuery && console.warn(new require_defaults.ChimeraQueryTrustIdMismatchError(this.#config.name, localId, id));
-				if (!this.#config.trustQuery) throw new require_defaults.ChimeraQueryTrustIdMismatchError(this.#config.name, localId, id);
-			}
-			if (success) {
-				this.#deleteItem();
-				this.#emit("selfDeleted", {
-					id,
-					instance: this
-				});
-			} else {
-				const error = new require_defaults.ChimeraQueryUnsuccessfulDeletionError(this.#config.name, this.#params.id);
-				this.#state = ChimeraQueryFetchingState.ReErrored;
-				this.#lastError = error;
-				throw error;
-			}
-			return { result };
-		}, (error) => this.#setError(error, new require_defaults.ChimeraQueryDeletingError(this.#config.name, error)))));
-	}
-	constructor(config, params, existingItem, toCreateItem) {
-		super();
-		this.#config = config;
-		this.#idGetter = config.idGetter;
-		this.#params = params;
-		this.#promise = null;
-		this.#item = null;
-		this.#mutable = null;
-		this.#state = ChimeraQueryFetchingState.Initialized;
-		if (existingItem) {
-			const item = existingItem;
-			this.#setItem(item);
-			if (config.devMode && this.#idGetter(item) !== params.id) {
-				this.#state = ChimeraQueryFetchingState.Errored;
-				throw new require_defaults.ChimeraInternalError(`Invalid item query [id] (changed from "${params.id}" to "${this.#idGetter(item)}")`);
-			}
-			this.#state = ChimeraQueryFetchingState.Prefetched;
-		} else if (toCreateItem) {
-			this.#state = ChimeraQueryFetchingState.Creating;
-			const { controller } = this.#prepareRequestParams();
-			this.#setPromise(this.#watchPromise(makeCancellablePromise(config.itemCreator(toCreateItem, { signal: controller.signal }), controller).then(({ data }) => {
-				this.#params.id = this.#idGetter(data);
-				return { data };
-			}), controller));
-		} else {
-			this.#state = ChimeraQueryFetchingState.Fetching;
-			const { controller } = this.#prepareRequestParams();
-			this.#setPromise(this.#watchPromise(makeCancellablePromise(config.itemFetcher(params, { signal: controller.signal }), controller), controller));
-		}
-		this.#emit("initialized", { instance: this });
-	}
-	get [ChimeraGetParamsSym]() {
-		return this.#params;
-	}
-	[ChimeraSetOneSym](item) {
-		this.#setItem(item);
-		!this.inProgress && (this.#state = ChimeraQueryFetchingState.Actualized);
-	}
-	[ChimeraDeleteOneSym](id) {
-		if (id === this.#params.id) {
-			this.#promise?.cancel();
-			this.#promise = null;
-			this.#deleteItem();
-		}
-	}
-	get state() {
-		return this.#state;
-	}
-	get inProgress() {
-		return IN_PROGRESS_STATES.includes(this.#state);
-	}
-	get ready() {
-		return this.#item !== null;
-	}
-	get lastError() {
-		return this.#lastError;
-	}
-	get id() {
-		return this.#params.id;
-	}
-	/** Return an item if it is ready, throw error otherwise */
-	get data() {
-		return this.#readyItem();
-	}
-	/** Get ref for an item that can be changed as a regular object. To send changes to updater, use <commit> method */
-	get mutable() {
-		this.#readyItem();
-		return this.#mutable;
-	}
-	get promise() {
-		return this.#promise;
-	}
-	/**
-	* Wait for the current progress process to complete (both success or error)
-	*/
-	get progress() {
-		return new Promise((res) => {
-			const resolve = () => queueMicrotask(() => res());
-			if (this.#promise) {
-				this.#promise.then(resolve, resolve);
-				this.#promise.cancelled(() => this.progress.then(resolve, resolve));
-			} else resolve();
-		});
-	}
-	/**
-	* Wait for the current progress process to complete, throw an error if it fails
-	*/
-	get result() {
-		return new Promise((res, rej) => {
-			const resolve = () => queueMicrotask(() => res());
-			if (this.#promise) {
-				this.#promise.then(resolve, rej);
-				this.#promise.cancelled(() => this.#promise ? this.result.then(res, rej) : rej("cancelled"));
-			} else resolve();
-		});
-	}
-	/**
-	*  Trigger refetch, return existing refetch promise if already running
-	*  @param force If true cancels any running process and starts a new one
-	*  @throws {ChimeraQueryAlreadyRunningError} If deleting or updating already in progress
-	*/
-	refetch(force = false) {
-		if (!force && this.#promise && [ChimeraQueryFetchingState.Fetching, ChimeraQueryFetchingState.Refetching].includes(this.#state)) return this.#promise;
-		if (this.#state === ChimeraQueryFetchingState.Creating) throw new require_defaults.ChimeraQueryNotCreatedError(this.#config.name);
-		if (!force && [ChimeraQueryFetchingState.Updating, ChimeraQueryFetchingState.Deleting].includes(this.#state)) throw new require_defaults.ChimeraQueryAlreadyRunningError(this.#config.name, this.#state);
-		this.#state = ChimeraQueryFetchingState.Refetching;
-		const { controller } = this.#prepareRequestParams();
-		return this.#setPromise(this.#watchPromise(makeCancellablePromise(this.#config.itemFetcher(this.#params, { signal: controller.signal }), controller), controller));
-	}
-	/**
-	* Update item using updated copy, a running update process will be cancelled
-	* @param newItem new item to replace existing
-	* @param force if true cancels any running process including fetch and delete
-	* @throws {ChimeraQueryAlreadyRunningError} If deleting or updating already in progress
-	*/
-	update(newItem, force = false) {
-		if (this.#state === ChimeraQueryFetchingState.Creating) throw new require_defaults.ChimeraQueryNotCreatedError(this.#config.name);
-		if (!force && [
-			ChimeraQueryFetchingState.Fetching,
-			ChimeraQueryFetchingState.Refetching,
-			ChimeraQueryFetchingState.Deleting
-		].includes(this.#state)) throw new require_defaults.ChimeraQueryAlreadyRunningError(this.#config.name, this.#state);
-		this.#mutableItem();
-		return this.#updateItem(newItem);
-	}
-	/**
-	* Update item using function with draft item as argument
-	* that can be used to patch item in place or return a patched value,
-	* a running update process will be cancelled
-	* @param mutator mutator function
-	* @param force if true cancels any running process including fetch and delete
-	* @throws {ChimeraQueryAlreadyRunningError} If deleting or updating already in progress
-	*/
-	mutate(mutator, force = false) {
-		if (this.#state === ChimeraQueryFetchingState.Creating) throw new require_defaults.ChimeraQueryNotCreatedError(this.#config.name);
-		if (!force && [
-			ChimeraQueryFetchingState.Fetching,
-			ChimeraQueryFetchingState.Refetching,
-			ChimeraQueryFetchingState.Deleting
-		].includes(this.#state)) throw new require_defaults.ChimeraQueryAlreadyRunningError(this.#config.name, this.#state);
-		const item = deepObjectClone(this.#mutableItem());
-		return this.#updateItem(mutator(item) ?? item);
-	}
-	/**
-	* Commit updated value from mutable ref, a running update process will be canceled
-	* @param force if true cancels any running process including fetch and delete
-	* @throws {ChimeraQueryAlreadyRunningError} If deleting or updating already in progress
-	*/
-	commit(force = false) {
-		if (this.#state === ChimeraQueryFetchingState.Creating) throw new require_defaults.ChimeraQueryNotCreatedError(this.#config.name);
-		if (!force && [
-			ChimeraQueryFetchingState.Fetching,
-			ChimeraQueryFetchingState.Refetching,
-			ChimeraQueryFetchingState.Deleting
-		].includes(this.#state)) throw new require_defaults.ChimeraQueryAlreadyRunningError(this.#config.name, this.#state);
-		this.#mutableItem();
-		return this.#updateItem(this.#mutable);
-	}
-	/**
-	* Request to delete the value.
-	* Local copy will still be available if it was present.
-	* A running delete process will be canceled
-	* @param force if true cancels any running process including fetch and update
-	* @throws {ChimeraQueryAlreadyRunningError} If deleting or updating already in progress
-	*/
-	delete(force = false) {
-		if (this.#state === ChimeraQueryFetchingState.Creating) throw new require_defaults.ChimeraQueryNotCreatedError(this.#config.name);
-		if (!force && [
-			ChimeraQueryFetchingState.Fetching,
-			ChimeraQueryFetchingState.Refetching,
-			ChimeraQueryFetchingState.Updating
-		].includes(this.#state)) throw new require_defaults.ChimeraQueryAlreadyRunningError(this.#config.name, this.#state);
-		return this.#requestDelete();
-	}
-	toJSON() {
-		return this.#readyItem();
-	}
-	toString() {
-		return `${this.#readyItem()}`;
-	}
-};
-
-//#endregion
-//#region src/shared/ChimeraWeakValueMap/ChimeraWeakValueMap.ts
-var ChimeraWeakValueMap = class extends ChimeraEventEmitter {
-	#map;
-	#registry;
-	#cleanupScheduled = false;
-	#emit(event, arg) {
-		queueMicrotask(() => super.emit(event, arg));
-	}
-	emit() {
-		throw new require_defaults.ChimeraInternalError("External events dispatching is not supported.");
-	}
-	#scheduleCleanup() {
-		if (this.#cleanupScheduled) return;
-		this.#cleanupScheduled = true;
-		(typeof requestIdleCallback !== "undefined" ? requestIdleCallback : (cb) => setTimeout(cb, 0))(() => {
-			this.#cleanup();
-			this.#cleanupScheduled = false;
-		});
-	}
-	#cleanup() {
-		for (const [key, weakRef] of this.#map.entries()) if (weakRef.deref() === void 0) {
-			this.#map.delete(key);
-			this.#emit("finalize", {
-				instance: this,
-				key
-			});
-		}
-	}
-	constructor(values) {
-		super();
-		this.#registry = new FinalizationRegistry((key) => {
-			const weakRef = this.#map.get(key);
-			if (weakRef && weakRef.deref() === void 0) {
-				this.#map.delete(key);
-				this.#emit("finalize", {
-					instance: this,
-					key
-				});
-			}
-		});
-		this.#map = new Map(values ? values.map(([k, v]) => {
-			this.#registry.register(v, k, v);
-			return [k, new WeakRef(v)];
-		}) : null);
-	}
-	set(key, value) {
-		const existingRef = this.#map.get(key);
-		if (existingRef) {
-			const existingValue = existingRef.deref();
-			if (existingValue) this.#registry.unregister(existingValue);
-		}
-		this.#registry.register(value, key, value);
-		this.#map.set(key, new WeakRef(value));
-		this.#emit("set", {
-			instance: this,
-			key,
-			value
-		});
-		return this;
-	}
-	delete(key) {
-		if (!this.#map.has(key)) return false;
-		const value = this.#map.get(key)?.deref();
-		if (value === void 0) {
-			this.#map.delete(key);
-			this.#emit("finalize", {
-				instance: this,
-				key
-			});
-			return true;
-		}
-		this.#map.delete(key);
-		this.#registry.unregister(value);
-		this.#emit("delete", {
-			instance: this,
-			key,
-			value
-		});
-		return true;
-	}
-	has(key) {
-		const weakRef = this.#map.get(key);
-		const value = weakRef?.deref();
-		if (value === void 0 && weakRef) {
-			this.#map.delete(key);
-			this.#emit("finalize", {
-				instance: this,
-				key
-			});
-			this.#scheduleCleanup();
-		}
-		return value !== void 0;
-	}
-	forEach(callbackFn, thisArg) {
-		this.#map.forEach((weakRef, k) => {
-			const value = weakRef.deref();
-			if (value !== void 0) callbackFn.call(thisArg, value, k, this);
-			else {
-				this.#map.delete(k);
-				this.#emit("finalize", {
-					instance: this,
-					key: k
-				});
-			}
-		});
-		if (this.#map.size > 0) this.#scheduleCleanup();
-	}
-	get(key) {
-		const weakRef = this.#map.get(key);
-		const value = weakRef?.deref();
-		if (value === void 0 && weakRef) {
-			this.#map.delete(key);
-			this.#emit("finalize", {
-				instance: this,
-				key
-			});
-			this.#scheduleCleanup();
-		}
-		return value;
-	}
-	get size() {
-		this.#cleanup();
-		return this.#map.size;
-	}
-	*entries() {
-		for (const [k, weakRef] of this.#map.entries()) {
-			const value = weakRef.deref();
-			if (value !== void 0) yield [k, value];
-			else {
-				this.#map.delete(k);
-				this.#emit("finalize", {
-					instance: this,
-					key: k
-				});
-			}
-		}
-		if (this.#map.size > 0) this.#scheduleCleanup();
-	}
-	*keys() {
-		for (const [k, weakRef] of this.#map.entries()) if (weakRef.deref() !== void 0) yield k;
-		else {
-			this.#map.delete(k);
-			this.#emit("finalize", {
-				instance: this,
-				key: k
-			});
-		}
-		if (this.#map.size > 0) this.#scheduleCleanup();
-	}
-	*values() {
-		for (const weakRef of this.#map.values()) {
-			const value = weakRef.deref();
-			if (value !== void 0) yield value;
-		}
-		this.#cleanup();
-	}
-	*[Symbol.iterator]() {
-		yield* this.entries();
-	}
-	clear() {
-		for (const weakRef of this.#map.values()) {
-			const value = weakRef.deref();
-			if (value !== void 0) this.#registry.unregister(value);
-		}
-		this.#map.clear();
-		this.#emit("clear", { instance: this });
-	}
-	cleanup() {
-		this.#cleanup();
-	}
-	get rawSize() {
-		return this.#map.size;
-	}
-};
-
-//#endregion
-//#region src/store/ChimeraEntityRepository.ts
-var ChimeraEntityRepository = class extends ChimeraEventEmitter {
-	#entityConfig;
-	#filterConfig;
-	#orderConfig;
-	#idGetter;
-	#itemsMap;
-	#collectionQueryMap;
-	#itemQueryMap;
-	#emit(event, arg) {
-		queueMicrotask(() => super.emit(event, arg));
-	}
-	emit() {
-		throw new require_defaults.ChimeraInternalError("External events dispatching is not supported.");
-	}
-	#registerUpdate(item, skipItem) {
-		const id = this.#idGetter(item);
-		const oldItem = this.#itemsMap.get(id);
-		this.#itemsMap.set(id, item);
-		const itemQuery = this.#itemQueryMap.get(id);
-		itemQuery && skipItem !== itemQuery && itemQuery[ChimeraSetOneSym](item);
-		!oldItem && this.#emit("itemAdded", {
-			instance: this,
-			item
-		});
-		this.#emit("itemUpdated", {
-			instance: this,
-			item,
-			oldItem: oldItem ?? null
-		});
-	}
-	#registerDelete(id, skipItem) {
-		const oldItem = this.#itemsMap.get(id);
-		if (!oldItem) return;
-		this.#itemsMap.delete(id);
-		const itemQuery = this.#itemQueryMap.get(id);
-		itemQuery && skipItem !== itemQuery && itemQuery[ChimeraDeleteOneSym](id);
-		this.#emit("itemDeleted", {
-			instance: this,
-			oldItem: oldItem ?? null
-		});
-	}
-	#propagateUpdateOne(item, { item: skipItem, collection: skipCollection } = {}) {
-		this.#registerUpdate(item, skipItem);
-		for (const c of this.#collectionQueryMap.values()) c !== skipCollection && c[ChimeraSetOneSym](item);
-	}
-	#propagateDeleteOne(id, { item: skipItem, collection: skipCollection } = {}) {
-		this.#registerDelete(id, skipItem);
-		for (const c of this.#collectionQueryMap.values()) c !== skipCollection && c[ChimeraDeleteOneSym](id);
-	}
-	#propagateUpdateMany(items, { item: skipItem, collection: skipCollection } = {}) {
-		for (const item of items) this.#registerUpdate(item, skipItem);
-		this.#emit("updated", {
-			instance: this,
-			items
-		});
-		for (const c of this.#collectionQueryMap.values()) c !== skipCollection && c[ChimeraSetManySym](items);
-	}
-	#propagateDeleteMany(ids, { item: skipItem, collection: skipCollection } = {}) {
-		for (const id of ids) this.#registerDelete(id, skipItem);
-		this.#emit("deleted", {
-			ids,
-			instance: this
-		});
-		for (const c of this.#collectionQueryMap.values()) c !== skipCollection && c[ChimeraDeleteManySym](ids);
-	}
-	#itemUpdateHandler(query, item) {
-		this.#propagateUpdateOne(item, { item: query });
-	}
-	#itemDeleteHandler(query, id) {
-		this.#itemQueryMap.delete(id);
-		this.#propagateDeleteOne(id, { item: query });
-	}
-	#prepareItemQuery(query) {
-		if (query.id !== "") this.#itemQueryMap.set(query.id, query);
-		query.on("selfCreated", ({ instance }) => this.#itemQueryMap.set(instance.id, instance));
-		query.on("selfUpdated", ({ instance, item }) => this.#itemUpdateHandler(instance, item));
-		query.on("selfDeleted", ({ instance, id }) => this.#itemDeleteHandler(instance, id));
-		return query;
-	}
-	#simplifyCollectionParams(params) {
-		return {
-			filter: simplifyFilter(params.filter),
-			meta: params.meta,
-			order: simplifyOrderBy(params.order)
-		};
-	}
-	#getCollectionKey({ order, filter }) {
-		return `ORDER<${order ? this.#orderConfig.getKey(order) : ""}>\nFILTER<${filter ? this.#filterConfig.getFilterKey(filter) : ""}>`;
-	}
-	#collectionUpdateHandler(query, items) {
-		this.#propagateUpdateMany(items, { collection: query });
-	}
-	#collectionCreateHandler(query, item) {
-		this.#propagateUpdateOne(item, { collection: query });
-	}
-	#collectionItemUpdated(query, item) {
-		this.#propagateUpdateOne(item, { collection: query });
-	}
-	#collectionItemDeleted(query, id) {
-		this.#propagateDeleteOne(id, { collection: query });
-	}
-	#prepareCollectionQuery(query) {
-		this.#collectionQueryMap.set(this.#getCollectionKey(query[ChimeraGetParamsSym]), query);
-		query.on("selfUpdated", ({ instance, items }) => this.#collectionUpdateHandler(instance, items));
-		query.on("selfItemCreated", ({ instance, item }) => this.#collectionCreateHandler(instance, item));
-		query.on("selfItemUpdated", ({ instance, item }) => this.#collectionItemUpdated(instance, item));
-		query.on("selfItemDeleted", ({ instance, id }) => this.#collectionItemDeleted(instance, id));
-		return query;
-	}
-	#getParentQuery(filter) {
-		for (const q of this.#collectionQueryMap.values()) if (q.ready && isFilterSubset(q[ChimeraGetParamsSym].filter, filter, this.#filterConfig.getOperatorKey)) return q;
-		return null;
-	}
-	constructor(config, filterConfig, orderConfig) {
-		super();
-		this.#entityConfig = config;
-		this.#filterConfig = filterConfig;
-		this.#orderConfig = orderConfig;
-		this.#idGetter = config.idGetter;
-		this.#itemsMap = new ChimeraWeakValueMap();
-		this.#collectionQueryMap = new ChimeraWeakValueMap();
-		this.#itemQueryMap = new ChimeraWeakValueMap();
-		this.#emit("initialized", { instance: this });
-	}
-	[ChimeraSetOneSym](item) {
-		this.#propagateUpdateOne(item);
-	}
-	[ChimeraDeleteOneSym](id) {
-		this.#propagateDeleteOne(id);
-	}
-	[ChimeraSetManySym](items) {
-		this.#propagateUpdateMany(items);
-	}
-	[ChimeraDeleteManySym](ids) {
-		this.#propagateDeleteMany(ids);
-	}
-	[ChimeraUpdateMixedSym](toAdd, toDelete) {
-		this.#propagateUpdateMany(toAdd);
-		this.#propagateDeleteMany(toDelete);
-	}
-	createItem(item, meta) {
-		return this.#prepareItemQuery(new ChimeraItemQuery(this.#entityConfig, {
-			id: "",
-			meta
-		}, null, item));
-	}
-	getItem(id, meta) {
-		const query = this.#itemQueryMap.get(id);
-		if (query) return query;
-		return this.#prepareItemQuery(new ChimeraItemQuery(this.#entityConfig, {
-			id,
-			meta
-		}, this.#itemsMap.get(id) ?? null, null));
-	}
-	getCollection(params) {
-		const simplifiedParams = this.#simplifyCollectionParams(params);
-		const key = this.#getCollectionKey(simplifiedParams);
-		const query = this.#collectionQueryMap.get(key);
-		if (query) return query;
-		return this.#prepareCollectionQuery(new ChimeraCollectionQuery(this.#entityConfig, simplifiedParams, this.#getParentQuery(simplifiedParams.filter), buildComparator(this.#orderConfig.primitiveComparator, params.order), compileFilter(this.#filterConfig, params.filter), false));
-	}
-};
-
-//#endregion
-//#region src/store/ChimeraStore.ts
-const resolveIdGetter = (key, def, val) => {
-	if (val) return typeof val === "function" ? val : (v) => v[val];
-	return typeof def === "function" ? (v) => def(key, v) : (v) => v[def];
-};
-var ChimeraStore = class extends ChimeraEventEmitter {
-	#reposMap;
-	#queryConfig;
-	#filterConfig;
-	#orderConfig;
-	#debugConfig;
-	#initialConfig;
-	#emit(event, arg) {
-		queueMicrotask(() => super.emit(event, arg));
-	}
-	emit() {
-		throw new require_defaults.ChimeraInternalError("External events dispatching is not supported.");
-	}
-	#addRepository(entityName) {
-		const repo = this.#reposMap[entityName] = new ChimeraEntityRepository(this.#queryConfig[entityName], this.#filterConfig, this.#orderConfig);
-		repo.once("initialized", (e) => this.#emit("repositoryInitialized", {
-			entityName,
-			instance: this,
-			repository: e.instance
-		}));
-		return repo;
-	}
-	constructor(config) {
-		super();
-		this.#initialConfig = deepObjectFreeze(deepObjectClone(config));
-		const { query: queryConfig, order: orderConfig, filter: filterConfig, debug: debugConfig } = config;
-		this.#filterConfig = deepObjectAssign(deepObjectClone(require_defaults.chimeraDefaultFilterConfig), filterConfig ?? {});
-		this.#orderConfig = deepObjectAssign(deepObjectClone(require_defaults.chimeraDefaultOrderConfig), orderConfig ?? {});
-		this.#debugConfig = deepObjectAssign(deepObjectClone(require_defaults.chimeraDefaultDebugConfig), debugConfig ?? {});
-		const query = deepObjectAssign(deepObjectClone(require_defaults.chimeraDefaultQueryConfig), queryConfig?.defaults ?? {});
-		this.#queryConfig = Object.fromEntries(Object.entries(queryConfig?.entities ?? require_defaults.chimeraDefaultQueryConfig.entities).map(([key, value]) => [key, {
-			batchedCreator: value.batchedCreator ? value.batchedCreator : (...args) => query.batchedCreator(key, ...args),
-			batchedDeleter: value.batchedDeleter ? value.batchedDeleter : (...args) => query.batchedDeleter(key, ...args),
-			batchedUpdater: value.batchedUpdater ? value.batchedUpdater : (...args) => query.batchedUpdater(key, ...args),
-			collectionFetcher: value.collectionFetcher ? value.collectionFetcher : (...args) => query.collectionFetcher(key, ...args),
-			devMode: this.#debugConfig.devMode,
-			idGetter: resolveIdGetter(key, query.idGetter, value.idGetter),
-			itemCreator: value.itemCreator ? value.itemCreator : (...args) => query.itemCreator(key, ...args),
-			itemDeleter: value.itemDeleter ? value.itemDeleter : (...args) => query.itemDeleter(key, ...args),
-			itemFetcher: value.itemFetcher ? value.itemFetcher : (...args) => query.itemFetcher(key, ...args),
-			itemUpdater: value.itemUpdater ? value.itemUpdater : (...args) => query.itemUpdater(key, ...args),
-			name: key,
-			trustQuery: value.trustQuery ?? query.trustQuery,
-			updateDebounceTimeout: value.updateDebounceTimeout ?? query.updateDebounceTimeout
-		}]));
-		this.#reposMap = {};
-		this.#emit("initialized", { instance: this });
-	}
-	get config() {
-		return this.#initialConfig;
-	}
-	from(entityName) {
-		return this.#reposMap[entityName] ?? this.#addRepository(entityName);
-	}
-	updateOne(entityName, item) {
-		const repo = this.#reposMap[entityName];
-		if (repo) {
-			repo[ChimeraSetOneSym](item);
-			this.#emit("itemUpdated", {
-				entityName,
-				instance: this,
-				item,
-				repository: repo
-			});
-		}
-	}
-	updateMany(entityName, items) {
-		const repo = this.#reposMap[entityName];
-		if (repo) {
-			repo[ChimeraSetManySym](items);
-			this.#emit("updated", {
-				entityName,
-				instance: this,
-				items,
-				repository: repo
-			});
-		}
-	}
-	deleteOne(entityName, id) {
-		const repo = this.#reposMap[entityName];
-		if (repo) {
-			repo[ChimeraDeleteOneSym](id);
-			this.#emit("itemDeleted", {
-				entityName,
-				id,
-				instance: this,
-				repository: repo
-			});
-		}
-	}
-	deleteMany(entityName, ids) {
-		const repo = this.#reposMap[entityName];
-		if (repo) {
-			repo[ChimeraDeleteManySym](ids);
-			this.#emit("deleted", {
-				entityName,
-				ids,
-				instance: this,
-				repository: repo
-			});
-		}
-	}
-	updateMixed(entityName, toAdd, toDelete) {
-		const repo = this.#reposMap[entityName];
-		if (repo) {
-			repo[ChimeraUpdateMixedSym](toAdd, toDelete);
-			this.#emit("deleted", {
-				entityName,
-				ids: toDelete,
-				instance: this,
-				repository: repo
-			});
-			this.#emit("updated", {
-				entityName,
-				instance: this,
-				items: toAdd,
-				repository: repo
-			});
-		}
-	}
-};
-
-//#endregion
-Object.defineProperty(exports, 'ChimeraCollectionQuery', {
-  enumerable: true,
-  get: function () {
-    return ChimeraCollectionQuery;
-  }
-});
-Object.defineProperty(exports, 'ChimeraFilterError', {
-  enumerable: true,
-  get: function () {
-    return ChimeraFilterError;
-  }
-});
-Object.defineProperty(exports, 'ChimeraFilterOperatorError', {
-  enumerable: true,
-  get: function () {
-    return ChimeraFilterOperatorError;
-  }
-});
-Object.defineProperty(exports, 'ChimeraFilterOperatorNotFoundError', {
-  enumerable: true,
-  get: function () {
-    return ChimeraFilterOperatorNotFoundError;
-  }
-});
-Object.defineProperty(exports, 'ChimeraItemQuery', {
-  enumerable: true,
-  get: function () {
-    return ChimeraItemQuery;
-  }
-});
-Object.defineProperty(exports, 'ChimeraOrderNulls', {
-  enumerable: true,
-  get: function () {
-    return ChimeraOrderNulls;
-  }
-});
-Object.defineProperty(exports, 'ChimeraQueryFetchingState', {
-  enumerable: true,
-  get: function () {
-    return ChimeraQueryFetchingState;
-  }
-});
-Object.defineProperty(exports, 'ChimeraStore', {
-  enumerable: true,
-  get: function () {
-    return ChimeraStore;
-  }
-});
-Object.defineProperty(exports, 'ChimeraWeakValueMap', {
-  enumerable: true,
-  get: function () {
-    return ChimeraWeakValueMap;
-  }
-});
-Object.defineProperty(exports, 'chimeraCreateConjunction', {
-  enumerable: true,
-  get: function () {
-    return chimeraCreateConjunction;
-  }
-});
-Object.defineProperty(exports, 'chimeraCreateNot', {
-  enumerable: true,
-  get: function () {
-    return chimeraCreateNot;
-  }
-});
-Object.defineProperty(exports, 'chimeraCreateOperator', {
-  enumerable: true,
-  get: function () {
-    return chimeraCreateOperator;
-  }
-});
-Object.defineProperty(exports, 'chimeraCreateOrderBy', {
-  enumerable: true,
-  get: function () {
-    return chimeraCreateOrderBy;
-  }
-});
-Object.defineProperty(exports, 'chimeraIsConjunction', {
-  enumerable: true,
-  get: function () {
-    return chimeraIsConjunction;
-  }
-});
-Object.defineProperty(exports, 'chimeraIsOperator', {
-  enumerable: true,
-  get: function () {
-    return chimeraIsOperator;
-  }
-});
-//# sourceMappingURL=src-TJG6k3Nr.cjs.map