@soeditor/core 0.5.0

package/dist/index.js

@@ -0,0 +1,1132 @@
+class SoEditorError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = new.target.name;
+  }
+}
+class EditorDestroyedError extends SoEditorError {
+  constructor() {
+    super("The editor has been destroyed and can no longer be used.");
+  }
+}
+class EditorInitializationAbortedError extends SoEditorError {
+  constructor() {
+    super(
+      "Editor initialization was aborted because destruction began before startup completed."
+    );
+  }
+}
+class ReentrantDispatchError extends SoEditorError {
+  constructor() {
+    super(
+      "Cannot dispatch a transaction while another dispatch is active."
+    );
+  }
+}
+class TransactionOwnershipError extends SoEditorError {
+  constructor() {
+    super("The transaction was not created by this editor.");
+  }
+}
+class TransactionAlreadyCommittedError extends SoEditorError {
+  constructor() {
+    super("The transaction has already been committed.");
+  }
+}
+class StaleTransactionError extends SoEditorError {
+  constructor(baseVersion, currentVersion) {
+    super(
+      `Transaction base version ${baseVersion} does not match current editor version ${currentVersion}.`
+    );
+  }
+}
+class UnsupportedConfigValueError extends SoEditorError {
+  constructor(path, kind) {
+    super(
+      `Configuration value at "${path}" has unsupported type "${kind}".`
+    );
+  }
+}
+class CyclicConfigurationError extends SoEditorError {
+  constructor(path) {
+    super(`Configuration value at "${path}" contains a cycle.`);
+  }
+}
+class UnsupportedDocumentFormatError extends SoEditorError {
+  constructor(format) {
+    super(`Document format "${format}" is not supported in this release.`);
+  }
+}
+class CommandNotFoundError extends SoEditorError {
+  constructor(id) {
+    super(`Command "${id}" is not registered.`);
+  }
+}
+class CommandAlreadyRegisteredError extends SoEditorError {
+  constructor(id) {
+    super(`Command "${id}" is already registered.`);
+  }
+}
+class PluginNotFoundError extends SoEditorError {
+  constructor(id) {
+    super(`Plugin "${id}" is not loaded.`);
+  }
+}
+class PluginDuplicateIdError extends SoEditorError {
+  constructor(id) {
+    super(`Plugin ID "${id}" is declared by multiple plugin constructors.`);
+  }
+}
+class PluginDependencyCycleError extends SoEditorError {
+  path;
+  constructor(path) {
+    super(`Plugin dependency cycle detected: ${path.join(" -> ")}.`);
+    this.path = Object.freeze([...path]);
+  }
+}
+class ServiceNotFoundError extends SoEditorError {
+  constructor(id) {
+    super(`Service "${id}" is not registered.`);
+  }
+}
+class ServiceAlreadyRegisteredError extends SoEditorError {
+  constructor(id) {
+    super(`Service "${id}" is already registered.`);
+  }
+}
+function isRecord(value) {
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function cloneConfig(value, path = "config", ancestors = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value === "boolean" || typeof value === "number" || typeof value === "string") {
+    return value;
+  }
+  if (typeof value !== "object") {
+    throw new UnsupportedConfigValueError(path, typeof value);
+  }
+  if (ancestors.has(value)) {
+    throw new CyclicConfigurationError(path);
+  }
+  ancestors.add(value);
+  if (Array.isArray(value)) {
+    try {
+      return cloneConfigArray(value, path, ancestors);
+    } finally {
+      ancestors.delete(value);
+    }
+  }
+  if (!isRecord(value)) {
+    ancestors.delete(value);
+    throw new UnsupportedConfigValueError(path, "non-plain object");
+  }
+  try {
+    if (Object.getOwnPropertySymbols(value).length > 0) {
+      throw new UnsupportedConfigValueError(path, "symbol-keyed object");
+    }
+    const copy = {};
+    for (const [key, descriptor] of Object.entries(
+      Object.getOwnPropertyDescriptors(value)
+    )) {
+      if (!("value" in descriptor)) {
+        throw new UnsupportedConfigValueError(
+          `${path}.${key}`,
+          "accessor"
+        );
+      }
+      if (!descriptor.enumerable) {
+        continue;
+      }
+      Object.defineProperty(copy, key, {
+        enumerable: true,
+        value: cloneConfig(
+          descriptor.value,
+          `${path}.${key}`,
+          ancestors
+        ),
+        writable: true
+      });
+    }
+    return Object.freeze(copy);
+  } finally {
+    ancestors.delete(value);
+  }
+}
+function cloneConfigArray(value, path, ancestors) {
+  if (Object.getOwnPropertySymbols(value).length > 0) {
+    throw new UnsupportedConfigValueError(path, "symbol-keyed array");
+  }
+  const propertyNames = Object.getOwnPropertyNames(value);
+  const indexNames = propertyNames.filter((name) => name !== "length");
+  for (const name of indexNames) {
+    const index = Number(name);
+    if (!Number.isInteger(index) || index < 0 || String(index) !== name) {
+      throw new UnsupportedConfigValueError(
+        `${path}.${name}`,
+        "custom array property"
+      );
+    }
+  }
+  if (indexNames.length !== value.length) {
+    throw new UnsupportedConfigValueError(path, "sparse array");
+  }
+  const copy = [];
+  for (let index = 0; index < value.length; index += 1) {
+    const descriptor = Object.getOwnPropertyDescriptor(
+      value,
+      String(index)
+    );
+    if (descriptor === void 0 || !descriptor.enumerable || !("value" in descriptor)) {
+      throw new UnsupportedConfigValueError(
+        `${path}[${index}]`,
+        descriptor !== void 0 && !("value" in descriptor) ? "accessor" : "nonstandard array index"
+      );
+    }
+    copy.push(
+      cloneConfig(descriptor.value, `${path}[${index}]`, ancestors)
+    );
+  }
+  return Object.freeze(copy);
+}
+class Config {
+  #values;
+  /** Creates an immutable defensive copy of supported configuration data. */
+  constructor(values = {}) {
+    this.#values = cloneConfig(values);
+  }
+  /** Returns whether a dotted configuration path exists. */
+  has(path) {
+    return this.#find(path).found;
+  }
+  /** Returns a value at a dotted path, or undefined when absent. */
+  get(path) {
+    const result = this.#find(path);
+    return result.found ? result.value : void 0;
+  }
+  #find(path) {
+    if (path.length === 0) {
+      return { found: false };
+    }
+    let current = this.#values;
+    for (const segment of path.split(".")) {
+      if (typeof current !== "object" || current === null || !Object.prototype.hasOwnProperty.call(current, segment)) {
+        return { found: false };
+      }
+      current = current[segment];
+    }
+    return { found: true, value: current };
+  }
+}
+const records$4 = /* @__PURE__ */ new WeakMap();
+class EventBus {
+  constructor(assertAvailable = () => void 0) {
+    records$4.set(this, {
+      assertAvailable,
+      listeners: /* @__PURE__ */ new Map()
+    });
+  }
+  on(name, listener) {
+    const record = getRecord$4(this);
+    record.assertAvailable();
+    const listeners = record.listeners.get(name) ?? /* @__PURE__ */ new Set();
+    listeners.add(listener);
+    record.listeners.set(name, listeners);
+    return () => {
+      listeners.delete(listener);
+      if (listeners.size === 0) {
+        record.listeners.delete(name);
+      }
+    };
+  }
+  once(name, listener) {
+    let dispose = () => void 0;
+    const wrapped = (payload) => {
+      dispose();
+      listener(payload);
+    };
+    dispose = this.on(name, wrapped);
+    return dispose;
+  }
+  emit(name, payload) {
+    const record = getRecord$4(this);
+    record.assertAvailable();
+    throwListenerErrors(notify(record, name, payload));
+  }
+}
+function createEditorEvents(events) {
+  return Object.freeze({
+    on: events.on.bind(events),
+    once: events.once.bind(events)
+  });
+}
+function getRecord$4(events) {
+  const record = records$4.get(events);
+  if (record === void 0) {
+    throw new Error("Event bus storage is unavailable.");
+  }
+  return record;
+}
+function notify(record, name, payload) {
+  const listeners = record.listeners.get(name);
+  if (listeners === void 0) {
+    return [];
+  }
+  const errors = [];
+  for (const listener of [...listeners]) {
+    try {
+      listener(payload);
+    } catch (error) {
+      errors.push(error);
+    }
+  }
+  return errors;
+}
+function throwListenerErrors(errors) {
+  if (errors.length === 1) {
+    throw errors[0];
+  }
+  if (errors.length > 1) {
+    throw new AggregateError(errors, "Multiple event listeners failed.");
+  }
+}
+function emitSafely(events, name, payload) {
+  const record = getRecord$4(events);
+  const errors = notify(record, name, payload);
+  if (name !== "event:error") {
+    for (const error of errors) {
+      notify(record, "event:error", {
+        eventName: String(name),
+        error
+      });
+    }
+  }
+  return errors;
+}
+function emitInternally(events, name, payload) {
+  throwListenerErrors(notify(getRecord$4(events), name, payload));
+}
+function clearEvents(events) {
+  getRecord$4(events).listeners.clear();
+}
+const records$3 = /* @__PURE__ */ new WeakMap();
+class CommandRegistry {
+  constructor(editor, events, assertAvailable) {
+    records$3.set(this, {
+      assertAvailable,
+      commands: /* @__PURE__ */ new Map(),
+      context: Object.freeze({ editor }),
+      events
+    });
+  }
+  register(command) {
+    const record = getRecord$3(this);
+    record.assertAvailable();
+    if (record.commands.has(command.id)) {
+      throw new CommandAlreadyRegisteredError(command.id);
+    }
+    record.commands.set(command.id, command);
+  }
+  unregister(id) {
+    const record = getRecord$3(this);
+    record.assertAvailable();
+    return record.commands.delete(id);
+  }
+  has(id) {
+    const record = getRecord$3(this);
+    record.assertAvailable();
+    return record.commands.has(id);
+  }
+  get(id) {
+    const record = getRecord$3(this);
+    record.assertAvailable();
+    const command = record.commands.get(id);
+    if (command === void 0) {
+      throw new CommandNotFoundError(id);
+    }
+    return command;
+  }
+  ids() {
+    const record = getRecord$3(this);
+    record.assertAvailable();
+    return Object.freeze([...record.commands.keys()]);
+  }
+  canExecute(id) {
+    const record = getRecord$3(this);
+    const command = this.get(id);
+    return command.canExecute?.(record.context) ?? true;
+  }
+  isActive(id) {
+    const record = getRecord$3(this);
+    const command = this.get(id);
+    return command.isActive?.(record.context) ?? false;
+  }
+  execute(id, ...args) {
+    const record = getRecord$3(this);
+    const command = this.get(id);
+    if (!(command.canExecute?.(record.context) ?? true)) {
+      return void 0;
+    }
+    const event = Object.freeze({
+      commandId: id,
+      args: Object.freeze(args)
+    });
+    emitInternally(record.events, "command:beforeExecute", event);
+    let result;
+    let then;
+    try {
+      result = command.execute(record.context, ...args);
+      then = getThenMethod(result);
+    } catch (error) {
+      emitSafely(
+        record.events,
+        "command:error",
+        Object.freeze({ ...event, error })
+      );
+      throw error;
+    }
+    if (then !== void 0) {
+      return assimilateThenable(result, then).then(
+        (value) => {
+          emitInternally(
+            record.events,
+            "command:afterExecute",
+            event
+          );
+          return value;
+        },
+        (error) => {
+          emitSafely(
+            record.events,
+            "command:error",
+            Object.freeze({ ...event, error })
+          );
+          throw error;
+        }
+      );
+    }
+    emitInternally(record.events, "command:afterExecute", event);
+    return result;
+  }
+}
+function getRecord$3(registry) {
+  const record = records$3.get(registry);
+  if (record === void 0) {
+    throw new Error("Command registry storage is unavailable.");
+  }
+  return record;
+}
+function getThenMethod(value) {
+  if ((typeof value !== "object" || value === null) && typeof value !== "function") {
+    return void 0;
+  }
+  const then = Reflect.get(value, "then");
+  return typeof then === "function" ? then : void 0;
+}
+function assimilateThenable(value, then) {
+  return new Promise((resolve, reject) => {
+    try {
+      then.call(value, resolve, reject);
+    } catch (error) {
+      reject(error);
+    }
+  });
+}
+function clearCommands(registry) {
+  getRecord$3(registry).commands.clear();
+}
+const records$2 = /* @__PURE__ */ new WeakMap();
+class PluginManager {
+  constructor(editor, events, assertAvailable) {
+    records$2.set(this, {
+      assertAvailable,
+      editor,
+      events,
+      instances: /* @__PURE__ */ new Map(),
+      order: []
+    });
+  }
+  has(key) {
+    const record = getRecord$2(this);
+    record.assertAvailable();
+    return record.instances.has(typeof key === "string" ? key : key.id);
+  }
+  get(key) {
+    const record = getRecord$2(this);
+    record.assertAvailable();
+    const id = typeof key === "string" ? key : key.id;
+    const entry = record.instances.get(id);
+    if (entry === void 0) {
+      throw new PluginNotFoundError(id);
+    }
+    return entry.instance;
+  }
+  tryGet(key) {
+    const record = getRecord$2(this);
+    record.assertAvailable();
+    const id = typeof key === "string" ? key : key.id;
+    return record.instances.get(id)?.instance;
+  }
+}
+function getRecord$2(manager) {
+  const record = records$2.get(manager);
+  if (record === void 0) {
+    throw new Error("Plugin manager storage is unavailable.");
+  }
+  return record;
+}
+function emitPluginError(record, pluginId, phase, error) {
+  emitSafely(
+    record.events,
+    "plugin:error",
+    Object.freeze({ pluginId, phase, error })
+  );
+}
+async function initializePlugins(manager, constructors, startup) {
+  const record = getRecord$2(manager);
+  const order = resolvePlugins(constructors);
+  startup.assertInitializing();
+  record.order = order;
+  const context = Object.freeze({ editor: record.editor });
+  for (const constructor of record.order) {
+    startup.assertInitializing();
+    let instance;
+    try {
+      instance = new constructor(context);
+    } catch (error) {
+      startup.assertInitializing();
+      emitPluginError(record, constructor.id, "construct", error);
+      throw error;
+    }
+    startup.assertInitializing();
+    record.instances.set(constructor.id, {
+      constructor,
+      instance,
+      stage: "constructed"
+    });
+  }
+  for (const constructor of record.order) {
+    startup.assertInitializing();
+    const entry = record.instances.get(constructor.id);
+    if (entry === void 0) {
+      throw new Error(`Plugin "${constructor.id}" was not constructed.`);
+    }
+    try {
+      await waitForStartupHook(entry.instance.init?.(), startup);
+    } catch (error) {
+      startup.assertInitializing();
+      emitPluginError(record, constructor.id, "init", error);
+      throw error;
+    }
+    startup.assertInitializing();
+    entry.stage = "initialized";
+  }
+  for (const constructor of record.order) {
+    startup.assertInitializing();
+    const entry = record.instances.get(constructor.id);
+    if (entry === void 0) {
+      throw new Error(`Plugin "${constructor.id}" was not constructed.`);
+    }
+    try {
+      await waitForStartupHook(entry.instance.ready?.(), startup);
+    } catch (error) {
+      startup.assertInitializing();
+      emitPluginError(record, constructor.id, "ready", error);
+      throw error;
+    }
+    startup.assertInitializing();
+    entry.stage = "ready";
+  }
+  startup.assertInitializing();
+}
+async function waitForStartupHook(result, startup) {
+  const hookOutcome = Promise.resolve(
+    result
+  ).then(
+    () => ({ status: "fulfilled" }),
+    (error) => ({ status: "rejected", error })
+  );
+  const activeDestroy = startup.getDestroyPromise();
+  if (activeDestroy !== void 0) {
+    await activeDestroy;
+    startup.assertInitializing();
+    return;
+  }
+  const outcome = await Promise.race([
+    hookOutcome,
+    startup.destructionStarted.then(() => ({
+      status: "destroying"
+    }))
+  ]);
+  if (outcome.status === "rejected") {
+    throw outcome.error;
+  }
+  if (outcome.status === "destroying") {
+    const destroyPromise = startup.getDestroyPromise();
+    if (destroyPromise === void 0) {
+      throw new Error(
+        "Editor destruction started without a shared destroy promise."
+      );
+    }
+    await destroyPromise;
+    startup.assertInitializing();
+  }
+}
+async function destroyPlugins(manager) {
+  const record = getRecord$2(manager);
+  for (const constructor of [...record.order].reverse()) {
+    const entry = record.instances.get(constructor.id);
+    if (entry === void 0 || entry.stage === "constructed" || entry.stage === "destroyed") {
+      continue;
+    }
+    entry.stage = "destroyed";
+    try {
+      await entry.instance.destroy?.();
+    } catch (error) {
+      emitPluginError(record, constructor.id, "destroy", error);
+    }
+  }
+  record.instances.clear();
+  record.order = [];
+}
+function resolvePlugins(roots) {
+  const byId = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = [];
+  const ordered = [];
+  const visit = (constructor) => {
+    const existing = byId.get(constructor.id);
+    if (existing !== void 0 && existing !== constructor) {
+      throw new PluginDuplicateIdError(constructor.id);
+    }
+    byId.set(constructor.id, constructor);
+    const cycleStart = visiting.indexOf(constructor);
+    if (cycleStart !== -1) {
+      const path = visiting.slice(cycleStart).map((item) => item.id);
+      path.push(constructor.id);
+      throw new PluginDependencyCycleError(path);
+    }
+    if (visited.has(constructor)) {
+      return;
+    }
+    visiting.push(constructor);
+    for (const requirement of constructor.requires ?? []) {
+      visit(requirement);
+    }
+    visiting.pop();
+    visited.add(constructor);
+    ordered.push(constructor);
+  };
+  for (const constructor of roots) {
+    visit(constructor);
+  }
+  return Object.freeze(ordered);
+}
+const records$1 = /* @__PURE__ */ new WeakMap();
+function serviceId(key) {
+  return typeof key === "string" ? key : key.id;
+}
+class ServiceRegistry {
+  constructor(assertAvailable) {
+    records$1.set(this, { assertAvailable, services: /* @__PURE__ */ new Map() });
+  }
+  register(key, service) {
+    const record = getRecord$1(this);
+    record.assertAvailable();
+    const id = serviceId(key);
+    if (record.services.has(id)) {
+      throw new ServiceAlreadyRegisteredError(id);
+    }
+    record.services.set(id, service);
+  }
+  replace(key, service) {
+    const record = getRecord$1(this);
+    record.assertAvailable();
+    record.services.set(serviceId(key), service);
+  }
+  has(key) {
+    const record = getRecord$1(this);
+    record.assertAvailable();
+    return record.services.has(serviceId(key));
+  }
+  get(key) {
+    const record = getRecord$1(this);
+    record.assertAvailable();
+    const id = serviceId(key);
+    if (!record.services.has(id)) {
+      throw new ServiceNotFoundError(id);
+    }
+    return record.services.get(id);
+  }
+  tryGet(key) {
+    const record = getRecord$1(this);
+    record.assertAvailable();
+    return record.services.get(serviceId(key));
+  }
+  unregister(key) {
+    const record = getRecord$1(this);
+    record.assertAvailable();
+    return record.services.delete(serviceId(key));
+  }
+}
+function getRecord$1(registry) {
+  const record = records$1.get(registry);
+  if (record === void 0) {
+    throw new Error("Service registry storage is unavailable.");
+  }
+  return record;
+}
+function clearServices(registry) {
+  getRecord$1(registry).services.clear();
+}
+function createEditorDocument(source, format, revision = 0, metadata = {}) {
+  return Object.freeze({
+    format,
+    source,
+    revision,
+    metadata: Object.freeze({ ...metadata })
+  });
+}
+function createEditorState(values) {
+  return Object.freeze({ ...values });
+}
+const records = /* @__PURE__ */ new WeakMap();
+class EditorTransaction {
+  constructor(record) {
+    records.set(this, record);
+  }
+  get origin() {
+    return getRecord(this).origin;
+  }
+  get operations() {
+    return [...getRecord(this).operations];
+  }
+  get metadata() {
+    return Object.freeze(Object.fromEntries(getRecord(this).metadata));
+  }
+  replaceDocument(source) {
+    const record = getMutableRecord(this);
+    record.operations.push(
+      Object.freeze({ type: "replace-document", source })
+    );
+    return this;
+  }
+  setMode(mode) {
+    const record = getMutableRecord(this);
+    record.operations.push(Object.freeze({ type: "set-mode", mode }));
+    return this;
+  }
+  setMeta(key, value) {
+    getMutableRecord(this).metadata.set(key, value);
+    return this;
+  }
+  getMeta(key) {
+    return getRecord(this).metadata.get(key);
+  }
+}
+function getRecord(transaction) {
+  const record = records.get(transaction);
+  if (record === void 0) {
+    throw new TransactionOwnershipError();
+  }
+  return record;
+}
+function getMutableRecord(transaction) {
+  const record = getRecord(transaction);
+  if (record.committed) {
+    throw new TransactionAlreadyCommittedError();
+  }
+  return record;
+}
+function createTransaction(owner, baseVersion, options) {
+  return new EditorTransaction({
+    baseVersion,
+    committed: false,
+    metadata: /* @__PURE__ */ new Map(),
+    operations: [],
+    origin: options.origin ?? "system",
+    owner
+  });
+}
+function commitTransaction(transaction, owner, currentVersion) {
+  const record = getMutableRecord(transaction);
+  if (record.owner !== owner) {
+    throw new TransactionOwnershipError();
+  }
+  if (record.baseVersion !== currentVersion) {
+    throw new StaleTransactionError(record.baseVersion, currentVersion);
+  }
+  record.committed = true;
+  return Object.freeze([...record.operations]);
+}
+class Editor {
+  /** Commands available to consumers and plugins. */
+  commands;
+  /** Immutable instance configuration. */
+  config;
+  /** Subscription-only access to typed editor events. */
+  events;
+  /** Loaded plugin lookup capabilities. */
+  plugins;
+  /** Cross-feature service capabilities. */
+  services;
+  #commandRegistry;
+  #destructionStarted;
+  #eventBus;
+  #owner = Object.freeze({});
+  #pluginManager;
+  #serviceRegistry;
+  #destroyPromise;
+  #dispatching = false;
+  #lifecycle = "initializing";
+  #resolveDestructionStarted;
+  #state;
+  #stateVersion = 0;
+  constructor(options) {
+    const format = options.format ?? "html";
+    if (format !== "html" && format !== "markdown") {
+      throw new UnsupportedDocumentFormatError(format);
+    }
+    this.#state = createEditorState({
+      document: createEditorDocument(options.data ?? "", format),
+      mode: options.mode ?? (format === "markdown" ? "markdown" : "visual"),
+      readonly: options.readonly ?? false,
+      dirty: false
+    });
+    this.#destructionStarted = new Promise((resolve) => {
+      this.#resolveDestructionStarted = resolve;
+    });
+    this.config = new Config(options.config);
+    const assertAvailable = () => this.#assertNotDestroyed();
+    this.#eventBus = new EventBus(assertAvailable);
+    this.#commandRegistry = new CommandRegistry(
+      this,
+      this.#eventBus,
+      assertAvailable
+    );
+    this.#serviceRegistry = new ServiceRegistry(assertAvailable);
+    this.#pluginManager = new PluginManager(
+      this,
+      this.#eventBus,
+      assertAvailable
+    );
+    this.commands = this.#commandRegistry;
+    this.events = createEditorEvents(this.#eventBus);
+    this.services = this.#serviceRegistry;
+    this.plugins = this.#pluginManager;
+  }
+  /** The current immutable state snapshot. */
+  get state() {
+    return this.#state;
+  }
+  /** Creates and initializes an editor and all requested plugins. */
+  static async create(options = {}) {
+    const editor = new Editor(options);
+    try {
+      await initializePlugins(
+        editor.#pluginManager,
+        options.plugins ?? [],
+        {
+          assertInitializing: () => editor.#assertInitializing(),
+          destructionStarted: editor.#destructionStarted,
+          getDestroyPromise: () => editor.#destroyPromise
+        }
+      );
+      editor.#transitionToReady();
+      let readyEventError;
+      let readyEventFailed = false;
+      try {
+        emitInternally(
+          editor.#eventBus,
+          "editor:ready",
+          Object.freeze({ editor })
+        );
+      } catch (error) {
+        readyEventFailed = true;
+        readyEventError = error;
+      }
+      editor.#assertCreationCanReturn();
+      if (readyEventFailed) {
+        throw readyEventError;
+      }
+      return editor;
+    } catch (error) {
+      await editor.destroy();
+      throw error;
+    }
+  }
+  /** Creates a mutable transaction owned by the current editor state. */
+  createTransaction(options = {}) {
+    this.#assertAlive();
+    return createTransaction(this.#owner, this.#stateVersion, options);
+  }
+  /**
+   * Applies one owned, current, uncommitted transaction.
+   *
+   * Synchronous reentrant dispatch is rejected with
+   * `ReentrantDispatchError` rather than queued.
+   */
+  dispatch(transaction) {
+    this.#assertAlive();
+    if (this.#dispatching) {
+      throw new ReentrantDispatchError();
+    }
+    this.#dispatching = true;
+    try {
+      const operations = commitTransaction(
+        transaction,
+        this.#owner,
+        this.#stateVersion
+      );
+      this.#applyOperations(transaction, operations);
+    } finally {
+      this.#dispatching = false;
+    }
+  }
+  /** Builds and dispatches one editor-owned transaction. */
+  update(callback, options = {}) {
+    this.#assertAlive();
+    const transaction = this.createTransaction(options);
+    callback(transaction);
+    this.dispatch(transaction);
+  }
+  /** Executes a registered command through this editor's command collection. */
+  execute(commandId, ...args) {
+    this.#assertAlive();
+    return this.#commandRegistry.execute(commandId, ...args);
+  }
+  /** Returns canonical source, including after editor destruction. */
+  getData() {
+    return this.#state.document.source;
+  }
+  /**
+   * Administratively replaces canonical source through a transaction.
+   *
+   * This remains allowed when `readonly` is true; future user-facing editing
+   * surfaces must enforce readonly policy before creating user transactions.
+   */
+  setData(source) {
+    this.update((transaction) => transaction.replaceDocument(source), {
+      origin: "source"
+    });
+  }
+  /** Marks the current state as saved without changing document revision. */
+  markClean() {
+    this.#assertAlive();
+    if (!this.#state.dirty) {
+      return;
+    }
+    const previous = this.#state;
+    const current = createEditorState({ ...previous, dirty: false });
+    this.#state = current;
+    this.#stateVersion += 1;
+    emitInternally(
+      this.#eventBus,
+      "state:change",
+      Object.freeze({ previous, current })
+    );
+  }
+  /**
+   * Destroys initialized plugins and clears all owned infrastructure.
+   *
+   * Calls made while destruction is pending return the same promise.
+   */
+  destroy() {
+    if (this.#destroyPromise !== void 0) {
+      return this.#destroyPromise;
+    }
+    this.#lifecycle = "destroying";
+    let resolveDestroy;
+    let rejectDestroy;
+    const destroyPromise = new Promise((resolve, reject) => {
+      resolveDestroy = resolve;
+      rejectDestroy = reject;
+    });
+    this.#destroyPromise = destroyPromise;
+    this.#resolveDestructionStarted();
+    void this.#performDestroy().then(resolveDestroy, rejectDestroy);
+    return destroyPromise;
+  }
+  #applyOperations(transaction, operations) {
+    const previous = this.#state;
+    let source = previous.document.source;
+    let mode = previous.mode;
+    for (const operation of operations) {
+      switch (operation.type) {
+        case "replace-document":
+          source = operation.source;
+          break;
+        case "set-mode":
+          mode = operation.mode;
+          break;
+        default:
+          assertNever(operation);
+      }
+    }
+    const documentChanged = source !== previous.document.source;
+    const modeChanged = mode !== previous.mode;
+    if (!documentChanged && !modeChanged) {
+      return;
+    }
+    const document = documentChanged ? createEditorDocument(
+      source,
+      previous.document.format,
+      previous.document.revision + 1,
+      previous.document.metadata
+    ) : previous.document;
+    const current = createEditorState({
+      document,
+      mode,
+      readonly: previous.readonly,
+      dirty: documentChanged ? true : previous.dirty
+    });
+    if (documentChanged) {
+      emitInternally(
+        this.#eventBus,
+        "document:beforeChange",
+        Object.freeze({
+          previous: previous.document,
+          current: document,
+          transaction
+        })
+      );
+    }
+    this.#state = current;
+    this.#stateVersion += 1;
+    const notificationErrors = [];
+    if (documentChanged) {
+      attemptNotification(
+        notificationErrors,
+        () => emitInternally(
+          this.#eventBus,
+          "document:change",
+          Object.freeze({
+            previous: previous.document,
+            current: document,
+            transaction
+          })
+        )
+      );
+    }
+    if (modeChanged) {
+      attemptNotification(
+        notificationErrors,
+        () => emitInternally(
+          this.#eventBus,
+          "mode:change",
+          Object.freeze({
+            previous: previous.mode,
+            current: mode,
+            transaction
+          })
+        )
+      );
+    }
+    attemptNotification(
+      notificationErrors,
+      () => emitInternally(
+        this.#eventBus,
+        "state:change",
+        Object.freeze({ previous, current, transaction })
+      )
+    );
+    throwNotificationErrors(notificationErrors);
+  }
+  async #performDestroy() {
+    try {
+      await destroyPlugins(this.#pluginManager);
+    } finally {
+      this.#lifecycle = "destroyed";
+      try {
+        emitSafely(
+          this.#eventBus,
+          "editor:destroy",
+          Object.freeze({ editor: this })
+        );
+      } finally {
+        clearCommands(this.#commandRegistry);
+        clearServices(this.#serviceRegistry);
+        clearEvents(this.#eventBus);
+      }
+    }
+  }
+  #assertAlive() {
+    if (this.#lifecycle === "destroying" || this.#lifecycle === "destroyed") {
+      throw new EditorDestroyedError();
+    }
+  }
+  #assertInitializing() {
+    if (this.#lifecycle !== "initializing") {
+      throw new EditorInitializationAbortedError();
+    }
+  }
+  #transitionToReady() {
+    this.#assertInitializing();
+    this.#lifecycle = "ready";
+  }
+  #assertCreationCanReturn() {
+    if (this.#lifecycle !== "ready") {
+      throw new EditorInitializationAbortedError();
+    }
+  }
+  #assertNotDestroyed() {
+    if (this.#lifecycle === "destroying" || this.#lifecycle === "destroyed") {
+      throw new EditorDestroyedError();
+    }
+  }
+}
+function assertNever(operation) {
+  throw new Error(`Unsupported operation: ${JSON.stringify(operation)}.`);
+}
+function attemptNotification(errors, notify2) {
+  try {
+    notify2();
+  } catch (error) {
+    errors.push(error);
+  }
+}
+function throwNotificationErrors(errors) {
+  if (errors.length === 1) {
+    throw errors[0];
+  }
+  if (errors.length > 1) {
+    throw new AggregateError(
+      errors,
+      "Multiple editor state notifications failed."
+    );
+  }
+}
+class Plugin {
+  /** The editor instance that owns this plugin. */
+  editor;
+  /** Creates a plugin owned by the editor in the supplied context. */
+  constructor(context) {
+    this.editor = context.editor;
+  }
+}
+function createServiceToken(id) {
+  return Object.freeze({ id });
+}
+export {
+  CommandAlreadyRegisteredError,
+  CommandNotFoundError,
+  Config,
+  CyclicConfigurationError,
+  Editor,
+  EditorDestroyedError,
+  EditorInitializationAbortedError,
+  Plugin,
+  PluginDependencyCycleError,
+  PluginDuplicateIdError,
+  PluginNotFoundError,
+  ReentrantDispatchError,
+  ServiceAlreadyRegisteredError,
+  ServiceNotFoundError,
+  SoEditorError,
+  StaleTransactionError,
+  TransactionAlreadyCommittedError,
+  TransactionOwnershipError,
+  UnsupportedConfigValueError,
+  UnsupportedDocumentFormatError,
+  createServiceToken
+};
+//# sourceMappingURL=index.js.map