@etrepum/lexical-builder 0.0.36-nightly.20250714.0 → 0.0.37-nightly.20250715.0

package/dist/index.js

@@ -1,15 +1,15 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-import { shallowMergeConfig, definePlan, safeCast, provideOutput, configPlan } from "@etrepum/lexical-builder-core";
-import { configPlan as configPlan2, declarePeerDependency, definePlan as definePlan2, provideOutput as provideOutput2, safeCast as safeCast2, shallowMergeConfig as shallowMergeConfig2 } from "@etrepum/lexical-builder-core";
+import { shallowMergeConfig, defineExtension, safeCast, provideOutput, configExtension } from "@etrepum/lexical-builder-core";
+import { configExtension as configExtension2, declarePeerDependency, defineExtension as defineExtension2, provideOutput as provideOutput2, safeCast as safeCast2, shallowMergeConfig as shallowMergeConfig2 } from "@etrepum/lexical-builder-core";
 import { RootNode, TextNode, LineBreakNode, TabNode, ParagraphNode, $getRoot, $createParagraphNode, createEditor } from "lexical";
 import { mergeRegister } from "@lexical/utils";
 import { registerDragonSupport } from "@lexical/dragon";
 import { createEmptyHistoryState, registerHistory } from "@lexical/history";
 import { registerPlainText } from "@lexical/plain-text";
 import { HeadingNode, QuoteNode, registerRichText } from "@lexical/rich-text";
