entropic-bond 1.57.1 → 1.59.0

package/lib/entropic-bond.js

@@ -1,1885 +1,1219 @@
-class I {
-  constructor() {
-    this.subscribers = /* @__PURE__ */ new Set();
-  }
-  /**
-   * Subscribes a listener callback function. On every notification, 
-   * the listener callback will be called with an event as a parameter if sent.
-   * 
-   * @param callback the listener callback
-   * @returns a function to unsubscribe the listener from further notifications
-   */
-  subscribe(e) {
-    return this.subscribers.add(e), () => this.unsubscribe(e);
-  }
-  /**
-   * Removes the callback from the notification list.
-   * 
-   * @param listenerCallback the listener callback to remove
-   */
-  unsubscribe(e) {
-    this.subscribers.delete(e);
-  }
-  /**
-   * Notifies all the subscribers with the event passed as parameter.
-   * 
-   * @param event the event passed to all subscribers.
-   */
-  notify(e) {
-    this.subscribers.forEach((t) => t(e));
-  }
-  /**
-   * Returns the number of subscribers.
-   * 
-   * @returns the number of subscribers
-   * @example
-   * const observable = new Observable<number>()
-   * observable.subscribe( event => console.log( event ) )
-   * observable.subscribe( event => console.log( event ) )
-   * observable.subscribe( event => console.log( event ) )
-   * console.log( observable.subscribersCount ) // 3
-   */
-  get subscribersCount() {
-    return this.subscribers.size;
-  }
+//#region src/observable/observable.ts
+var e = class {
+	constructor() {
+		this.subscribers = /* @__PURE__ */ new Set();
+	}
+	subscribe(e) {
+		return this.subscribers.add(e), () => this.unsubscribe(e);
+	}
+	unsubscribe(e) {
+		this.subscribers.delete(e);
+	}
+	notify(e) {
+		this.subscribers.forEach((t) => t(e));
+	}
+	get subscribersCount() {
+		return this.subscribers.size;
+	}
+}, t = [];
+for (let e = 0; e < 256; ++e) t.push((e + 256).toString(16).slice(1));
+function n(e, n = 0) {
+	return (t[e[n + 0]] + t[e[n + 1]] + t[e[n + 2]] + t[e[n + 3]] + "-" + t[e[n + 4]] + t[e[n + 5]] + "-" + t[e[n + 6]] + t[e[n + 7]] + "-" + t[e[n + 8]] + t[e[n + 9]] + "-" + t[e[n + 10]] + t[e[n + 11]] + t[e[n + 12]] + t[e[n + 13]] + t[e[n + 14]] + t[e[n + 15]]).toLowerCase();
 }
-const m = [];
-for (let i = 0; i < 256; ++i)
-  m.push((i + 256).toString(16).slice(1));
-function Y(i, e = 0) {
-  return (m[i[e + 0]] + m[i[e + 1]] + m[i[e + 2]] + m[i[e + 3]] + "-" + m[i[e + 4]] + m[i[e + 5]] + "-" + m[i[e + 6]] + m[i[e + 7]] + "-" + m[i[e + 8]] + m[i[e + 9]] + "-" + m[i[e + 10]] + m[i[e + 11]] + m[i[e + 12]] + m[i[e + 13]] + m[i[e + 14]] + m[i[e + 15]]).toLowerCase();
+//#endregion
+//#region node_modules/uuid/dist/rng.js
+var r, i = new Uint8Array(16);
+function a() {
+	if (!r) {
+		if (typeof crypto > "u" || !crypto.getRandomValues) throw Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
+		r = crypto.getRandomValues.bind(crypto);
+	}
+	return r(i);
 }
-let F;
-const z = new Uint8Array(16);
-function J() {
-  if (!F) {
-    if (typeof crypto > "u" || !crypto.getRandomValues)
-      throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
-    F = crypto.getRandomValues.bind(crypto);
-  }
-  return F(z);
+var o = { randomUUID: typeof crypto < "u" && crypto.randomUUID && crypto.randomUUID.bind(crypto) };
+//#endregion
+//#region node_modules/uuid/dist/v4.js
+function s(e, t, r) {
+	e ||= {};
+	let i = e.random ?? e.rng?.() ?? a();
+	if (i.length < 16) throw Error("Random bytes length must be >= 16");
+	if (i[6] = i[6] & 15 | 64, i[8] = i[8] & 63 | 128, t) {
+		if (r ||= 0, r < 0 || r + 16 > t.length) throw RangeError(`UUID byte range ${r}:${r + 15} is out of buffer bounds`);
+		for (let e = 0; e < 16; ++e) t[r + e] = i[e];
+		return t;
+	}
+	return n(i);
 }
-const H = typeof crypto < "u" && crypto.randomUUID && crypto.randomUUID.bind(crypto), M = { randomUUID: H };
-function Z(i, e, t) {
-  i = i || {};
-  const r = i.random ?? i.rng?.() ?? J();
-  if (r.length < 16)
-    throw new Error("Random bytes length must be >= 16");
-  return r[6] = r[6] & 15 | 64, r[8] = r[8] & 63 | 128, Y(r);
+function c(e, t, n) {
+	return o.randomUUID && !t && !e ? o.randomUUID() : s(e, t, n);
 }
-function G(i, e, t) {
-  return M.randomUUID && !i ? M.randomUUID() : Z(i);
+//#endregion
+//#region \0@oxc-project+runtime@0.127.0/helpers/decorate.js
+function l(e, t, n, r) {
+	var i = arguments.length, a = i < 3 ? t : r === null ? r = Object.getOwnPropertyDescriptor(t, n) : r, o;
+	if (typeof Reflect == "object" && typeof Reflect.decorate == "function") a = Reflect.decorate(e, t, n, r);
+	else for (var s = e.length - 1; s >= 0; s--) (o = e[s]) && (a = (i < 3 ? o(a) : i > 3 ? o(t, n, a) : o(t, n)) || a);
+	return i > 3 && a && Object.defineProperty(t, n, a), a;
 }
-var K = Object.defineProperty, X = (i, e, t, r) => {
-  for (var s = void 0, n = i.length - 1, o; n >= 0; n--)
-    (o = i[n]) && (s = o(e, t, s) || s);
-  return s && K(e, t, s), s;
-}, l;
-const W = (l = class {
-  /**
-   * Registers a class to be used by the persistence engine.
-   * @param className the name of the class to be registered
-   * @param factory the constructor of the registered class
-   * @param annotation an annotation associated with the class
-   */
-  static registerFactory(e, t, r, s = !1) {
-    this._factoryMap[e] = { factory: t, annotation: r, isLegacy: s };
-  }
-  /**
-   * Returns the constructor of a registered class
-   * @param className the name of the class to be retrieved
-   * @returns the constructor of the class
-   * @throws an error if the class is not registered
-   * @see registerFactory
-   * @see registeredClasses
-   * @see classesExtending
-   * @see annotations
-   */
-  static classFactory(e) {
-    if (!e) throw new Error("You should provide a class name.");
-    if (!this._factoryMap[e]) throw new Error(`You should register class ${e} prior to use.`);
-    return this._factoryMap[e].factory;
-  }
-  /**
-   * Returns the names of all registered classes
-   * @returns the names of all registered classes
-   * @see registerFactory
-   * @see classFactory
-   */
-  static registeredClasses() {
-    return Object.entries(this._factoryMap).filter(([, e]) => !e.isLegacy).map(([e]) => e);
-  }
-  /**
-   * Returns the names of all registered classes, including legacy names
-   * @returns the names of all registered classes, including legacy names
-   * @see registerFactory
-   * @see classFactory
-   */
-  static registeredClassesAndLegacyNames() {
-    return Object.keys(this._factoryMap);
-  }
-  /**
-   * Returns the names of all registered classes that extend a given class
-   * @param derivedFrom the parent class to be queried
-   * @returns the names of all registered classes that extend the given class
-   * @see registerFactory
-   * @see classFactory
-   */
-  static classesExtending(e) {
-    return Object.entries(this._factoryMap).filter(([, t]) => new t.factory() instanceof e && !t.isLegacy).map(([t]) => t);
-  }
-  /**
-   * Returns the annotation associated with a registered class
-   * @param className the name of the class to be retrieved
-   * @returns the annotation associated with the class
-   * @throws an error if the class is not registered
-   * @see registerFactory
-   */
-  static annotations(e) {
-    if (e instanceof l ? e = e.className : typeof e == "string" || (e = new e().className), !this._factoryMap[e]) throw new Error(`You should register class ${e} prior to use.`);
-    return this._factoryMap[e].annotation;
-  }
-  /**
-   * Returns a new instance of Persistent class.
-   * @param className the initial id of this instance. If not provided, a new id will be generated
-   */
-  constructor(e = G()) {
-    this._id = e;
-  }
-  /**
-   * Gets the class name of this instance.
-   */
-  get className() {
-    return this.__className;
-  }
-  /**
-   * Sets the id of this instance.
-   * @param value the id of this instance
-   */
-  setId(e) {
-    this._id = e;
-  }
-  /**
-   * Returns the id of this instance.
-   * @returns the id of this instance
-   */
-  get id() {
-    return this._id;
-  }
-  /**
-   * This method is called by the persistence engine when the instance has been
-   * just serialized. It is called after the properties are initialized with 
-   * serialized data.
-   */
-  afterDeserialize() {
-  }
-  /**
-   * This method is called by the persistence engine before the instance is
-   * serialized. 
-   */
-  beforeSerialize() {
-  }
-  /**
-   * Returns an array of the persistent properties of this instance.
-   * @returns an array of the persistent properties of this instance
-   */
-  getPersistentProperties() {
-    return this._persistentProperties ? this._persistentProperties.map((e) => ({
-      ...e,
-      name: e.name.slice(1)
-    })) : [];
-  }
-  /**
-   * Get the property information of this instance
-   * @param propName the persistent property name
-   * @returns the property information
-   */
-  getPropInfo(e) {
-    const t = this.getPersistentProperties().find((r) => r.name === e);
-    if (!t) throw new Error(`Property "${e}" has not been registered.`);
-    return t;
-  }
-  /**
-   * Query if the property is required
-   * To mark a property as required, use the @required decorator
-   * @param propName the persistent property name
-   * @returns true if the property is required
-   * @see required
-   */
-  isRequired(e) {
-    const t = this.getPropInfo(e).validator;
-    return t != null;
-  }
-  /**
-   * Query if the property value is valid
-   * Define the validator function using the @required decorator
-   * @param propName the persistent property name
-   * @returns true if the property value is valid using the validator function
-   * passed to the @required decorator
-   * @see required
-   */
-  isPropValueValid(e) {
-    const t = this.getPropInfo(e);
-    return t.validator ? t.validator(this[t.name], t, this) : !0;
-  }
-  /**
-   * Copy the persistent properties of the given instance to this instance. 
-   * The property `id` will be ignored.
-   * Only the properties that are not null or undefined will be copied.
-   * @param instance the instance to be copied
-   * @returns this instance
-   * @see fromObject
-   * @see toObject
-   */
-  clone(e) {
-    const t = e.toObject();
-    return delete t.id, this.fromObject(t);
-  }
-  /**
-   * Initializes the persistent properties of this instance from the properties 
-   * of given object.
-   * @param obj the object to be copied
-   * @returns this instance
-   * @see clone
-   * @see toObject
-   */
-  fromObject(e) {
-    return this.fromObj(e), this.afterDeserialize(), this;
-  }
-  fromObj(e) {
-    return this._persistentProperties ? (this._persistentProperties.forEach((t) => {
-      const r = this.removeUnderscore(t), s = e[r];
-      s != null && (this[t.name] = this.fromDeepObject(s));
-    }), this) : this;
-  }
-  /**
-   * Returns a plain object representation of this instance.
-   * Only the properties that are not null or undefined will be copied.
-   * @returns a plain object representation of this instance
-   * @see fromObject
-   * @see clone
-   */
-  toObject() {
-    const e = {}, t = this.toObj(e);
-    return this.pushDocument(e, this.className, t), {
-      ...t,
-      __rootCollections: e
-    };
-  }
-  toObj(e) {
-    if (!this._persistentProperties) return {};
-    this.beforeSerialize();
-    const t = {};
-    if (!this.className) throw new Error(`You should register \`${this.constructor.name || this.toString() || "this"}\` class prior to streaming it.`);
-    return this._persistentProperties.forEach((r) => {
-      const s = this[r.name], n = this.removeUnderscore(r);
-      s != null && (r.isReference ? t[n] = this.toReferenceObj(r, e) : t[n] = this.toDeepObj(s, e), r.searchableArray && (t[l.searchableArrayNameFor(n)] = s.map((o) => o.id)));
-    }), t.__className = this.className, t;
-  }
-  static searchableArrayNameFor(e) {
-    return `__${e}_searchable`;
-  }
-  fromDeepObject(e) {
-    if (e == null) return e;
-    if (Array.isArray(e))
-      return e.map((t) => this.fromDeepObject(t));
-    if (e.__documentReference) {
-      const t = e, r = l.createInstance(t);
-      return r.__documentReference = e.__documentReference, r;
-    }
-    if (e.__className)
-      return l.createInstance(e);
-    if (typeof e == "object") {
-      const t = {};
-      return Object.entries(e).forEach(
-        ([r, s]) => t[r] = this.fromDeepObject(s)
-      ), t;
-    }
-    return e;
-  }
-  toDeepObj(e, t) {
-    if (e != null) {
-      if (Array.isArray(e))
-        return e.map((r) => this.toDeepObj(r, t));
-      if (e.__documentReference) return e;
-      if (e instanceof l)
-        return e.toObj(t);
-      if (typeof e == "object") {
-        const r = {};
-        return Object.entries(e).forEach(
-          ([s, n]) => r[s] = this.toDeepObj(n, t)
-        ), r;
-      }
-      return e;
-    }
-  }
-  static collectionPath(e, t, r) {
-    let s;
-    return typeof t.storeInCollection == "function" ? s = t.storeInCollection(e, t, r) : s = t.storeInCollection ?? e.className, s;
-  }
-  toReferenceObj(e, t) {
-    const r = this[e.name];
-    return Array.isArray(r) ? r.map((s) => (e.isPureReference || this.pushDocument(t, l.collectionPath(s, e), s), this.buildRefObject(s, l.collectionPath(s, e), e.cachedProps))) : (e.isPureReference || this.pushDocument(t, l.collectionPath(r, e), r), this.buildRefObject(r, l.collectionPath(r, e), e.cachedProps));
-  }
-  buildRefObject(e, t, r) {
-    const s = r?.reduce((n, o) => (e[o] !== void 0 && (n[o] = e[o]), n), {});
-    return {
-      id: e.id,
-      __className: e.className || e.__className,
-      __documentReference: {
-        storedInCollection: t
-      },
-      ...s
-    };
-  }
-  pushDocument(e, t, r) {
-    if ("__documentReference" in r && r.__documentReference) return;
-    e[t] || (e[t] = []);
-    const s = this.toDeepObj(r, e);
-    e[t].push(s);
-  }
-  removeUnderscore(e) {
-    return e.name.slice(1);
-  }
-  static createReference(e) {
-    const t = l.createInstance(e);
-    return t.__documentReference = e.__documentReference || { storedInCollection: t.className }, t;
-  }
-  static createInstance(e) {
-    if (typeof e == "string")
-      return new (l.classFactory(e))();
-    try {
-      return new (l.classFactory(e.__className))().fromObject(e);
-    } catch (t) {
-      const r = Object.entries(e).filter(([s, n]) => n != null && typeof n != "function").map(([s, n]) => `${s}: ${n}`).join(`,
-	`);
-      throw new Error(`${t}
------> Class name not found in object:
-{
-	 ${r} 
-}
-`);
-    }
-  }
-  static propInfo(e, t) {
-    return l.createInstance(e).getPropInfo(t);
-  }
-  /**
-   * Return the type of a persistent property.
-   * Several strategies are used to determine the type:
-   * - If the typeName is defined in the property info a decorator, it is used
-   * - If the property value is an array, the type of the first element is used
-   * - If the property value is a Persistent instance, its class name is used
-   * - Otherwise, the typeof operator is used to determine the type
-   * @param propInfo the persistent property info to retrieve the type
-   * @returns the type of the property or the type of the first element if the property is an array or undefined if cannot be determined
-   */
-  static propType(e) {
-    if (e.typeName) return Array.isArray(e.typeName) ? "undefined[]" : e.typeName ?? "undefined";
-    const r = l.createInstance(e.ownerClassName())[e.name];
-    if (Array.isArray(r)) {
-      if (r.length === 0) return "undefined[]";
-      const s = r[0];
-      return s instanceof l ? s.className + "[]" : typeof s + "[]";
-    } else
-      return r instanceof l ? r.className : typeof r;
-  }
-  /**
-   * Retrieves a collection of references with the properties that are stored in the reference object
-   * @returns the references collection
-   */
-  static getSystemRegisteredReferencesWithCachedProps() {
-    return l.registeredClasses().reduce((r, s) => {
-      const o = l.createInstance(s).getPersistentProperties().filter(
-        (a) => a.cachedProps
-      );
-      return o.length > 0 && (r[s] = o), r;
-    }, {});
-  }
-}, l._factoryMap = {}, l);
-X([
-  j
-], W.prototype, "_id");
-let d = W;
-function j(i, e) {
-  return _()(i, e);
-}
-function ce(i) {
-  return function(e, t) {
-    return _({
-      storeInCollection: i,
-      isReference: !0
-    })(e, t);
-  };
-}
-function ue(i, e) {
-  return _({ isReference: !0 })(i, e);
-}
-function he(i, e, t, r) {
-  return function(s, n) {
-    const o = {
-      isReference: !0,
-      storeInCollection: t,
-      typeName: e,
-      cachedProps: i,
-      ownerCollection: r ?? s.className
-    };
-    return _(o)(s, n);
-  };
-}
-function le(i, e, t) {
-  return _({ isReference: !0, isPureReference: !0, storeInCollection: t })(i, e);
+//#endregion
+//#region src/persistent/persistent.ts
+var u = class e {
+	static registerFactory(e, t, n, r = !1) {
+		this._factoryMap[e] = {
+			factory: t,
+			annotation: n,
+			isLegacy: r
+		};
+	}
+	static classFactory(e) {
+		if (!e) throw Error("You should provide a class name.");
+		if (!this._factoryMap[e]) throw Error(`You should register class ${e} prior to use.`);
+		return this._factoryMap[e].factory;
+	}
+	static registeredClasses() {
+		return Object.entries(this._factoryMap).filter(([, e]) => !e.isLegacy).map(([e]) => e);
+	}
+	static registeredClassesAndLegacyNames() {
+		return Object.keys(this._factoryMap);
+	}
+	static classesExtending(e) {
+		return Object.entries(this._factoryMap).filter(([, t]) => new t.factory() instanceof e && !t.isLegacy).map(([e]) => e);
+	}
+	static isInstanceOf(t, n) {
+		let r = e.classFactory(n);
+		return t instanceof e ? t instanceof r : e.createInstance(t) instanceof r;
+	}
+	static annotations(t) {
+		if (t instanceof e ? t = t.className : typeof t == "string" || (t = new t().className), !this._factoryMap[t]) throw Error(`You should register class ${t} prior to use.`);
+		return this._factoryMap[t].annotation;
+	}
+	constructor(e = c()) {
+		this._id = e;
+	}
+	get className() {
+		return this.__className;
+	}
+	setId(e) {
+		this._id = e;
+	}
+	get id() {
+		return this._id;
+	}
+	afterDeserialize() {}
+	beforeSerialize() {}
+	getPersistentProperties() {
+		return this._persistentProperties ? this._persistentProperties.map((e) => ({
+			...e,
+			name: e.name.slice(1)
+		})) : [];
+	}
+	getPropInfo(e) {
+		let t = this.getPersistentProperties().find((t) => t.name === e);
+		if (!t) throw Error(`Property "${e}" has not been registered.`);
+		return t;
+	}
+	isRequired(e) {
+		return this.getPropInfo(e).validator != null;
+	}
+	isPropValueValid(e) {
+		let t = this.getPropInfo(e);
+		return t.validator ? t.validator(this[t.name], t, this) : !0;
+	}
+	clone(e) {
+		let t = e.toObject();
+		return delete t.id, this.fromObject(t);
+	}
+	fromObject(e) {
+		return this.fromObj(e), this.afterDeserialize(), this;
+	}
+	fromObj(e) {
+		return this._persistentProperties && this._persistentProperties.forEach((t) => {
+			let n = e[this.removeUnderscore(t)];
+			n != null && (this[t.name] = this.fromDeepObject(n));
+		}), this;
+	}
+	toObject() {
+		let e = {}, t = this.toObj(e);
+		return this.pushDocument(e, this.className, t), {
+			...t,
+			__rootCollections: e
+		};
+	}
+	toObj(t) {
+		if (!this._persistentProperties) return {};
+		this.beforeSerialize();
+		let n = {};
+		if (!this.className) throw Error(`You should register \`${this.constructor.name || this.toString() || "this"}\` class prior to streaming it.`);
+		return this._persistentProperties.forEach((r) => {
+			let i = this[r.name], a = this.removeUnderscore(r);
+			i != null && (r.isReference ? n[a] = this.toReferenceObj(r, t) : n[a] = this.toDeepObj(i, t), r.searchableArray && (n[e.searchableArrayNameFor(a)] = i.map((e) => e.id)));
+		}), n.__className = this.className, n;
+	}
+	static searchableArrayNameFor(e) {
+		return `__${e}_searchable`;
+	}
+	fromDeepObject(t) {
+		if (t == null) return t;
+		if (Array.isArray(t)) return t.map((e) => this.fromDeepObject(e));
+		if (t.__documentReference) {
+			let n = t, r = e.createInstance(n);
+			return r.__documentReference = t.__documentReference, r;
+		}
+		if (t.__className) return e.createInstance(t);
+		if (typeof t == "object") {
+			let e = {};
+			return Object.entries(t).forEach(([t, n]) => e[t] = this.fromDeepObject(n)), e;
+		}
+		return t;
+	}
+	toDeepObj(t, n) {
+		if (t != null) {
+			if (Array.isArray(t)) return t.map((e) => this.toDeepObj(e, n));
+			if (t.__documentReference) return t;
+			if (t instanceof e) return t.toObj(n);
+			if (typeof t == "object") {
+				let e = {};
+				return Object.entries(t).forEach(([t, r]) => e[t] = this.toDeepObj(r, n)), e;
+			}
+			return t;
+		}
+	}
+	static collectionPath(e, t, n) {
+		let r;
+		return r = typeof t.storeInCollection == "function" ? t.storeInCollection(e, t, n) : t.storeInCollection ?? e.className, r;
+	}
+	toReferenceObj(t, n) {
+		let r = this[t.name];
+		return Array.isArray(r) ? r.map((r) => (t.isPureReference || this.pushDocument(n, e.collectionPath(r, t), r), this.buildRefObject(r, e.collectionPath(r, t), t.cachedProps))) : (t.isPureReference || this.pushDocument(n, e.collectionPath(r, t), r), this.buildRefObject(r, e.collectionPath(r, t), t.cachedProps));
+	}
+	buildRefObject(e, t, n) {
+		let r = n?.reduce((t, n) => (e[n] !== void 0 && (t[n] = e[n]), t), {});
+		return {
+			id: e.id,
+			__className: e.className || e.__className,
+			__documentReference: { storedInCollection: t },
+			...r
+		};
+	}
+	pushDocument(e, t, n) {
+		if ("__documentReference" in n && n.__documentReference) return;
+		e[t] || (e[t] = []);
+		let r = this.toDeepObj(n, e);
+		e[t].push(r);
+	}
+	removeUnderscore(e) {
+		return e.name.slice(1);
+	}
+	static createReference(t) {
+		let n = e.createInstance(t);
+		return n.__documentReference = t.__documentReference || { storedInCollection: n.className }, n;
+	}
+	static createInstance(t) {
+		if (typeof t == "string") return new (e.classFactory(t))();
+		try {
+			return new (e.classFactory(t.__className))().fromObject(t);
+		} catch (e) {
+			let n = Object.entries(t).filter(([e, t]) => t != null && typeof t != "function").map(([e, t]) => `${e}: ${t}`).join(",\n	");
+			throw Error(`${e}\n-----> Class name not found in object:\n{\n\t ${n} \n}\n`);
+		}
+	}
+	static propInfo(t, n) {
+		return e.createInstance(t).getPropInfo(n);
+	}
+	static propType(t) {
+		if (t.typeName) return Array.isArray(t.typeName) ? "undefined[]" : t.typeName ?? "undefined";
+		let n = e.createInstance(t.ownerClassName())[t.name];
+		if (Array.isArray(n)) {
+			if (n.length === 0) return "undefined[]";
+			let t = n[0];
+			return t instanceof e ? t.className + "[]" : typeof t + "[]";
+		} else if (n instanceof e) return n.className;
+		else return typeof n;
+	}
+	static getSystemRegisteredReferencesWithCachedProps() {
+		return e.registeredClasses().reduce((t, n) => {
+			let r = e.createInstance(n).getPersistentProperties().filter((e) => e.cachedProps);
+			return r.length > 0 && (t[n] = r), t;
+		}, {});
+	}
+	static {
+		this._factoryMap = {};
+	}
+};
+l([d], u.prototype, "_id", void 0);
+function d(e, t) {
+	return _()(e, t);
 }
-function de(i, e, t, r) {
-  return function(s, n) {
-    return _({
-      isReference: !0,
-      isPureReference: !0,
-      storeInCollection: t,
-      ownerCollection: r,
-      typeName: e,
-      cachedProps: i
-    })(s, n);
-  };
+function f(e) {
+	return function(t, n) {
+		return _({
+			storeInCollection: e,
+			isReference: !0
+		})(t, n);
+	};
 }
-function _(i) {
-  return function(e, t) {
-    Object.getOwnPropertyDescriptor(e, "_persistentProperties") || (e._persistentProperties ? e._persistentProperties = [...e._persistentProperties] : e._persistentProperties = []);
-    const r = e._persistentProperties.find((s) => s.name === t);
-    r ? Object.assign(r, i) : e._persistentProperties.push({
-      name: t,
-      ownerClassName: () => e.className,
-      ...i
-    });
-  };
+function p(e, t) {
+	return _({ isReference: !0 })(e, t);
 }
-function ee(i, e) {
-  return (t) => {
-    d.registerFactory(i, t, e), t.prototype.__className = i;
-  };
+function m(e, t, n, r) {
+	return function(i, a) {
+		return _({
+			isReference: !0,
+			storeInCollection: n,
+			typeName: t,
+			cachedProps: e,
+			ownerCollection: r ?? i.className
+		})(i, a);
+	};
 }
-function fe(i) {
-  return (e) => {
-    d.registerFactory(i, e, void 0, !0);
-  };
+function h(e, t, n) {
+	return _({
+		isReference: !0,
+		isPureReference: !0,
+		storeInCollection: n
+	})(e, t);
 }
-function me(i, e) {
-  return _({ searchableArray: !0 })(i, e);
+function g(e, t, n, r) {
+	return function(i, a) {
+		return _({
+			isReference: !0,
+			isPureReference: !0,
+			storeInCollection: n,
+			ownerCollection: r,
+			typeName: t,
+			cachedProps: e
+		})(i, a);
+	};
 }
-function pe(i, e) {
-  return _({ validator: (t) => t != null })(i, e);
+function _(e) {
+	return function(t, n) {
+		Object.getOwnPropertyDescriptor(t, "_persistentProperties") || (t._persistentProperties ? t._persistentProperties = [...t._persistentProperties] : t._persistentProperties = []);
+		let r = t._persistentProperties.find((e) => e.name === n);
+		r ? Object.assign(r, e) : t._persistentProperties.push({
+			name: n,
+			ownerClassName: () => t.className,
+			...e
+		});
+	};
 }
-function ge(i = (e) => e != null) {
-  return function(e, t) {
-    return _({ validator: i })(e, t);
-  };
+function v(e, t) {
+	return (n) => {
+		u.registerFactory(e, n, t), n.prototype.__className = e;
+	};
 }
-function _e(i) {
-  let e;
-  return typeof i == "function" ? e = new i().className : e = i, function(t, r) {
-    return _({ typeName: e })(t, r);
-  };
+function y(e) {
+	return (t) => {
+		u.registerFactory(e, t, void 0, !0);
+	};
 }
-class ye extends d {
-  constructor() {
-    super(...arguments), this._onChange = new I();
-  }
-  /**
-   * Subscribes a listener callback function. Every time a property is changed, 
-   * the listener callback will be called with the property change event.
-   * 
-   * @param listenerCallback the listener callback
-   * @returns a function to unsubscribe the listener from further notifications
-   */
-  onChange(e) {
-    return this._onChange.subscribe(e);
-  }
-  /**
-   * Removes the listener callback subscrition from the notifications.
-   * 
-   * @param listenerCallback the listener callback to remove
-   */
-  removeOnChange(e) {
-    this._onChange.unsubscribe(e);
-  }
-  /**
-   * Changes the value of the property and notifies the subscribers about the change.
-   * This is a helper method that can be used in the property setter.
-   * 
-   * @param propName the name of the property to be changed
-   * @param value the new value for the property
-   * @returns true in case the property has been effectively changed, false otherwise
-   */
-  changeProp(e, t) {
-    const r = "_" + String(e);
-    return this[r] !== t ? (this[r] = t, this._onChange.notify({ [e]: t }), !0) : !1;
-  }
-  /**
-   * Notifies the subscribers a property or group of properties change.
-   * This is a helper function to be used when you want to notify property changes.
-   * 
-   * @param event the event with the changed properties
-   */
-  notify(e) {
-    this._onChange.notify(e);
-  }
-  /**
-   * Inserts a new element in an arbitrary array property of this class and 
-   * fires a change event if successfully inserted. To avoid repeated elements
-   * to be inserted, you can pass a function that checks for inequity.
-   * 
-   * @param arrayPropName the name of the array property of this class where you
-   * 											want to insert the	new element.
-   * @param element the element to be inserted
-   * @param isUnique a function that checks for inequity of the two elements 
-   * 									passed as parameter. If the returned value is true, the 
-   * 									value will be	pushed into the array. When the function is 
-   * 									not provided, the element will be inserted regardless it is
-   * 									already in the array.
-   * @returns the inserted element or undefined if the element was not inserted.
-   */
-  pushAndNotify(e, t, r) {
-    const s = "_" + String(e);
-    if (!(r && this[s].find(
-      (o) => !r(o, t)
-    )))
-      return this[s].push(t), this.notify({ [e]: this[e] }), t;
-  }
-  /**
-   * Removes an element from an arbitrary array property of this class and fires
-   * a change event on operation success.
-   * 
-   * @param arrayPropName the name of the array property of this class where you
-   * 											want to insert the	new element.
-   * @param element the element to be inserted
-   * @param isEqual a function that checks for equity of the two elements 
-   * 									passed as parameter. If the returned value is true, the 
-   * 									value will be	removed from the array. 
-   * @returns the removed element or undefined if the element was not removed.
-   */
-  removeAndNotify(e, t, r) {
-    const s = "_" + String(e), n = this[s].length;
-    if (this[s] = this[s].filter(
-      (o) => !r(o, t)
-    ), n !== this[s].length)
-      return this.notify({ [e]: this[e] }), t;
-  }
+function b(e, t) {
+	return _({ searchableArray: !0 })(e, t);
 }
-const N = class N {
-  constructor(e, t, r) {
-    if (r) {
-      if (!(t instanceof d)) throw new Error(N.error.persistentNeedForSubCollection);
-      this.collectionName = `${t.className}/${t.id}/${r}`;
-    } else
-      this.collectionName = t instanceof d ? t.className : t;
-    this._stream = e;
-  }
-  /**
-   * Finds an stored object in the database by its id. The field id is provided
-   * by the Persistent parent class and it is automatically managed. Therefore,
-   * you should obtain the id by looking at the id field of the object.
-   * 
-   * @param id the id to look for
-   * @param instance you can pass an instace that will be filled with the found data
-   * @returns a promise resolving to an instance with the found data
-   */
-  findById(e, t) {
-    return new Promise((r, s) => {
-      this._stream.findById(e, this.collectionName).then((n) => {
-        n ? (t ? t.fromObject(n) : t = d.createInstance(n), r(t)) : r(void 0);
-      }).catch((n) => s(n));
-    });
-  }
-  /**
-   * Stores an object in the database
-   * 
-   * @param instance the object instance to store
-   * @returns a promise 
-   */
-  save(e) {
-    const t = e.toObject();
-    return this.collectionName !== t.__className && (t.__rootCollections[this.collectionName] = t.__rootCollections[t.__className], delete t.__rootCollections[t.__className]), new Promise((r, s) => {
-      this._stream.save(t.__rootCollections).then(() => r()).catch((n) => s(n));
-    });
-  }
-  /**
-   * Removes an element from the database by id
-   * @param id the id of the element to be removed
-   * @returns a promise
-   */
-  delete(e) {
-    return new Promise((t, r) => {
-      this._stream.delete(e, this.collectionName).then(() => t()).catch((s) => r(s));
-    });
-  }
-  /**
-   * Call find to retrieve a Query object used to define the search conditions
-   * @returns a Query object
-   */
-  find() {
-    return new te(this);
-  }
-  /**
-   * Define the search conditions. You pass query operations and how the query
-   * results are returned to the QueryObject
-   * @param queryObject the QueryObject with the search constrains
-   * @param objectType Deprecated! - restricts the search to a specific instances of the class type
-   * @returns a promise resolving to a collection of matched documents
-   */
-  query(e = {}, t) {
-    if (t) {
-      const r = t instanceof d ? t.className : t;
-      e.operations || (e.operations = []), e.operations.push(
-        { property: "__className", operator: "==", value: r }
-      );
-    }
-    return this.mapToInstance(
-      () => this._stream.find(this.preprocessQueryObject(e), this.collectionName)
-    );
-  }
-  /**
-   * Get the amount of documents matching the query
-   * @param queryObject the QueryObject with the search constrains
-   * @returns a promise resolving to the amount of matched documents
-   */
-  count(e) {
-    return this._stream.count(e, this.collectionName);
-  }
-  /**
-   * Get the next bunch of documents matching the last query
-   * @param limit the max amount of documents to retrieve. If not set, uses the
-   * last limit set
-   * @returns a promise resolving to a collection of matched documents
-   */
-  next(e) {
-    return this.mapToInstance(() => this._stream.next(e));
-  }
-  onDocumentChange(e, t) {
-    return this._stream.onDocumentChange(
-      this.collectionName,
-      e,
-      (r) => t(w.toPersistentDocumentChange(r))
-    );
-  }
-  onCollectionChange(e, t) {
-    return this._stream.onCollectionChange(
-      this.preprocessQueryObject(e.getQueryObject()),
-      this.collectionName,
-      (r) => t(r.map(
-        (s) => w.toPersistentDocumentChange(s)
-      ))
-    );
-  }
-  // /**
-  //  * Get the previous bunch of documents matching the last query
-  //  * @param limit the max amount of documents to retrieve. If not set, uses the
-  //  * last limit set
-  //  * @returns a promise resolving to a collection of matched documents
-  //  */
-  // prev<U extends T>( limit?: number ): Promise<U[]> {
-  // 	return this.mapToInstance( () => this._stream.prev( limit ) )
-  // }
-  mapToInstance(e) {
-    return new Promise((t, r) => {
-      e().then((s) => t(
-        s.map((n) => d.createInstance(n))
-      )).catch((s) => r(s));
-    });
-  }
-  /**
-   * Normalizes the query object to match the data source requirements.
-   * Call this method before you do any query operation on the concrete data source
-   * @param queryObject the query object containing the query operations
-   * @param operatorConversor a function that converts the query operators to the
-   * operators supported by the concrete data source
-   * @returns the normalized query object
-   */
-  preprocessQueryObject(e) {
-    if (Object.values(e).length === 0) return e;
-    const t = e.operations?.map((r) => {
-      const s = r.value[0] ?? r.value;
-      return w.isArrayOperator(r.operator) && s instanceof d ? {
-        property: d.searchableArrayNameFor(r.property),
-        operator: r.operator,
-        value: Array.isArray(r.value) ? r.value.map((n) => n.id) : s.id,
-        aggregate: r.aggregate
-      } : {
-        property: r.property,
-        operator: r.operator,
-        value: r.value instanceof d ? { id: r.value.id } : r.value,
-        aggregate: r.aggregate
-      };
-    }) ?? [];
-    return {
-      ...e,
-      operations: t
-    };
-  }
-};
-N.error = {
-  persistentNeedForSubCollection: "The document parameter for a sub-collection should be a Persistent instace",
-  invalidQueryOrder: "Cannot add where calls after or calls"
-};
-let R = N;
-class te {
-  constructor(e) {
-    this.queryObject = { operations: [] }, this.model = e;
-  }
-  /**
-   * Matches all documents that the value of the property satisfies the condition
-   * in the operator parameter. Subsequent `where` calls will be operated to the
-   * previous ones using the AND operator
-   * @param property the property to be compared
-   * @param operator the operator to be used in the comparison. The available
-   * operators are: ==, !=, >, >=, < and <=
-   * @param value the value to be compared
-   * @param aggregate if true, the query will use the logical or operator and 
-   * aggregate the results to the previous query
-   * @returns this Query object to make chained calls possible
-   * @example
-   * query.where( 'name', '==', 'John' )
-   * query.where( 'age', '>', 18 )
-   * query.where( 'age', '==', 18 ).where( 'name', '==', 'John' )
-   * @see whereDeepProp
-   * @see or
-   * @see orDeepProp
-   */
-  where(e, t, r, s) {
-    if (this.queryObject.operations?.at(-1)?.aggregate && !s) throw new Error(R.error.invalidQueryOrder);
-    return this.queryObject.operations?.push({
-      property: e,
-      operator: t,
-      value: r,
-      aggregate: s
-    }), this;
-  }
-  // where2<P extends PropPath<T>>( property: P, operator: QueryOperator, value: PropPathType<T, P> ) {
-  // 	if ( property.indexOf( '.' ) > 0 ) return this.whereDeepProp( property, operator, value )
-  // 	let val = value instanceof Persistent? { id: value.id } : value
-  // 	this.queryObject.operations.push({
-  // 		property,
-  // 		operator,
-  // 		value: val
-  // 	})
-  // 	return this
-  // }
-  /**
-   * Matches all documents that the value of the deep property satisfies the condition
-   * in the operator parameter
-   * @param propertyPath the path to the property to be compared
-   * @param operator the operator to be used in the comparison. The available
-   * operators are: ==, !=, >, >=, < and <=
-   * @param value the value to be compared
-   * @returns this Query object to make chained calls possible
-   * @example
-   * query.whereDeepProp( 'address.street', '==', 'Main Street' )
-   * @see where
-   * @see or
-   * @see orDeepProp
-   */
-  whereDeepProp(e, t, r, s) {
-    if (this.queryObject.operations?.at(-1)?.aggregate && !s) throw new Error(R.error.invalidQueryOrder);
-    const n = e.split(".");
-    let o = {}, a = n.length > 1 ? o : r;
-    return n.slice(1).forEach((u, h) => {
-      o[u] = h < n.length - 2 ? {} : r, o = o[u];
-    }), this.queryObject.operations?.push({
-      property: n[0],
-      operator: t,
-      value: a,
-      aggregate: s
-    }), this;
-  }
-  /**
-   * Matches all documents that the value of the property satisfies the condition
-   * in the operator parameter and aggregates the results to the previous query
-   * @param property the property to be compared
-   * @param operator the operator to be used in the comparison. The available
-   * operators are: ==, !=, >, >=, < and <=
-   * @returns this Query object to make chained calls possible
-   * @example
-   * query.where( 'name', '==', 'John' ).and( 'age', '>', 18 )
-   * @see andDeepProp
-   * @see where
-   * @see whereDeepProp
-   * @see or
-   * @see orDeepProp
-   */
-  and(e, t, r) {
-    return this.where(e, t, r);
-  }
-  /**
-   * Matches all documents that the value of the deep property satisfies the condition
-   * in the operator parameter and aggregates the results to the previous query
-   * @param propertyPath the path to the property to be compared
-   * @param operator the operator to be used in the comparison. The available
-   * operators are: ==, !=, >, >=, < and <=
-   * @param value the value to be compared
-   * @returns this Query object to make chained calls possible
-   * @example
-   * query.whereDeepProp( 'address.street', '==', 'Main Street' ).andDeepProp( 'address.city', '==', 'New York' )
-   * @see and
-   * @see where
-   * @see whereDeepProp
-   * @see or
-   * @see orDeepProp
-   */
-  andDeepProp(e, t, r) {
-    return this.whereDeepProp(e, t, r);
-  }
-  /**
-   * Matches all documents that the value of the property satisfies the condition
-   * in the operator parameter and aggregates the results to the previous query
-   * @param property the property to be compared
-   * @param operator the operator to be used in the comparison. The available
-   * operators are: ==, !=, >, >=, < and <=
-   * @returns this Query object to make chained calls possible
-   * @example
-   * query.or( 'name', '==', 'John' )
-   * query.or( 'age', '>', 18 )
-   * @see orDeepProp
-   * @see where
-   * @see whereDeepProp
-   */
-  or(e, t, r) {
-    return this.where(e, t, r, !0);
-  }
-  /**
-   * Matches all documents that the value of the deep property satisfies the condition
-   * in the operator parameter and aggregates the results to the previous query
-   * @param propertyPath the path to the property to be compared
-   * @param operator the operator to be used in the comparison. The available
-   * operators are: ==, !=, >, >=, < and <=
-   * @param value the value to be compared
-   * @returns this Query object to make chained calls possible
-   * @example
-   * query.orDeepProp( 'address.street', '==', 'Main Street' )
-   * @see or
-   * @see where
-   * @see whereDeepProp
-   */
-  orDeepProp(e, t, r) {
-    return this.whereDeepProp(e, t, r, !0);
-  }
-  /**
-   * Defines a where condition to match documents that are instances of the
-   * given class
-   * @param classId the class name or an instance to match
-   * @returns this Query object to make chained calls possible
-   * @example
-   * query.instanceOf( 'Person' )
-   * query.instanceOf( Person )
-   * query.instanceOf( Person ).where( 'age', '>', 18 )
-   */
-  instanceOf(e) {
-    const t = e instanceof d ? e.className : e;
-    return this.queryObject.operations?.push({
-      property: "__className",
-      operator: "==",
-      value: t
-    }), this;
-  }
-  /**
-   * Executes the query and returns the result
-   * @param limit the max amount of documents to retrieve. If not set, uses the
-   * last limit set or all the matching documents
-   * @returns a promise resolving to a collection of matched documents
-   * @example
-   * const namedJohn = await query.where( 'name', '==', 'John' ).get()
-   */
-  get(e) {
-    return e && (this.queryObject.limit = e), this.model.query(this.queryObject);
-  }
-  /**
-   * Limits the number of documents to retrieve
-   * @param maxDocs the max amount of documents to retrieve
-   * @returns this Query object to make chained calls possible
-   * @example
-   * query.where( 'name', '==', 'John' ).limit( 10 )
-   */
-  limit(e) {
-    return this.queryObject.limit = e, this;
-  }
-  /**
-   * Orders the result set by a property.
-   * @param propertyName The name of the property to order by
-   * @param order The sort direction. Possible values are 'asc' and 'desc'
-   * @returns a chainable query object
-   * @example
-   * query.orderBy( 'name', 'asc' )
-   * query.orderBy( 'age', 'desc' )
-   */
-  orderBy(e, t = "asc") {
-    return this.queryObject.sort = {
-      propertyName: e,
-      order: t
-    }, this;
-  }
-  /**
-   * Orders the result set by a deep property
-   * 
-   * @param propertyPath The full path of the deep property. It should be 
-   * 											separated by dots like person.name.firstName.
-   * @param order The sort direction. Possible values are 'asc' and 'desc'
-   * @returns a chainable query object
-   */
-  orderByDeepProp(e, t = "asc") {
-    return this.queryObject.sort = {
-      propertyName: e,
-      order: t
-    }, this;
-  }
-  /**
-   * Returns the number of documents that match the query
-   * @returns a promise resolving to the number of documents that match the query
-   * @example
-   * const count = await query.where( 'name', '==', 'John' ).count()
-   */
-  count() {
-    return this.model.count(this.queryObject);
-  }
-  getQueryObject() {
-    return this.queryObject;
-  }
-  getQueryModel() {
-    return this.model;
-  }
-}
-const P = class P {
-  constructor() {
-  }
-  /**
-   * Registers a data source to be used by the store.
-   * You need to register a data source before using the store.
-   * @param dataSource the data source to be used by the store
-   */
-  static useDataSource(e) {
-    this._dataSource = e;
-  }
-  /**
-   * The data source currently used by the store
-   * @returns the data source
-   */
-  static get dataSource() {
-    return P._dataSource;
-  }
-  /**
-   * Retrieves a model for a collection
-   * @param classId the class name or an instance of the document type stored in the collection
-   * @returns the model for the collection
-   */
-  static getModel(e) {
-    if (!P._dataSource) throw new Error(this.error.shouldBeRegistered);
-    return new R(P._dataSource, e);
-  }
-  /**
-   * Retrieves a model for a subcollection 
-   * @param document the persistent object that owns the subcollection
-   * @param subCollection the name of the subcollection
-   * @returns the model for the subcollection
-   */
-  static getModelForSubCollection(e, t) {
-    if (!P._dataSource) throw new Error(this.error.shouldBeRegistered);
-    return new R(P._dataSource, e, t);
-  }
-  /**
-   * Populates property references with actual data from the store.
-   * It will not retrieve data if the instance is already populated
-   * @param instance the data to be populated.
-   * @returns the populated instance
-   */
-  static async populate(e) {
-    if (!e) return;
-    const t = async (r) => {
-      const s = r;
-      if (!s.__documentReference) return r;
-      const o = await this.getModel(s.__documentReference.storedInCollection).findById(s.id, r);
-      return o && (o.__documentReference = void 0), o;
-    };
-    return Array.isArray(e) ? (await Promise.all(
-      e.map((s) => t(s))
-    )).filter((s) => s) : t(e);
-  }
-  /**
-   * Checks if an instance is populated
-   * @param instance the instance or array of instances to be checked
-   * @returns true if the instance is populated
-   */
-  static isPopulated(e) {
-    return Array.isArray(e) ? e.reduce(
-      (t, r) => t && r.__documentReference === void 0,
-      !0
-    ) : e.__documentReference === void 0;
-  }
-};
-P.error = { shouldBeRegistered: "You should register a data source before using the data Store." };
-let k = P;
-class L {
-  constructor(e) {
-    this._resolveCollectionPaths = () => {
-      throw new Error("The method collectionsMatchingTemplate has not been implemented in the concrete data source");
-    }, this._disabledChangeListeners = /* @__PURE__ */ new Set(), this._collectionsToWatch = {}, e && (this._beforeUpdate = e.beforeUpdateDocument, this._afterUpdate = e.afterUpdateDocument, this._afterDocumentChange = e.afterDocumentChange, this._beforeDocumentChange = e.beforeDocumentChange, this._beforeQueryOwnerCollection = e.beforeQueryOwnerCollection), this.installUpdaters();
-  }
-  installUpdaters() {
-    const e = d.getSystemRegisteredReferencesWithCachedProps();
-    this._collectionsToWatch = {}, Object.entries(e).forEach(([t, r]) => {
-      r.forEach((s) => {
-        if (!s.typeName) return;
-        (Array.isArray(s.typeName) ? s.typeName : [s?.typeName ?? t]).map((o) => d.collectionPath(d.createInstance(o), s)).forEach((o) => {
-          this._collectionsToWatch[o] || (this._collectionsToWatch[o] = []), this._collectionsToWatch[o].find((u) => u.name === s.name && u.ownerClassName() === s.ownerClassName()) || this._collectionsToWatch[o].push(s);
-        });
-      });
-    });
-  }
-  /**
-   * Set a callback to be executed before updating each document that has a cached prop to update. 
-   * The callback receives the document to update and the prop that triggered the update as parameters.
-   * @param callback The callback to be executed before updating each document that has a cached prop to update.
-   */
-  set beforeDocumentChange(e) {
-    this._beforeDocumentChange = e;
-  }
-  /**
-   * Set a callback to be executed after updating each document that has a cached prop to update. 
-   * The callback receives the document that was updated and the prop that triggered the update as parameters.
-   * @param callback The callback to be executed after updating each document that has a cached prop to update.
-   */
-  set afterDocumentChange(e) {
-    this._afterDocumentChange = e;
-  }
-  /**
-   * Set a callback to be executed before updating each document that has a cached prop to update.
-   * The callback receives the document to update and the prop that triggered the update as parameters.
-   * @param callback The callback to be executed before updating each document that has a cached prop to update.
-   */
-  set beforeUpdateDocument(e) {
-    this._beforeUpdate = e;
-  }
-  /**
-   * Set a callback to be executed after updating each document that has a cached prop to update.
-   * The callback receives the document that was updated and the prop that triggered the update as parameters.
-   * @param callback The callback to be executed after updating each document that has a cached prop to update.
-   */
-  set afterUpdateDocument(e) {
-    this._afterUpdate = e;
-  }
-  set beforeQueryOwnerCollection(e) {
-    this._beforeQueryOwnerCollection = e;
-  }
-  set resolveCollectionPaths(e) {
-    this._resolveCollectionPaths = e;
-  }
-  get collectionsToWatch() {
-    return this._collectionsToWatch;
-  }
-  updateProps(e, t) {
-    const r = this._collectionsToWatch[e];
-    return r ? this.onDocumentChange(t, r) : Promise.resolve();
-  }
-  async onDocumentChange(e, t) {
-    const r = w.toPersistentDocumentChange(e);
-    this._beforeDocumentChange?.(r, t);
-    const s = {};
-    e.type !== "update" || !r.before || r.after?.id && this._disabledChangeListeners.has(r.after?.id) || (await Promise.all(t.map(async (n) => {
-      const o = L.ownerCollectionPath(d.createInstance(n.ownerClassName()), n, r.params), a = await this._resolveCollectionPaths(o);
-      await Promise.all(a.map(async (u) => {
-        const h = k.getModel(u);
-        let c = h.find(), b = !1;
-        n.cachedProps?.forEach((f) => {
-          const S = r.before[f], O = r.after[f];
-          S !== O && (b = !0);
-        }), b && (n.searchableArray ? c = c.where(n.name, "contains", r.before) : c = c.where(n.name, "==", r.before)), c = this._beforeQueryOwnerCollection?.(c) ?? c;
-        const E = await c.get();
-        return s[u] = {
-          totalDocumentsToUpdate: E.length,
-          updatedDocuments: [],
-          documentsToUpdate: E.map((f) => f.name ?? f.id)
-        }, Promise.all([
-          E.map(async (f) => {
-            let S = !1;
-            if (n.cachedProps?.forEach((O) => {
-              const A = r.before[O], q = r.after[O];
-              A !== q && (S = !0);
-            }), S) {
-              if (n.searchableArray) {
-                const O = f[n.name].findIndex((A) => A.id === r.before.id);
-                f[n.name][O] = r.after;
-              } else
-                f[`_${n.name}`] = r.after;
-              this._beforeUpdate?.(f, n), this.disableChangeListener(f), await h.save(f), this.enableChangeListener(f), s[u]?.updatedDocuments.push(f.id), this._afterUpdate?.(f, n);
-            } else return Promise.resolve();
-          })
-        ]);
-      }));
-    })), this._afterDocumentChange?.(s, t));
-  }
-  disableChangeListener(e) {
-    this._disabledChangeListeners.add(e.id);
-  }
-  enableChangeListener(e) {
-    this._disabledChangeListeners.delete(e.id);
-  }
-  static ownerCollectionPath(e, t, r) {
-    let s;
-    return typeof t.ownerCollection == "function" ? s = t.ownerCollection(e, t, r) : s = t.ownerCollection ?? e.className, s;
-  }
+function x(e, t) {
+	return _({ validator: (e) => e != null })(e, t);
 }
-class w {
-  constructor() {
-    this._cachedPropsUpdater = void 0;
-  }
-  installCachedPropsUpdater(e) {
-    return this._cachedPropsUpdater = new L(e), this._cachedPropsUpdater.resolveCollectionPaths = this.resolveCollectionPaths.bind(this), this._cachedPropsUpdater;
-  }
-  get cachedPropsUpdater() {
-    return this._cachedPropsUpdater;
-  }
-  /**
-   * Utility method to convert a query object to a property path query object
-   * 
-   * @param queryObject the query object to be converted
-   * @returns a property path query object
-   * @example
-   * const queryObject = {
-   * 	operations: [{ property: 'name', operator: '==', value: { ancestorName: { father: 'Felipe' }}]
-   * }
-   * const propPathQueryObject = DataSource.toPropertyPathQueryObject( queryObject )
-   * // returned value: [{ property: 'name.ancestorName.father', operator: '==', value: 'Felipe' }]
-   */
-  static toPropertyPathOperations(e) {
-    return e ? e.map((t) => {
-      if (w.isArrayOperator(t.operator) && t.value[0] instanceof d)
-        return {
-          property: d.searchableArrayNameFor(t.property),
-          operator: t.operator,
-          value: t.value.map((o) => o.id),
-          aggregate: t.aggregate
-        };
-      const [r, s] = this.toPropertyPathValue(t.value);
-      return {
-        property: `${String(t.property)}${r ? "." + r : ""}`,
-        operator: t.operator,
-        value: s,
-        aggregate: t.aggregate
-      };
-    }) : [];
-  }
-  static isArrayOperator(e) {
-    return e === "containsAny" || e === "contains";
-  }
-  static toPersistentDocumentChange(e) {
-    return {
-      ...e,
-      before: e.before && d.createInstance(e.before),
-      after: e.after && d.createInstance(e.after)
-    };
-  }
-  static toPropertyPathValue(e) {
-    if (typeof e == "object" && !Array.isArray(e)) {
-      const t = Object.keys(e)[0], [r, s] = this.toPropertyPathValue(e[t]);
-      return [`${t}${r ? "." + r : ""}`, s];
-    } else
-      return [void 0, e];
-  }
-  static isStringMatchingTemplate(e, t) {
-    const s = e.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&").replace(/\\\$\\\{[^}]+\\\}/g, "([^/]+)").replace(/\\\{[^}]+\\\}/g, "([^/]+)");
-    return new RegExp("^" + s + "$").test(t);
-  }
-  static extractTemplateParams(e, t) {
-    const r = [], n = t.replace(/[-\/\\^$*+?.()|[\]{}]/g, "\\$&").replace(/\\\{([^}]+)\\\}/g, (h, c) => (r.push(c), "([^/]+)")), o = new RegExp("^" + n + "$"), a = e.match(o), u = {};
-    return a && r.forEach((h, c) => {
-      u[h] = a[c + 1];
-    }), u;
-  }
+function S(e = (e) => e != null) {
+	return function(t, n) {
+		return _({ validator: e })(t, n);
+	};
 }
-class be extends w {
-  /**
-   * @param jsonRawData the JSON object to be used as data store
-   */
-  constructor(e) {
-    super(), this._jsonRawData = {}, this._lastMatchingDocs = [], this._lastLimit = 0, this._cursor = 0, this._simulateDelay = 0, this._pendingPromises = [], this._documentListeners = {}, this._collectionListeners = {}, this._serverCollectionListeners = {}, e && (this._jsonRawData = e);
-  }
-  /**
-   * Set the JSON object to initialize the data store. Use to set the it after 
-   * the constructor has been called.
-   * @param jsonRawData the JSON object to be used as data store
-   */
-  setDataStore(e) {
-    return this._jsonRawData = e, this;
-  }
-  /**
-   * Introduce a delay in the execution of operations to simulate a real data source
-   * @param miliSeconds the number of milliseconds to delay the execution of operations
-   * @returns a chainable reference to this object
-   */
-  simulateDelay(e) {
-    return this._simulateDelay = e, this;
-  }
-  findById(e, t) {
-    if (this._simulateError?.findById) throw new Error(this._simulateError.findById);
-    return this.resolveWithDelay(this._jsonRawData[t]?.[e]);
-  }
-  save(e) {
-    if (this._simulateError?.store) throw new Error(this._simulateError.store);
-    return Object.entries(e).forEach(([t, r]) => {
-      this._jsonRawData[t] || (this._jsonRawData[t] = {}), r?.forEach((s) => {
-        const n = this._jsonRawData[t][s.id];
-        this._jsonRawData[t][s.id] = s, this.notifyChange(t, s, n);
-      });
-    }), this.resolveWithDelay();
-  }
-  find(e, t) {
-    if (this._simulateError?.find) throw new Error(this._simulateError.find);
-    const r = Object.values(this._jsonRawData[t] || {});
-    return e ? (this._lastLimit = e.limit || 0, this._cursor = 0, this._lastMatchingDocs = Object.entries(e).reduce(
-      (s, [n, o]) => this.queryProcessor(s, n, o),
-      Object.values(r)
-    ), this.resolveWithDelay(this._lastMatchingDocs.slice(0, e.limit))) : this.resolveWithDelay(r);
-  }
-  delete(e, t) {
-    if (this._simulateError?.delete) throw new Error(this._simulateError.delete);
-    return delete this._jsonRawData[t][e], this.resolveWithDelay();
-  }
-  next(e) {
-    return e && (this._lastLimit = e), this.incCursor(this._lastLimit), this.resolveWithDelay(this._lastMatchingDocs.slice(this._cursor, this._cursor + this._lastLimit));
-  }
-  count(e, t) {
-    return this.resolveWithDelay(
-      Object.keys(this._jsonRawData[t] ?? {}).length
-    );
-  }
-  onCollectionChange(e, t, r) {
-    let s = this._collectionListeners[t];
-    s || (this._collectionListeners[t] = {}, s = this._collectionListeners[t]);
-    const n = (a) => {
-      if (!a.after) return;
-      const u = [a.after];
-      a.before && u.push(a.before);
-      const c = this.retrieveQueryDocs(u, e.operations).filter((b, E, f) => E === f.findIndex((S) => S.id === b.id));
-      c.length > 0 && r(c.map((b) => ({
-        before: a.before,
-        after: b,
-        type: a.type,
-        params: a.params
-      })));
-    }, o = Math.random().toString(36).substring(2, 9);
-    return s[o] = n, () => delete s[o];
-  }
-  onDocumentChange(e, t, r) {
-    let s = this._documentListeners[e];
-    s || (this._documentListeners[e] = {}, s = this._documentListeners[e]);
-    const n = (a) => {
-      a.after && a.after.id === t && r(a);
-    }, o = Math.random().toString(36).substring(2, 9);
-    return s[o] = n, () => delete s[o];
-  }
-  /**
-   * @returns the raw data store data as a JSON object
-   */
-  get rawData() {
-    return this._jsonRawData;
-  }
-  /**
-   * Wait for all pending promises to be resolved
-   * @returns a promise that resolves when all pending promises are resolved
-   */
-  wait() {
-    return Promise.all([...this._pendingPromises]);
-  }
-  incCursor(e) {
-    this._cursor += e, this._cursor > this._lastMatchingDocs.length && (this._cursor = this._lastMatchingDocs.length);
-  }
-  simulateError(e) {
-    return e === void 0 ? (this._simulateError = void 0, this) : (typeof e == "string" ? this._simulateError = {
-      store: e,
-      find: e,
-      findById: e,
-      delete: e
-    } : this._simulateError = e, this);
-  }
-  notifyChange(e, t, r) {
-    const s = {
-      before: r,
-      after: t,
-      collectionPath: e,
-      params: {},
-      type: r ? "update" : "create"
-    };
-    Object.values(this._serverCollectionListeners[e] ?? {}).forEach((n) => n(s)), Object.values(this._documentListeners[e] ?? {}).forEach((n) => n(s)), Object.values(this._collectionListeners[e] ?? {}).forEach((n) => n(s));
-  }
-  decCursor(e) {
-    return this._cursor -= e, this._cursor < 0 ? (this._cursor = 0, !0) : !1;
-  }
-  queryProcessor(e, t, r) {
-    return {
-      limit: (n) => e,
-      //.slice( 0, limit ),
-      operations: (n) => this.retrieveQueryDocs(e, n),
-      sort: ({ order: n, propertyName: o }) => e.sort((a, u) => n === "asc" ? this.deepValue(a, o) > this.deepValue(u, o) ? 1 : -1 : this.deepValue(a, o) < this.deepValue(u, o) ? 1 : -1)
-    }[t](r);
-  }
-  retrieveQueryDocs(e, t) {
-    return t.reduce((r, s, n) => {
-      if (s.aggregate) {
-        const o = e.filter((a) => this.isQueryMatched(a, s));
-        return n === 0 ? o : r.concat(o);
-      } else
-        return r.filter((o) => this.isQueryMatched(o, s));
-    }, e);
-  }
-  deepValue(e, t) {
-    return t.split(".").reduce((s, n) => s[n], e);
-  }
-  isQueryMatched(e, t) {
-    const r = {
-      "==": (h, c) => h === c,
-      "!=": (h, c) => h !== c,
-      "<": (h, c) => h < c,
-      "<=": (h, c) => h <= c,
-      ">": (h, c) => h > c,
-      ">=": (h, c) => h >= c,
-      containsAny: (h, c) => h?.some((b) => c?.includes(b)),
-      contains: (h, c) => h?.includes(c)
-    }, { property: s, value: n, operator: o } = t, [a, u] = this.retrieveValuesToCompare(e, s, n);
-    return r[o](a, u);
-  }
-  retrieveValuesToCompare(e, t, r) {
-    const s = e[t];
-    if (s && typeof r == "object" && !Array.isArray(r)) {
-      const a = Object.keys(r)[0];
-      var [n, o] = this.retrieveValuesToCompare(s, a, r?.[a]);
-    }
-    return [n || s, o || r];
-  }
-  resolveWithDelay(e) {
-    if (this._simulateDelay <= 0) return Promise.resolve(e);
-    const t = new Promise((r) => {
-      setTimeout(
-        () => r(e),
-        this._simulateDelay
-      );
-    });
-    return this._pendingPromises.push(t), t.finally(
-      () => this._pendingPromises = this._pendingPromises.filter((r) => r === t)
-    ), t;
-  }
-  resolveCollectionPaths(e) {
-    return Promise.resolve(this.collectionsMatchingTemplate(e));
-  }
-  collectionsMatchingTemplate(e) {
-    return Object.keys(this._jsonRawData).filter((t) => w.isStringMatchingTemplate(e, t));
-  }
+function C(e) {
+	let t;
+	return t = typeof e == "function" ? new e().className : e, function(e, n) {
+		return _({ typeName: t })(e, n);
+	};
 }
-const v = class v {
-  static registerCloudStorage(e, t) {
-    v._cloudStorageFactoryMap[e] = t;
-  }
-  static createInstance(e) {
-    const t = v._cloudStorageFactoryMap[e];
-    if (!t)
-      throw new Error(`You should register the ${e} cloud storage provider prior to use it`);
-    return t();
-  }
-  get className() {
-    return this.__className;
-  }
-  static useCloudStorage(e) {
-    v._defaultCloudStorage = e;
-  }
-  static get defaultCloudStorage() {
-    if (!v._defaultCloudStorage)
-      throw new Error("You should define a default cloud storage provider prior to use it");
-    return v._defaultCloudStorage;
-  }
+//#endregion
+//#region src/persistent/entropic-component.ts
+var w = class extends u {
+	constructor(...t) {
+		super(...t), this._onChange = new e();
+	}
+	onChange(e) {
+		return this._onChange.subscribe(e);
+	}
+	removeOnChange(e) {
+		this._onChange.unsubscribe(e);
+	}
+	changeProp(e, t) {
+		let n = "_" + String(e);
+		return this[n] === t ? !1 : (this[n] = t, this._onChange.notify({ [e]: t }), !0);
+	}
+	notify(e) {
+		this._onChange.notify(e);
+	}
+	pushAndNotify(e, t, n) {
+		let r = "_" + String(e);
+		if (!(n && this[r].find((e) => !n(e, t)))) return this[r].push(t), this.notify({ [e]: this[e] }), t;
+	}
+	removeAndNotify(e, t, n) {
+		let r = "_" + String(e), i = this[r].length;
+		if (this[r] = this[r].filter((e) => !n(e, t)), i !== this[r].length) return this.notify({ [e]: this[e] }), t;
+	}
+}, T = class e {
+	static {
+		this.error = {
+			persistentNeedForSubCollection: "The document parameter for a sub-collection should be a Persistent instace",
+			invalidQueryOrder: "Cannot add where calls after or calls"
+		};
+	}
+	constructor(t, n, r) {
+		if (r) {
+			if (!(n instanceof u)) throw Error(e.error.persistentNeedForSubCollection);
+			this.collectionName = `${n.className}/${n.id}/${r}`;
+		} else this.collectionName = n instanceof u ? n.className : n;
+		this._stream = t;
+	}
+	findById(e, t) {
+		return new Promise((n, r) => {
+			this._stream.findById(e, this.collectionName).then((e) => {
+				e ? (t ? t.fromObject(e) : t = u.createInstance(e), n(t)) : n(void 0);
+			}).catch((e) => r(e));
+		});
+	}
+	save(e) {
+		let t = e.toObject();
+		return this.collectionName !== t.__className && (t.__rootCollections[this.collectionName] = t.__rootCollections[t.__className], delete t.__rootCollections[t.__className]), new Promise((e, n) => {
+			this._stream.save(t.__rootCollections).then(() => e()).catch((e) => n(e));
+		});
+	}
+	delete(e) {
+		return new Promise((t, n) => {
+			this._stream.delete(e, this.collectionName).then(() => t()).catch((e) => n(e));
+		});
+	}
+	find() {
+		return new E(this);
+	}
+	query(e = {}, t) {
+		if (t) {
+			let n = t instanceof u ? t.className : t;
+			e.operations ||= [], e.operations.push({
+				property: "__className",
+				operator: "==",
+				value: n
+			});
+		}
+		return this.mapToInstance(() => this._stream.find(this.preprocessQueryObject(e), this.collectionName));
+	}
+	count(e) {
+		return this._stream.count(e, this.collectionName);
+	}
+	next(e) {
+		return this.mapToInstance(() => this._stream.next(e));
+	}
+	onDocumentChange(e, t) {
+		return this._stream.onDocumentChange(this.collectionName, e, (e) => t(k.toPersistentDocumentChange(e)));
+	}
+	onCollectionChange(e, t) {
+		return this._stream.onCollectionChange(this.preprocessQueryObject(e.getQueryObject()), this.collectionName, (e) => t(e.map((e) => k.toPersistentDocumentChange(e))));
+	}
+	onCollectionTemplateChange(e, t) {
+		return this._stream.onDocumentTemplateChange(e, (e) => t(k.toPersistentDocumentChange(e)));
+	}
+	mapToInstance(e) {
+		return new Promise((t, n) => {
+			e().then((e) => t(e.map((e) => u.createInstance(e)))).catch((e) => n(e));
+		});
+	}
+	preprocessQueryObject(e) {
+		if (Object.values(e).length === 0) return e;
+		let t = e.operations?.map((e) => {
+			let t = e.value[0] ?? e.value;
+			return k.isArrayOperator(e.operator) && t instanceof u ? {
+				property: u.searchableArrayNameFor(e.property),
+				operator: e.operator,
+				value: Array.isArray(e.value) ? e.value.map((e) => e.id) : t.id,
+				aggregate: e.aggregate
+			} : {
+				property: e.property,
+				operator: e.operator,
+				value: e.value instanceof u ? { id: e.value.id } : e.value,
+				aggregate: e.aggregate
+			};
+		}) ?? [];
+		return {
+			...e,
+			operations: t
+		};
+	}
+}, E = class {
+	constructor(e) {
+		this.queryObject = { operations: [] }, this.model = e;
+	}
+	where(e, t, n, r) {
+		if (this.queryObject.operations?.at(-1)?.aggregate && !r) throw Error(T.error.invalidQueryOrder);
+		return this.queryObject.operations?.push({
+			property: e,
+			operator: t,
+			value: n,
+			aggregate: r
+		}), this;
+	}
+	whereDeepProp(e, t, n, r) {
+		if (this.queryObject.operations?.at(-1)?.aggregate && !r) throw Error(T.error.invalidQueryOrder);
+		let i = e.split("."), a = {}, o = i.length > 1 ? a : n;
+		return i.slice(1).forEach((e, t) => {
+			a[e] = t < i.length - 2 ? {} : n, a = a[e];
+		}), this.queryObject.operations?.push({
+			property: i[0],
+			operator: t,
+			value: o,
+			aggregate: r
+		}), this;
+	}
+	and(e, t, n) {
+		return this.where(e, t, n);
+	}
+	andDeepProp(e, t, n) {
+		return this.whereDeepProp(e, t, n);
+	}
+	or(e, t, n) {
+		return this.where(e, t, n, !0);
+	}
+	orDeepProp(e, t, n) {
+		return this.whereDeepProp(e, t, n, !0);
+	}
+	instanceOf(e) {
+		let t = e instanceof u ? e.className : e;
+		return this.queryObject.operations?.push({
+			property: "__className",
+			operator: "==",
+			value: t
+		}), this;
+	}
+	get(e) {
+		return e && (this.queryObject.limit = e), this.model.query(this.queryObject);
+	}
+	limit(e) {
+		return this.queryObject.limit = e, this;
+	}
+	orderBy(e, t = "asc") {
+		return this.queryObject.sort = {
+			propertyName: e,
+			order: t
+		}, this;
+	}
+	orderByDeepProp(e, t = "asc") {
+		return this.queryObject.sort = {
+			propertyName: e,
+			order: t
+		}, this;
+	}
+	count() {
+		return this.model.count(this.queryObject);
+	}
+	getQueryObject() {
+		return this.queryObject;
+	}
+	getQueryModel() {
+		return this.model;
+	}
+}, D = class e {
+	constructor() {}
+	static {
+		this.error = { shouldBeRegistered: "You should register a data source before using the data Store." };
+	}
+	static useDataSource(e) {
+		this._dataSource = e;
+	}
+	static get dataSource() {
+		return e._dataSource;
+	}
+	static getModel(t) {
+		if (!e._dataSource) throw Error(this.error.shouldBeRegistered);
+		return new T(e._dataSource, t);
+	}
+	static getModelForSubCollection(t, n) {
+		if (!e._dataSource) throw Error(this.error.shouldBeRegistered);
+		return new T(e._dataSource, t, n);
+	}
+	static async populate(e) {
+		if (!e) return;
+		let t = async (e) => {
+			let t = e;
+			if (!t.__documentReference) return e;
+			let n = await this.getModel(t.__documentReference.storedInCollection).findById(t.id, e);
+			return n && (n.__documentReference = void 0), n;
+		};
+		return Array.isArray(e) ? (await Promise.all(e.map((e) => t(e)))).filter((e) => e) : t(e);
+	}
+	static isPopulated(e) {
+		return Array.isArray(e) ? e.reduce((e, t) => e && t.__documentReference === void 0, !0) : e.__documentReference === void 0;
+	}
+}, O = class e {
+	constructor(e) {
+		this._resolveCollectionPaths = () => {
+			throw Error("The method collectionsMatchingTemplate has not been implemented in the concrete data source");
+		}, this._disabledChangeListeners = /* @__PURE__ */ new Set(), this._collectionsToWatch = {}, e && (this._beforeUpdate = e.beforeUpdateDocument, this._afterUpdate = e.afterUpdateDocument, this._afterDocumentChange = e.afterDocumentChange, this._beforeDocumentChange = e.beforeDocumentChange, this._beforeQueryOwnerCollection = e.beforeQueryOwnerCollection), this.installUpdaters();
+	}
+	installUpdaters() {
+		let e = u.getSystemRegisteredReferencesWithCachedProps();
+		this._collectionsToWatch = {}, Object.entries(e).forEach(([e, t]) => {
+			t.forEach((t) => {
+				t.typeName && (Array.isArray(t.typeName) ? t.typeName : [t?.typeName ?? e]).map((e) => u.collectionPath(u.createInstance(e), t)).forEach((e) => {
+					this._collectionsToWatch[e] || (this._collectionsToWatch[e] = []), this._collectionsToWatch[e].find((e) => e.name === t.name && e.ownerClassName() === t.ownerClassName()) || this._collectionsToWatch[e].push(t);
+				});
+			});
+		});
+	}
+	set beforeDocumentChange(e) {
+		this._beforeDocumentChange = e;
+	}
+	set afterDocumentChange(e) {
+		this._afterDocumentChange = e;
+	}
+	set beforeUpdateDocument(e) {
+		this._beforeUpdate = e;
+	}
+	set afterUpdateDocument(e) {
+		this._afterUpdate = e;
+	}
+	set beforeQueryOwnerCollection(e) {
+		this._beforeQueryOwnerCollection = e;
+	}
+	set resolveCollectionPaths(e) {
+		this._resolveCollectionPaths = e;
+	}
+	get collectionsToWatch() {
+		return this._collectionsToWatch;
+	}
+	updateProps(e, t) {
+		let n = this._collectionsToWatch[e];
+		return n ? this.onDocumentChange(t, n) : Promise.resolve();
+	}
+	async onDocumentChange(t, n) {
+		let r = k.toPersistentDocumentChange(t);
+		this._beforeDocumentChange?.(r, n);
+		let i = {};
+		t.type !== "update" || !r.before || r.after?.id && this._disabledChangeListeners.has(r.after?.id) || (await Promise.all(n.map(async (t) => {
+			let n = e.ownerCollectionPath(u.createInstance(t.ownerClassName()), t, r.params), a = await this._resolveCollectionPaths(n);
+			await Promise.all(a.map(async (e) => {
+				let n = D.getModel(e), a = n.find(), o = !1;
+				t.cachedProps?.forEach((e) => {
+					r.before[e] !== r.after[e] && (o = !0);
+				}), o && (a = t.searchableArray ? a.where(t.name, "contains", r.before) : a.where(t.name, "==", r.before)), a = this._beforeQueryOwnerCollection?.(a) ?? a;
+				let s = await a.get();
+				return i[e] = {
+					totalDocumentsToUpdate: s.length,
+					updatedDocuments: [],
+					documentsToUpdate: s.map((e) => e.name ?? e.id)
+				}, Promise.all([s.map(async (a) => {
+					let o = !1;
+					if (t.cachedProps?.forEach((e) => {
+						r.before[e] !== r.after[e] && (o = !0);
+					}), o) {
+						if (t.searchableArray) {
+							let e = a[t.name].findIndex((e) => e.id === r.before.id);
+							a[t.name][e] = r.after;
+						} else a[`_${t.name}`] = r.after;
+						this._beforeUpdate?.(a, t), this.disableChangeListener(a), await n.save(a), this.enableChangeListener(a), i[e]?.updatedDocuments.push(a.id), this._afterUpdate?.(a, t);
+					} else return Promise.resolve();
+				})]);
+			}));
+		})), this._afterDocumentChange?.(i, n));
+	}
+	disableChangeListener(e) {
+		this._disabledChangeListeners.add(e.id);
+	}
+	enableChangeListener(e) {
+		this._disabledChangeListeners.delete(e.id);
+	}
+	static ownerCollectionPath(e, t, n) {
+		let r;
+		return r = typeof t.ownerCollection == "function" ? t.ownerCollection(e, t, n) : t.ownerCollection ?? e.className, r;
+	}
+}, k = class e {
+	constructor() {
+		this._cachedPropsUpdater = void 0;
+	}
+	installCachedPropsUpdater(e) {
+		return this._cachedPropsUpdater = new O(e), this._cachedPropsUpdater.resolveCollectionPaths = this.resolveCollectionPaths.bind(this), this._cachedPropsUpdater;
+	}
+	get cachedPropsUpdater() {
+		return this._cachedPropsUpdater;
+	}
+	static toPropertyPathOperations(t) {
+		return t ? t.map((t) => {
+			if (e.isArrayOperator(t.operator) && t.value[0] instanceof u) return {
+				property: u.searchableArrayNameFor(t.property),
+				operator: t.operator,
+				value: t.value.map((e) => e.id),
+				aggregate: t.aggregate
+			};
+			let [n, r] = this.toPropertyPathValue(t.value);
+			return {
+				property: `${String(t.property)}${n ? "." + n : ""}`,
+				operator: t.operator,
+				value: r,
+				aggregate: t.aggregate
+			};
+		}) : [];
+	}
+	static isArrayOperator(e) {
+		return e === "containsAny" || e === "contains";
+	}
+	static toPersistentDocumentChange(e) {
+		return {
+			...e,
+			before: e.before && u.createInstance(e.before),
+			after: e.after && u.createInstance(e.after)
+		};
+	}
+	static toPropertyPathValue(e) {
+		if (typeof e == "object" && !Array.isArray(e)) {
+			let t = Object.keys(e)[0], [n, r] = this.toPropertyPathValue(e[t]);
+			return [`${t}${n ? "." + n : ""}`, r];
+		} else return [void 0, e];
+	}
+	static isStringMatchingTemplate(e, t) {
+		let n = e.split("/"), r = t.split("/");
+		if (r.length > n.length) return !1;
+		for (let e = 0; e < r.length; e++) {
+			let t = n[e], i = r[e];
+			if (!(t.startsWith("{") && t.endsWith("}") || t.startsWith("${") && t.endsWith("}")) && t !== i) return !1;
+		}
+		for (let e = r.length; e < n.length; e++) {
+			let t = n[e];
+			if (!(t.startsWith("{") && t.endsWith("}") || t.startsWith("${") && t.endsWith("}"))) return !1;
+		}
+		return !0;
+	}
+	static extractTemplateParams(e, t) {
+		let n = t.split("/"), r = e.split("/"), i = {};
+		if (r.length > n.length) return i;
+		for (let e = 0; e < r.length; e++) {
+			let t = n[e], a = r[e];
+			if (t.startsWith("{") && t.endsWith("}")) i[t.slice(1, -1)] = a;
+			else if (t.startsWith("${") && t.endsWith("}")) i[t.slice(2, -1)] = a;
+			else if (t !== a) return {};
+		}
+		for (let e = r.length; e < n.length; e++) {
+			let t = n[e];
+			if (!(t.startsWith("{") && t.endsWith("}") || t.startsWith("${") && t.endsWith("}"))) return {};
+		}
+		return i;
+	}
+}, A = class extends k {
+	constructor(e) {
+		super(), this._jsonRawData = {}, this._lastMatchingDocs = [], this._lastLimit = 0, this._cursor = 0, this._simulateDelay = 0, this._pendingPromises = [], this._documentListeners = {}, this._collectionListeners = {}, e && (this._jsonRawData = e);
+	}
+	setDataStore(e) {
+		return this._jsonRawData = e, this;
+	}
+	simulateDelay(e) {
+		return this._simulateDelay = e, this;
+	}
+	findById(e, t) {
+		if (this._simulateError?.findById) throw Error(this._simulateError.findById);
+		return this.resolveWithDelay(this._jsonRawData[t]?.[e]);
+	}
+	save(e) {
+		if (this._simulateError?.store) throw Error(this._simulateError.store);
+		return Object.entries(e).forEach(([e, t]) => {
+			this._jsonRawData[e] || (this._jsonRawData[e] = {}), t?.forEach((t) => {
+				let n = this._jsonRawData[e][t.id];
+				this._jsonRawData[e][t.id] = t, this.notifyChange(e, t, n);
+			});
+		}), this.resolveWithDelay();
+	}
+	find(e, t) {
+		if (this._simulateError?.find) throw Error(this._simulateError.find);
+		let n = Object.values(this._jsonRawData[t] || {});
+		return e ? (this._lastLimit = e.limit || 0, this._cursor = 0, this._lastMatchingDocs = Object.entries(e).reduce((e, [t, n]) => this.queryProcessor(e, t, n), Object.values(n)), this.resolveWithDelay(this._lastMatchingDocs.slice(0, e.limit))) : this.resolveWithDelay(n);
+	}
+	delete(e, t) {
+		if (this._simulateError?.delete) throw Error(this._simulateError.delete);
+		return delete this._jsonRawData[t][e], this.resolveWithDelay();
+	}
+	next(e) {
+		return e && (this._lastLimit = e), this.incCursor(this._lastLimit), this.resolveWithDelay(this._lastMatchingDocs.slice(this._cursor, this._cursor + this._lastLimit));
+	}
+	count(e, t) {
+		return this.resolveWithDelay(Object.keys(this._jsonRawData[t] ?? {}).length);
+	}
+	onCollectionChange(e, t, n) {
+		let r = this._collectionListeners[t];
+		r ||= (this._collectionListeners[t] = {}, this._collectionListeners[t]);
+		let i = (t) => {
+			if (!t.after) return;
+			let r = [t.after];
+			t.before && r.push(t.before);
+			let i = this.retrieveQueryDocs(r, e.operations).filter((e, t, n) => t === n.findIndex((t) => t.id === e.id));
+			i.length > 0 && n(i.map((e) => ({
+				before: t.before,
+				after: e,
+				type: t.type,
+				params: t.params
+			})));
+		}, a = Math.random().toString(36).substring(2, 9);
+		return r[a] = i, () => delete r[a];
+	}
+	onDocumentChange(e, t, n) {
+		let r = this._documentListeners[e];
+		r ||= (this._documentListeners[e] = {}, this._documentListeners[e]);
+		let i = (e) => {
+			e.after && e.after.id === t && n(e);
+		}, a = Math.random().toString(36).substring(2, 9);
+		return r[a] = i, () => delete r[a];
+	}
+	onDocumentTemplateChange(e, t) {
+		let n = this.collectionsMatchingTemplate(e), r = [];
+		return n.forEach((n) => {
+			let i = this._documentListeners[n];
+			i ||= (this._documentListeners[n] = {}, this._documentListeners[n]);
+			let a = (r) => {
+				r.params = k.extractTemplateParams(n, e), t(r);
+			}, o = Math.random().toString(36).substring(2, 9);
+			i[o] = a, r.push(() => delete i[o]);
+		}), () => r.forEach((e) => e());
+	}
+	get rawData() {
+		return this._jsonRawData;
+	}
+	wait() {
+		return Promise.all([...this._pendingPromises]);
+	}
+	incCursor(e) {
+		this._cursor += e, this._cursor > this._lastMatchingDocs.length && (this._cursor = this._lastMatchingDocs.length);
+	}
+	simulateError(e) {
+		return e === void 0 ? (this._simulateError = void 0, this) : (typeof e == "string" ? this._simulateError = {
+			store: e,
+			find: e,
+			findById: e,
+			delete: e
+		} : this._simulateError = e, this);
+	}
+	notifyChange(e, t, n) {
+		let r = {
+			before: n,
+			after: t,
+			collectionPath: e,
+			params: {},
+			type: n ? "update" : "create"
+		};
+		Object.values(this._documentListeners[e] ?? {}).forEach((e) => e(r)), Object.values(this._collectionListeners[e] ?? {}).forEach((e) => e(r));
+	}
+	decCursor(e) {
+		return this._cursor -= e, this._cursor < 0 ? (this._cursor = 0, !0) : !1;
+	}
+	queryProcessor(e, t, n) {
+		return {
+			limit: (t) => e,
+			operations: (t) => this.retrieveQueryDocs(e, t),
+			sort: ({ order: t, propertyName: n }) => e.sort((e, r) => t === "asc" ? this.deepValue(e, n) > this.deepValue(r, n) ? 1 : -1 : this.deepValue(e, n) < this.deepValue(r, n) ? 1 : -1)
+		}[t](n);
+	}
+	retrieveQueryDocs(e, t) {
+		return t.reduce((t, n, r) => {
+			if (n.aggregate) {
+				let i = e.filter((e) => this.isQueryMatched(e, n));
+				return r === 0 ? i : t.concat(i);
+			} else return t.filter((e) => this.isQueryMatched(e, n));
+		}, e);
+	}
+	deepValue(e, t) {
+		return t.split(".").reduce((e, t) => e[t], e);
+	}
+	isQueryMatched(e, t) {
+		let n = {
+			"==": (e, t) => e === t,
+			"!=": (e, t) => e !== t,
+			"<": (e, t) => e < t,
+			"<=": (e, t) => e <= t,
+			">": (e, t) => e > t,
+			">=": (e, t) => e >= t,
+			containsAny: (e, t) => e?.some((e) => t?.includes(e)),
+			contains: (e, t) => e?.includes(t)
+		}, { property: r, value: i, operator: a } = t, [o, s] = this.retrieveValuesToCompare(e, r, i);
+		return n[a](o, s);
+	}
+	retrieveValuesToCompare(e, t, n) {
+		let r = e[t];
+		if (r && typeof n == "object" && !Array.isArray(n)) {
+			let e = Object.keys(n)[0];
+			var [i, a] = this.retrieveValuesToCompare(r, e, n?.[e]);
+		}
+		return [i || r, a || n];
+	}
+	resolveWithDelay(e) {
+		if (this._simulateDelay <= 0) return Promise.resolve(e);
+		let t = new Promise((t) => {
+			setTimeout(() => t(e), this._simulateDelay);
+		});
+		return this._pendingPromises.push(t), t.finally(() => this._pendingPromises = this._pendingPromises.filter((e) => e === t)), t;
+	}
+	resolveCollectionPaths(e) {
+		return Promise.resolve(this.collectionsMatchingTemplate(e));
+	}
+	collectionsMatchingTemplate(e) {
+		return Object.keys(this._jsonRawData).filter((t) => k.isStringMatchingTemplate(e, t));
+	}
+}, j = class e {
+	static registerCloudStorage(t, n) {
+		e._cloudStorageFactoryMap[t] = n;
+	}
+	static createInstance(t) {
+		let n = e._cloudStorageFactoryMap[t];
+		if (!n) throw Error(`You should register the ${t} cloud storage provider prior to use it`);
+		return n();
+	}
+	get className() {
+		return this.__className;
+	}
+	static useCloudStorage(t) {
+		e._defaultCloudStorage = t;
+	}
+	static get defaultCloudStorage() {
+		if (!e._defaultCloudStorage) throw Error("You should define a default cloud storage provider prior to use it");
+		return e._defaultCloudStorage;
+	}
+	static {
+		this._cloudStorageFactoryMap = {};
+	}
 };
-v._cloudStorageFactoryMap = {};
-let C = v;
-function re(i, e) {
-  return C.registerCloudStorage(i, e), (t) => {
-    t.prototype.__className = i;
-  };
+function M(e, t) {
+	return j.registerCloudStorage(e, t), (t) => {
+		t.prototype.__className = e;
+	};
 }
-var se = Object.getOwnPropertyDescriptor, ie = (i, e, t, r) => {
-  for (var s = r > 1 ? void 0 : r ? se(e, t) : e, n = i.length - 1, o; n >= 0; n--)
-    (o = i[n]) && (s = o(s) || s);
-  return s;
+//#endregion
+//#region src/cloud-storage/mock-cloud-storage.ts
+var N = class extends j {
+	constructor(e = "") {
+		super(), this._simulateDelay = 0, this._pendingPromises = [], this.mockFileSystem = {}, this._pathToMockFiles = e;
+	}
+	simulateDelay(e) {
+		return this._simulateDelay = e, this;
+	}
+	resolveWithDelay(e) {
+		if (this._simulateDelay <= 0) return Promise.resolve(e);
+		let t = new Promise((t) => {
+			setTimeout(() => t(e), this._simulateDelay);
+		});
+		return this._pendingPromises.push(t), t.finally(() => this._pendingPromises = this._pendingPromises.filter((e) => e === t)), t;
+	}
+	save(e, t) {
+		let n = e;
+		this._onProgress && this._onProgress(0, 100), this.mockFileSystem[e] = JSON.stringify(t), this._onProgress && this._onProgress(100, 100);
+		let r = t instanceof File ? t.name : n;
+		return this.resolveWithDelay(r);
+	}
+	uploadControl() {
+		return {
+			resume: () => {},
+			pause: () => {},
+			cancel: () => {},
+			onProgress: (e) => this._onProgress = e
+		};
+	}
+	getUrl(e) {
+		return Promise.resolve(this._pathToMockFiles + e);
+	}
+	delete(e) {
+		return delete this.mockFileSystem[e], this.resolveWithDelay();
+	}
 };
-let T = class extends C {
-  constructor(i = "") {
-    super(), this._simulateDelay = 0, this._pendingPromises = [], this.mockFileSystem = {}, this._pathToMockFiles = i;
-  }
-  /**
-   * Introduce a delay in the execution of operations to simulate a real data source
-   * @param miliSeconds the number of milliseconds to delay the execution of operations
-   * @returns a chainable reference to this object
-   */
-  simulateDelay(i) {
-    return this._simulateDelay = i, this;
-  }
-  resolveWithDelay(i) {
-    if (this._simulateDelay <= 0) return Promise.resolve(i);
-    const e = new Promise((t) => {
-      setTimeout(
-        () => t(i),
-        this._simulateDelay
-      );
-    });
-    return this._pendingPromises.push(e), e.finally(
-      () => this._pendingPromises = this._pendingPromises.filter((t) => t === e)
-    ), e;
-  }
-  save(i, e) {
-    const t = i;
-    this._onProgress && this._onProgress(0, 100), this.mockFileSystem[i] = JSON.stringify(e), this._onProgress && this._onProgress(100, 100);
-    const r = e instanceof File ? e.name : t;
-    return this.resolveWithDelay(r);
-  }
-  uploadControl() {
-    return {
-      resume: () => {
-      },
-      pause: () => {
-      },
-      cancel: () => {
-      },
-      onProgress: (i) => this._onProgress = i
-    };
-  }
-  getUrl(i) {
-    return Promise.resolve(this._pathToMockFiles + i);
-  }
-  delete(i) {
-    return delete this.mockFileSystem[i], this.resolveWithDelay();
-  }
+N = l([M("MockCloudStorage", () => new N())], N);
+//#endregion
+//#region src/cloud-storage/stored-file.ts
+var P = /* @__PURE__ */ function(e) {
+	return e[e.stored = 0] = "stored", e[e.pendingDataSet = 1] = "pendingDataSet", e[e.deleted = 2] = "deleted", e;
+}({}), F = class extends u {
+	constructor(...t) {
+		super(...t), this._onChange = new e();
+	}
+	async save({ data: e, fileName: t, progress: n, cloudStorageProvider: r } = {}) {
+		let i = e || this._pendingData;
+		i && (this._reference && await this.delete(), this.provider = r || j.defaultCloudStorage, this._originalFileName = t || (i instanceof File ? i.name : void 0), this._reference = await this.provider.save(this.id, i, n), this._url = await this.provider.getUrl(this._reference), this._pendingData = void 0, this._onChange.notify({
+			event: P.stored,
+			storedFile: this
+		}));
+	}
+	uploadControl() {
+		return this.provider.uploadControl();
+	}
+	async delete() {
+		if (!this._reference) throw Error("Cannot delete a not stored file");
+		await this.provider.delete(this._reference), this._reference = void 0, this._url = void 0, this._onChange.notify({
+			event: P.deleted,
+			storedFile: this
+		});
+	}
+	set provider(e) {
+		this._provider = e, this._cloudStorageProviderName = e.className;
+	}
+	get provider() {
+		if (!this._provider) try {
+			this._provider = j.createInstance(this._cloudStorageProviderName);
+		} catch {
+			this._provider = j.defaultCloudStorage;
+		}
+		return this._provider;
+	}
+	get url() {
+		return this._url;
+	}
+	get mimeType() {
+		return this._mimeType;
+	}
+	setDataToStore(e) {
+		return this._pendingData = e, this._originalFileName = e instanceof File ? e.name : void 0, this._mimeType = e instanceof Blob ? e.type : void 0, this._onChange.notify({
+			event: P.pendingDataSet,
+			pendingData: e,
+			storedFile: this
+		}), this;
+	}
+	get originalFileName() {
+		return this._originalFileName;
+	}
+	onChange(e) {
+		return this._onChange.subscribe(e);
+	}
 };
-T = ie([
-  re("MockCloudStorage", () => new T())
-], T);
-var ne = Object.defineProperty, oe = Object.getOwnPropertyDescriptor, U = (i, e, t, r) => {
-  for (var s = r > 1 ? void 0 : r ? oe(e, t) : e, n = i.length - 1, o; n >= 0; n--)
-    (o = i[n]) && (s = (r ? o(e, t, s) : o(s)) || s);
-  return r && s && ne(e, t, s), s;
-}, ae = /* @__PURE__ */ ((i) => (i[i.stored = 0] = "stored", i[i.pendingDataSet = 1] = "pendingDataSet", i[i.deleted = 2] = "deleted", i))(ae || {});
-let D = class extends d {
-  constructor() {
-    super(...arguments), this._onChange = new I();
-  }
-  async save({ data: i, fileName: e, progress: t, cloudStorageProvider: r } = {}) {
-    const s = i || this._pendingData;
-    s && (this._reference && await this.delete(), this.provider = r || C.defaultCloudStorage, this._originalFileName = e || (s instanceof File ? s.name : void 0), this._reference = await this.provider.save(this.id, s, t), this._url = await this.provider.getUrl(this._reference), this._pendingData = void 0, this._onChange.notify({ event: 0, storedFile: this }));
-  }
-  uploadControl() {
-    return this.provider.uploadControl();
-  }
-  async delete() {
-    if (!this._reference) throw new Error("Cannot delete a not stored file");
-    await this.provider.delete(this._reference), this._reference = void 0, this._url = void 0, this._onChange.notify({ event: 2, storedFile: this });
-  }
-  set provider(i) {
-    this._provider = i, this._cloudStorageProviderName = i.className;
-  }
-  get provider() {
-    if (!this._provider)
-      try {
-        this._provider = C.createInstance(this._cloudStorageProviderName);
-      } catch {
-        this._provider = C.defaultCloudStorage;
-      }
-    return this._provider;
-  }
-  get url() {
-    return this._url;
-  }
-  get mimeType() {
-    return this._mimeType;
-  }
-  setDataToStore(i) {
-    return this._pendingData = i, this._originalFileName = i instanceof File ? i.name : void 0, this._mimeType = i instanceof Blob ? i.type : void 0, this._onChange.notify({
-      event: 1,
-      pendingData: i,
-      storedFile: this
-    }), this;
-  }
-  get originalFileName() {
-    return this._originalFileName;
-  }
-  onChange(i) {
-    return this._onChange.subscribe(i);
-  }
+l([d], F.prototype, "_reference", void 0), l([d], F.prototype, "_url", void 0), l([d], F.prototype, "_cloudStorageProviderName", void 0), l([d], F.prototype, "_originalFileName", void 0), l([d], F.prototype, "_mimeType", void 0), F = l([v("StoredFile")], F);
+//#endregion
+//#region src/auth/auth.ts
+var I = class {}, L = class t extends I {
+	static {
+		this.error = { shouldBeRegistered: "You should register an auth service before using Auth." };
+	}
+	constructor() {
+		if (super(), this._onAuthStateChange = new e(), !t._authService) throw Error(t.error.shouldBeRegistered);
+		t._authService.onAuthStateChange((e) => this.authStateChanged(e));
+	}
+	static useAuthService(e) {
+		t._authService != e && (t._authService = e, this._instance = void 0);
+	}
+	static get instance() {
+		return this._instance ||= new this();
+	}
+	signUp(e) {
+		return t._authService.signUp(e);
+	}
+	login(e) {
+		return t._authService.login(e);
+	}
+	logout() {
+		return t._authService.logout();
+	}
+	resetEmailPassword(e) {
+		return t._authService.resetEmailPassword(e);
+	}
+	resendVerificationEmail(e, n, r) {
+		return t._authService.resendVerificationEmail(e, n, r);
+	}
+	refreshToken() {
+		return t._authService.refreshToken();
+	}
+	onAuthStateChange(e) {
+		return this._onAuthStateChange.subscribe(e);
+	}
+	removeAuthStateChange(e) {
+		this._onAuthStateChange.unsubscribe(e);
+	}
+	linkAdditionalProvider(e) {
+		return t._authService.linkAdditionalProvider(e);
+	}
+	unlinkProvider(e) {
+		return t._authService.unlinkProvider(e);
+	}
+	authStateChanged(e) {
+		this._onAuthStateChange.notify(e);
+	}
+	static {
+		this._instance = void 0;
+	}
+}, R = class extends I {
+	constructor(...e) {
+		super(...e), this.pendingPromises = [], this._fakeRegisteredUsers = {};
+	}
+	signUp(e) {
+		let { verificationLink: t, email: n, password: r, authProvider: i } = e, a = new Promise(async (a, o) => {
+			i === "email" && (n || o({
+				code: "missingEmail",
+				message: "missingEmail"
+			}), r || o({
+				code: "missingPassword",
+				message: "missingPassword"
+			})), r !== "fail" && n !== "fail" ? (this._loggedUser = this.userCredentials(e), this._fakeRegisteredUsers[this._loggedUser.id] = this._loggedUser, a(this._loggedUser), this.notifyChange?.(this._loggedUser)) : (o({
+				code: "userNotFound",
+				message: t || "Test auth error"
+			}), this.notifyChange?.(void 0));
+		});
+		return this.pendingPromises.push(a), a;
+	}
+	login(e) {
+		let t = Object.values(this._fakeRegisteredUsers).find((t) => t.email === e.email);
+		return e.authProvider === "email" && !t && e.email && (e.email = "fail"), this.signUp(e);
+	}
+	onAuthStateChange(e) {
+		this.notifyChange = e, this.notifyChange(this._loggedUser);
+	}
+	async logout() {
+		let e = new Promise((e) => {
+			this._loggedUser = void 0, e(), this.notifyChange?.(void 0);
+		});
+		return this.pendingPromises.push(e), e;
+	}
+	resetEmailPassword(e) {
+		return Object.values(this._fakeRegisteredUsers).find((t) => t.email === e) ? Promise.resolve() : Promise.reject({
+			code: "userNotFound",
+			message: "Test auth error"
+		});
+	}
+	resendVerificationEmail(e, t, n) {
+		return Object.values(this._fakeRegisteredUsers).find((t) => t.email === e) ? Promise.resolve() : Promise.reject({
+			code: "userNotFound",
+			message: "Test auth error"
+		});
+	}
+	refreshToken() {
+		return Promise.resolve();
+	}
+	linkAdditionalProvider(e) {
+		throw Error("Not implemented.");
+	}
+	unlinkProvider(e) {
+		throw Error("Not implemented.");
+	}
+	async flush() {
+		await Promise.all(this.pendingPromises), this.pendingPromises = [];
+	}
+	fakeRegisteredUser(e) {
+		if (this._fakeRegisteredUsers[e.id]) throw Error(`User with id ${e.id} already exists in fake user list`);
+		return this._fakeRegisteredUsers[e.id] = e, this;
+	}
+	get fakeRegisteredUsers() {
+		return this._fakeRegisteredUsers;
+	}
+	userCredentials(e) {
+		let t = Object.values(this._fakeRegisteredUsers).find((t) => t.email === e.email);
+		return t ? { ...t } : {
+			id: e.authProvider || `testUID${e.email ? "-" + e.email : ""}`,
+			email: e.email || "testEmail",
+			name: e.authProvider || `testName${e.email ? " " + e.email : ""}`,
+			phoneNumber: "testPhone",
+			customData: { role: "test" },
+			lastLogin: 0,
+			creationDate: 0
+		};
+	}
+}, z = class e {
+	constructor() {}
+	static {
+		this.error = { shouldBeRegistered: "You should register a cloud functions service with useCloudFunctionsService static method before using CloudFunctions." };
+	}
+	static useCloudFunctionsService(e) {
+		this._cloudFunctionsService != e && (this._cloudFunctionsService = e);
+	}
+	static get instance() {
+		if (!this._cloudFunctionsService) throw Error(e.error.shouldBeRegistered);
+		return e._instance ||= new e();
+	}
+	getRawFunction(t) {
+		return e._cloudFunctionsService.retrieveFunction(t);
+	}
+	getFunction(t) {
+		let n = e._cloudFunctionsService.callFunction, r = this.getRawFunction(t);
+		return async (e) => {
+			let t = await n(r, this.processParam(e));
+			return this.processResult(t);
+		};
+	}
+	processParam(e) {
+		if (e != null) return e instanceof u ? e.toObject() : Array.isArray(e) ? e.map((e) => this.processParam(e)) : typeof e == "object" ? Object.entries(e).reduce((e, [t, n]) => (e[t] = this.processParam(n), e), {}) : e;
+	}
+	processResult(e) {
+		if (e != null) return e.__className ? u.createInstance(e) : Array.isArray(e) ? e.map((e) => this.processResult(e)) : typeof e == "object" ? Object.entries(e).reduce((e, [t, n]) => (e[t] = this.processResult(n), e), {}) : e;
+	}
+}, B = class {
+	constructor(e) {
+		this._registeredFunctions = e;
+	}
+	retrieveFunction(e) {
+		let t = this._registeredFunctions[e];
+		if (!t) throw Error(`Cloud function ${e} is not registered.`);
+		return t;
+	}
+	callFunction(e, t) {
+		return e(t);
+	}
+}, V = class {}, H = class e extends V {
+	static {
+		this.error = { shouldBeRegistered: "You should register a Server Auth service before using the Server Auth." };
+	}
+	constructor() {
+		super();
+	}
+	static useServerAuthService(t) {
+		e._authService != t && (e._authService = t, this._instance = void 0);
+	}
+	static get instance() {
+		if (!e._authService) throw Error(e.error.shouldBeRegistered);
+		return this._instance ||= new e();
+	}
+	getUser(t) {
+		return e._authService.getUser(t);
+	}
+	updateUser(t, n) {
+		return e._authService.updateUser(t, n);
+	}
+	setCustomCredentials(t, n) {
+		return e._authService.setCustomCredentials(t, n);
+	}
+	deleteUser(t) {
+		return e._authService.deleteUser(t);
+	}
+	static {
+		this._instance = void 0;
+	}
+}, U = class extends V {
+	constructor(e) {
+		super(), this._userCredentials = e;
+	}
+	getUser(e) {
+		return this._userCredentials[e] || Promise.resolve(void 0), Promise.resolve(this._userCredentials[e]);
+	}
+	setCustomCredentials(e, t) {
+		let n = this._userCredentials[e];
+		if (!n) throw Error(`User ${e} not found in the auth system`);
+		return n.customData = { ...t }, Promise.resolve();
+	}
+	updateUser(e, t) {
+		return this._userCredentials[e] = {
+			...this._userCredentials,
+			...t,
+			id: e
+		}, Promise.resolve(this._userCredentials[e]);
+	}
+	deleteUser(e) {
+		return delete this._userCredentials[e], Promise.resolve();
+	}
+	get userCredentials() {
+		return this._userCredentials;
+	}
 };
-U([
-  j
-], D.prototype, "_reference", 2);
-U([
-  j
-], D.prototype, "_url", 2);
-U([
-  j
-], D.prototype, "_cloudStorageProviderName", 2);
-U([
-  j
-], D.prototype, "_originalFileName", 2);
-U([
-  j
-], D.prototype, "_mimeType", 2);
-D = U([
-  ee("StoredFile")
-], D);
-class Q {
+//#endregion
+//#region src/utils/utils.ts
+function W(e, t) {
+	return e ? e.replace(/\${\s*(\w*)\s*}/g, function(e, n) {
+		return t[n] || "";
+	}) : "";
 }
-const p = class p extends Q {
-  constructor() {
-    if (super(), this._onAuthStateChange = new I(), !p._authService) throw new Error(p.error.shouldBeRegistered);
-    p._authService.onAuthStateChange(
-      (e) => this.authStateChanged(e)
-    );
-  }
-  /**
-   * Registers an authentication service to be used by the Auth class.
-   * You need to register an authentication service before using the Auth class.
-   * @param authService the authentication service to be used by the Auth class
-   */
-  static useAuthService(e) {
-    p._authService != e && (p._authService = e, this._instance = void 0);
-  }
-  /**
-   * The instance of the Auth class
-   * @returns the authentication service
-   */
-  static get instance() {
-    return this._instance || (this._instance = new this());
-  }
-  /**
-   * Signs up a new user
-   * @param singData the data to be used to sign up the user
-   * @returns a promise that resolves to the user credentials
-   * @example
-   * // Sign up a new user with email and password
-   * Auth.instance.signUp({ authProvider: 'email', email: 'john@test.com', password: '123456' })
-   * // Sign up a new user with a Google account
-   * Auth.instance.signUp({ authProvider: 'google'})
-   */
-  signUp(e) {
-    return p._authService.signUp(e);
-  }
-  /**
-   * Logs in an existing user
-   * @param singData the data to be used to log in the user
-   * @returns a promise that resolves to the user credentials
-   * @example
-   * // Log in an existing user with email and password
-   * Auth.instance.login({ authProvider: 'email', email: 'john@test.com', password: '123456' })
-   * // Log in an existing user with a Google account
-   * Auth.instance.login({ authProvider: 'google'})
-   */
-  login(e) {
-    return p._authService.login(e);
-  }
-  /**
-   * Logs out the current user
-   * @returns a promise that resolves when the user is logged out
-   */
-  logout() {
-    return p._authService.logout();
-  }
-  /**
-   * Resets the password associated with the email.
-   * @param email the email address of the user to reset the password
-   * @returns a promise that resolves when the process is done
-   */
-  resetEmailPassword(e) {
-    return p._authService.resetEmailPassword(e);
-  }
-  /**
-   * Resends the email verification to the user.
-   * @returns a promise that resolves when the process is done
-   */
-  resendVerificationEmail(e, t, r) {
-    return p._authService.resendVerificationEmail(e, t, r);
-  }
-  refreshToken() {
-    return p._authService.refreshToken();
-  }
-  /**
-   * Adds a listener to be called when the authentication state changes.
-   * @param onChange the listener to be called when the authentication state changes.
-   * The listener is called with the user credentials as a parameter.
-   * If the user is logged out, the listener is called with `undefined` as a parameter.
-   * @returns a function to remove the listener
-   * @example
-   * // Add a listener to be called when the authentication state changes
-   * const removeListener = Auth.instance.onAuthStateChange( userCredentials => {
-   * 	if ( userCredentials ) {
-   * 		// The user is logged in
-   * 	} else {
-   * 		// The user is logged out
-   * 	}
-   * })
-   */
-  onAuthStateChange(e) {
-    return this._onAuthStateChange.subscribe(e);
-  }
-  /**
-   * Removes a listener that was added by `onAuthStateChange` method.
-   * @param onChange the listener to be removed
-   */
-  removeAuthStateChange(e) {
-    this._onAuthStateChange.unsubscribe(e);
-  }
-  /**
-   * Links an additional authentication provider to the authenticated user.
-   * @param provider the provider to be linked
-   * @returns a promise that resolves when the process is done
-   * @example
-   * // Link a Google account to the auth service
-   * Auth.instance.linkAdditionalProvider({ authProvider: 'google' })
-   */
-  linkAdditionalProvider(e) {
-    return p._authService.linkAdditionalProvider(e);
-  }
-  /**
-   * Unlinks an authentication provider from the authenticated user.
-   * @param provider the provider to be unlinked
-   * @returns a promise that resolves when the process is done
-   * @example
-   * // Unlink the Google account from the auth service
-   * Auth.instance.unlinkProvider({ authProvider: 'google' })
-   */
-  unlinkProvider(e) {
-    return p._authService.unlinkProvider(e);
-  }
-  authStateChanged(e) {
-    this._onAuthStateChange.notify(e);
-  }
-};
-p.error = { shouldBeRegistered: "You should register an auth service before using Auth." }, p._instance = void 0;
-let x = p;
-class Pe extends Q {
-  constructor() {
-    super(...arguments), this.pendingPromises = [], this._fakeRegisteredUsers = {};
-  }
-  signUp(e) {
-    const { verificationLink: t, email: r, password: s, authProvider: n } = e, o = new Promise(async (a, u) => {
-      n === "email" && (r || u({ code: "missingEmail", message: "missingEmail" }), s || u({ code: "missingPassword", message: "missingPassword" })), s !== "fail" && r !== "fail" ? (this._loggedUser = this.userCredentials(e), this._fakeRegisteredUsers[this._loggedUser.id] = this._loggedUser, a(this._loggedUser), this.notifyChange?.(this._loggedUser)) : (u({ code: "userNotFound", message: t || "Test auth error" }), this.notifyChange?.(void 0));
-    });
-    return this.pendingPromises.push(o), o;
-  }
-  login(e) {
-    const t = Object.values(this._fakeRegisteredUsers).find(
-      (r) => r.email === e.email
-    );
-    return e.authProvider === "email" && !t && e.email && (e.email = "fail"), this.signUp(e);
-  }
-  onAuthStateChange(e) {
-    this.notifyChange = e, this.notifyChange(this._loggedUser);
-  }
-  async logout() {
-    const e = new Promise((t) => {
-      this._loggedUser = void 0, t(), this.notifyChange?.(void 0);
-    });
-    return this.pendingPromises.push(e), e;
-  }
-  resetEmailPassword(e) {
-    return Object.values(this._fakeRegisteredUsers).find(
-      (r) => r.email === e
-    ) ? Promise.resolve() : Promise.reject({ code: "userNotFound", message: "Test auth error" });
-  }
-  resendVerificationEmail(e, t, r) {
-    return Object.values(this._fakeRegisteredUsers).find(
-      (n) => n.email === e
-    ) ? Promise.resolve() : Promise.reject({ code: "userNotFound", message: "Test auth error" });
-  }
-  refreshToken() {
-    return Promise.resolve();
-  }
-  linkAdditionalProvider(e) {
-    throw new Error("Not implemented.");
-  }
-  unlinkProvider(e) {
-    throw new Error("Not implemented.");
-  }
-  async flush() {
-    await Promise.all(this.pendingPromises), this.pendingPromises = [];
-  }
-  fakeRegisteredUser(e) {
-    if (this._fakeRegisteredUsers[e.id]) throw new Error(`User with id ${e.id} already exists in fake user list`);
-    return this._fakeRegisteredUsers[e.id] = e, this;
-  }
-  get fakeRegisteredUsers() {
-    return this._fakeRegisteredUsers;
-  }
-  userCredentials(e) {
-    const t = Object.values(this._fakeRegisteredUsers).find(
-      (r) => r.email === e.email
-    );
-    return t ? { ...t } : {
-      id: e.authProvider || `testUID${e.email ? "-" + e.email : ""}`,
-      email: e.email || "testEmail",
-      name: e.authProvider || `testName${e.email ? " " + e.email : ""}`,
-      phoneNumber: "testPhone",
-      customData: {
-        role: "test"
-      },
-      lastLogin: 0,
-      creationDate: 0
-    };
-  }
-}
-const y = class y {
-  constructor() {
-  }
-  static useCloudFunctionsService(e) {
-    this._cloudFunctionsService != e && (this._cloudFunctionsService = e);
-  }
-  static get instance() {
-    if (!this._cloudFunctionsService) throw new Error(y.error.shouldBeRegistered);
-    return y._instance || (y._instance = new y());
-  }
-  getRawFunction(e) {
-    return y._cloudFunctionsService.retrieveFunction(e);
-  }
-  getFunction(e) {
-    const t = y._cloudFunctionsService.callFunction, r = this.getRawFunction(e);
-    return async (s) => {
-      const n = await t(r, this.processParam(s));
-      return this.processResult(n);
-    };
-  }
-  processParam(e) {
-    if (e != null)
-      return e instanceof d ? e.toObject() : Array.isArray(e) ? e.map((t) => this.processParam(t)) : typeof e == "object" ? Object.entries(e).reduce((t, [r, s]) => (t[r] = this.processParam(s), t), {}) : e;
-  }
-  processResult(e) {
-    if (e != null)
-      return e.__className ? d.createInstance(e) : Array.isArray(e) ? e.map((t) => this.processResult(t)) : typeof e == "object" ? Object.entries(e).reduce((t, [r, s]) => (t[r] = this.processResult(s), t), {}) : e;
-  }
-};
-y.error = { shouldBeRegistered: "You should register a cloud functions service with useCloudFunctionsService static method before using CloudFunctions." };
-let $ = y;
-class ve {
-  constructor(e) {
-    this._registeredFunctions = e;
-  }
-  retrieveFunction(e) {
-    const t = this._registeredFunctions[e];
-    if (!t) throw new Error(`Cloud function ${e} is not registered.`);
-    return t;
-  }
-  callFunction(e, t) {
-    return e(t);
-  }
+function G(e) {
+	return e ? e.replace(/([-_ ][\w])/g, (e) => e.toUpperCase().replace("-", "").replace("_", "").replace(" ", "")) : "";
 }
-class B {
-}
-const g = class g extends B {
-  constructor() {
-    super();
-  }
-  static useServerAuthService(e) {
-    g._authService != e && (g._authService = e, this._instance = void 0);
-  }
-  static get instance() {
-    if (!g._authService) throw new Error(g.error.shouldBeRegistered);
-    return this._instance || (this._instance = new g());
-  }
-  getUser(e) {
-    return g._authService.getUser(e);
-  }
-  updateUser(e, t) {
-    return g._authService.updateUser(e, t);
-  }
-  setCustomCredentials(e, t) {
-    return g._authService.setCustomCredentials(e, t);
-  }
-  deleteUser(e) {
-    return g._authService.deleteUser(e);
-  }
-};
-g.error = { shouldBeRegistered: "You should register a Server Auth service before using the Server Auth." }, g._instance = void 0;
-let V = g;
-class we extends B {
-  constructor(e) {
-    super(), this._userCredentials = e;
-  }
-  getUser(e) {
-    return this._userCredentials[e] || Promise.resolve(void 0), Promise.resolve(this._userCredentials[e]);
-  }
-  setCustomCredentials(e, t) {
-    const r = this._userCredentials[e];
-    if (!r) throw new Error(`User ${e} not found in the auth system`);
-    return r.customData = { ...t }, Promise.resolve();
-  }
-  updateUser(e, t) {
-    return this._userCredentials[e] = {
-      ...this._userCredentials,
-      ...t,
-      id: e
-    }, Promise.resolve(this._userCredentials[e]);
-  }
-  deleteUser(e) {
-    return delete this._userCredentials[e], Promise.resolve();
-  }
-  get userCredentials() {
-    return this._userCredentials;
-  }
+function K(e, t = "-") {
+	if (!e) return "";
+	let n = e.slice(1).replace(/( |[A-Z])/g, (e) => e === " " ? "-" : t + e[0].toLowerCase());
+	return e[0].toLocaleLowerCase() + n.replace(/--/g, "-");
 }
-function Ce(i, e) {
-  return i ? i.replace(/\${\s*(\w*)\s*}/g, function(t, r) {
-    return e[r] || "";
-  }) : "";
+function q(e, t) {
+	return t.split(".").reduce((e, t) => e[t], e);
 }
-function De(i) {
-  return i ? i.replace(
-    /([-_ ][\w])/g,
-    (e) => e.toUpperCase().replace("-", "").replace("_", "").replace(" ", "")
-  ) : "";
-}
-function Se(i, e = "-") {
-  if (!i) return "";
-  const t = i.slice(1).replace(/( |[A-Z])/g, (r) => r === " " ? "-" : e + r[0].toLowerCase());
-  return i[0].toLocaleLowerCase() + t.replace(/--/g, "-");
-}
-function Oe(i, e) {
-  return e.split(".").reduce((t, r) => t[r], i);
-}
-export {
-  x as Auth,
-  Pe as AuthMock,
-  Q as AuthService,
-  $ as CloudFunctions,
-  ve as CloudFunctionsMock,
-  C as CloudStorage,
-  w as DataSource,
-  ye as EntropicComponent,
-  be as JsonDataSource,
-  T as MockCloudStorage,
-  R as Model,
-  I as Observable,
-  d as Persistent,
-  te as Query,
-  V as ServerAuth,
-  we as ServerAuthMock,
-  B as ServerAuthService,
-  k as Store,
-  D as StoredFile,
-  ae as StoredFileEvent,
-  De as camelCase,
-  Oe as getDeepValue,
-  j as persistent,
-  _ as persistentParser,
-  le as persistentPureReference,
-  de as persistentPureReferenceWithCachedProps,
-  ue as persistentReference,
-  ce as persistentReferenceAt,
-  he as persistentReferenceWithCachedProps,
-  re as registerCloudStorage,
-  fe as registerLegacyClassName,
-  ee as registerPersistentClass,
-  Ce as replaceValue,
-  pe as required,
-  ge as requiredWithValidator,
-  me as searchableArray,
-  Se as snakeCase,
-  _e as typeName
-};
-//# sourceMappingURL=entropic-bond.js.map
+//#endregion
+export { L as Auth, R as AuthMock, I as AuthService, z as CloudFunctions, B as CloudFunctionsMock, j as CloudStorage, k as DataSource, w as EntropicComponent, A as JsonDataSource, N as MockCloudStorage, T as Model, e as Observable, u as Persistent, E as Query, H as ServerAuth, U as ServerAuthMock, V as ServerAuthService, D as Store, F as StoredFile, P as StoredFileEvent, G as camelCase, q as getDeepValue, d as persistent, _ as persistentParser, h as persistentPureReference, g as persistentPureReferenceWithCachedProps, p as persistentReference, f as persistentReferenceAt, m as persistentReferenceWithCachedProps, M as registerCloudStorage, y as registerLegacyClassName, v as registerPersistentClass, W as replaceValue, x as required, S as requiredWithValidator, b as searchableArray, K as snakeCase, C as typeName };
+
+//# sourceMappingURL=entropic-bond.js.map