@entropic-bond/crud-panel 4.0.4 → 4.1.0

package/lib/entropic-bond-crud-panel.js

@@ -0,0 +1,2362 @@
+class Le {
+  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(t) {
+    return this.subscribers.add(t), () => this.unsubscribe(t);
+  }
+  /**
+   * Removes the callback from the notification list.
+   * 
+   * @param listenerCallback the listener callback to remove
+   */
+  unsubscribe(t) {
+    this.subscribers.delete(t);
+  }
+  /**
+   * Notifies all the subscribers with the event passed as parameter.
+   * 
+   * @param event the event passed to all subscribers.
+   */
+  notify(t) {
+    this.subscribers.forEach((s) => s(t));
+  }
+  /**
+   * 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;
+  }
+}
+let Me;
+const Qr = new Uint8Array(16);
+function Xr() {
+  if (!Me && (Me = typeof crypto < "u" && crypto.getRandomValues && crypto.getRandomValues.bind(crypto), !Me))
+    throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
+  return Me(Qr);
+}
+const N = [];
+for (let n = 0; n < 256; ++n)
+  N.push((n + 256).toString(16).slice(1));
+function Zr(n, t = 0) {
+  return N[n[t + 0]] + N[n[t + 1]] + N[n[t + 2]] + N[n[t + 3]] + "-" + N[n[t + 4]] + N[n[t + 5]] + "-" + N[n[t + 6]] + N[n[t + 7]] + "-" + N[n[t + 8]] + N[n[t + 9]] + "-" + N[n[t + 10]] + N[n[t + 11]] + N[n[t + 12]] + N[n[t + 13]] + N[n[t + 14]] + N[n[t + 15]];
+}
+const en = typeof crypto < "u" && crypto.randomUUID && crypto.randomUUID.bind(crypto), Mt = {
+  randomUUID: en
+};
+function tn(n, t, s) {
+  if (Mt.randomUUID && !t && !n)
+    return Mt.randomUUID();
+  n = n || {};
+  const l = n.random || (n.rng || Xr)();
+  if (l[6] = l[6] & 15 | 64, l[8] = l[8] & 63 | 128, t) {
+    s = s || 0;
+    for (let c = 0; c < 16; ++c)
+      t[s + c] = l[c];
+    return t;
+  }
+  return Zr(l);
+}
+var rn = Object.defineProperty, nn = Object.getOwnPropertyDescriptor, on = (n, t, s, l) => {
+  for (var c = l > 1 ? void 0 : l ? nn(t, s) : t, y = n.length - 1, D; y >= 0; y--)
+    (D = n[y]) && (c = (l ? D(t, s, c) : D(c)) || c);
+  return l && c && rn(t, s, c), c;
+}, x;
+const xt = (x = 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(n, t, s) {
+    this._factoryMap[n] = { factory: t, annotation: 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(n) {
+    if (!n)
+      throw new Error("You should provide a class name.");
+    if (!this._factoryMap[n])
+      throw new Error(`You should register class ${n} prior to use.`);
+    return this._factoryMap[n].factory;
+  }
+  /**
+   * Returns the names of all registered classes
+   * @returns the names of all registered classes
+   * @see registerFactory
+   * @see classFactory
+   */
+  static registeredClasses() {
+    return Object.keys(this._factoryMap);
+  }
+  /**
+   * Returns the names of all registered classes that extend a given class
+   * @param derivedFrom the class to be extended
+   * @returns the names of all registered classes that extend the given class
+   * @see registerFactory
+   * @see classFactory
+   */
+  static classesExtending(n) {
+    return Object.entries(this._factoryMap).filter(([, t]) => new t.factory() instanceof n).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(n) {
+    if (n instanceof x ? n = n.className : typeof n == "string" || (n = new n().className), !this._factoryMap[n])
+      throw new Error(`You should register class ${n} prior to use.`);
+    return this._factoryMap[n].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(n = tn()) {
+    this._id = n;
+  }
+  /**
+   * 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(n) {
+    this._id = n;
+  }
+  /**
+   * 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((n) => ({
+      ...n,
+      name: n.name.slice(1)
+    })) : [];
+  }
+  /**
+   * Get the property information of this instance
+   * @param propName the persistent property name
+   * @returns the property information
+   */
+  getPropInfo(n) {
+    const t = this.getPersistentProperties().find((s) => s.name === n);
+    if (!t)
+      throw new Error(`Property "${n}" 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(n) {
+    return this.getPropInfo(n).validator != 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(n) {
+    const t = this.getPropInfo(n);
+    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(n) {
+    const t = n.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(n) {
+    return this.fromObj(n), this.afterDeserialize(), this;
+  }
+  fromObj(n) {
+    return this._persistentProperties ? (this._persistentProperties.forEach((t) => {
+      const s = this.removeUnderscore(t), l = n[s];
+      l != null && (this[t.name] = this.fromDeepObject(l));
+    }), 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 n = {}, t = this.toObj(n);
+    return this.pushDocument(n, this.className, t), {
+      ...t,
+      __rootCollections: n
+    };
+  }
+  toObj(n) {
+    if (!this._persistentProperties)
+      return {};
+    this.beforeSerialize();
+    const t = {};
+    if (!this.className)
+      throw new Error("You should register this class prior to streaming it.");
+    return this._persistentProperties.forEach((s) => {
+      const l = this[s.name], c = this.removeUnderscore(s);
+      l != null && (s.isReference ? t[c] = this.toReferenceObj(s, n) : t[c] = this.toDeepObj(l, n), s.searchableArray && (t[x.searchableArrayNameFor(c)] = l.map((y) => y.id)));
+    }), t.__className = this.className, t;
+  }
+  static searchableArrayNameFor(n) {
+    return `__${n}_searchable`;
+  }
+  fromDeepObject(n) {
+    if (n == null)
+      return n;
+    if (Array.isArray(n))
+      return n.map((t) => this.fromDeepObject(t));
+    if (n.__documentReference) {
+      const t = n, s = x.createInstance(t);
+      return s.__documentReference = n.__documentReference, s;
+    }
+    if (n.__className)
+      return x.createInstance(n);
+    if (typeof n == "object") {
+      const t = {};
+      return Object.entries(n).forEach(
+        ([s, l]) => t[s] = this.fromDeepObject(l)
+      ), t;
+    }
+    return n;
+  }
+  toDeepObj(n, t) {
+    if (n != null) {
+      if (Array.isArray(n))
+        return n.map((s) => this.toDeepObj(s, t));
+      if (n.__documentReference)
+        return n;
+      if (n instanceof x)
+        return n.toObj(t);
+      if (typeof n == "object") {
+        const s = {};
+        return Object.entries(n).forEach(
+          ([l, c]) => s[l] = this.toDeepObj(c, t)
+        ), s;
+      }
+      return n;
+    }
+  }
+  toReferenceObj(n, t) {
+    const s = this[n.name], l = (c) => {
+      let y;
+      return typeof n.storeInCollection == "function" ? y = n.storeInCollection(c, n) : y = n.storeInCollection || c.className, y;
+    };
+    return Array.isArray(s) ? s.map((c) => (n.isPureReference || this.pushDocument(t, l(c), c), this.buildRefObject(c, l(c), n.forcedPersistentProps))) : (n.isPureReference || this.pushDocument(t, l(s), s), this.buildRefObject(s, l(s), n.forcedPersistentProps));
+  }
+  buildRefObject(n, t, s) {
+    const l = s == null ? void 0 : s.reduce((c, y) => (n[y] !== void 0 && (c[y] = n[y]), c), {});
+    return {
+      id: n.id,
+      __className: n.className || n.__className,
+      __documentReference: {
+        storedInCollection: t
+      },
+      ...l
+    };
+  }
+  pushDocument(n, t, s) {
+    if ("__documentReference" in s && s.__documentReference)
+      return;
+    n[t] || (n[t] = []);
+    const l = this.toDeepObj(s, n);
+    n[t].push(l);
+  }
+  removeUnderscore(n) {
+    return n.name.slice(1);
+  }
+  static createReference(n) {
+    const t = x.createInstance(n);
+    return t.__documentReference = n.__documentReference || { storedInCollection: t.className }, t;
+  }
+  static createInstance(n) {
+    if (typeof n == "string")
+      return new (x.classFactory(n))();
+    try {
+      return new (x.classFactory(n.__className))().fromObject(n);
+    } catch (t) {
+      const s = Object.entries(n).filter(([l, c]) => c != null && typeof c != "function").map(([l, c]) => `${l}: ${c}`).join(`,
+	`);
+      throw new Error(`${t}
+-----> Class name not found in object:
+{
+	 ${s} 
+}
+`);
+    }
+  }
+  static propInfo(n, t) {
+    return x.createInstance(n).getPropInfo(t);
+  }
+}, x._factoryMap = {}, x);
+on([
+  de
+], xt.prototype, "_id", 2);
+let Wt = xt;
+function de(n, t) {
+  return sn()(n, t);
+}
+function sn(n) {
+  return function(t, s) {
+    Object.getOwnPropertyDescriptor(t, "_persistentProperties") || (t._persistentProperties ? t._persistentProperties = [...t._persistentProperties] : t._persistentProperties = []);
+    const l = t._persistentProperties.find((c) => c.name === s);
+    l ? Object.assign(l, n) : t._persistentProperties.push({
+      name: s,
+      ...n
+    });
+  };
+}
+function an(n, t) {
+  return (s) => {
+    Wt.registerFactory(n, s, t), s.prototype.__className = n;
+  };
+}
+const Yt = class le {
+  static registerCloudStorage(t, s) {
+    le._cloudStorageFactoryMap[t] = s;
+  }
+  static createInstance(t) {
+    const s = le._cloudStorageFactoryMap[t];
+    if (!s)
+      throw new Error(`You should register the ${t} cloud storage provider prior to use it`);
+    return s();
+  }
+  get className() {
+    return this.__className;
+  }
+  static useCloudStorage(t) {
+    le._defaultCloudStorage = t;
+  }
+  static get defaultCloudStorage() {
+    if (!le._defaultCloudStorage)
+      throw new Error("You should define a default cloud storage provider prior to use it");
+    return le._defaultCloudStorage;
+  }
+};
+Yt._cloudStorageFactoryMap = {};
+let be = Yt;
+function un(n, t) {
+  return be.registerCloudStorage(n, t), (s) => {
+    s.prototype.__className = n;
+  };
+}
+var cn = Object.defineProperty, ln = Object.getOwnPropertyDescriptor, fn = (n, t, s, l) => {
+  for (var c = l > 1 ? void 0 : l ? ln(t, s) : t, y = n.length - 1, D; y >= 0; y--)
+    (D = n[y]) && (c = (l ? D(t, s, c) : D(c)) || c);
+  return l && c && cn(t, s, c), c;
+};
+let Ze = class extends be {
+  constructor(n = "") {
+    super(), this._simulateDelay = 0, this._pendingPromises = [], this.mockFileSystem = {}, this._pathToMockFiles = n;
+  }
+  /**
+   * 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(n) {
+    return this._simulateDelay = n, this;
+  }
+  resolveWithDelay(n) {
+    if (this._simulateDelay <= 0)
+      return Promise.resolve(n);
+    const t = new Promise((s) => {
+      setTimeout(
+        () => s(n),
+        this._simulateDelay
+      );
+    });
+    return this._pendingPromises.push(t), t.finally(
+      () => this._pendingPromises = this._pendingPromises.filter((s) => s === t)
+    ), t;
+  }
+  save(n, t) {
+    const s = n;
+    this._onProgress && this._onProgress(0, 100), this.mockFileSystem[n] = JSON.stringify(t), this._onProgress && this._onProgress(100, 100);
+    const l = t instanceof File ? t.name : s;
+    return this.resolveWithDelay(l);
+  }
+  uploadControl() {
+    return {
+      resume: () => {
+      },
+      pause: () => {
+      },
+      cancel: () => {
+      },
+      onProgress: (n) => this._onProgress = n
+    };
+  }
+  getUrl(n) {
+    return Promise.resolve(this._pathToMockFiles + n);
+  }
+  delete(n) {
+    return delete this.mockFileSystem[n], this.resolveWithDelay();
+  }
+};
+Ze = fn([
+  un("MockCloudStorage", () => new Ze())
+], Ze);
+var dn = Object.defineProperty, pn = Object.getOwnPropertyDescriptor, pe = (n, t, s, l) => {
+  for (var c = l > 1 ? void 0 : l ? pn(t, s) : t, y = n.length - 1, D; y >= 0; y--)
+    (D = n[y]) && (c = (l ? D(t, s, c) : D(c)) || c);
+  return l && c && dn(t, s, c), c;
+};
+let ne = class extends Wt {
+  constructor() {
+    super(...arguments), this._onChange = new Le();
+  }
+  async save({ data: n, fileName: t, progress: s, cloudStorageProvider: l } = {}) {
+    const c = n || this._pendingData;
+    c && (this._reference && await this.delete(), this.provider = l || be.defaultCloudStorage, this._originalFileName = t || (c instanceof File ? c.name : void 0), this._reference = await this.provider.save(this.id, c, s), 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(n) {
+    this._provider = n, this._cloudStorageProviderName = n.className;
+  }
+  get provider() {
+    if (!this._provider)
+      try {
+        this._provider = be.createInstance(this._cloudStorageProviderName);
+      } catch {
+        this._provider = be.defaultCloudStorage;
+      }
+    return this._provider;
+  }
+  get url() {
+    return this._url;
+  }
+  get mimeType() {
+    return this._mimeType;
+  }
+  setDataToStore(n) {
+    return this._pendingData = n, this._originalFileName = n instanceof File ? n.name : void 0, this._mimeType = n instanceof Blob ? n.type : void 0, this._onChange.notify({
+      event: 1,
+      pendingData: n,
+      storedFile: this
+    }), this;
+  }
+  get originalFileName() {
+    return this._originalFileName;
+  }
+  onChange(n) {
+    return this._onChange.subscribe(n);
+  }
+};
+pe([
+  de
+], ne.prototype, "_reference", 2);
+pe([
+  de
+], ne.prototype, "_url", 2);
+pe([
+  de
+], ne.prototype, "_cloudStorageProviderName", 2);
+pe([
+  de
+], ne.prototype, "_originalFileName", 2);
+pe([
+  de
+], ne.prototype, "_mimeType", 2);
+ne = pe([
+  an("StoredFile")
+], ne);
+function hn(n, t = "-") {
+  if (!n)
+    return "";
+  const s = n.slice(1).replace(/( |[A-Z])/g, (l) => l === " " ? "-" : t + l[0].toLowerCase());
+  return n[0].toLocaleLowerCase() + s.replace(/--/g, "-");
+}
+class mn {
+  constructor() {
+    this._stages = {}, this._onProgress = new Le();
+  }
+  notifyBusy(t, s) {
+    this.pushStage({
+      name: s ?? "",
+      progress: t ? 0 : 1,
+      total: 1
+    });
+  }
+  pushStage(t) {
+    this._stages[t.name] = t;
+    const s = Object.values(this._stages).reduce((l, c, y, D) => l + c.progress / c.total / D.length, 0);
+    this._onProgress.notify({
+      busy: s < 1,
+      overallProgress: s,
+      stages: this._stages
+    }), s >= 1 && (this._stages = {});
+  }
+  onProgress(t) {
+    return this._onProgress.subscribe(t);
+  }
+}
+const re = class re {
+  constructor(t) {
+    this.progressController = new mn(), this.onChangeHdl = new Le(), this.onErrorHdl = new Le(), this.validator = {}, this.setDocument(t || this.createDocument());
+  }
+  allRequiredPropertiesFilled() {
+    return this.nonFilledRequiredProperties.length <= 0;
+  }
+  get nonFilledRequiredProperties() {
+    return this.requiredProperties.filter((t) => this.validateProp(t));
+  }
+  get requiredProperties() {
+    if (!this.document)
+      throw new Error(re.errorMessages.missedDocument);
+    return this.document.getPersistentProperties().filter((t) => this.document.isRequired(t.name)).map((t) => t.name);
+  }
+  addValidator(t, s, l) {
+    this.validator[t] = {
+      func: s,
+      errorMessage: l
+    };
+  }
+  removeValidator(t) {
+    delete this.validator[t];
+  }
+  failedValidationError(t) {
+    var s;
+    return (s = this.validator[t]) == null ? void 0 : s.errorMessage;
+  }
+  validateProp(t) {
+    if (!this.document)
+      throw new Error(re.errorMessages.missedDocument);
+    const s = this.document[t];
+    return this.validator[t] ? !this.validator[t].func(s) : !this.document.isPropValueValid(t);
+  }
+  storeDoc() {
+    if (!this.document)
+      throw new Error(re.errorMessages.missedDocument);
+    return this.model.save(this.document);
+  }
+  deleteDoc() {
+    if (!this.document)
+      throw new Error(re.errorMessages.missedDocument);
+    return this.model.delete(this.document.id);
+  }
+  /**
+   * Override this method to customize the query used to retrieve the documents 
+   * in the documentCollection method. This is the default method used by 
+   * the documentCollection method. If the findDocs method is overridden and returns
+   * non undefined value, then this queryDocs method will not be used.
+   * 
+   * @param limit the maximum number of documents to retrieve
+   * @returns a query to retrieve the documents
+   * @see documentCollection
+   * @see findDocs
+   */
+  queryDocs(t) {
+    let s = this.model.find();
+    return t && (s = s.limit(t)), s;
+  }
+  /**
+   * Override this method to customize the query used to retrieve the documents 
+   * in the documentCollection method. The default method called by the 
+   * documentCollection method is the queryDocs method. If this findDocs method 
+   * returns a non undefined value, then this method will be used instead of the
+   * queryDocs method.
+   * 
+   * @param limit the maximum number of documents to retrieve
+   * @returns a query to retrieve the documents
+   * @see documentCollection
+   * @see queryDocs
+   */
+  findDocs(t) {
+  }
+  /**
+   * Sets a filter function to filter in memory the documents returned by the `documentCollection` method.
+   * 
+   * @param filter the filter function
+   * @returns the controller itself
+   */
+  async setFilter(t) {
+    return this._filter = t, this.onChangeHdl.notify({ action: "filterChange" }), this;
+  }
+  /**
+   * Removes the filter function set by the `setFilter` method.
+   * @returns the controller itself
+   */
+  resetFilter() {
+    return this._filter = void 0, this.onChangeHdl.notify({ action: "filterChange" }), this;
+  }
+  onChange(t) {
+    return this.onChangeHdl.subscribe(t);
+  }
+  /**
+   * Notifies the observer of any error that occurs during the execution of the controller.
+   * If there are no subscribers to this event, the error will be thrown.
+   * 
+   * @param observer 
+   * @returns the unsubscriber function
+   */
+  onError(t) {
+    return this.onErrorHdl.subscribe(t);
+  }
+  notifyChange(t) {
+    this.onChangeHdl.notify(t);
+  }
+  newDocument() {
+    return this.setDocument(this.createDocument());
+  }
+  async storeDocument() {
+    const t = "Saving main document";
+    try {
+      this.progressController.notifyBusy(!0, t), await this.storeDoc(), this.onChangeHdl.notify({
+        documentCollection: await this.documentCollection(),
+        action: "saved"
+      });
+    } catch (s) {
+      if (this.onChangeHdl.notify({ error: this.errorToError(s) }), this.onErrorHdl.notify(this.errorToError(s)), this.throwOnError)
+        throw s;
+    } finally {
+      this.progressController.notifyBusy(!1, t);
+    }
+  }
+  async deleteDocument() {
+    const t = "Delete main document";
+    try {
+      this.progressController.notifyBusy(!0, t), await this.deleteDoc(), this.onChangeHdl.notify({
+        documentCollection: await this.documentCollection(),
+        action: "deleted"
+      });
+    } catch (s) {
+      if (this.onChangeHdl.notify({ error: this.errorToError(s) }), this.onErrorHdl.notify(this.errorToError(s)), this.throwOnError)
+        throw s;
+    } finally {
+      this.progressController.notifyBusy(!1, t);
+    }
+  }
+  async documentCollection(t) {
+    const s = "Retrieving document collection";
+    let l = [];
+    try {
+      this.progressController.notifyBusy(!0, s);
+      const c = this.findDocs(t);
+      c ? l = await c : l = await this.queryDocs(t).get();
+    } catch (c) {
+      if (this.onChangeHdl.notify({ error: this.errorToError(c) }), this.onErrorHdl.notify(this.errorToError(c)), this.throwOnError)
+        throw c;
+    } finally {
+      this.progressController.notifyBusy(!1, s);
+    }
+    return l;
+  }
+  filter(t) {
+    return t.filter((s) => {
+      var l;
+      return ((l = this._filter) == null ? void 0 : l.call(this, s)) ?? !0;
+    });
+  }
+  onProgress(t) {
+    return this.progressController.onProgress(t);
+  }
+  get model() {
+    return this._model || (this._model = this.getModel());
+  }
+  setDocument(t) {
+    return this._document !== t && (this.unsubscribeDocument && this.unsubscribeDocument(), t && (this.unsubscribeDocument = t.onChange((s) => this.onChangeHdl.notify({ documentProps: s }))), this._document = t, this.onChangeHdl.notify({ documentChanged: this._document })), this;
+  }
+  set document(t) {
+    this.setDocument(t);
+  }
+  get document() {
+    return this._document;
+  }
+  /**
+   * Use this method to throw an error in a controlled way.
+   * It will notify the subscribers of the `onError` event and throw the error 
+   * if there are no subscribers to the `onError` event.
+   * 
+   * @param error the error to throw
+   */
+  managedThrow(t) {
+    if (this.onChangeHdl.notify({ error: this.errorToError(t) }), this.onErrorHdl.notify(this.errorToError(t)), this.throwOnError)
+      throw this.errorToError(t);
+  }
+  errorToError(t) {
+    return t instanceof Error ? t : typeof t == "string" ? new Error(t) : "code" in t ? new Error(t.code) : "message" in t ? new Error(t.error) : new Error(JSON.stringify(t));
+  }
+  get throwOnError() {
+    return this.onErrorHdl.subscribersCount === 0;
+  }
+};
+re.errorMessages = {
+  missedDocument: "No document to save"
+};
+let Lt = re;
+function yn(n) {
+  return n && n.__esModule && Object.prototype.hasOwnProperty.call(n, "default") ? n.default : n;
+}
+var et = { exports: {} }, g = {};
+/**
+ * @license React
+ * react.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var Ut;
+function vn() {
+  if (Ut)
+    return g;
+  Ut = 1;
+  var n = Symbol.for("react.element"), t = Symbol.for("react.portal"), s = Symbol.for("react.fragment"), l = Symbol.for("react.strict_mode"), c = Symbol.for("react.profiler"), y = Symbol.for("react.provider"), D = Symbol.for("react.context"), F = Symbol.for("react.forward_ref"), U = Symbol.for("react.suspense"), B = Symbol.for("react.memo"), z = Symbol.for("react.lazy"), H = Symbol.iterator;
+  function Z(o) {
+    return o === null || typeof o != "object" ? null : (o = H && o[H] || o["@@iterator"], typeof o == "function" ? o : null);
+  }
+  var V = { isMounted: function() {
+    return !1;
+  }, enqueueForceUpdate: function() {
+  }, enqueueReplaceState: function() {
+  }, enqueueSetState: function() {
+  } }, q = Object.assign, Ee = {};
+  function K(o, f, v) {
+    this.props = o, this.context = f, this.refs = Ee, this.updater = v || V;
+  }
+  K.prototype.isReactComponent = {}, K.prototype.setState = function(o, f) {
+    if (typeof o != "object" && typeof o != "function" && o != null)
+      throw Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");
+    this.updater.enqueueSetState(this, o, f, "setState");
+  }, K.prototype.forceUpdate = function(o) {
+    this.updater.enqueueForceUpdate(this, o, "forceUpdate");
+  };
+  function we() {
+  }
+  we.prototype = K.prototype;
+  function oe(o, f, v) {
+    this.props = o, this.context = f, this.refs = Ee, this.updater = v || V;
+  }
+  var ie = oe.prototype = new we();
+  ie.constructor = oe, q(ie, K.prototype), ie.isPureReactComponent = !0;
+  var G = Array.isArray, A = Object.prototype.hasOwnProperty, L = { current: null }, J = { key: !0, ref: !0, __self: !0, __source: !0 };
+  function ee(o, f, v) {
+    var E, _ = {}, C = null, k = null;
+    if (f != null)
+      for (E in f.ref !== void 0 && (k = f.ref), f.key !== void 0 && (C = "" + f.key), f)
+        A.call(f, E) && !J.hasOwnProperty(E) && (_[E] = f[E]);
+    var R = arguments.length - 2;
+    if (R === 1)
+      _.children = v;
+    else if (1 < R) {
+      for (var P = Array(R), $ = 0; $ < R; $++)
+        P[$] = arguments[$ + 2];
+      _.children = P;
+    }
+    if (o && o.defaultProps)
+      for (E in R = o.defaultProps, R)
+        _[E] === void 0 && (_[E] = R[E]);
+    return { $$typeof: n, type: o, key: C, ref: k, props: _, _owner: L.current };
+  }
+  function Ce(o, f) {
+    return { $$typeof: n, type: o.type, key: f, ref: o.ref, props: o.props, _owner: o._owner };
+  }
+  function he(o) {
+    return typeof o == "object" && o !== null && o.$$typeof === n;
+  }
+  function Ue(o) {
+    var f = { "=": "=0", ":": "=2" };
+    return "$" + o.replace(/[=:]/g, function(v) {
+      return f[v];
+    });
+  }
+  var Re = /\/+/g;
+  function me(o, f) {
+    return typeof o == "object" && o !== null && o.key != null ? Ue("" + o.key) : f.toString(36);
+  }
+  function se(o, f, v, E, _) {
+    var C = typeof o;
+    (C === "undefined" || C === "boolean") && (o = null);
+    var k = !1;
+    if (o === null)
+      k = !0;
+    else
+      switch (C) {
+        case "string":
+        case "number":
+          k = !0;
+          break;
+        case "object":
+          switch (o.$$typeof) {
+            case n:
+            case t:
+              k = !0;
+          }
+      }
+    if (k)
+      return k = o, _ = _(k), o = E === "" ? "." + me(k, 0) : E, G(_) ? (v = "", o != null && (v = o.replace(Re, "$&/") + "/"), se(_, f, v, "", function($) {
+        return $;
+      })) : _ != null && (he(_) && (_ = Ce(_, v + (!_.key || k && k.key === _.key ? "" : ("" + _.key).replace(Re, "$&/") + "/") + o)), f.push(_)), 1;
+    if (k = 0, E = E === "" ? "." : E + ":", G(o))
+      for (var R = 0; R < o.length; R++) {
+        C = o[R];
+        var P = E + me(C, R);
+        k += se(C, f, v, P, _);
+      }
+    else if (P = Z(o), typeof P == "function")
+      for (o = P.call(o), R = 0; !(C = o.next()).done; )
+        C = C.value, P = E + me(C, R++), k += se(C, f, v, P, _);
+    else if (C === "object")
+      throw f = String(o), Error("Objects are not valid as a React child (found: " + (f === "[object Object]" ? "object with keys {" + Object.keys(o).join(", ") + "}" : f) + "). If you meant to render a collection of children, use an array instead.");
+    return k;
+  }
+  function Y(o, f, v) {
+    if (o == null)
+      return o;
+    var E = [], _ = 0;
+    return se(o, E, "", "", function(C) {
+      return f.call(v, C, _++);
+    }), E;
+  }
+  function Q(o) {
+    if (o._status === -1) {
+      var f = o._result;
+      f = f(), f.then(function(v) {
+        (o._status === 0 || o._status === -1) && (o._status = 1, o._result = v);
+      }, function(v) {
+        (o._status === 0 || o._status === -1) && (o._status = 2, o._result = v);
+      }), o._status === -1 && (o._status = 0, o._result = f);
+    }
+    if (o._status === 1)
+      return o._result.default;
+    throw o._result;
+  }
+  var h = { current: null }, te = { transition: null }, Pe = { ReactCurrentDispatcher: h, ReactCurrentBatchConfig: te, ReactCurrentOwner: L };
+  return g.Children = { map: Y, forEach: function(o, f, v) {
+    Y(o, function() {
+      f.apply(this, arguments);
+    }, v);
+  }, count: function(o) {
+    var f = 0;
+    return Y(o, function() {
+      f++;
+    }), f;
+  }, toArray: function(o) {
+    return Y(o, function(f) {
+      return f;
+    }) || [];
+  }, only: function(o) {
+    if (!he(o))
+      throw Error("React.Children.only expected to receive a single React element child.");
+    return o;
+  } }, g.Component = K, g.Fragment = s, g.Profiler = c, g.PureComponent = oe, g.StrictMode = l, g.Suspense = U, g.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = Pe, g.cloneElement = function(o, f, v) {
+    if (o == null)
+      throw Error("React.cloneElement(...): The argument must be a React element, but you passed " + o + ".");
+    var E = q({}, o.props), _ = o.key, C = o.ref, k = o._owner;
+    if (f != null) {
+      if (f.ref !== void 0 && (C = f.ref, k = L.current), f.key !== void 0 && (_ = "" + f.key), o.type && o.type.defaultProps)
+        var R = o.type.defaultProps;
+      for (P in f)
+        A.call(f, P) && !J.hasOwnProperty(P) && (E[P] = f[P] === void 0 && R !== void 0 ? R[P] : f[P]);
+    }
+    var P = arguments.length - 2;
+    if (P === 1)
+      E.children = v;
+    else if (1 < P) {
+      R = Array(P);
+      for (var $ = 0; $ < P; $++)
+        R[$] = arguments[$ + 2];
+      E.children = R;
+    }
+    return { $$typeof: n, type: o.type, key: _, ref: C, props: E, _owner: k };
+  }, g.createContext = function(o) {
+    return o = { $$typeof: D, _currentValue: o, _currentValue2: o, _threadCount: 0, Provider: null, Consumer: null, _defaultValue: null, _globalName: null }, o.Provider = { $$typeof: y, _context: o }, o.Consumer = o;
+  }, g.createElement = ee, g.createFactory = function(o) {
+    var f = ee.bind(null, o);
+    return f.type = o, f;
+  }, g.createRef = function() {
+    return { current: null };
+  }, g.forwardRef = function(o) {
+    return { $$typeof: F, render: o };
+  }, g.isValidElement = he, g.lazy = function(o) {
+    return { $$typeof: z, _payload: { _status: -1, _result: o }, _init: Q };
+  }, g.memo = function(o, f) {
+    return { $$typeof: B, type: o, compare: f === void 0 ? null : f };
+  }, g.startTransition = function(o) {
+    var f = te.transition;
+    te.transition = {};
+    try {
+      o();
+    } finally {
+      te.transition = f;
+    }
+  }, g.unstable_act = function() {
+    throw Error("act(...) is not supported in production builds of React.");
+  }, g.useCallback = function(o, f) {
+    return h.current.useCallback(o, f);
+  }, g.useContext = function(o) {
+    return h.current.useContext(o);
+  }, g.useDebugValue = function() {
+  }, g.useDeferredValue = function(o) {
+    return h.current.useDeferredValue(o);
+  }, g.useEffect = function(o, f) {
+    return h.current.useEffect(o, f);
+  }, g.useId = function() {
+    return h.current.useId();
+  }, g.useImperativeHandle = function(o, f, v) {
+    return h.current.useImperativeHandle(o, f, v);
+  }, g.useInsertionEffect = function(o, f) {
+    return h.current.useInsertionEffect(o, f);
+  }, g.useLayoutEffect = function(o, f) {
+    return h.current.useLayoutEffect(o, f);
+  }, g.useMemo = function(o, f) {
+    return h.current.useMemo(o, f);
+  }, g.useReducer = function(o, f, v) {
+    return h.current.useReducer(o, f, v);
+  }, g.useRef = function(o) {
+    return h.current.useRef(o);
+  }, g.useState = function(o) {
+    return h.current.useState(o);
+  }, g.useSyncExternalStore = function(o, f, v) {
+    return h.current.useSyncExternalStore(o, f, v);
+  }, g.useTransition = function() {
+    return h.current.useTransition();
+  }, g.version = "18.2.0", g;
+}
+var _e = { exports: {} };
+/**
+ * @license React
+ * react.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+_e.exports;
+var Vt;
+function gn() {
+  return Vt || (Vt = 1, function(n, t) {
+    process.env.NODE_ENV !== "production" && function() {
+      typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
+      var s = "18.2.0", l = Symbol.for("react.element"), c = Symbol.for("react.portal"), y = Symbol.for("react.fragment"), D = Symbol.for("react.strict_mode"), F = Symbol.for("react.profiler"), U = Symbol.for("react.provider"), B = Symbol.for("react.context"), z = Symbol.for("react.forward_ref"), H = Symbol.for("react.suspense"), Z = Symbol.for("react.suspense_list"), V = Symbol.for("react.memo"), q = Symbol.for("react.lazy"), Ee = Symbol.for("react.offscreen"), K = Symbol.iterator, we = "@@iterator";
+      function oe(e) {
+        if (e === null || typeof e != "object")
+          return null;
+        var r = K && e[K] || e[we];
+        return typeof r == "function" ? r : null;
+      }
+      var ie = {
+        /**
+         * @internal
+         * @type {ReactComponent}
+         */
+        current: null
+      }, G = {
+        transition: null
+      }, A = {
+        current: null,
+        // Used to reproduce behavior of `batchedUpdates` in legacy mode.
+        isBatchingLegacy: !1,
+        didScheduleLegacyUpdate: !1
+      }, L = {
+        /**
+         * @internal
+         * @type {ReactComponent}
+         */
+        current: null
+      }, J = {}, ee = null;
+      function Ce(e) {
+        ee = e;
+      }
+      J.setExtraStackFrame = function(e) {
+        ee = e;
+      }, J.getCurrentStack = null, J.getStackAddendum = function() {
+        var e = "";
+        ee && (e += ee);
+        var r = J.getCurrentStack;
+        return r && (e += r() || ""), e;
+      };
+      var he = !1, Ue = !1, Re = !1, me = !1, se = !1, Y = {
+        ReactCurrentDispatcher: ie,
+        ReactCurrentBatchConfig: G,
+        ReactCurrentOwner: L
+      };
+      Y.ReactDebugCurrentFrame = J, Y.ReactCurrentActQueue = A;
+      function Q(e) {
+        {
+          for (var r = arguments.length, i = new Array(r > 1 ? r - 1 : 0), a = 1; a < r; a++)
+            i[a - 1] = arguments[a];
+          te("warn", e, i);
+        }
+      }
+      function h(e) {
+        {
+          for (var r = arguments.length, i = new Array(r > 1 ? r - 1 : 0), a = 1; a < r; a++)
+            i[a - 1] = arguments[a];
+          te("error", e, i);
+        }
+      }
+      function te(e, r, i) {
+        {
+          var a = Y.ReactDebugCurrentFrame, u = a.getStackAddendum();
+          u !== "" && (r += "%s", i = i.concat([u]));
+          var p = i.map(function(d) {
+            return String(d);
+          });
+          p.unshift("Warning: " + r), Function.prototype.apply.call(console[e], console, p);
+        }
+      }
+      var Pe = {};
+      function o(e, r) {
+        {
+          var i = e.constructor, a = i && (i.displayName || i.name) || "ReactClass", u = a + "." + r;
+          if (Pe[u])
+            return;
+          h("Can't call %s on a component that is not yet mounted. This is a no-op, but it might indicate a bug in your application. Instead, assign to `this.state` directly or define a `state = {};` class property with the desired state in the %s component.", r, a), Pe[u] = !0;
+        }
+      }
+      var f = {
+        /**
+         * Checks whether or not this composite component is mounted.
+         * @param {ReactClass} publicInstance The instance we want to test.
+         * @return {boolean} True if mounted, false otherwise.
+         * @protected
+         * @final
+         */
+        isMounted: function(e) {
+          return !1;
+        },
+        /**
+         * Forces an update. This should only be invoked when it is known with
+         * certainty that we are **not** in a DOM transaction.
+         *
+         * You may want to call this when you know that some deeper aspect of the
+         * component's state has changed but `setState` was not called.
+         *
+         * This will not invoke `shouldComponentUpdate`, but it will invoke
+         * `componentWillUpdate` and `componentDidUpdate`.
+         *
+         * @param {ReactClass} publicInstance The instance that should rerender.
+         * @param {?function} callback Called after component is updated.
+         * @param {?string} callerName name of the calling function in the public API.
+         * @internal
+         */
+        enqueueForceUpdate: function(e, r, i) {
+          o(e, "forceUpdate");
+        },
+        /**
+         * Replaces all of the state. Always use this or `setState` to mutate state.
+         * You should treat `this.state` as immutable.
+         *
+         * There is no guarantee that `this.state` will be immediately updated, so
+         * accessing `this.state` after calling this method may return the old value.
+         *
+         * @param {ReactClass} publicInstance The instance that should rerender.
+         * @param {object} completeState Next state.
+         * @param {?function} callback Called after component is updated.
+         * @param {?string} callerName name of the calling function in the public API.
+         * @internal
+         */
+        enqueueReplaceState: function(e, r, i, a) {
+          o(e, "replaceState");
+        },
+        /**
+         * Sets a subset of the state. This only exists because _pendingState is
+         * internal. This provides a merging strategy that is not available to deep
+         * properties which is confusing. TODO: Expose pendingState or don't use it
+         * during the merge.
+         *
+         * @param {ReactClass} publicInstance The instance that should rerender.
+         * @param {object} partialState Next partial state to be merged with state.
+         * @param {?function} callback Called after component is updated.
+         * @param {?string} Name of the calling function in the public API.
+         * @internal
+         */
+        enqueueSetState: function(e, r, i, a) {
+          o(e, "setState");
+        }
+      }, v = Object.assign, E = {};
+      Object.freeze(E);
+      function _(e, r, i) {
+        this.props = e, this.context = r, this.refs = E, this.updater = i || f;
+      }
+      _.prototype.isReactComponent = {}, _.prototype.setState = function(e, r) {
+        if (typeof e != "object" && typeof e != "function" && e != null)
+          throw new Error("setState(...): takes an object of state variables to update or a function which returns an object of state variables.");
+        this.updater.enqueueSetState(this, e, r, "setState");
+      }, _.prototype.forceUpdate = function(e) {
+        this.updater.enqueueForceUpdate(this, e, "forceUpdate");
+      };
+      {
+        var C = {
+          isMounted: ["isMounted", "Instead, make sure to clean up subscriptions and pending requests in componentWillUnmount to prevent memory leaks."],
+          replaceState: ["replaceState", "Refactor your code to use setState instead (see https://github.com/facebook/react/issues/3236)."]
+        }, k = function(e, r) {
+          Object.defineProperty(_.prototype, e, {
+            get: function() {
+              Q("%s(...) is deprecated in plain JavaScript React classes. %s", r[0], r[1]);
+            }
+          });
+        };
+        for (var R in C)
+          C.hasOwnProperty(R) && k(R, C[R]);
+      }
+      function P() {
+      }
+      P.prototype = _.prototype;
+      function $(e, r, i) {
+        this.props = e, this.context = r, this.refs = E, this.updater = i || f;
+      }
+      var Ve = $.prototype = new P();
+      Ve.constructor = $, v(Ve, _.prototype), Ve.isPureReactComponent = !0;
+      function Ht() {
+        var e = {
+          current: null
+        };
+        return Object.seal(e), e;
+      }
+      var Bt = Array.isArray;
+      function Se(e) {
+        return Bt(e);
+      }
+      function zt(e) {
+        {
+          var r = typeof Symbol == "function" && Symbol.toStringTag, i = r && e[Symbol.toStringTag] || e.constructor.name || "Object";
+          return i;
+        }
+      }
+      function qt(e) {
+        try {
+          return tt(e), !1;
+        } catch {
+          return !0;
+        }
+      }
+      function tt(e) {
+        return "" + e;
+      }
+      function Oe(e) {
+        if (qt(e))
+          return h("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", zt(e)), tt(e);
+      }
+      function Kt(e, r, i) {
+        var a = e.displayName;
+        if (a)
+          return a;
+        var u = r.displayName || r.name || "";
+        return u !== "" ? i + "(" + u + ")" : i;
+      }
+      function rt(e) {
+        return e.displayName || "Context";
+      }
+      function X(e) {
+        if (e == null)
+          return null;
+        if (typeof e.tag == "number" && h("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), typeof e == "function")
+          return e.displayName || e.name || null;
+        if (typeof e == "string")
+          return e;
+        switch (e) {
+          case y:
+            return "Fragment";
+          case c:
+            return "Portal";
+          case F:
+            return "Profiler";
+          case D:
+            return "StrictMode";
+          case H:
+            return "Suspense";
+          case Z:
+            return "SuspenseList";
+        }
+        if (typeof e == "object")
+          switch (e.$$typeof) {
+            case B:
+              var r = e;
+              return rt(r) + ".Consumer";
+            case U:
+              var i = e;
+              return rt(i._context) + ".Provider";
+            case z:
+              return Kt(e, e.render, "ForwardRef");
+            case V:
+              var a = e.displayName || null;
+              return a !== null ? a : X(e.type) || "Memo";
+            case q: {
+              var u = e, p = u._payload, d = u._init;
+              try {
+                return X(d(p));
+              } catch {
+                return null;
+              }
+            }
+          }
+        return null;
+      }
+      var ye = Object.prototype.hasOwnProperty, nt = {
+        key: !0,
+        ref: !0,
+        __self: !0,
+        __source: !0
+      }, ot, it, xe;
+      xe = {};
+      function st(e) {
+        if (ye.call(e, "ref")) {
+          var r = Object.getOwnPropertyDescriptor(e, "ref").get;
+          if (r && r.isReactWarning)
+            return !1;
+        }
+        return e.ref !== void 0;
+      }
+      function at(e) {
+        if (ye.call(e, "key")) {
+          var r = Object.getOwnPropertyDescriptor(e, "key").get;
+          if (r && r.isReactWarning)
+            return !1;
+        }
+        return e.key !== void 0;
+      }
+      function Gt(e, r) {
+        var i = function() {
+          ot || (ot = !0, h("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", r));
+        };
+        i.isReactWarning = !0, Object.defineProperty(e, "key", {
+          get: i,
+          configurable: !0
+        });
+      }
+      function Jt(e, r) {
+        var i = function() {
+          it || (it = !0, h("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", r));
+        };
+        i.isReactWarning = !0, Object.defineProperty(e, "ref", {
+          get: i,
+          configurable: !0
+        });
+      }
+      function Qt(e) {
+        if (typeof e.ref == "string" && L.current && e.__self && L.current.stateNode !== e.__self) {
+          var r = X(L.current.type);
+          xe[r] || (h('Component "%s" contains the string ref "%s". Support for string refs will be removed in a future major release. This case cannot be automatically converted to an arrow function. We ask you to manually fix this case by using useRef() or createRef() instead. Learn more about using refs safely here: https://reactjs.org/link/strict-mode-string-ref', r, e.ref), xe[r] = !0);
+        }
+      }
+      var We = function(e, r, i, a, u, p, d) {
+        var m = {
+          // This tag allows us to uniquely identify this as a React Element
+          $$typeof: l,
+          // Built-in properties that belong on the element
+          type: e,
+          key: r,
+          ref: i,
+          props: d,
+          // Record the component responsible for creating this element.
+          _owner: p
+        };
+        return m._store = {}, Object.defineProperty(m._store, "validated", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !0,
+          value: !1
+        }), Object.defineProperty(m, "_self", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !1,
+          value: a
+        }), Object.defineProperty(m, "_source", {
+          configurable: !1,
+          enumerable: !1,
+          writable: !1,
+          value: u
+        }), Object.freeze && (Object.freeze(m.props), Object.freeze(m)), m;
+      };
+      function Xt(e, r, i) {
+        var a, u = {}, p = null, d = null, m = null, b = null;
+        if (r != null) {
+          st(r) && (d = r.ref, Qt(r)), at(r) && (Oe(r.key), p = "" + r.key), m = r.__self === void 0 ? null : r.__self, b = r.__source === void 0 ? null : r.__source;
+          for (a in r)
+            ye.call(r, a) && !nt.hasOwnProperty(a) && (u[a] = r[a]);
+        }
+        var w = arguments.length - 2;
+        if (w === 1)
+          u.children = i;
+        else if (w > 1) {
+          for (var S = Array(w), O = 0; O < w; O++)
+            S[O] = arguments[O + 2];
+          Object.freeze && Object.freeze(S), u.children = S;
+        }
+        if (e && e.defaultProps) {
+          var T = e.defaultProps;
+          for (a in T)
+            u[a] === void 0 && (u[a] = T[a]);
+        }
+        if (p || d) {
+          var j = typeof e == "function" ? e.displayName || e.name || "Unknown" : e;
+          p && Gt(u, j), d && Jt(u, j);
+        }
+        return We(e, p, d, m, b, L.current, u);
+      }
+      function Zt(e, r) {
+        var i = We(e.type, r, e.ref, e._self, e._source, e._owner, e.props);
+        return i;
+      }
+      function er(e, r, i) {
+        if (e == null)
+          throw new Error("React.cloneElement(...): The argument must be a React element, but you passed " + e + ".");
+        var a, u = v({}, e.props), p = e.key, d = e.ref, m = e._self, b = e._source, w = e._owner;
+        if (r != null) {
+          st(r) && (d = r.ref, w = L.current), at(r) && (Oe(r.key), p = "" + r.key);
+          var S;
+          e.type && e.type.defaultProps && (S = e.type.defaultProps);
+          for (a in r)
+            ye.call(r, a) && !nt.hasOwnProperty(a) && (r[a] === void 0 && S !== void 0 ? u[a] = S[a] : u[a] = r[a]);
+        }
+        var O = arguments.length - 2;
+        if (O === 1)
+          u.children = i;
+        else if (O > 1) {
+          for (var T = Array(O), j = 0; j < O; j++)
+            T[j] = arguments[j + 2];
+          u.children = T;
+        }
+        return We(e.type, p, d, m, b, w, u);
+      }
+      function ae(e) {
+        return typeof e == "object" && e !== null && e.$$typeof === l;
+      }
+      var ut = ".", tr = ":";
+      function rr(e) {
+        var r = /[=:]/g, i = {
+          "=": "=0",
+          ":": "=2"
+        }, a = e.replace(r, function(u) {
+          return i[u];
+        });
+        return "$" + a;
+      }
+      var ct = !1, nr = /\/+/g;
+      function lt(e) {
+        return e.replace(nr, "$&/");
+      }
+      function Ye(e, r) {
+        return typeof e == "object" && e !== null && e.key != null ? (Oe(e.key), rr("" + e.key)) : r.toString(36);
+      }
+      function De(e, r, i, a, u) {
+        var p = typeof e;
+        (p === "undefined" || p === "boolean") && (e = null);
+        var d = !1;
+        if (e === null)
+          d = !0;
+        else
+          switch (p) {
+            case "string":
+            case "number":
+              d = !0;
+              break;
+            case "object":
+              switch (e.$$typeof) {
+                case l:
+                case c:
+                  d = !0;
+              }
+          }
+        if (d) {
+          var m = e, b = u(m), w = a === "" ? ut + Ye(m, 0) : a;
+          if (Se(b)) {
+            var S = "";
+            w != null && (S = lt(w) + "/"), De(b, r, S, "", function(Jr) {
+              return Jr;
+            });
+          } else
+            b != null && (ae(b) && (b.key && (!m || m.key !== b.key) && Oe(b.key), b = Zt(
+              b,
+              // Keep both the (mapped) and old keys if they differ, just as
+              // traverseAllChildren used to do for objects as children
+              i + // $FlowFixMe Flow incorrectly thinks React.Portal doesn't have a key
+              (b.key && (!m || m.key !== b.key) ? (
+                // $FlowFixMe Flow incorrectly thinks existing element's key can be a number
+                // eslint-disable-next-line react-internal/safe-string-coercion
+                lt("" + b.key) + "/"
+              ) : "") + w
+            )), r.push(b));
+          return 1;
+        }
+        var O, T, j = 0, I = a === "" ? ut : a + tr;
+        if (Se(e))
+          for (var $e = 0; $e < e.length; $e++)
+            O = e[$e], T = I + Ye(O, $e), j += De(O, r, i, T, u);
+        else {
+          var Xe = oe(e);
+          if (typeof Xe == "function") {
+            var Nt = e;
+            Xe === Nt.entries && (ct || Q("Using Maps as children is not supported. Use an array of keyed ReactElements instead."), ct = !0);
+            for (var Kr = Xe.call(Nt), Ft, Gr = 0; !(Ft = Kr.next()).done; )
+              O = Ft.value, T = I + Ye(O, Gr++), j += De(O, r, i, T, u);
+          } else if (p === "object") {
+            var $t = String(e);
+            throw new Error("Objects are not valid as a React child (found: " + ($t === "[object Object]" ? "object with keys {" + Object.keys(e).join(", ") + "}" : $t) + "). If you meant to render a collection of children, use an array instead.");
+          }
+        }
+        return j;
+      }
+      function Te(e, r, i) {
+        if (e == null)
+          return e;
+        var a = [], u = 0;
+        return De(e, a, "", "", function(p) {
+          return r.call(i, p, u++);
+        }), a;
+      }
+      function or(e) {
+        var r = 0;
+        return Te(e, function() {
+          r++;
+        }), r;
+      }
+      function ir(e, r, i) {
+        Te(e, function() {
+          r.apply(this, arguments);
+        }, i);
+      }
+      function sr(e) {
+        return Te(e, function(r) {
+          return r;
+        }) || [];
+      }
+      function ar(e) {
+        if (!ae(e))
+          throw new Error("React.Children.only expected to receive a single React element child.");
+        return e;
+      }
+      function ur(e) {
+        var r = {
+          $$typeof: B,
+          // As a workaround to support multiple concurrent renderers, we categorize
+          // some renderers as primary and others as secondary. We only expect
+          // there to be two concurrent renderers at most: React Native (primary) and
+          // Fabric (secondary); React DOM (primary) and React ART (secondary).
+          // Secondary renderers store their context values on separate fields.
+          _currentValue: e,
+          _currentValue2: e,
+          // Used to track how many concurrent renderers this context currently
+          // supports within in a single renderer. Such as parallel server rendering.
+          _threadCount: 0,
+          // These are circular
+          Provider: null,
+          Consumer: null,
+          // Add these to use same hidden class in VM as ServerContext
+          _defaultValue: null,
+          _globalName: null
+        };
+        r.Provider = {
+          $$typeof: U,
+          _context: r
+        };
+        var i = !1, a = !1, u = !1;
+        {
+          var p = {
+            $$typeof: B,
+            _context: r
+          };
+          Object.defineProperties(p, {
+            Provider: {
+              get: function() {
+                return a || (a = !0, h("Rendering <Context.Consumer.Provider> is not supported and will be removed in a future major release. Did you mean to render <Context.Provider> instead?")), r.Provider;
+              },
+              set: function(d) {
+                r.Provider = d;
+              }
+            },
+            _currentValue: {
+              get: function() {
+                return r._currentValue;
+              },
+              set: function(d) {
+                r._currentValue = d;
+              }
+            },
+            _currentValue2: {
+              get: function() {
+                return r._currentValue2;
+              },
+              set: function(d) {
+                r._currentValue2 = d;
+              }
+            },
+            _threadCount: {
+              get: function() {
+                return r._threadCount;
+              },
+              set: function(d) {
+                r._threadCount = d;
+              }
+            },
+            Consumer: {
+              get: function() {
+                return i || (i = !0, h("Rendering <Context.Consumer.Consumer> is not supported and will be removed in a future major release. Did you mean to render <Context.Consumer> instead?")), r.Consumer;
+              }
+            },
+            displayName: {
+              get: function() {
+                return r.displayName;
+              },
+              set: function(d) {
+                u || (Q("Setting `displayName` on Context.Consumer has no effect. You should set it directly on the context with Context.displayName = '%s'.", d), u = !0);
+              }
+            }
+          }), r.Consumer = p;
+        }
+        return r._currentRenderer = null, r._currentRenderer2 = null, r;
+      }
+      var ve = -1, He = 0, ft = 1, cr = 2;
+      function lr(e) {
+        if (e._status === ve) {
+          var r = e._result, i = r();
+          if (i.then(function(p) {
+            if (e._status === He || e._status === ve) {
+              var d = e;
+              d._status = ft, d._result = p;
+            }
+          }, function(p) {
+            if (e._status === He || e._status === ve) {
+              var d = e;
+              d._status = cr, d._result = p;
+            }
+          }), e._status === ve) {
+            var a = e;
+            a._status = He, a._result = i;
+          }
+        }
+        if (e._status === ft) {
+          var u = e._result;
+          return u === void 0 && h(`lazy: Expected the result of a dynamic import() call. Instead received: %s
+
+Your code should look like: 
+  const MyComponent = lazy(() => import('./MyComponent'))
+
+Did you accidentally put curly braces around the import?`, u), "default" in u || h(`lazy: Expected the result of a dynamic import() call. Instead received: %s
+
+Your code should look like: 
+  const MyComponent = lazy(() => import('./MyComponent'))`, u), u.default;
+        } else
+          throw e._result;
+      }
+      function fr(e) {
+        var r = {
+          // We use these fields to store the result.
+          _status: ve,
+          _result: e
+        }, i = {
+          $$typeof: q,
+          _payload: r,
+          _init: lr
+        };
+        {
+          var a, u;
+          Object.defineProperties(i, {
+            defaultProps: {
+              configurable: !0,
+              get: function() {
+                return a;
+              },
+              set: function(p) {
+                h("React.lazy(...): It is not supported to assign `defaultProps` to a lazy component import. Either specify them where the component is defined, or create a wrapping component around it."), a = p, Object.defineProperty(i, "defaultProps", {
+                  enumerable: !0
+                });
+              }
+            },
+            propTypes: {
+              configurable: !0,
+              get: function() {
+                return u;
+              },
+              set: function(p) {
+                h("React.lazy(...): It is not supported to assign `propTypes` to a lazy component import. Either specify them where the component is defined, or create a wrapping component around it."), u = p, Object.defineProperty(i, "propTypes", {
+                  enumerable: !0
+                });
+              }
+            }
+          });
+        }
+        return i;
+      }
+      function dr(e) {
+        e != null && e.$$typeof === V ? h("forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...)).") : typeof e != "function" ? h("forwardRef requires a render function but was given %s.", e === null ? "null" : typeof e) : e.length !== 0 && e.length !== 2 && h("forwardRef render functions accept exactly two parameters: props and ref. %s", e.length === 1 ? "Did you forget to use the ref parameter?" : "Any additional parameter will be undefined."), e != null && (e.defaultProps != null || e.propTypes != null) && h("forwardRef render functions do not support propTypes or defaultProps. Did you accidentally pass a React component?");
+        var r = {
+          $$typeof: z,
+          render: e
+        };
+        {
+          var i;
+          Object.defineProperty(r, "displayName", {
+            enumerable: !1,
+            configurable: !0,
+            get: function() {
+              return i;
+            },
+            set: function(a) {
+              i = a, !e.name && !e.displayName && (e.displayName = a);
+            }
+          });
+        }
+        return r;
+      }
+      var dt;
+      dt = Symbol.for("react.module.reference");
+      function pt(e) {
+        return !!(typeof e == "string" || typeof e == "function" || e === y || e === F || se || e === D || e === H || e === Z || me || e === Ee || he || Ue || Re || typeof e == "object" && e !== null && (e.$$typeof === q || e.$$typeof === V || e.$$typeof === U || e.$$typeof === B || e.$$typeof === z || // This needs to include all possible module reference object
+        // types supported by any Flight configuration anywhere since
+        // we don't know which Flight build this will end up being used
+        // with.
+        e.$$typeof === dt || e.getModuleId !== void 0));
+      }
+      function pr(e, r) {
+        pt(e) || h("memo: The first argument must be a component. Instead received: %s", e === null ? "null" : typeof e);
+        var i = {
+          $$typeof: V,
+          type: e,
+          compare: r === void 0 ? null : r
+        };
+        {
+          var a;
+          Object.defineProperty(i, "displayName", {
+            enumerable: !1,
+            configurable: !0,
+            get: function() {
+              return a;
+            },
+            set: function(u) {
+              a = u, !e.name && !e.displayName && (e.displayName = u);
+            }
+          });
+        }
+        return i;
+      }
+      function M() {
+        var e = ie.current;
+        return e === null && h(`Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:
+1. You might have mismatching versions of React and the renderer (such as React DOM)
+2. You might be breaking the Rules of Hooks
+3. You might have more than one copy of React in the same app
+See https://reactjs.org/link/invalid-hook-call for tips about how to debug and fix this problem.`), e;
+      }
+      function hr(e) {
+        var r = M();
+        if (e._context !== void 0) {
+          var i = e._context;
+          i.Consumer === e ? h("Calling useContext(Context.Consumer) is not supported, may cause bugs, and will be removed in a future major release. Did you mean to call useContext(Context) instead?") : i.Provider === e && h("Calling useContext(Context.Provider) is not supported. Did you mean to call useContext(Context) instead?");
+        }
+        return r.useContext(e);
+      }
+      function mr(e) {
+        var r = M();
+        return r.useState(e);
+      }
+      function yr(e, r, i) {
+        var a = M();
+        return a.useReducer(e, r, i);
+      }
+      function vr(e) {
+        var r = M();
+        return r.useRef(e);
+      }
+      function gr(e, r) {
+        var i = M();
+        return i.useEffect(e, r);
+      }
+      function _r(e, r) {
+        var i = M();
+        return i.useInsertionEffect(e, r);
+      }
+      function br(e, r) {
+        var i = M();
+        return i.useLayoutEffect(e, r);
+      }
+      function Er(e, r) {
+        var i = M();
+        return i.useCallback(e, r);
+      }
+      function wr(e, r) {
+        var i = M();
+        return i.useMemo(e, r);
+      }
+      function Cr(e, r, i) {
+        var a = M();
+        return a.useImperativeHandle(e, r, i);
+      }
+      function Rr(e, r) {
+        {
+          var i = M();
+          return i.useDebugValue(e, r);
+        }
+      }
+      function Pr() {
+        var e = M();
+        return e.useTransition();
+      }
+      function Sr(e) {
+        var r = M();
+        return r.useDeferredValue(e);
+      }
+      function Or() {
+        var e = M();
+        return e.useId();
+      }
+      function Dr(e, r, i) {
+        var a = M();
+        return a.useSyncExternalStore(e, r, i);
+      }
+      var ge = 0, ht, mt, yt, vt, gt, _t, bt;
+      function Et() {
+      }
+      Et.__reactDisabledLog = !0;
+      function Tr() {
+        {
+          if (ge === 0) {
+            ht = console.log, mt = console.info, yt = console.warn, vt = console.error, gt = console.group, _t = console.groupCollapsed, bt = console.groupEnd;
+            var e = {
+              configurable: !0,
+              enumerable: !0,
+              value: Et,
+              writable: !0
+            };
+            Object.defineProperties(console, {
+              info: e,
+              log: e,
+              warn: e,
+              error: e,
+              group: e,
+              groupCollapsed: e,
+              groupEnd: e
+            });
+          }
+          ge++;
+        }
+      }
+      function kr() {
+        {
+          if (ge--, ge === 0) {
+            var e = {
+              configurable: !0,
+              enumerable: !0,
+              writable: !0
+            };
+            Object.defineProperties(console, {
+              log: v({}, e, {
+                value: ht
+              }),
+              info: v({}, e, {
+                value: mt
+              }),
+              warn: v({}, e, {
+                value: yt
+              }),
+              error: v({}, e, {
+                value: vt
+              }),
+              group: v({}, e, {
+                value: gt
+              }),
+              groupCollapsed: v({}, e, {
+                value: _t
+              }),
+              groupEnd: v({}, e, {
+                value: bt
+              })
+            });
+          }
+          ge < 0 && h("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
+        }
+      }
+      var Be = Y.ReactCurrentDispatcher, ze;
+      function ke(e, r, i) {
+        {
+          if (ze === void 0)
+            try {
+              throw Error();
+            } catch (u) {
+              var a = u.stack.trim().match(/\n( *(at )?)/);
+              ze = a && a[1] || "";
+            }
+          return `
+` + ze + e;
+        }
+      }
+      var qe = !1, je;
+      {
+        var jr = typeof WeakMap == "function" ? WeakMap : Map;
+        je = new jr();
+      }
+      function wt(e, r) {
+        if (!e || qe)
+          return "";
+        {
+          var i = je.get(e);
+          if (i !== void 0)
+            return i;
+        }
+        var a;
+        qe = !0;
+        var u = Error.prepareStackTrace;
+        Error.prepareStackTrace = void 0;
+        var p;
+        p = Be.current, Be.current = null, Tr();
+        try {
+          if (r) {
+            var d = function() {
+              throw Error();
+            };
+            if (Object.defineProperty(d.prototype, "props", {
+              set: function() {
+                throw Error();
+              }
+            }), typeof Reflect == "object" && Reflect.construct) {
+              try {
+                Reflect.construct(d, []);
+              } catch (I) {
+                a = I;
+              }
+              Reflect.construct(e, [], d);
+            } else {
+              try {
+                d.call();
+              } catch (I) {
+                a = I;
+              }
+              e.call(d.prototype);
+            }
+          } else {
+            try {
+              throw Error();
+            } catch (I) {
+              a = I;
+            }
+            e();
+          }
+        } catch (I) {
+          if (I && a && typeof I.stack == "string") {
+            for (var m = I.stack.split(`
+`), b = a.stack.split(`
+`), w = m.length - 1, S = b.length - 1; w >= 1 && S >= 0 && m[w] !== b[S]; )
+              S--;
+            for (; w >= 1 && S >= 0; w--, S--)
+              if (m[w] !== b[S]) {
+                if (w !== 1 || S !== 1)
+                  do
+                    if (w--, S--, S < 0 || m[w] !== b[S]) {
+                      var O = `
+` + m[w].replace(" at new ", " at ");
+                      return e.displayName && O.includes("<anonymous>") && (O = O.replace("<anonymous>", e.displayName)), typeof e == "function" && je.set(e, O), O;
+                    }
+                  while (w >= 1 && S >= 0);
+                break;
+              }
+          }
+        } finally {
+          qe = !1, Be.current = p, kr(), Error.prepareStackTrace = u;
+        }
+        var T = e ? e.displayName || e.name : "", j = T ? ke(T) : "";
+        return typeof e == "function" && je.set(e, j), j;
+      }
+      function Ar(e, r, i) {
+        return wt(e, !1);
+      }
+      function Ir(e) {
+        var r = e.prototype;
+        return !!(r && r.isReactComponent);
+      }
+      function Ae(e, r, i) {
+        if (e == null)
+          return "";
+        if (typeof e == "function")
+          return wt(e, Ir(e));
+        if (typeof e == "string")
+          return ke(e);
+        switch (e) {
+          case H:
+            return ke("Suspense");
+          case Z:
+            return ke("SuspenseList");
+        }
+        if (typeof e == "object")
+          switch (e.$$typeof) {
+            case z:
+              return Ar(e.render);
+            case V:
+              return Ae(e.type, r, i);
+            case q: {
+              var a = e, u = a._payload, p = a._init;
+              try {
+                return Ae(p(u), r, i);
+              } catch {
+              }
+            }
+          }
+        return "";
+      }
+      var Ct = {}, Rt = Y.ReactDebugCurrentFrame;
+      function Ie(e) {
+        if (e) {
+          var r = e._owner, i = Ae(e.type, e._source, r ? r.type : null);
+          Rt.setExtraStackFrame(i);
+        } else
+          Rt.setExtraStackFrame(null);
+      }
+      function Nr(e, r, i, a, u) {
+        {
+          var p = Function.call.bind(ye);
+          for (var d in e)
+            if (p(e, d)) {
+              var m = void 0;
+              try {
+                if (typeof e[d] != "function") {
+                  var b = Error((a || "React class") + ": " + i + " type `" + d + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof e[d] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+                  throw b.name = "Invariant Violation", b;
+                }
+                m = e[d](r, d, a, i, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
+              } catch (w) {
+                m = w;
+              }
+              m && !(m instanceof Error) && (Ie(u), h("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", a || "React class", i, d, typeof m), Ie(null)), m instanceof Error && !(m.message in Ct) && (Ct[m.message] = !0, Ie(u), h("Failed %s type: %s", i, m.message), Ie(null));
+            }
+        }
+      }
+      function ue(e) {
+        if (e) {
+          var r = e._owner, i = Ae(e.type, e._source, r ? r.type : null);
+          Ce(i);
+        } else
+          Ce(null);
+      }
+      var Ke;
+      Ke = !1;
+      function Pt() {
+        if (L.current) {
+          var e = X(L.current.type);
+          if (e)
+            return `
+
+Check the render method of \`` + e + "`.";
+        }
+        return "";
+      }
+      function Fr(e) {
+        if (e !== void 0) {
+          var r = e.fileName.replace(/^.*[\\\/]/, ""), i = e.lineNumber;
+          return `
+
+Check your code at ` + r + ":" + i + ".";
+        }
+        return "";
+      }
+      function $r(e) {
+        return e != null ? Fr(e.__source) : "";
+      }
+      var St = {};
+      function Mr(e) {
+        var r = Pt();
+        if (!r) {
+          var i = typeof e == "string" ? e : e.displayName || e.name;
+          i && (r = `
+
+Check the top-level render call using <` + i + ">.");
+        }
+        return r;
+      }
+      function Ot(e, r) {
+        if (!(!e._store || e._store.validated || e.key != null)) {
+          e._store.validated = !0;
+          var i = Mr(r);
+          if (!St[i]) {
+            St[i] = !0;
+            var a = "";
+            e && e._owner && e._owner !== L.current && (a = " It was passed a child from " + X(e._owner.type) + "."), ue(e), h('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', i, a), ue(null);
+          }
+        }
+      }
+      function Dt(e, r) {
+        if (typeof e == "object") {
+          if (Se(e))
+            for (var i = 0; i < e.length; i++) {
+              var a = e[i];
+              ae(a) && Ot(a, r);
+            }
+          else if (ae(e))
+            e._store && (e._store.validated = !0);
+          else if (e) {
+            var u = oe(e);
+            if (typeof u == "function" && u !== e.entries)
+              for (var p = u.call(e), d; !(d = p.next()).done; )
+                ae(d.value) && Ot(d.value, r);
+          }
+        }
+      }
+      function Tt(e) {
+        {
+          var r = e.type;
+          if (r == null || typeof r == "string")
+            return;
+          var i;
+          if (typeof r == "function")
+            i = r.propTypes;
+          else if (typeof r == "object" && (r.$$typeof === z || // Note: Memo only checks outer props here.
+          // Inner props are checked in the reconciler.
+          r.$$typeof === V))
+            i = r.propTypes;
+          else
+            return;
+          if (i) {
+            var a = X(r);
+            Nr(i, e.props, "prop", a, e);
+          } else if (r.PropTypes !== void 0 && !Ke) {
+            Ke = !0;
+            var u = X(r);
+            h("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", u || "Unknown");
+          }
+          typeof r.getDefaultProps == "function" && !r.getDefaultProps.isReactClassApproved && h("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
+        }
+      }
+      function Lr(e) {
+        {
+          for (var r = Object.keys(e.props), i = 0; i < r.length; i++) {
+            var a = r[i];
+            if (a !== "children" && a !== "key") {
+              ue(e), h("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", a), ue(null);
+              break;
+            }
+          }
+          e.ref !== null && (ue(e), h("Invalid attribute `ref` supplied to `React.Fragment`."), ue(null));
+        }
+      }
+      function kt(e, r, i) {
+        var a = pt(e);
+        if (!a) {
+          var u = "";
+          (e === void 0 || typeof e == "object" && e !== null && Object.keys(e).length === 0) && (u += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.");
+          var p = $r(r);
+          p ? u += p : u += Pt();
+          var d;
+          e === null ? d = "null" : Se(e) ? d = "array" : e !== void 0 && e.$$typeof === l ? (d = "<" + (X(e.type) || "Unknown") + " />", u = " Did you accidentally export a JSX literal instead of a component?") : d = typeof e, h("React.createElement: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", d, u);
+        }
+        var m = Xt.apply(this, arguments);
+        if (m == null)
+          return m;
+        if (a)
+          for (var b = 2; b < arguments.length; b++)
+            Dt(arguments[b], e);
+        return e === y ? Lr(m) : Tt(m), m;
+      }
+      var jt = !1;
+      function Ur(e) {
+        var r = kt.bind(null, e);
+        return r.type = e, jt || (jt = !0, Q("React.createFactory() is deprecated and will be removed in a future major release. Consider using JSX or use React.createElement() directly instead.")), Object.defineProperty(r, "type", {
+          enumerable: !1,
+          get: function() {
+            return Q("Factory.type is deprecated. Access the class directly before passing it to createFactory."), Object.defineProperty(this, "type", {
+              value: e
+            }), e;
+          }
+        }), r;
+      }
+      function Vr(e, r, i) {
+        for (var a = er.apply(this, arguments), u = 2; u < arguments.length; u++)
+          Dt(arguments[u], a.type);
+        return Tt(a), a;
+      }
+      function xr(e, r) {
+        var i = G.transition;
+        G.transition = {};
+        var a = G.transition;
+        G.transition._updatedFibers = /* @__PURE__ */ new Set();
+        try {
+          e();
+        } finally {
+          if (G.transition = i, i === null && a._updatedFibers) {
+            var u = a._updatedFibers.size;
+            u > 10 && Q("Detected a large number of updates inside startTransition. If this is due to a subscription please re-write it to use React provided hooks. Otherwise concurrent mode guarantees are off the table."), a._updatedFibers.clear();
+          }
+        }
+      }
+      var At = !1, Ne = null;
+      function Wr(e) {
+        if (Ne === null)
+          try {
+            var r = ("require" + Math.random()).slice(0, 7), i = n && n[r];
+            Ne = i.call(n, "timers").setImmediate;
+          } catch {
+            Ne = function(u) {
+              At === !1 && (At = !0, typeof MessageChannel > "u" && h("This browser does not have a MessageChannel implementation, so enqueuing tasks via await act(async () => ...) will fail. Please file an issue at https://github.com/facebook/react/issues if you encounter this warning."));
+              var p = new MessageChannel();
+              p.port1.onmessage = u, p.port2.postMessage(void 0);
+            };
+          }
+        return Ne(e);
+      }
+      var ce = 0, It = !1;
+      function Yr(e) {
+        {
+          var r = ce;
+          ce++, A.current === null && (A.current = []);
+          var i = A.isBatchingLegacy, a;
+          try {
+            if (A.isBatchingLegacy = !0, a = e(), !i && A.didScheduleLegacyUpdate) {
+              var u = A.current;
+              u !== null && (A.didScheduleLegacyUpdate = !1, Qe(u));
+            }
+          } catch (T) {
+            throw Fe(r), T;
+          } finally {
+            A.isBatchingLegacy = i;
+          }
+          if (a !== null && typeof a == "object" && typeof a.then == "function") {
+            var p = a, d = !1, m = {
+              then: function(T, j) {
+                d = !0, p.then(function(I) {
+                  Fe(r), ce === 0 ? Ge(I, T, j) : T(I);
+                }, function(I) {
+                  Fe(r), j(I);
+                });
+              }
+            };
+            return !It && typeof Promise < "u" && Promise.resolve().then(function() {
+            }).then(function() {
+              d || (It = !0, h("You called act(async () => ...) without await. This could lead to unexpected testing behaviour, interleaving multiple act calls and mixing their scopes. You should - await act(async () => ...);"));
+            }), m;
+          } else {
+            var b = a;
+            if (Fe(r), ce === 0) {
+              var w = A.current;
+              w !== null && (Qe(w), A.current = null);
+              var S = {
+                then: function(T, j) {
+                  A.current === null ? (A.current = [], Ge(b, T, j)) : T(b);
+                }
+              };
+              return S;
+            } else {
+              var O = {
+                then: function(T, j) {
+                  T(b);
+                }
+              };
+              return O;
+            }
+          }
+        }
+      }
+      function Fe(e) {
+        e !== ce - 1 && h("You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. "), ce = e;
+      }
+      function Ge(e, r, i) {
+        {
+          var a = A.current;
+          if (a !== null)
+            try {
+              Qe(a), Wr(function() {
+                a.length === 0 ? (A.current = null, r(e)) : Ge(e, r, i);
+              });
+            } catch (u) {
+              i(u);
+            }
+          else
+            r(e);
+        }
+      }
+      var Je = !1;
+      function Qe(e) {
+        if (!Je) {
+          Je = !0;
+          var r = 0;
+          try {
+            for (; r < e.length; r++) {
+              var i = e[r];
+              do
+                i = i(!0);
+              while (i !== null);
+            }
+            e.length = 0;
+          } catch (a) {
+            throw e = e.slice(r + 1), a;
+          } finally {
+            Je = !1;
+          }
+        }
+      }
+      var Hr = kt, Br = Vr, zr = Ur, qr = {
+        map: Te,
+        forEach: ir,
+        count: or,
+        toArray: sr,
+        only: ar
+      };
+      t.Children = qr, t.Component = _, t.Fragment = y, t.Profiler = F, t.PureComponent = $, t.StrictMode = D, t.Suspense = H, t.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = Y, t.cloneElement = Br, t.createContext = ur, t.createElement = Hr, t.createFactory = zr, t.createRef = Ht, t.forwardRef = dr, t.isValidElement = ae, t.lazy = fr, t.memo = pr, t.startTransition = xr, t.unstable_act = Yr, t.useCallback = Er, t.useContext = hr, t.useDebugValue = Rr, t.useDeferredValue = Sr, t.useEffect = gr, t.useId = Or, t.useImperativeHandle = Cr, t.useInsertionEffect = _r, t.useLayoutEffect = br, t.useMemo = wr, t.useReducer = yr, t.useRef = vr, t.useState = mr, t.useSyncExternalStore = Dr, t.useTransition = Pr, t.version = s, typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
+    }();
+  }(_e, _e.exports)), _e.exports;
+}
+process.env.NODE_ENV === "production" ? et.exports = vn() : et.exports = gn();
+var fe = et.exports;
+const W = /* @__PURE__ */ yn(fe);
+class _n extends fe.Component {
+  constructor(t) {
+    super(t), this.unfilteredDocuments = [], this.state = {
+      documents: [],
+      mode: 0
+      /* normal */
+    };
+  }
+  async componentDidMount() {
+    const { controller: t } = this.props;
+    this.unsubscriber = t.onChange((s) => {
+      s.documentCollection && (this.unfilteredDocuments = s.documentCollection, this.setState({
+        documents: t.filter(this.unfilteredDocuments)
+      })), s.action === "filterChange" ? this.setState({
+        documents: t.filter(this.unfilteredDocuments)
+      }) : this.setState({});
+    }), this.unfilteredDocuments = await t.documentCollection(), this.setState({
+      documents: t.filter(this.unfilteredDocuments)
+    });
+  }
+  componentWillUnmount() {
+    var t;
+    (t = this.unsubscriber) == null || t.call(this);
+  }
+  newDocument() {
+    this.props.controller.newDocument(), this.setState({
+      mode: 1
+      /* add */
+    });
+  }
+  editDocument(t) {
+    this.props.controller.setDocument(t), this.setState({
+      mode: 2
+      /* edit */
+    });
+  }
+  async storeDocument(t) {
+    const { controller: s, layout: l } = this.props;
+    s.setDocument(t), await s.storeDocument(), l === "formAndItems" ? this.newDocument() : this.setState({
+      mode: 0
+      /* normal */
+    });
+  }
+  invokeContentViewChild(t) {
+    const { children: s, layout: l, controller: c } = this.props, { mode: y } = this.state, D = l !== "formAndItems";
+    if (!c.document)
+      return;
+    const F = {
+      controller: c,
+      submitButtonCaption: y == 2 ? t == null ? void 0 : t.updateButtonLabel : t == null ? void 0 : t.addButtonLabel,
+      onSubmit: (U) => this.storeDocument(U),
+      onCancel: D ? () => this.setState({
+        mode: 0
+        /* normal */
+      }) : () => this.newDocument()
+    };
+    return typeof s[0] == "function" ? fe.cloneElement(s[0](F), { key: c.document.id }) : fe.cloneElement(s[0], { key: c.document.id, ...F });
+  }
+  invokeDetailViewChild(t) {
+    const { children: s, controller: l } = this.props, c = {
+      document: t,
+      onSelect: (y) => this.editDocument(y),
+      onDelete: (y) => l.setDocument(y).deleteDocument()
+    };
+    return typeof s[1] == "function" ? fe.cloneElement(s[1](c), { key: t.id }) : fe.cloneElement(s[1], { key: t.id, ...c });
+  }
+  render() {
+    var V;
+    const { mode: t, documents: s } = this.state, { className: l, cardAddButton: c, controller: y } = this.props, D = hn((V = y.document) == null ? void 0 : V.className);
+    let F = this.props.labels || {};
+    const U = this.props.layout || "itemsAlways";
+    typeof F == "function" && (F = F(y));
+    const { addNewDocumentLabel: B, singularDocumentInCollectionCaption: z, documentsInCollectionCaption: H, noDocumentsFoundLabel: Z } = F;
+    return /* @__PURE__ */ W.createElement("div", { className: `crud-panel ${D} ${l || ""}` }, t === 0 && U !== "formAndItems" && !c && /* @__PURE__ */ W.createElement("div", { className: "header" }, this.props.header ? typeof this.props.header == "function" ? this.props.header(y, () => this.newDocument(), F) : this.props.header : /* @__PURE__ */ W.createElement("button", { onClick: () => this.newDocument() }, B)), (U === "formAndItems" || t === 1 || t === 2) && /* @__PURE__ */ W.createElement("div", { className: "content-panel" }, this.invokeContentViewChild(F)), (U === "itemsAlways" || U === "formAndItems" || t === 0) && /* @__PURE__ */ W.createElement("div", { className: "collection-panel" }, (s == null ? void 0 : s.length) > 0 && /* @__PURE__ */ W.createElement("h3", null, s.length > 1 ? H : z || H), /* @__PURE__ */ W.createElement("div", { className: "documents" }, c && /* @__PURE__ */ W.createElement(
+      "div",
+      {
+        className: "crud-card card-add-button clickable",
+        onClick: () => this.newDocument()
+      },
+      /* @__PURE__ */ W.createElement("div", { className: "button-element" }, c),
+      /* @__PURE__ */ W.createElement("div", { className: "add-label" }, B)
+    ), s != null && s.length ? s.map((q) => this.invokeDetailViewChild(q)) : /* @__PURE__ */ W.createElement("p", null, Z))), /* @__PURE__ */ W.createElement("div", { className: "footer" }, this.props.footer && typeof this.props.footer == "function" ? this.props.footer(y, () => this.newDocument(), F) : this.props.footer));
+  }
+}
+export {
+  Lt as CrudController,
+  _n as CrudPanel
+};