-const PACKAGE_VERSION = "0.0.36-nightly.20250714.0";
+const PACKAGE_VERSION = "0.0.37-nightly.20250715.0";
 function invariant(cond, message, ...args) {
   if (cond) {
     return;
@@ -29,7 +29,7 @@ function deepThemeMergeInPlace(a, b) {
   }
   return b;
 }
-const PlanRepStateIds = {
+const ExtensionRepStateIds = {
   unmarked: 0,
   temporary: 1,
   permanent: 2,
@@ -38,90 +38,94 @@ const PlanRepStateIds = {
   registered: 5,
   afterInitialization: 6
 };
-function isExactlyUnmarkedPlanRepState(state) {
-  return state.id === PlanRepStateIds.unmarked;
+function isExactlyUnmarkedExtensionRepState(state) {
+  return state.id === ExtensionRepStateIds.unmarked;
 }
-function isExactlyTemporaryPlanRepState(state) {
-  return state.id === PlanRepStateIds.temporary;
+function isExactlyTemporaryExtensionRepState(state) {
+  return state.id === ExtensionRepStateIds.temporary;
 }
-function isExactlyPermanentPlanRepState(state) {
-  return state.id === PlanRepStateIds.permanent;
+function isExactlyPermanentExtensionRepState(state) {
+  return state.id === ExtensionRepStateIds.permanent;
 }
-function isInitializedPlanRepState(state) {
-  return state.id >= PlanRepStateIds.initialized;
+function isInitializedExtensionRepState(state) {
+  return state.id >= ExtensionRepStateIds.initialized;
 }
-function isConfiguredPlanRepState(state) {
-  return state.id >= PlanRepStateIds.configured;
+function isConfiguredExtensionRepState(state) {
+  return state.id >= ExtensionRepStateIds.configured;
 }
-function isRegisteredPlanRepState(state) {
-  return state.id >= PlanRepStateIds.registered;
+function isRegisteredExtensionRepState(state) {
+  return state.id >= ExtensionRepStateIds.registered;
 }
 function isAfterInitializationState(state) {
-  return state.id >= PlanRepStateIds.afterInitialization;
+  return state.id >= ExtensionRepStateIds.afterInitialization;
 }
 function applyTemporaryMark(state) {
   invariant(
-    isExactlyUnmarkedPlanRepState(state),
-    "LexicalBuilder: Can not apply a temporary mark to state"
+    isExactlyUnmarkedExtensionRepState(state),
+    "LexicalBuilder: Can not apply a temporary mark from state id %s (expected %s unmarked)",
+    String(state.id),
+    String(ExtensionRepStateIds.unmarked)
   );
-  return Object.assign(state, { id: PlanRepStateIds.temporary });
+  return Object.assign(state, { id: ExtensionRepStateIds.temporary });
 }
 function applyPermanentMark(state) {
   invariant(
-    isExactlyTemporaryPlanRepState(state),
-    "LexicalBuilder: Can not apply a permanent mark to state"
+    isExactlyTemporaryExtensionRepState(state),
+    "LexicalBuilder: Can not apply a permanent mark from state id %s (expected %s temporary)",
+    String(state.id),
+    String(ExtensionRepStateIds.temporary)
   );
-  return Object.assign(state, { id: PlanRepStateIds.permanent });
+  return Object.assign(state, { id: ExtensionRepStateIds.permanent });
 }
 function applyConfiguredState(state, config, registerState) {
   return Object.assign(state, {
-    id: PlanRepStateIds.configured,
+    id: ExtensionRepStateIds.configured,
     config,
     registerState
   });
 }
 function applyInitializedState(state, initResult, registerState) {
   return Object.assign(state, {
-    id: PlanRepStateIds.initialized,
+    id: ExtensionRepStateIds.initialized,
     initResult,
     registerState
   });
 }
 function applyRegisteredState(state, cleanup) {
   return Object.assign(state, {
-    id: PlanRepStateIds.registered,
+    id: ExtensionRepStateIds.registered,
     output: cleanup ? cleanup.output : void 0
   });
 }
 function applyAfterInitializationState(state) {
-  return Object.assign(state, { id: PlanRepStateIds.afterInitialization });
+  return Object.assign(state, { id: ExtensionRepStateIds.afterInitialization });
 }
 const emptySet = /* @__PURE__ */ new Set();
-class PlanRep {
-  constructor(builder, plan) {
+class ExtensionRep {
+  constructor(builder, extension) {
     __publicField(this, "builder");
     __publicField(this, "configs");
     __publicField(this, "_dependency");
     __publicField(this, "_output");
     __publicField(this, "_peerNameSet");
-    __publicField(this, "plan");
+    __publicField(this, "extension");
     __publicField(this, "state");
     this.builder = builder;
-    this.plan = plan;
+    this.extension = extension;
     this.configs = /* @__PURE__ */ new Set();
-    this.state = { id: PlanRepStateIds.unmarked };
+    this.state = { id: ExtensionRepStateIds.unmarked };
   }
   afterInitialization(editor) {
     const state = this.state;
     invariant(
-      state.id === PlanRepStateIds.registered,
-      "PlanRep: afterInitialization called in state id %s (expected %s registered)",
+      state.id === ExtensionRepStateIds.registered,
+      "ExtensionRep: afterInitialization called in state id %s (expected %s registered)",
       String(state.id),
-      String(PlanRepStateIds.registered)
+      String(ExtensionRepStateIds.registered)
     );
     let rval;
-    if (this.plan.afterInitialization) {
-      rval = this.plan.afterInitialization(
+    if (this.extension.afterInitialization) {
+      rval = this.extension.afterInitialization(
         editor,
         state.config,
         state.registerState
@@ -133,14 +137,14 @@ class PlanRep {
   register(editor) {
     const state = this.state;
     invariant(
-      state.id === PlanRepStateIds.initialized,
-      "PlanRep: register called in state id %s (expected %s initialized)",
+      state.id === ExtensionRepStateIds.initialized,
+      "ExtensionRep: register called in state id %s (expected %s initialized)",
       String(state.id),
-      String(PlanRepStateIds.initialized)
+      String(ExtensionRepStateIds.initialized)
     );
     let cleanup;
-    if (this.plan.register) {
-      cleanup = this.plan.register(
+    if (this.extension.register) {
+      cleanup = this.extension.register(
         editor,
         state.config,
         state.registerState
@@ -152,8 +156,8 @@ class PlanRep {
   init(editorConfig, signal) {
     const initialState = this.state;
     invariant(
-      isExactlyPermanentPlanRepState(initialState),
-      "LexicalBuilder: Can not configure from state id %s",
+      isExactlyPermanentExtensionRepState(initialState),
+      "ExtensionRep: Can not configure from state id %s",
       String(initialState.id)
     );
     const initState = {
@@ -176,8 +180,8 @@ class PlanRep {
     );
     this.state = state;
     let initResult;
-    if (this.plan.init) {
-      initResult = this.plan.init(
+    if (this.extension.init) {
+      initResult = this.extension.init(
         editorConfig,
         state.config,
         initState
@@ -187,85 +191,87 @@ class PlanRep {
   }
   getInitResult() {
     invariant(
-      this.plan.init !== void 0,
-      "PlanRep: getInitResult() called for Plan %s that does not define init",
-      this.plan.name
+      this.extension.init !== void 0,
+      "ExtensionRep: getInitResult() called for Extension %s that does not define init",
+      this.extension.name
     );
     const state = this.state;
     invariant(
-      isInitializedPlanRepState(state),
-      "PlanRep: getInitResult() called for PlanRep in state id %s < %s (initialized)",
+      isInitializedExtensionRepState(state),
+      "ExtensionRep: getInitResult() called for ExtensionRep in state id %s < %s (initialized)",
       String(state.id),
-      String(PlanRepStateIds.initialized)
+      String(ExtensionRepStateIds.initialized)
     );
     return state.initResult;
   }
   getInitPeer(name) {
-    const rep = this.builder.planNameMap.get(name);
-    return rep ? rep.getPlanInitDependency() : void 0;
+    const rep = this.builder.extensionNameMap.get(name);
+    return rep ? rep.getExtensionInitDependency() : void 0;
   }
-  getPlanInitDependency() {
+  getExtensionInitDependency() {
     const state = this.state;
     invariant(
-      isConfiguredPlanRepState(state),
-      "LexicalPlanBuilder: getPlanInitDependency called in state id %s (expected >= %s configured)",
+      isConfiguredExtensionRepState(state),
+      "ExtensionRep: getExtensionInitDependency called in state id %s (expected >= %s configured)",
       String(state.id),
-      String(PlanRepStateIds.configured)
+      String(ExtensionRepStateIds.configured)
     );
     return { config: state.config };
   }
   getPeer(name) {
-    const rep = this.builder.planNameMap.get(name);
-    return rep ? rep.getPlanDependency() : void 0;
+    const rep = this.builder.extensionNameMap.get(name);
+    return rep ? rep.getExtensionDependency() : void 0;
   }
   getInitDependency(dep) {
-    const rep = this.builder.getPlanRep(dep);
+    const rep = this.builder.getExtensionRep(dep);
     invariant(
       rep !== void 0,
-      "LexicalPlanBuilder: Plan %s missing dependency plan %s to be in registry",
-      this.plan.name,
+      "LexicalExtensionBuilder: Extension %s missing dependency extension %s to be in registry",
+      this.extension.name,
       dep.name
     );
-    return rep.getPlanInitDependency();
+    return rep.getExtensionInitDependency();
   }
   getDependency(dep) {
-    const rep = this.builder.getPlanRep(dep);
+    const rep = this.builder.getExtensionRep(dep);
     invariant(
       rep !== void 0,
-      "LexicalPlanBuilder: Plan %s missing dependency plan %s to be in registry",
-      this.plan.name,
+      "LexicalExtensionBuilder: Extension %s missing dependency extension %s to be in registry",
+      this.extension.name,
       dep.name
     );
-    return rep.getPlanDependency();
+    return rep.getExtensionDependency();
   }
   getState() {
     const state = this.state;
     invariant(
       isAfterInitializationState(state),
-      "PlanRep getState called in state id %s (expected %s afterInitialization)",
+      "ExtensionRep getState called in state id %s (expected %s afterInitialization)",
       String(state.id),
-      String(PlanRepStateIds.afterInitialization)
+      String(ExtensionRepStateIds.afterInitialization)
     );
     return state;
   }
   getDirectDependentNames() {
-    return this.builder.incomingEdges.get(this.plan.name) || emptySet;
+    return this.builder.incomingEdges.get(this.extension.name) || emptySet;
   }
   getPeerNameSet() {
     let s = this._peerNameSet;
     if (!s) {
-      s = new Set((this.plan.peerDependencies || []).map(([name]) => name));
+      s = new Set(
+        (this.extension.peerDependencies || []).map(([name]) => name)
+      );
       this._peerNameSet = s;
     }
     return s;
   }
-  getPlanDependency() {
+  getExtensionDependency() {
     if (!this._dependency) {
       const state = this.state;
       invariant(
-        isRegisteredPlanRepState(state),
-        "Plan %s used as a dependency before registration",
-        this.plan.name
+        isRegisteredExtensionRepState(state),
+        "Extension %s used as a dependency before registration",
+        this.extension.name
       );
       this._dependency = {
         config: state.config,
@@ -275,8 +281,8 @@ class PlanRep {
     return this._dependency;
   }
   mergeConfigs() {
-    let config = this.plan.config || {};
-    const mergeConfig = this.plan.mergeConfig ? this.plan.mergeConfig.bind(this.plan) : shallowMergeConfig;
+    let config = this.extension.config || {};
+    const mergeConfig = this.extension.mergeConfig ? this.extension.mergeConfig.bind(this.extension) : shallowMergeConfig;
     for (const cfg of this.configs) {
       config = mergeConfig(config, cfg);
     }
@@ -290,10 +296,10 @@ function $defaultInitializer() {
     root.append($createParagraphNode());
   }
 }
-const InitialStatePlan = definePlan({
+const InitialStateExtension = defineExtension({
   name: "@etrepum/lexical-builder/InitialState",
   // These are automatically added by createEditor, we add them here so they are
-  // visible during planRep.init so plans can see all known types before the
+  // visible during extensionRep.init so extensions can see all known types before the
   // editor is created.
   // (excluding ArtificialNode__DO_NOT_USE because it isn't really public API
   // and shouldn't change anything)
@@ -331,8 +337,8 @@ const InitialStatePlan = definePlan({
   }
 });
 const builderSymbol = Symbol.for("@etrepum/lexical-builder");
-function buildEditorFromPlans(...plans) {
-  return LexicalBuilder.fromPlans(plans).buildEditor();
+function buildEditorFromExtensions(...extensions) {
+  return LexicalBuilder.fromExtensions(extensions).buildEditor();
 }
 function noop() {
 }
@@ -342,32 +348,32 @@ function defaultOnError(err) {
 function maybeWithBuilder(editor) {
   return editor;
 }
-function normalizePlanArgument(arg) {
+function normalizeExtensionArgument(arg) {
   return Array.isArray(arg) ? arg : [arg];
 }
 class LexicalBuilder {
   constructor(roots) {
     __publicField(this, "roots");
-    __publicField(this, "planNameMap");
+    __publicField(this, "extensionNameMap");
     __publicField(this, "outgoingConfigEdges");
     __publicField(this, "incomingEdges");
     __publicField(this, "conflicts");
-    __publicField(this, "_sortedPlanReps");
+    __publicField(this, "_sortedExtensionReps");
     __publicField(this, "PACKAGE_VERSION");
     this.outgoingConfigEdges = /* @__PURE__ */ new Map();
     this.incomingEdges = /* @__PURE__ */ new Map();
-    this.planNameMap = /* @__PURE__ */ new Map();
+    this.extensionNameMap = /* @__PURE__ */ new Map();
     this.conflicts = /* @__PURE__ */ new Map();
     this.PACKAGE_VERSION = PACKAGE_VERSION;
     this.roots = roots;
-    for (const plan of roots) {
-      this.addPlan(plan);
+    for (const extension of roots) {
+      this.addExtension(extension);
     }
   }
-  static fromPlans(plans) {
-    const roots = [normalizePlanArgument(InitialStatePlan)];
-    for (const plan of plans) {
-      roots.push(normalizePlanArgument(plan));
+  static fromExtensions(extensions) {
+    const roots = [normalizeExtensionArgument(InitialStateExtension)];
+    for (const extension of extensions) {
+      roots.push(normalizeExtensionArgument(extension));
     }
     return new LexicalBuilder(roots);
   }
@@ -427,126 +433,126 @@ class LexicalBuilder {
     );
     return editor;
   }
-  getPlanRep(plan) {
-    const rep = this.planNameMap.get(plan.name);
+  getExtensionRep(extension) {
+    const rep = this.extensionNameMap.get(extension.name);
     if (rep) {
       invariant(
-        rep.plan === plan,
-        "LexicalBuilder: A registered plan with name %s exists but does not match the given plan",
-        plan.name
+        rep.extension === extension,
+        "LexicalBuilder: A registered extension with name %s exists but does not match the given extension",
+        extension.name
       );
       return rep;
     }
   }
-  addEdge(fromPlanName, toPlanName, configs) {
-    const outgoing = this.outgoingConfigEdges.get(fromPlanName);
+  addEdge(fromExtensionName, toExtensionName, configs) {
+    const outgoing = this.outgoingConfigEdges.get(fromExtensionName);
     if (outgoing) {
-      outgoing.set(toPlanName, configs);
+      outgoing.set(toExtensionName, configs);
     } else {
       this.outgoingConfigEdges.set(
-        fromPlanName,
-        /* @__PURE__ */ new Map([[toPlanName, configs]])
+        fromExtensionName,
+        /* @__PURE__ */ new Map([[toExtensionName, configs]])
       );
     }
-    const incoming = this.incomingEdges.get(toPlanName);
+    const incoming = this.incomingEdges.get(toExtensionName);
     if (incoming) {
-      incoming.add(fromPlanName);
+      incoming.add(fromExtensionName);
     } else {
-      this.incomingEdges.set(toPlanName, /* @__PURE__ */ new Set([fromPlanName]));
+      this.incomingEdges.set(toExtensionName, /* @__PURE__ */ new Set([fromExtensionName]));
     }
   }
-  addPlan(arg) {
+  addExtension(arg) {
     invariant(
-      this._sortedPlanReps === void 0,
-      "LexicalBuilder: addPlan called after finalization"
+      this._sortedExtensionReps === void 0,
+      "LexicalBuilder: addExtension called after finalization"
     );
-    const normalized = normalizePlanArgument(arg);
-    const [plan] = normalized;
+    const normalized = normalizeExtensionArgument(arg);
+    const [extension] = normalized;
     invariant(
-      typeof plan.name === "string",
-      "LexicalBuilder: plan name must be string, not %s",
-      typeof plan.name
+      typeof extension.name === "string",
+      "LexicalBuilder: extension name must be string, not %s",
+      typeof extension.name
     );
-    let planRep = this.planNameMap.get(plan.name);
+    let extensionRep = this.extensionNameMap.get(extension.name);
     invariant(
-      planRep === void 0 || planRep.plan === plan,
-      "LexicalBuilder: Multiple plans registered with name %s, names must be unique",
-      plan.name
+      extensionRep === void 0 || extensionRep.extension === extension,
+      "LexicalBuilder: Multiple extensions registered with name %s, names must be unique",
+      extension.name
     );
-    if (!planRep) {
-      planRep = new PlanRep(this, plan);
-      this.planNameMap.set(plan.name, planRep);
-      const hasConflict = this.conflicts.get(plan.name);
+    if (!extensionRep) {
+      extensionRep = new ExtensionRep(this, extension);
+      this.extensionNameMap.set(extension.name, extensionRep);
+      const hasConflict = this.conflicts.get(extension.name);
       if (typeof hasConflict === "string") {
         invariant(
           false,
-          "LexicalBuilder: plan %s conflicts with %s",
-          plan.name,
+          "LexicalBuilder: extension %s conflicts with %s",
+          extension.name,
           hasConflict
         );
       }
-      for (const name of plan.conflictsWith || []) {
+      for (const name of extension.conflictsWith || []) {
         invariant(
-          !this.planNameMap.has(name),
-          "LexicalBuilder: plan %s conflicts with %s",
-          plan.name,
+          !this.extensionNameMap.has(name),
+          "LexicalBuilder: extension %s conflicts with %s",
+          extension.name,
           name
         );
-        this.conflicts.set(name, plan.name);
+        this.conflicts.set(name, extension.name);
       }
-      for (const dep of plan.dependencies || []) {
-        const normDep = normalizePlanArgument(dep);
-        this.addEdge(plan.name, normDep[0].name, normDep.slice(1));
-        this.addPlan(normDep);
+      for (const dep of extension.dependencies || []) {
+        const normDep = normalizeExtensionArgument(dep);
+        this.addEdge(extension.name, normDep[0].name, normDep.slice(1));
+        this.addExtension(normDep);
       }
-      for (const [depName, config] of plan.peerDependencies || []) {
-        this.addEdge(plan.name, depName, config ? [config] : []);
+      for (const [depName, config] of extension.peerDependencies || []) {
+        this.addEdge(extension.name, depName, config ? [config] : []);
       }
     }
   }
-  sortedPlanReps() {
-    if (this._sortedPlanReps) {
-      return this._sortedPlanReps;
+  sortedExtensionReps() {
+    if (this._sortedExtensionReps) {
+      return this._sortedExtensionReps;
     }
-    const sortedPlanReps = [];
-    const visit = (rep, fromPlanName) => {
+    const sortedExtensionReps = [];
+    const visit = (rep, fromExtensionName) => {
       let mark = rep.state;
-      if (isExactlyPermanentPlanRepState(mark)) {
+      if (isExactlyPermanentExtensionRepState(mark)) {
         return;
       }
-      const planName = rep.plan.name;
+      const extensionName = rep.extension.name;
       invariant(
-        isExactlyUnmarkedPlanRepState(mark),
-        "LexicalBuilder: Circular dependency detected for Plan %s from %s",
-        planName,
-        fromPlanName || "[unknown]"
+        isExactlyUnmarkedExtensionRepState(mark),
+        "LexicalBuilder: Circular dependency detected for Extension %s from %s",
+        extensionName,
+        fromExtensionName || "[unknown]"
       );
       mark = applyTemporaryMark(mark);
       rep.state = mark;
-      const outgoingConfigEdges = this.outgoingConfigEdges.get(planName);
+      const outgoingConfigEdges = this.outgoingConfigEdges.get(extensionName);
       if (outgoingConfigEdges) {
-        for (const toPlanName of outgoingConfigEdges.keys()) {
-          const toRep = this.planNameMap.get(toPlanName);
+        for (const toExtensionName of outgoingConfigEdges.keys()) {
+          const toRep = this.extensionNameMap.get(toExtensionName);
           if (toRep) {
-            visit(toRep, planName);
+            visit(toRep, extensionName);
           }
         }
       }
       mark = applyPermanentMark(mark);
       rep.state = mark;
-      sortedPlanReps.push(rep);
+      sortedExtensionReps.push(rep);
     };
-    for (const rep of this.planNameMap.values()) {
-      if (isExactlyUnmarkedPlanRepState(rep.state)) {
+    for (const rep of this.extensionNameMap.values()) {
+      if (isExactlyUnmarkedExtensionRepState(rep.state)) {
         visit(rep);
       }
     }
-    for (const rep of sortedPlanReps) {
-      for (const [toPlanName, configs] of this.outgoingConfigEdges.get(
-        rep.plan.name
+    for (const rep of sortedExtensionReps) {
+      for (const [toExtensionName, configs] of this.outgoingConfigEdges.get(
+        rep.extension.name
       ) || []) {
         if (configs.length > 0) {
-          const toRep = this.planNameMap.get(toPlanName);
+          const toRep = this.extensionNameMap.get(toExtensionName);
           if (toRep) {
             for (const config of configs) {
               toRep.configs.add(config);
@@ -555,33 +561,33 @@ class LexicalBuilder {
         }
       }
     }
-    for (const [plan, ...configs] of this.roots) {
+    for (const [extension, ...configs] of this.roots) {
       if (configs.length > 0) {
-        const toRep = this.planNameMap.get(plan.name);
+        const toRep = this.extensionNameMap.get(extension.name);
         invariant(
           toRep !== void 0,
-          "LexicalBuilder: Expecting existing PlanRep for %s",
-          plan.name
+          "LexicalBuilder: Expecting existing ExtensionRep for %s",
+          extension.name
         );
         for (const config of configs) {
           toRep.configs.add(config);
         }
       }
     }
-    this._sortedPlanReps = sortedPlanReps;
-    return this._sortedPlanReps;
+    this._sortedExtensionReps = sortedExtensionReps;
+    return this._sortedExtensionReps;
   }
   registerEditor(editor, controller) {
     const cleanups = [];
-    const planReps = this.sortedPlanReps();
-    for (const planRep of planReps) {
-      const cleanup = planRep.register(editor);
+    const extensionReps = this.sortedExtensionReps();
+    for (const extensionRep of extensionReps) {
+      const cleanup = extensionRep.register(editor);
       if (cleanup) {
         cleanups.push(cleanup);
       }
     }
-    for (const planRep of planReps) {
-      const cleanup = planRep.afterInitialization(editor);
+    for (const extensionRep of extensionReps) {
+      const cleanup = extensionRep.afterInitialization(editor);
       if (cleanup) {
         cleanups.push(cleanup);
       }
@@ -607,57 +613,57 @@ class LexicalBuilder {
     const htmlExport = /* @__PURE__ */ new Map();
     const htmlImport = {};
     const theme = {};
-    const planReps = this.sortedPlanReps();
-    for (const planRep of planReps) {
-      const { plan } = planRep;
-      if (plan.onError !== void 0) {
-        config.onError = plan.onError;
+    const extensionReps = this.sortedExtensionReps();
+    for (const extensionRep of extensionReps) {
+      const { extension } = extensionRep;
+      if (extension.onError !== void 0) {
+        config.onError = extension.onError;
       }
-      if (plan.disableEvents !== void 0) {
-        config.disableEvents = plan.disableEvents;
+      if (extension.disableEvents !== void 0) {
+        config.disableEvents = extension.disableEvents;
       }
-      if (plan.parentEditor !== void 0) {
-        config.parentEditor = plan.parentEditor;
+      if (extension.parentEditor !== void 0) {
+        config.parentEditor = extension.parentEditor;
       }
-      if (plan.editable !== void 0) {
-        config.editable = plan.editable;
+      if (extension.editable !== void 0) {
+        config.editable = extension.editable;
       }
-      if (plan.namespace !== void 0) {
-        config.namespace = plan.namespace;
+      if (extension.namespace !== void 0) {
+        config.namespace = extension.namespace;
       }
-      if (plan.$initialEditorState !== void 0) {
-        config.$initialEditorState = plan.$initialEditorState;
+      if (extension.$initialEditorState !== void 0) {
+        config.$initialEditorState = extension.$initialEditorState;
       }
-      if (plan.nodes) {
-        for (const node of plan.nodes) {
+      if (extension.nodes) {
+        for (const node of extension.nodes) {
           if (typeof node !== "function") {
-            const conflictPlan = replacedNodes.get(node.replace);
-            if (conflictPlan) {
+            const conflictExtension = replacedNodes.get(node.replace);
+            if (conflictExtension) {
               invariant(
                 false,
-                "LexicalBuilder: Plan %s can not register replacement for node %s because %s already did",
-                plan.name,
+                "LexicalBuilder: Extension %s can not register replacement for node %s because %s already did",
+                extension.name,
                 node.replace.name,
-                conflictPlan.plan.name
+                conflictExtension.extension.name
               );
             }
-            replacedNodes.set(node.replace, planRep);
+            replacedNodes.set(node.replace, extensionRep);
           }
           nodes.add(node);
         }
       }
-      if (plan.html) {
-        if (plan.html.export) {
-          for (const [k, v] of plan.html.export.entries()) {
+      if (extension.html) {
+        if (extension.html.export) {
+          for (const [k, v] of extension.html.export.entries()) {
             htmlExport.set(k, v);
           }
         }
-        if (plan.html.import) {
-          Object.assign(htmlImport, plan.html.import);
+        if (extension.html.import) {
+          Object.assign(htmlImport, extension.html.import);
         }
       }
-      if (plan.theme) {
-        deepThemeMergeInPlace(theme, plan.theme);
+      if (extension.theme) {
+        deepThemeMergeInPlace(theme, extension.theme);
       }
     }
     if (Object.keys(theme).length > 0) {
@@ -677,8 +683,8 @@ class LexicalBuilder {
         config.html.export = htmlExport;
       }
     }
-    for (const planRep of planReps) {
-      planRep.init(config, signal);
+    for (const extensionRep of extensionReps) {
+      extensionRep.init(config, signal);
     }
     if (!config.onError) {
       config.onError = defaultOnError;
@@ -686,27 +692,27 @@ class LexicalBuilder {
     return config;
   }
 }
-function getPlanDependencyFromEditor(editor, plan) {
+function getExtensionDependencyFromEditor(editor, extension) {
   const builder = LexicalBuilder.fromEditor(editor);
-  const rep = builder.getPlanRep(plan);
+  const rep = builder.getExtensionRep(extension);
   invariant(
     rep !== void 0,
-    "getPlanFromEditor: Plan %s was not built when creating this editor",
-    plan.name
+    "getExtensionDependencyFromEditor: Extension %s was not built when creating this editor",
+    extension.name
   );
-  return rep.getPlanDependency();
+  return rep.getExtensionDependency();
 }
-function getPeerDependencyFromEditor(editor, planName) {
+function getPeerDependencyFromEditor(editor, extensionName) {
   const builder = LexicalBuilder.fromEditor(editor);
-  const peer = builder.planNameMap.get(planName);
-  return peer ? peer.getPlanDependency() : void 0;
+  const peer = builder.extensionNameMap.get(extensionName);
+  return peer ? peer.getExtensionDependency() : void 0;
 }
-function getPeerDependencyFromEditorOrThrow(editor, planName) {
-  const dep = getPeerDependencyFromEditor(editor, planName);
+function getPeerDependencyFromEditorOrThrow(editor, extensionName) {
+  const dep = getPeerDependencyFromEditor(editor, extensionName);
   invariant(
     dep !== void 0,
-    "getPeerDependencyFromEditorOrThrow: Editor was not build with Plan %s",
-    planName
+    "getPeerDependencyFromEditorOrThrow: Editor was not built with Extension %s",
+    extensionName
   );
   return dep;
 }
@@ -720,7 +726,7 @@ function getKnownTypesAndNodes(config) {
   }
   return { types, nodes };
 }
-const AutoFocusPlan = definePlan({
+const AutoFocusExtension = defineExtension({
   config: safeCast({}),
   name: "@etrepum/lexical-builder/AutoFocus",
   register(editor, { defaultSelection }) {
@@ -797,7 +803,7 @@ function disabledToggle(opts) {
     registerStoreToggle(disabled, (v) => !v, opts.register)
   ];
 }
-const DragonPlan = definePlan({
+const DragonExtension = defineExtension({
   name: "@lexical/dragon",
   config: safeCast({ disabled: typeof window === "undefined" }),
   register: (editor, config) => provideOutput(
@@ -807,7 +813,7 @@ const DragonPlan = definePlan({
     })
   )
 });
-const HistoryPlan = definePlan({
+const HistoryExtension = defineExtension({
   config: safeCast({
     createInitialHistoryState: createEmptyHistoryState,
     delay: 300,
@@ -827,13 +833,13 @@ const HistoryPlan = definePlan({
   }
 });
 function getHistoryPeer(editor) {
-  return editor ? getPeerDependencyFromEditor(editor, HistoryPlan.name) : null;
+  return editor ? getPeerDependencyFromEditor(editor, HistoryExtension.name) : null;
 }
-const SharedHistoryPlan = definePlan({
+const SharedHistoryExtension = defineExtension({
   name: "@etrepum/lexical-builder/SharedHistory",
-  dependencies: [configPlan(HistoryPlan, { disabled: true })],
+  dependencies: [configExtension(HistoryExtension, { disabled: true })],
   init(editorConfig, _config, state) {
-    const { config } = state.getDependency(HistoryPlan);
+    const { config } = state.getDependency(HistoryExtension);
     const parentPeer = getHistoryPeer(editorConfig.parentEditor);
     if (parentPeer) {
       config.delay = parentPeer.config.delay;
@@ -847,43 +853,43 @@ const SharedHistoryPlan = definePlan({
       return () => {
       };
     }
-    const disabled = state.getDependency(HistoryPlan).output.disabled;
+    const disabled = state.getDependency(HistoryExtension).output.disabled;
     return parentPeer.output.disabled.subscribe(disabled.set.bind(disabled));
   }
 });
-const PlainTextPlan = definePlan({
+const PlainTextExtension = defineExtension({
   conflictsWith: ["@lexical/rich-text"],
   name: "@lexical/plain-text",
-  dependencies: [DragonPlan],
+  dependencies: [DragonExtension],
   register: registerPlainText
 });
-const RichTextPlan = definePlan({
+const RichTextExtension = defineExtension({
   conflictsWith: ["@lexical/plain-text"],
   name: "@lexical/rich-text",
   nodes: [HeadingNode, QuoteNode],
-  dependencies: [DragonPlan],
+  dependencies: [DragonExtension],
   register: registerRichText
 });
 export {
-  AutoFocusPlan,
-  DragonPlan,
-  HistoryPlan,
-  InitialStatePlan,
+  AutoFocusExtension,
+  DragonExtension,
+  HistoryExtension,
+  InitialStateExtension,
   LexicalBuilder,
   PACKAGE_VERSION,
-  PlainTextPlan,
-  RichTextPlan,
-  SharedHistoryPlan,
+  PlainTextExtension,
+  RichTextExtension,
+  SharedHistoryExtension,
   Store,
-  buildEditorFromPlans,
-  configPlan2 as configPlan,
+  buildEditorFromExtensions,
+  configExtension2 as configExtension,
   declarePeerDependency,
-  definePlan2 as definePlan,
+  defineExtension2 as defineExtension,
   disabledToggle,
+  getExtensionDependencyFromEditor,
   getKnownTypesAndNodes,
   getPeerDependencyFromEditor,
   getPeerDependencyFromEditorOrThrow,
-  getPlanDependencyFromEditor,
   provideOutput2 as provideOutput,
   registerStoreToggle,
   safeCast2 as safeCast,