@hkyhy/marsun-components-core 0.1.89 → 0.1.98

package/dist/node_modules/@ckeditor/ckeditor5-watchdog/dist/index.js

@@ -0,0 +1,892 @@
+var v = Object.defineProperty;
+var P = (e, t, s) => t in e ? v(e, t, { enumerable: !0, configurable: !0, writable: !0, value: s }) : e[t] = s;
+var a = (e, t, s) => P(e, typeof t != "symbol" ? t + "" : t, s);
+import { cloneDeepWith as w } from "../../../es-toolkit/dist/compat/object/cloneDeepWith.js";
+import { throttle as S } from "../../../es-toolkit/dist/compat/function/throttle.js";
+import { isElement as y } from "../../../es-toolkit/dist/compat/predicate/isElement.js";
+/**
+ * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+ */
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+var E = class {
+  /**
+  * @param {module:watchdog/watchdog~WatchdogConfig} config The watchdog plugin configuration.
+  */
+  constructor(e) {
+    /**
+    * An array of crashes saved as an object with the following properties:
+    *
+    * * `message`: `String`,
+    * * `stack`: `String`,
+    * * `date`: `Number`,
+    * * `filename`: `String | undefined`,
+    * * `lineno`: `Number | undefined`,
+    * * `colno`: `Number | undefined`,
+    */
+    a(this, "crashes", []);
+    /**
+    * Specifies the state of the item watched by the watchdog. The state can be one of the following values:
+    *
+    * * `initializing` – Before the first initialization, and after crashes, before the item is ready.
+    * * `ready` – A state when the user can interact with the item.
+    * * `crashed` – A state when an error occurs. It quickly changes to `initializing` or `crashedPermanently`
+    * depending on how many and how frequent errors have been caught recently.
+    * * `crashedPermanently` – A state when the watchdog stops reacting to errors and keeps the item it is watching crashed,
+    * * `destroyed` – A state when the item is manually destroyed by the user after calling `watchdog.destroy()`.
+    */
+    a(this, "state", "initializing");
+    /**
+    * @see module:watchdog/watchdog~WatchdogConfig
+    */
+    a(this, "_crashNumberLimit");
+    /**
+    * Returns the result of the `Date.now()` call. It can be overridden in tests to mock time as some popular
+    * approaches like `sinon.useFakeTimers()` do not work well with error handling.
+    */
+    a(this, "_now", Date.now);
+    /**
+    * @see module:watchdog/watchdog~WatchdogConfig
+    */
+    a(this, "_minimumNonErrorTimePeriod");
+    /**
+    * Checks if the event error comes from the underlying item and restarts the item.
+    */
+    a(this, "_boundErrorHandler");
+    /**
+    * A dictionary of event emitter listeners.
+    */
+    a(this, "_listeners");
+    if (this.crashes = [], this._crashNumberLimit = typeof e.crashNumberLimit == "number" ? e.crashNumberLimit : 3, this._minimumNonErrorTimePeriod = typeof e.minimumNonErrorTimePeriod == "number" ? e.minimumNonErrorTimePeriod : 5e3, this._boundErrorHandler = (t) => {
+      const s = "error" in t ? t.error : t.reason;
+      s instanceof Error && this._handleError(s, t);
+    }, this._listeners = {}, !this._restart) throw new Error("The Watchdog class was split into the abstract `Watchdog` class and the `EditorWatchdog` class. Please, use `EditorWatchdog` if you have used the `Watchdog` class previously.");
+  }
+  /**
+  * Destroys the watchdog and releases the resources.
+  */
+  destroy() {
+    this._stopErrorHandling(), this._listeners = {};
+  }
+  /**
+  * Starts listening to a specific event name by registering a callback that will be executed
+  * whenever an event with a given name fires.
+  *
+  * Note that this method differs from the CKEditor 5's default `EventEmitterMixin` implementation.
+  *
+  * @param eventName The event name.
+  * @param callback A callback which will be added to event listeners.
+  */
+  on(e, t) {
+    this._listeners[e] || (this._listeners[e] = []), this._listeners[e].push(t);
+  }
+  /**
+  * Stops listening to the specified event name by removing the callback from event listeners.
+  *
+  * Note that this method differs from the CKEditor 5's default `EventEmitterMixin` implementation.
+  *
+  * @param eventName The event name.
+  * @param callback A callback which will be removed from event listeners.
+  */
+  off(e, t) {
+    this._listeners[e] = this._listeners[e].filter((s) => s !== t);
+  }
+  /**
+  * Fires an event with a given event name and arguments.
+  *
+  * Note that this method differs from the CKEditor 5's default `EventEmitterMixin` implementation.
+  */
+  _fire(e, ...t) {
+    const s = this._listeners[e] || [];
+    for (const r of s) r.apply(this, [null, ...t]);
+  }
+  /**
+  * Starts error handling by attaching global error handlers.
+  */
+  _startErrorHandling() {
+    window.addEventListener("error", this._boundErrorHandler), window.addEventListener("unhandledrejection", this._boundErrorHandler);
+  }
+  /**
+  * Stops error handling by detaching global error handlers.
+  */
+  _stopErrorHandling() {
+    window.removeEventListener("error", this._boundErrorHandler), window.removeEventListener("unhandledrejection", this._boundErrorHandler);
+  }
+  /**
+  * Checks if an error comes from the watched item and restarts it.
+  * It reacts to {@link module:utils/ckeditorerror~CKEditorError `CKEditorError` errors} only.
+  *
+  * @fires error
+  * @param error Error.
+  * @param evt An error event.
+  */
+  _handleError(e, t) {
+    if (this._shouldReactToError(e)) {
+      this.crashes.push({
+        message: e.message,
+        stack: e.stack,
+        filename: t instanceof ErrorEvent ? t.filename : void 0,
+        lineno: t instanceof ErrorEvent ? t.lineno : void 0,
+        colno: t instanceof ErrorEvent ? t.colno : void 0,
+        date: this._now()
+      });
+      const s = this._shouldRestart();
+      this.state = "crashed", this._fire("stateChange"), this._fire("error", {
+        error: e,
+        causesRestart: s
+      }), s ? this._restart() : (this.state = "crashedPermanently", this._fire("stateChange"));
+    }
+  }
+  /**
+  * Checks whether an error should be handled by the watchdog.
+  *
+  * @param error An error that was caught by the error handling process.
+  */
+  _shouldReactToError(e) {
+    return e.is && e.is("CKEditorError") && e.context !== void 0 && e.context !== null && this.state === "ready" && this._isErrorComingFromThisItem(e);
+  }
+  /**
+  * Checks if the watchdog should restart the underlying item.
+  */
+  _shouldRestart() {
+    return this.crashes.length <= this._crashNumberLimit ? !0 : (this.crashes[this.crashes.length - 1].date - this.crashes[this.crashes.length - 1 - this._crashNumberLimit].date) / this._crashNumberLimit > this._minimumNonErrorTimePeriod;
+  }
+};
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+function g(e, t = /* @__PURE__ */ new Set()) {
+  const s = [e], r = /* @__PURE__ */ new Set();
+  let i = 0;
+  for (; s.length > i; ) {
+    const o = s[i++];
+    if (!(r.has(o) || !x(o) || t.has(o)))
+      if (r.add(o), Symbol.iterator in o) try {
+        for (const c of o) s.push(c);
+      } catch {
+      }
+      else for (const c in o)
+        c !== "defaultValue" && s.push(o[c]);
+  }
+  return r;
+}
+function x(e) {
+  const t = Object.prototype.toString.call(e), s = typeof e;
+  return !(s === "number" || s === "boolean" || s === "string" || s === "symbol" || s === "function" || t === "[object Date]" || t === "[object RegExp]" || t === "[object Module]" || e === void 0 || e === null || e._watchdogExcluded || e instanceof EventTarget || e instanceof Event);
+}
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+function b(e, t, s = /* @__PURE__ */ new Set()) {
+  if (e === t && T(e)) return !0;
+  const r = g(e, s), i = g(t, s);
+  for (const o of r) if (i.has(o)) return !0;
+  return !1;
+}
+/* v8 ignore stop -- @preserve */
+function T(e) {
+  return typeof e == "object" && e !== null;
+}
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+function f(e, t, s) {
+  const r = t.root, i = t.roots || /* @__PURE__ */ Object.create(null);
+  s && !i[s] && (i[s] = r || /* @__PURE__ */ Object.create(null));
+  const o = N(e), c = A(t, o, s), n = Array.from(/* @__PURE__ */ new Set([
+    ...o ? Object.keys(e) : [],
+    ...Object.keys(i),
+    ...Object.keys(c)
+  ]));
+  for (const d of n) {
+    const h = i[d] || /* @__PURE__ */ Object.create(null);
+    h.initialData = "", h.placeholder ?? (h.placeholder = m(t, "placeholder", d)), h.label ?? (h.label = m(t, "label", d)), i[d] = h;
+  }
+  t.roots = i;
+}
+function N(e) {
+  return !!e && typeof e == "object" && !Array.isArray(e) && !k(e);
+}
+function A(e, t, s) {
+  return t || !s ? e.initialData || /* @__PURE__ */ Object.create(null) : { [s]: e.initialData };
+}
+function m(e, t, s) {
+  const r = e[t];
+  if (r) return typeof r == "string" ? r : r[s];
+}
+function k(e) {
+  return y(e);
+}
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+var R = class extends E {
+  /**
+  * @param Editor The editor class.
+  * @param watchdogConfig The watchdog plugin configuration.
+  */
+  constructor(t, s = {}) {
+    super(s);
+    /**
+    * The current editor instance.
+    */
+    a(this, "_editor", null);
+    /**
+    * A promise associated with the life cycle of the editor (creation or destruction processes).
+    *
+    * It is used to prevent the initialization of the editor if the previous instance has not been destroyed yet,
+    * and conversely, to prevent the destruction of the editor if it has not been initialized.
+    */
+    a(this, "_lifecyclePromise", null);
+    /**
+    * Throttled save method. The `save()` method is called the specified `saveInterval` after `throttledSave()` is called,
+    * unless a new action happens in the meantime.
+    */
+    a(this, "_throttledSave");
+    /**
+    * The latest saved editor data represented as a root name -> root data object.
+    */
+    a(this, "_data");
+    /**
+    * The last document version.
+    */
+    a(this, "_lastDocumentVersion");
+    /**
+    * The editor source element or data.
+    */
+    a(this, "_elementOrData");
+    /**
+    * Stores the original DOM element for single-root editors.
+    */
+    a(this, "_editorAttachTo", null);
+    /**
+    * Specifies whether the editor is a single-root editor (e.g. ClassicEditor) or a multi-root editor (e.g. MultiRootEditor).
+    */
+    a(this, "_isSingleRootEditor", !0);
+    /**
+    * Specifies whether the editor was created using config-based creator mode (without a source element or data as the first argument).
+    *
+    * @internal
+    */
+    a(this, "_isUsingConfigBasedCreator", !1);
+    /**
+    * The latest record of the editor editable elements. Used to restart the editor.
+    */
+    a(this, "_editables", {});
+    /**
+    * The editor configuration.
+    */
+    a(this, "_config");
+    a(this, "_excludedProps");
+    this._throttledSave = S(this._save.bind(this), typeof s.saveInterval == "number" ? s.saveInterval : 5e3), t && (this._creator = ((r, i) => i === void 0 ? t.create(r) : t.create(r, i))), this._destructor = (r) => r.destroy();
+  }
+  /**
+  * The current editor instance.
+  */
+  get editor() {
+    return this._editor;
+  }
+  /**
+  * @internal
+  */
+  get _item() {
+    return this._editor;
+  }
+  /**
+  * Sets the function that is responsible for the editor creation.
+  * It expects a function that should return a promise.
+  *
+  * For config-based editor creation:
+  *
+  * ```ts
+  * watchdog.setCreator( config => ClassicEditor.create( config ) );
+  * ```
+  *
+  * For legacy editor creation (with element or data as the first argument):
+  *
+  * ```ts
+  * watchdog.setCreator( ( element, config ) => ClassicEditor.create( element, config ) );
+  * ```
+  */
+  setCreator(t) {
+    this._creator = t;
+  }
+  /**
+  * Sets the function that is responsible for the editor destruction.
+  * Overrides the default destruction function, which destroys only the editor instance.
+  * It expects a function that should return a promise or `undefined`.
+  *
+  * ```ts
+  * watchdog.setDestructor( editor => {
+  * 	// Do something before the editor is destroyed.
+  *
+  * 	return editor
+  * 		.destroy()
+  * 		.then( () => {
+  * 			// Do something after the editor is destroyed.
+  * 		} );
+  * } );
+  * ```
+  */
+  setDestructor(t) {
+    this._destructor = t;
+  }
+  /**
+  * Restarts the editor instance. This method is called whenever an editor error occurs. It fires the `restart` event and changes
+  * the state to `initializing`.
+  *
+  * @fires restart
+  */
+  _restart() {
+    return Promise.resolve().then(() => (this.state = "initializing", this._fire("stateChange"), this._destroy())).catch((t) => {
+      console.error("An error happened during the editor destroying.", t);
+    }).then(() => {
+      var i;
+      this._isUsingConfigBasedCreator ? f(this._isSingleRootEditor ? "" : {}, this._config, this._isSingleRootEditor ? "main" : !1) : f(this._isSingleRootEditor ? this._editorAttachTo || "" : this._editables, this._config, this._isSingleRootEditor ? "main" : !1);
+      const t = {
+        ...this._config,
+        extraPlugins: this._config.extraPlugins || [],
+        _watchdogInitialData: this._data
+      };
+      t.extraPlugins.push(D);
+      const s = {};
+      for (const [o, c] of Object.entries(this._data.roots)) {
+        const n = t.roots[o] || /* @__PURE__ */ Object.create(null);
+        n.initialData = "", n.modelElement = c.modelElement, this._isUsingConfigBasedCreator && ((i = this._editables[o]) != null && i.isConnected ? n.element = this._editables[o] : c.isLoaded && !n.element && Object.assign(n, j(c.attributes))), c.isLoaded ? n.lazyLoad = !1 : delete n.modelAttributes, s[o] = n;
+      }
+      if (t.roots = s, delete t.initialData, delete t.root, this._isUsingConfigBasedCreator) return this.create(t, t.context);
+      const r = this._isSingleRootEditor ? this._editorAttachTo || "" : this._editables;
+      return this.create(r, t, t.context);
+    }).then(() => {
+      this._fire("restart");
+    });
+  }
+  create(t = this._isUsingConfigBasedCreator ? this._config : this._elementOrData, s = this._isUsingConfigBasedCreator ? void 0 : this._config, r) {
+    const i = this._detectConfigBasedCreator(t, s), o = i ? void 0 : t, c = i ? t : s, n = i ? s : r;
+    return this._lifecyclePromise = Promise.resolve(this._lifecyclePromise).then(() => {
+      if (super._startErrorHandling(), this._isUsingConfigBasedCreator = i, this._elementOrData = o, this._config = this._cloneEditorConfiguration(c || {}), this._config.context = n, i) {
+        this._editorAttachTo = null;
+        const d = this._config.roots ? Object.keys(this._config.roots).length : 0, h = this._config.initialData, _ = h && typeof h == "object";
+        this._isSingleRootEditor = !_ && d <= 1;
+      } else
+        this._editorAttachTo = l(o) ? o : null, this._isSingleRootEditor = l(o) || typeof o == "string";
+      return i ? this._creator(this._config) : this._creator(o, this._config);
+    }).then((d) => {
+      this._editor = d, d.model.document.on("change:data", this._throttledSave), this._lastDocumentVersion = d.model.document.version, this._data = this._getData(), this._editorAttachTo || (this._editables = this._getEditables()), this.state = "ready", this._fire("stateChange");
+    }).finally(() => {
+      this._lifecyclePromise = null;
+    }), this._lifecyclePromise;
+  }
+  /**
+  * Destroys the watchdog and the current editor instance. It fires the callback
+  * registered in {@link #setDestructor `setDestructor()`} and uses it to destroy the editor instance.
+  * It also sets the state to `destroyed`.
+  */
+  destroy() {
+    return this._lifecyclePromise = Promise.resolve(this._lifecyclePromise).then(() => (this.state = "destroyed", this._fire("stateChange"), super.destroy(), this._destroy())).finally(() => {
+      this._lifecyclePromise = null;
+    }), this._lifecyclePromise;
+  }
+  _destroy() {
+    return Promise.resolve().then(() => {
+      this._stopErrorHandling(), this._throttledSave.cancel();
+      const t = this._editor;
+      return this._editor = null, t.model.document.off("change:data", this._throttledSave), this._destructor(t);
+    });
+  }
+  /**
+  * Saves the editor data, so it can be restored after the crash even if the data cannot be fetched at
+  * the moment of the crash.
+  */
+  _save() {
+    const t = this._editor.model.document.version;
+    try {
+      this._data = this._getData(), this._editorAttachTo || (this._editables = this._getEditables()), this._lastDocumentVersion = t;
+    } catch (s) {
+      console.error(s, "An error happened during restoring editor data. Editor will be restored from the previously saved data.");
+    }
+  }
+  /**
+  * @internal
+  */
+  _setExcludedProperties(t) {
+    this._excludedProps = t;
+  }
+  /**
+  * Gets all data that is required to reinitialize editor instance.
+  */
+  _getData() {
+    const t = this._editor, s = t.model.document.roots.filter((n) => n.isAttached() && n.rootName != "$graveyard"), { plugins: r } = t, i = r.has("CommentsRepository") && r.get("CommentsRepository"), o = r.has("TrackChanges") && r.get("TrackChanges"), c = {
+      roots: {},
+      markers: {},
+      commentThreads: JSON.stringify([]),
+      suggestions: JSON.stringify([])
+    };
+    s.forEach((n) => {
+      c.roots[n.rootName] = {
+        content: JSON.stringify(Array.from(n.getChildren())),
+        attributes: JSON.stringify(Array.from(n.getAttributes())),
+        modelElement: n.name,
+        isLoaded: n._isLoaded
+      };
+    });
+    for (const n of t.model.markers)
+      n._affectsData && (c.markers[n.name] = {
+        rangeJSON: n.getRange().toJSON(),
+        usingOperation: n._managedUsingOperations,
+        affectsData: n._affectsData
+      });
+    return i && (c.commentThreads = JSON.stringify(i.getCommentThreads({
+      toJSON: !0,
+      skipNotAttached: !0
+    }))), o && (c.suggestions = JSON.stringify(o.getSuggestions({
+      toJSON: !0,
+      skipNotAttached: !0
+    }))), c;
+  }
+  /**
+  * For each attached model root, returns its HTML editable element (if available).
+  */
+  _getEditables() {
+    const t = {};
+    for (const s of this.editor.model.document.getRootNames()) {
+      const r = this.editor.ui.getEditableElement(s);
+      r && (t[s] = r);
+    }
+    return t;
+  }
+  /**
+  * Traverses the error context and the current editor to find out whether these structures are connected
+  * to each other via properties.
+  *
+  * @internal
+  */
+  _isErrorComingFromThisItem(t) {
+    return b(this._editor, t.context, this._excludedProps);
+  }
+  /**
+  * Detects whether the `create()` call was made in config-based creator mode
+  * (i.e., the first argument is a config object rather than a source element or data).
+  */
+  _detectConfigBasedCreator(t, s) {
+    if (typeof t == "string" || l(t) || s && typeof s == "object" && !("destroy" in s) && Object.keys(s).length > 0) return !1;
+    if (t && typeof t == "object") {
+      const r = Object.values(t);
+      if (r.length > 0 && r.every((i) => typeof i == "string" || l(i))) return !1;
+    }
+    return !0;
+  }
+  /**
+  * Clones the editor configuration.
+  */
+  _cloneEditorConfiguration(t) {
+    return w(t, (s, r) => {
+      if (l(s) || r === "context") return s;
+    });
+  }
+}, D = class {
+  constructor(e) {
+    a(this, "editor");
+    a(this, "_data");
+    this.editor = e, this._data = e.config.get("_watchdogInitialData");
+  }
+  /**
+  * @inheritDoc
+  */
+  init() {
+    this.editor.data.on("init", (e) => {
+      e.stop(), this.editor.model.enqueueChange({ isUndoable: !1 }, (t) => {
+        this._restoreCollaborationData(), this._restoreEditorData(t);
+      }), this.editor.data.fire("ready");
+    }, { priority: 999 });
+  }
+  /**
+  * Creates a model node (element or text) based on provided JSON.
+  */
+  _createNode(e, t) {
+    if ("name" in t) {
+      const s = e.createElement(t.name, t.attributes);
+      if (t.children) for (const r of t.children) s._appendChild(this._createNode(e, r));
+      return s;
+    } else return e.createText(t.data, t.attributes);
+  }
+  /**
+  * Restores the editor by setting the document data, roots attributes and markers.
+  */
+  _restoreEditorData(e) {
+    const t = this.editor;
+    Object.entries(this._data.roots).forEach(([s, { content: r, attributes: i }]) => {
+      const o = JSON.parse(r), c = JSON.parse(i), n = t.model.document.getRoot(s);
+      for (const [d, h] of c) e.setAttribute(d, h, n);
+      for (const d of o) {
+        const h = this._createNode(e, d);
+        e.insert(h, n, "end");
+      }
+    }), Object.entries(this._data.markers).forEach(([s, r]) => {
+      const { document: i } = t.model, { rangeJSON: { start: o, end: c }, ...n } = r, d = i.getRoot(o.root), h = e.createPositionFromPath(d, o.path, o.stickiness), _ = e.createPositionFromPath(d, c.path, c.stickiness), C = e.createRange(h, _);
+      e.addMarker(s, {
+        range: C,
+        ...n
+      });
+    });
+  }
+  /**
+  * Restores the editor collaboration data - comment threads and suggestions.
+  */
+  _restoreCollaborationData() {
+    const e = JSON.parse(this._data.commentThreads), t = JSON.parse(this._data.suggestions);
+    if (this.editor.plugins.has("CommentsRepository")) {
+      const s = this.editor.plugins.get("CommentsRepository");
+      for (const r of s.getCommentThreads()) s._removeCommentThread({ threadId: r.id });
+      e.forEach((r) => {
+        const i = this.editor.config.get("collaboration.channelId");
+        this.editor.plugins.get("CommentsRepository").addCommentThread({
+          channelId: i,
+          ...r
+        });
+      });
+    }
+    if (this.editor.plugins.has("TrackChangesEditing")) {
+      const s = this.editor.plugins.get("TrackChangesEditing");
+      for (const r of s.getSuggestions()) s._removeSuggestion(r);
+      t.forEach((r) => {
+        s.addSuggestionData(r);
+      });
+    }
+  }
+};
+function l(e) {
+  return y(e);
+}
+function j(e) {
+  const { $rootEditableOptions: t } = Object.fromEntries(JSON.parse(e));
+  return !t || typeof t != "object" ? {} : {
+    ...t.placeholder && { placeholder: t.placeholder },
+    ...t.label && { label: t.label },
+    ...t.element && { element: t.element }
+  };
+}
+/**
+* @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+* For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+*/
+const u = Symbol("MainQueueId");
+var H = class extends E {
+  /**
+  * The context watchdog class constructor.
+  *
+  * ```ts
+  * const watchdog = new ContextWatchdog( Context );
+  *
+  * await watchdog.create( contextConfiguration );
+  *
+  * await watchdog.add( item );
+  * ```
+  *
+  * See the {@glink features/watchdog Watchdog feature guide} to learn more how to use this feature.
+  *
+  * @param Context The {@link module:core/context~Context} class.
+  * @param watchdogConfig The watchdog configuration.
+  */
+  constructor(t, s = {}) {
+    super(s);
+    /**
+    * A map of internal watchdogs for added items.
+    */
+    a(this, "_watchdogs", /* @__PURE__ */ new Map());
+    /**
+    * The watchdog configuration.
+    */
+    a(this, "_watchdogConfig");
+    /**
+    * The current context instance.
+    */
+    a(this, "_context", null);
+    /**
+    * Context properties (nodes/references) that are gathered during the initial context creation
+    * and are used to distinguish the origin of an error.
+    */
+    a(this, "_contextProps", /* @__PURE__ */ new Set());
+    /**
+    * An action queue, which is used to handle async functions queuing.
+    */
+    a(this, "_actionQueues", new O());
+    /**
+    * The configuration for the {@link module:core/context~Context}.
+    */
+    a(this, "_contextConfig");
+    /**
+    * The watched item.
+    */
+    a(this, "_item");
+    this._watchdogConfig = s, this._creator = (r) => t.create(r), this._destructor = (r) => r.destroy(), this._actionQueues.onEmpty(() => {
+      this.state === "initializing" && (this.state = "ready", this._fire("stateChange"));
+    });
+  }
+  /**
+  * Sets the function that is responsible for the context creation.
+  * It expects a function that should return a promise (or `undefined`).
+  *
+  * ```ts
+  * watchdog.setCreator( config => Context.create( config ) );
+  * ```
+  */
+  setCreator(t) {
+    this._creator = t;
+  }
+  /**
+  * Sets the function that is responsible for the context destruction.
+  * Overrides the default destruction function, which destroys only the context instance.
+  * It expects a function that should return a promise (or `undefined`).
+  *
+  * ```ts
+  * watchdog.setDestructor( context => {
+  * 	// Do something before the context is destroyed.
+  *
+  * 	return context
+  * 		.destroy()
+  * 		.then( () => {
+  * 			// Do something after the context is destroyed.
+  * 		} );
+  * } );
+  * ```
+  */
+  setDestructor(t) {
+    this._destructor = t;
+  }
+  /**
+  * The context instance. Keep in mind that this property might be changed when the context watchdog restarts,
+  * so do not keep this instance internally. Always operate on the `ContextWatchdog#context` property.
+  */
+  get context() {
+    return this._context;
+  }
+  /**
+  * Initializes the context watchdog. Once it is created, the watchdog takes care about
+  * recreating the context and the provided items, and starts the error handling mechanism.
+  *
+  * ```ts
+  * await watchdog.create( {
+  * 	plugins: []
+  * } );
+  * ```
+  *
+  * @param contextConfig The context configuration. See {@link module:core/context~Context}.
+  */
+  create(t = {}) {
+    return this._actionQueues.enqueue(u, () => (this._contextConfig = t, this._create()));
+  }
+  /**
+  * Returns an item instance with the given `itemId`.
+  *
+  * ```ts
+  * const editor1 = watchdog.getItem( 'editor1' );
+  * ```
+  *
+  * @param itemId The item ID.
+  * @returns The item instance or `undefined` if an item with a given ID has not been found.
+  */
+  getItem(t) {
+    return this._getWatchdog(t)._item;
+  }
+  /**
+  * Gets the state of the given item. See {@link #state} for a list of available states.
+  *
+  * ```ts
+  * const editor1State = watchdog.getItemState( 'editor1' );
+  * ```
+  *
+  * @param itemId Item ID.
+  * @returns The state of the item.
+  */
+  getItemState(t) {
+    return this._getWatchdog(t).state;
+  }
+  /**
+  * Adds items to the watchdog. Once created, instances of these items will be available using the {@link #getItem} method.
+  *
+  * Items can be passed together as an array of objects:
+  *
+  * ```ts
+  * await watchdog.add( [ {
+  * 	id: 'editor1',
+  * 	type: 'editor',
+  * 	config: {
+  * 		attachTo: document.querySelector( '#editor' ),
+  * 		plugins: [ Essentials, Paragraph, Bold, Italic ],
+  * 		toolbar: [ 'bold', 'italic', 'alignment' ]
+  * 	},
+  * 	creator: config => ClassicEditor.create( config )
+  * } ] );
+  * ```
+  *
+  * Or one by one as objects:
+  *
+  * ```ts
+  * await watchdog.add( {
+  * 	id: 'editor1',
+  * 	type: 'editor',
+  * 	config: {
+  * 		attachTo: document.querySelector( '#editor' ),
+  * 		plugins: [ Essentials, Paragraph, Bold, Italic ],
+  * 		toolbar: [ 'bold', 'italic', 'alignment' ]
+  * 	},
+  * 	creator: config => ClassicEditor.create( config )
+  * } );
+  * ```
+  *
+  * Then an instance can be retrieved using the {@link #getItem} method:
+  *
+  * ```ts
+  * const editor1 = watchdog.getItem( 'editor1' );
+  * ```
+  *
+  * Note that this method can be called multiple times, but for performance reasons it is better
+  * to pass all items together.
+  *
+  * @param itemConfigurationOrItemConfigurations An item configuration object or an array of item configurations.
+  */
+  add(t) {
+    const s = p(t);
+    return Promise.all(s.map((r) => this._actionQueues.enqueue(r.id, () => {
+      if (this.state === "destroyed") throw new Error("Cannot add items to destroyed watchdog.");
+      if (!this._context) throw new Error("Context was not created yet. You should call the `ContextWatchdog#create()` method first.");
+      let i;
+      if (this._watchdogs.has(r.id)) throw new Error(`Item with the given id is already added: '${r.id}'.`);
+      if (r.type === "editor")
+        return i = new R(null, this._watchdogConfig), i.setCreator(r.creator), i._setExcludedProperties(this._contextProps), r.destructor && i.setDestructor(r.destructor), this._watchdogs.set(r.id, i), i.on("error", (o, { error: c, causesRestart: n }) => {
+          this._fire("itemError", {
+            itemId: r.id,
+            error: c
+          }), n && this._actionQueues.enqueue(r.id, () => new Promise((d) => {
+            const h = () => {
+              i.off("restart", h), this._fire("itemRestart", { itemId: r.id }), d();
+            };
+            i.on("restart", h);
+          }));
+        }), r.sourceElementOrData !== void 0 ? i.create(r.sourceElementOrData, r.config, this._context) : i.create(r.config, this._context);
+      throw new Error(`Not supported item type: '${r.type}'.`);
+    })));
+  }
+  /**
+  * Removes and destroys item(s) with given ID(s).
+  *
+  * ```ts
+  * await watchdog.remove( 'editor1' );
+  * ```
+  *
+  * Or
+  *
+  * ```ts
+  * await watchdog.remove( [ 'editor1', 'editor2' ] );
+  * ```
+  *
+  * @param itemIdOrItemIds Item ID or an array of item IDs.
+  */
+  remove(t) {
+    const s = p(t);
+    return Promise.all(s.map((r) => this._actionQueues.enqueue(r, () => {
+      const i = this._getWatchdog(r);
+      return this._watchdogs.delete(r), i.destroy();
+    })));
+  }
+  /**
+  * Destroys the context watchdog and all added items.
+  * Once the context watchdog is destroyed, new items cannot be added.
+  *
+  * ```ts
+  * await watchdog.destroy();
+  * ```
+  */
+  destroy() {
+    return this._actionQueues.enqueue(u, () => (this.state = "destroyed", this._fire("stateChange"), super.destroy(), this._destroy()));
+  }
+  /**
+  * Restarts the context watchdog.
+  */
+  _restart() {
+    return this._actionQueues.enqueue(u, () => (this.state = "initializing", this._fire("stateChange"), this._destroy().catch((t) => {
+      console.error("An error happened during destroying the context or items.", t);
+    }).then(() => this._create()).then(() => this._fire("restart"))));
+  }
+  /**
+  * Initializes the context watchdog.
+  */
+  _create() {
+    return Promise.resolve().then(() => (this._startErrorHandling(), this._creator(this._contextConfig))).then((t) => (this._context = t, this._contextProps = g(this._context), Promise.all(Array.from(this._watchdogs.values()).map((s) => (s._setExcludedProperties(this._contextProps), s._isUsingConfigBasedCreator ? s.create(void 0, this._context) : s.create(void 0, void 0, this._context))))));
+  }
+  /**
+  * Destroys the context instance and all added items.
+  */
+  _destroy() {
+    return Promise.resolve().then(() => {
+      this._stopErrorHandling();
+      const t = this._context;
+      return this._context = null, this._contextProps = /* @__PURE__ */ new Set(), Promise.all(Array.from(this._watchdogs.values()).map((s) => s.destroy())).then(() => this._destructor(t));
+    });
+  }
+  /**
+  * Returns the watchdog for a given item ID.
+  *
+  * @param itemId Item ID.
+  */
+  _getWatchdog(t) {
+    const s = this._watchdogs.get(t);
+    if (!s) throw new Error(`Item with the given id was not registered: ${t}.`);
+    return s;
+  }
+  /**
+  * Checks whether an error comes from the context instance and not from the item instances.
+  *
+  * @internal
+  */
+  _isErrorComingFromThisItem(t) {
+    for (const s of this._watchdogs.values()) if (s._isErrorComingFromThisItem(t)) return !1;
+    return b(this._context, t.context);
+  }
+}, O = class {
+  constructor() {
+    a(this, "_onEmptyCallbacks", []);
+    a(this, "_queues", /* @__PURE__ */ new Map());
+    a(this, "_activeActions", 0);
+  }
+  /**
+  * Used to register callbacks that will be run when the queue becomes empty.
+  *
+  * @param onEmptyCallback A callback that will be run whenever the queue becomes empty.
+  */
+  onEmpty(e) {
+    this._onEmptyCallbacks.push(e);
+  }
+  /**
+  * It adds asynchronous actions (functions) to the proper queue and runs them one by one.
+  *
+  * @param queueId The action queue ID.
+  * @param action A function that should be enqueued.
+  */
+  enqueue(e, t) {
+    const s = e === u;
+    this._activeActions++, this._queues.get(e) || this._queues.set(e, Promise.resolve());
+    const r = (s ? Promise.all(this._queues.values()) : Promise.all([this._queues.get(u), this._queues.get(e)])).then(t), i = r.catch(() => {
+    });
+    return this._queues.set(e, i), r.finally(() => {
+      this._activeActions--, this._queues.get(e) === i && this._activeActions === 0 && this._onEmptyCallbacks.forEach((o) => o());
+    });
+  }
+};
+function p(e) {
+  return Array.isArray(e) ? e : [e];
+}
+export {
+  H as ContextWatchdog,
+  R as EditorWatchdog,
+  E as Watchdog
+};
+//# sourceMappingURL=index.js.map