@etrepum/lexical-builder 0.0.28-nightly.20240705.0 → 0.0.28

package/dist/AutoFocusPlan.d.ts

@@ -16,5 +16,5 @@ export interface AutoFocusConfig {
  * A Plan to focus the LexicalEditor when the root element is set
  * (typically only when the editor is first created).
  */
-export declare const AutoFocusPlan: import('@etrepum/lexical-builder-core').LexicalPlan<AutoFocusConfig, "@etrepum/lexical-builder/AutoFocusPlan", unknown, unknown>;
+export declare const AutoFocusPlan: import('@etrepum/lexical-builder-core').LexicalPlan<AutoFocusConfig, "@etrepum/lexical-builder/AutoFocus", unknown, unknown>;
 //# sourceMappingURL=AutoFocusPlan.d.ts.map

package/dist/AutoFocusPlan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AutoFocusPlan.d.ts","sourceRoot":"","sources":["../src/AutoFocusPlan.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,gBAAgB,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;CAC5C;AAED;;;GAGG;AACH,eAAO,MAAM,aAAa,kIAwBxB,CAAC"}
+{"version":3,"file":"AutoFocusPlan.d.ts","sourceRoot":"","sources":["../src/AutoFocusPlan.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,gBAAgB,CAAC,EAAE,WAAW,GAAG,SAAS,CAAC;CAC5C;AAED;;;GAGG;AACH,eAAO,MAAM,aAAa,8HAwBxB,CAAC"}

package/dist/HistoryPlan.d.ts

@@ -13,7 +13,7 @@ export interface HistoryConfig {
 }
 /**
  * Registers necessary listeners to manage undo/redo history stack and related
- * editor commands, via the @lexical/history module.
+ * editor commands, via the \@lexical/history module.
  */
-export declare const HistoryPlan: import('@etrepum/lexical-builder-core').LexicalPlan<HistoryConfig, "@etrepum/lexical-builder/HistoryPlan", unknown, unknown>;
+export declare const HistoryPlan: import('@etrepum/lexical-builder-core').LexicalPlan<HistoryConfig, "@etrepum/lexical-builder/History", unknown, unknown>;
 //# sourceMappingURL=HistoryPlan.d.ts.map

package/dist/HistoryPlan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HistoryPlan.d.ts","sourceRoot":"","sources":["../src/HistoryPlan.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAEL,KAAK,YAAY,EAElB,MAAM,kBAAkB,CAAC;AAK1B,MAAM,WAAW,aAAa;IAC5B;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;OAEG;IACH,yBAAyB,EAAE,MAAM,YAAY,CAAC;CAC/C;AAED;;;GAGG;AACH,eAAO,MAAM,WAAW,8HAStB,CAAC"}
+{"version":3,"file":"HistoryPlan.d.ts","sourceRoot":"","sources":["../src/HistoryPlan.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAEL,KAAK,YAAY,EAElB,MAAM,kBAAkB,CAAC;AAG1B,MAAM,WAAW,aAAa;IAC5B;;;OAGG;IACH,KAAK,EAAE,MAAM,CAAC;IACd;;OAEG;IACH,yBAAyB,EAAE,MAAM,YAAY,CAAC;CAC/C;AAED;;;GAGG;AACH,eAAO,MAAM,WAAW,0HAStB,CAAC"}

package/dist/InitialStatePlan.d.ts

@@ -1,10 +1,8 @@
-import { LexicalEditor, EditorSetOptions } from 'lexical';
+import { EditorSetOptions, EditorUpdateOptions } from 'lexical';
 
-type EditorUpdateOptions = NonNullable<Parameters<LexicalEditor["update"]>[1]>;
 export interface InitialStateConfig {
     updateOptions: EditorUpdateOptions;
     setOptions: EditorSetOptions;
 }
 export declare const InitialStatePlan: import('@etrepum/lexical-builder-core').LexicalPlan<InitialStateConfig, "@etrepum/lexical-builder/InitialState", unknown, import('@etrepum/lexical-builder-core').InitialEditorStateType>;
-export {};
 //# sourceMappingURL=InitialStatePlan.d.ts.map

package/dist/InitialStatePlan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InitialStatePlan.d.ts","sourceRoot":"","sources":["../src/InitialStatePlan.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAIH,OAAO,EAQL,KAAK,aAAa,EAClB,KAAK,gBAAgB,EAGtB,MAAM,SAAS,CAAC;AAGjB,KAAK,mBAAmB,GAAG,WAAW,CAAC,UAAU,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAU/E,MAAM,WAAW,kBAAkB;IACjC,aAAa,EAAE,mBAAmB,CAAC;IACnC,UAAU,EAAE,gBAAgB,CAAC;CAC9B;AAED,eAAO,MAAM,gBAAgB,2LAoC3B,CAAC"}
+{"version":3,"file":"InitialStatePlan.d.ts","sourceRoot":"","sources":["../src/InitialStatePlan.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,EAQL,KAAK,gBAAgB,EACrB,KAAK,mBAAmB,EACzB,MAAM,SAAS,CAAC;AAWjB,MAAM,WAAW,kBAAkB;IACjC,aAAa,EAAE,mBAAmB,CAAC;IACnC,UAAU,EAAE,gBAAgB,CAAC;CAC9B;AAED,eAAO,MAAM,gBAAgB,2LA2C3B,CAAC"}

package/dist/LexicalBuilder.d.ts

@@ -1,4 +1,4 @@
-import { AnyLexicalPlan, AnyLexicalPlanArgument, LexicalEditorWithDispose, InitialEditorConfig } from '@etrepum/lexical-builder-core';
+import { AnyLexicalPlan, AnyLexicalPlanArgument, LexicalEditorWithDispose, InitialEditorConfig, LexicalPlanConfig } from '@etrepum/lexical-builder-core';
 import { LexicalEditor } from 'lexical';
 import { PlanRep } from './PlanRep';
 
@@ -8,8 +8,7 @@ export declare const builderSymbol: unique symbol;
  * Build a LexicalEditor by combining together one or more plans, optionally
  * overriding some of their configuration.
  *
- * @param plan A plan argument (a plan, or a plan with config overrides)
- * @param plans Optional additional plan arguments
+ * @param plans - Plan arguments (plans or plans with config overrides)
  * @returns An editor handle
  *
  * @example A single root plan with multiple dependencies
@@ -36,24 +35,29 @@ export declare const builderSymbol: unique symbol;
  * );
  * ```
  */
-export declare function buildEditorFromPlans(plan: AnyLexicalPlanArgument, ...plans: AnyLexicalPlanArgument[]): LexicalEditorWithDispose;
+export declare function buildEditorFromPlans(...plans: AnyLexicalPlanArgument[]): LexicalEditorWithDispose;
+type AnyNormalizedLexicalPlanArgument = ReturnType<typeof normalizePlanArgument>;
+declare function normalizePlanArgument(arg: AnyLexicalPlanArgument): import('@etrepum/lexical-builder-core/dist/types').NormalizedLexicalPlanArgument<any, string, any, any>;
 /** @internal */
 export declare class LexicalBuilder {
-    phases: Map<AnyLexicalPlan, PlanRep<AnyLexicalPlan>>[];
-    planMap: Map<AnyLexicalPlan, [number, PlanRep<AnyLexicalPlan>]>;
+    roots: readonly AnyNormalizedLexicalPlanArgument[];
     planNameMap: Map<string, PlanRep<AnyLexicalPlan>>;
-    reverseEdges: Map<AnyLexicalPlan, Set<AnyLexicalPlan>>;
-    addStack: Set<AnyLexicalPlan>;
+    outgoingConfigEdges: Map<string, Map<string, LexicalPlanConfig<AnyLexicalPlan>[]>>;
+    incomingEdges: Map<string, Set<string>>;
     conflicts: Map<string, string>;
+    _sortedPlanReps?: readonly PlanRep<AnyLexicalPlan>[];
     PACKAGE_VERSION: string;
-    constructor();
+    constructor(roots: AnyNormalizedLexicalPlanArgument[]);
+    static fromPlans(plans: AnyLexicalPlanArgument[]): LexicalBuilder;
     /** Look up the editor that was created by this LexicalBuilder or throw */
     static fromEditor(editor: LexicalEditor): LexicalBuilder;
     buildEditor(): LexicalEditorWithDispose;
     getPlanRep<Plan extends AnyLexicalPlan>(plan: Plan): PlanRep<Plan> | undefined;
-    addPlan(arg: AnyLexicalPlanArgument, parent?: AnyLexicalPlan): number;
-    sortedPlanReps(): Generator<PlanRep<AnyLexicalPlan>, void, undefined>;
+    addEdge(fromPlanName: string, toPlanName: string, configs: LexicalPlanConfig<AnyLexicalPlan>[]): void;
+    addPlan(arg: AnyLexicalPlanArgument): void;
+    sortedPlanReps(): readonly PlanRep<AnyLexicalPlan>[];
     registerEditor(editor: LexicalEditor, controller: AbortController): () => void;
     buildCreateEditorArgs(signal: AbortSignal): InitialEditorConfig;
 }
+export {};
 //# sourceMappingURL=LexicalBuilder.d.ts.map

package/dist/LexicalBuilder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"LexicalBuilder.d.ts","sourceRoot":"","sources":["../src/LexicalBuilder.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EACV,cAAc,EACd,sBAAsB,EACtB,wBAAwB,EACxB,mBAAmB,EAEpB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACL,KAAK,aAAa,EAOnB,MAAM,SAAS,CAAC;AAKjB,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC,+DAA+D;AAC/D,eAAO,MAAM,aAAa,eAAyC,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,sBAAsB,EAC5B,GAAG,KAAK,EAAE,sBAAsB,EAAE,GACjC,wBAAwB,CAQ1B;AAmBD,gBAAgB;AAChB,qBAAa,cAAc;IACzB,MAAM,EAAE,GAAG,CAAC,cAAc,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC;IACvD,OAAO,EAAE,GAAG,CAAC,cAAc,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC;IAChE,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC;IAClD,YAAY,EAAE,GAAG,CAAC,cAAc,EAAE,GAAG,CAAC,cAAc,CAAC,CAAC,CAAC;IACvD,QAAQ,EAAE,GAAG,CAAC,cAAc,CAAC,CAAC;IAC9B,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,eAAe,EAAE,MAAM,CAAC;;IAaxB,0EAA0E;IAC1E,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,aAAa,GAAG,cAAc;IAoBxD,WAAW,IAAI,wBAAwB;IA6BvC,UAAU,CAAC,IAAI,SAAS,cAAc,EACpC,IAAI,EAAE,IAAI,GACT,OAAO,CAAC,IAAI,CAAC,GAAG,SAAS;IAQ5B,OAAO,CAAC,GAAG,EAAE,sBAAsB,EAAE,MAAM,CAAC,EAAE,cAAc,GAAG,MAAM;IAmGpE,cAAc;IAMf,cAAc,CACZ,MAAM,EAAE,aAAa,EACrB,UAAU,EAAE,eAAe,GAC1B,MAAM,IAAI;IAiCb,qBAAqB,CAAC,MAAM,EAAE,WAAW;CAqF1C"}
+{"version":3,"file":"LexicalBuilder.d.ts","sourceRoot":"","sources":["../src/LexicalBuilder.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EACV,cAAc,EACd,sBAAsB,EACtB,wBAAwB,EACxB,mBAAmB,EACnB,iBAAiB,EAClB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EACL,KAAK,aAAa,EAOnB,MAAM,SAAS,CAAC;AAKjB,OAAO,EACL,OAAO,EAKR,MAAM,WAAW,CAAC;AAInB,+DAA+D;AAC/D,eAAO,MAAM,aAAa,eAAyC,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,KAAK,EAAE,sBAAsB,EAAE,GACjC,wBAAwB,CAE1B;AAqBD,KAAK,gCAAgC,GAAG,UAAU,CAChD,OAAO,qBAAqB,CAC7B,CAAC;AACF,iBAAS,qBAAqB,CAAC,GAAG,EAAE,sBAAsB,2GAEzD;AAED,gBAAgB;AAChB,qBAAa,cAAc;IACzB,KAAK,EAAE,SAAS,gCAAgC,EAAE,CAAC;IACnD,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC;IAClD,mBAAmB,EAAE,GAAG,CACtB,MAAM,EACN,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,cAAc,CAAC,EAAE,CAAC,CACjD,CAAC;IACF,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;IACxC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B,eAAe,CAAC,EAAE,SAAS,OAAO,CAAC,cAAc,CAAC,EAAE,CAAC;IACrD,eAAe,EAAE,MAAM,CAAC;gBAEZ,KAAK,EAAE,gCAAgC,EAAE;IAYrD,MAAM,CAAC,SAAS,CAAC,KAAK,EAAE,sBAAsB,EAAE,GAAG,cAAc;IAQjE,0EAA0E;IAC1E,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,aAAa,GAAG,cAAc;IAoBxD,WAAW,IAAI,wBAAwB;IAwCvC,UAAU,CAAC,IAAI,SAAS,cAAc,EACpC,IAAI,EAAE,IAAI,GACT,OAAO,CAAC,IAAI,CAAC,GAAG,SAAS;IAY5B,OAAO,CACL,YAAY,EAAE,MAAM,EACpB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,iBAAiB,CAAC,cAAc,CAAC,EAAE;IAmB9C,OAAO,CAAC,GAAG,EAAE,sBAAsB;IAkDnC,cAAc,IAAI,SAAS,OAAO,CAAC,cAAc,CAAC,EAAE;IAwEpD,cAAc,CACZ,MAAM,EAAE,aAAa,EACrB,UAAU,EAAE,eAAe,GAC1B,MAAM,IAAI;IA8Bb,qBAAqB,CAAC,MAAM,EAAE,WAAW;CAqF1C"}

package/dist/PlanRep.d.ts

@@ -1,31 +1,77 @@
-import { LexicalBuilder } from './LexicalBuilder';
-import { AnyLexicalPlan, InitialEditorConfig, LexicalPlanConfig, LexicalPlanDependency, LexicalPlanInit, LexicalPlanOutput, RegisterState } from '@etrepum/lexical-builder-core';
+import { AnyLexicalPlan, InitialEditorConfig, LexicalPlanConfig, LexicalPlanDependency, LexicalPlanInit, LexicalPlanOutput, RegisterCleanup, PlanInitState, PlanRegisterState } from '@etrepum/lexical-builder-core';
 import { LexicalEditor } from 'lexical';
+import { LexicalBuilder } from './LexicalBuilder';
 
+export declare const PlanRepStateIds: {
+    readonly unmarked: 0;
+    readonly temporary: 1;
+    readonly permanent: 2;
+    readonly configured: 3;
+    readonly initialized: 4;
+    readonly registered: 5;
+    readonly afterInitialization: 6;
+};
+interface UnmarkedState {
+    id: (typeof PlanRepStateIds)["unmarked"];
+}
+interface TemporaryState extends Omit<UnmarkedState, "id"> {
+    id: (typeof PlanRepStateIds)["temporary"];
+}
+interface PermanentState extends Omit<TemporaryState, "id"> {
+    id: (typeof PlanRepStateIds)["permanent"];
+}
+interface ConfiguredState<Plan extends AnyLexicalPlan> extends Omit<PermanentState, "id"> {
+    id: (typeof PlanRepStateIds)["configured"];
+    config: LexicalPlanConfig<Plan>;
+    registerState: PlanInitState;
+}
+interface InitializedState<Plan extends AnyLexicalPlan> extends Omit<ConfiguredState<Plan>, "id" | "registerState"> {
+    id: (typeof PlanRepStateIds)["initialized"];
+    initResult: LexicalPlanInit<Plan>;
+    registerState: PlanRegisterState<LexicalPlanInit<Plan>>;
+}
+interface RegisteredState<Plan extends AnyLexicalPlan> extends Omit<InitializedState<Plan>, "id"> {
+    id: (typeof PlanRepStateIds)["registered"];
+    output: LexicalPlanOutput<Plan>;
+}
+interface AfterInitializationState<Plan extends AnyLexicalPlan> extends Omit<RegisteredState<Plan>, "id"> {
+    id: (typeof PlanRepStateIds)["afterInitialization"];
+}
+export type PlanRepState<Plan extends AnyLexicalPlan> = UnmarkedState | TemporaryState | PermanentState | ConfiguredState<Plan> | InitializedState<Plan> | RegisteredState<Plan> | AfterInitializationState<Plan>;
+export declare function isExactlyUnmarkedPlanRepState<Plan extends AnyLexicalPlan>(state: PlanRepState<Plan>): state is UnmarkedState;
+export declare function isExactlyPermanentPlanRepState<Plan extends AnyLexicalPlan>(state: PlanRepState<Plan>): state is PermanentState;
+export declare function applyTemporaryMark<Plan extends AnyLexicalPlan>(state: PlanRepState<Plan>): TemporaryState;
+export declare function applyPermanentMark<Plan extends AnyLexicalPlan>(state: PlanRepState<Plan>): PermanentState;
+export declare function applyConfiguredState<Plan extends AnyLexicalPlan>(state: PermanentState, config: LexicalPlanConfig<Plan>, registerState: PlanInitState): ConfiguredState<Plan>;
+export declare function applyInitializedState<Plan extends AnyLexicalPlan>(state: ConfiguredState<Plan>, initResult: LexicalPlanInit<Plan>, registerState: PlanRegisterState<Plan>): InitializedState<Plan>;
+export declare function applyRegisteredState<Plan extends AnyLexicalPlan>(state: InitializedState<Plan>, cleanup?: RegisterCleanup<LexicalPlanOutput<Plan>> | undefined): never;
+export declare function applyAfterInitializationState<Plan extends AnyLexicalPlan>(state: RegisteredState<Plan>): AfterInitializationState<Plan>;
 /**
  * @internal
  */
 export declare class PlanRep<Plan extends AnyLexicalPlan> {
     builder: LexicalBuilder;
     configs: Set<Partial<LexicalPlanConfig<Plan>>>;
-    _config?: LexicalPlanConfig<Plan>;
     _dependency?: LexicalPlanDependency<Plan>;
     _output?: LexicalPlanOutput<Plan>;
     _peerNameSet?: Set<string>;
-    _registerState?: RegisterState<LexicalPlanInit<Plan>>;
-    _initResult?: LexicalPlanInit<Plan>;
     plan: Plan;
+    state: PlanRepState<Plan>;
     constructor(builder: LexicalBuilder, plan: Plan);
-    afterInitialization(editor: LexicalEditor, signal: AbortSignal): undefined | (() => void);
-    register(editor: LexicalEditor, signal: AbortSignal): undefined | (() => void);
+    afterInitialization(editor: LexicalEditor): undefined | (() => void);
+    register(editor: LexicalEditor): undefined | (() => void);
     init(editorConfig: InitialEditorConfig, signal: AbortSignal): void;
     getInitResult(): LexicalPlanInit<Plan>;
-    getRegisterState(signal: AbortSignal): RegisterState<LexicalPlanInit<Plan>>;
+    getInitPeer<PeerPlan extends AnyLexicalPlan = never>(name: PeerPlan["name"]): undefined | Omit<LexicalPlanDependency<PeerPlan>, "output">;
+    getPlanInitDependency(): Omit<LexicalPlanDependency<Plan>, "output">;
     getPeer<PeerPlan extends AnyLexicalPlan = never>(name: PeerPlan["name"]): undefined | LexicalPlanDependency<PeerPlan>;
+    getInitDependency<Dependency extends AnyLexicalPlan>(dep: Dependency): Omit<LexicalPlanDependency<Dependency>, "output">;
     getDependency<Dependency extends AnyLexicalPlan>(dep: Dependency): LexicalPlanDependency<Dependency>;
-    getDirectDependentNames(): string[];
-    getPeerNameSet(): Set<string>;
+    getState(): AfterInitializationState<Plan>;
+    getDirectDependentNames(): ReadonlySet<string>;
+    getPeerNameSet(): ReadonlySet<string>;
     getPlanDependency(): LexicalPlanDependency<Plan>;
-    getConfig(): LexicalPlanConfig<Plan>;
+    mergeConfigs(): LexicalPlanConfig<Plan>;
 }
+export {};
 //# sourceMappingURL=PlanRep.d.ts.map

package/dist/PlanRep.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PlanRep.d.ts","sourceRoot":"","sources":["../src/PlanRep.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,KAAK,EACV,cAAc,EACd,mBAAmB,EACnB,iBAAiB,EACjB,qBAAqB,EACrB,eAAe,EACf,iBAAiB,EACjB,aAAa,EACd,MAAM,+BAA+B,CAAC;AAKvC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAG7C;;GAEG;AACH,qBAAa,OAAO,CAAC,IAAI,SAAS,cAAc;IAC9C,OAAO,EAAE,cAAc,CAAC;IACxB,OAAO,EAAE,GAAG,CAAC,OAAO,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAC/C,OAAO,CAAC,EAAE,iBAAiB,CAAC,IAAI,CAAC,CAAC;IAClC,WAAW,CAAC,EAAE,qBAAqB,CAAC,IAAI,CAAC,CAAC;IAC1C,OAAO,CAAC,EAAE,iBAAiB,CAAC,IAAI,CAAC,CAAC;IAClC,YAAY,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAC3B,cAAc,CAAC,EAAE,aAAa,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC;IACtD,WAAW,CAAC,EAAE,eAAe,CAAC,IAAI,CAAC,CAAC;IACpC,IAAI,EAAE,IAAI,CAAC;gBACC,OAAO,EAAE,cAAc,EAAE,IAAI,EAAE,IAAI;IAK/C,mBAAmB,CACjB,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,WAAW,GAClB,SAAS,GAAG,CAAC,MAAM,IAAI,CAAC;IAU3B,QAAQ,CACN,MAAM,EAAE,aAAa,EACrB,MAAM,EAAE,WAAW,GAClB,SAAS,GAAG,CAAC,MAAM,IAAI,CAAC;IAiB3B,IAAI,CAAC,YAAY,EAAE,mBAAmB,EAAE,MAAM,EAAE,WAAW;IAW3D,aAAa,IAAI,eAAe,CAAC,IAAI,CAAC;IAQtC,gBAAgB,CAAC,MAAM,EAAE,WAAW,GAAG,aAAa,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;IAa3E,OAAO,CAAC,QAAQ,SAAS,cAAc,GAAG,KAAK,EAC7C,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,GACrB,SAAS,GAAG,qBAAqB,CAAC,QAAQ,CAAC;IAM9C,aAAa,CAAC,UAAU,SAAS,cAAc,EAC7C,GAAG,EAAE,UAAU,GACd,qBAAqB,CAAC,UAAU,CAAC;IAWpC,uBAAuB;IAOvB,cAAc;IASd,iBAAiB,IAAI,qBAAqB,CAAC,IAAI,CAAC;IAchD,SAAS,IAAI,iBAAiB,CAAC,IAAI,CAAC;CAcrC"}
+{"version":3,"file":"PlanRep.d.ts","sourceRoot":"","sources":["../src/PlanRep.ts"],"names":[],"mappings":"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"}

package/dist/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACpE,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAExD,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACnB,KAAK,EAAE,GAAG,CAAC,gBAAgB,CAAC,OAAO,WAAW,CAAC,CAAC,CAAC;CAClD;AACD,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,mBAAmB;;;EAYhE"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACzE,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE7D,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACnB,KAAK,EAAE,GAAG,CAAC,gBAAgB,CAAC,OAAO,WAAW,CAAC,CAAC,CAAC;CAClD;AACD,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,mBAAmB;;;EAYhE"}

package/dist/getPeerDependencyFromEditor.d.ts

@@ -17,8 +17,8 @@ import { AnyLexicalPlan, LexicalPlanDependency } from '@etrepum/lexical-builder-
  * getPeerDependencyFromEditor<typeof import("@some/plan").SomePlan>(editor, "@some/plan");
  * ```
 
- * @param editor The editor that may have been built using plan
- * @param planName The name of the Plan
+ * @param editor - The editor that may have been built using plan
+ * @param planName - The name of the Plan
  * @returns The config and output of the Plan or undefined
  */
 export declare function getPeerDependencyFromEditor<Plan extends AnyLexicalPlan = never>(editor: LexicalEditor, planName: Plan["name"]): LexicalPlanDependency<Plan> | undefined;

package/dist/getPeerDependencyFromEditor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getPeerDependencyFromEditor.d.ts","sourceRoot":"","sources":["../src/getPeerDependencyFromEditor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EACL,cAAc,EACd,qBAAqB,EACtB,MAAM,+BAA+B,CAAC;AAGvC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,2BAA2B,CACzC,IAAI,SAAS,cAAc,GAAG,KAAK,EAEnC,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,GACrB,qBAAqB,CAAC,IAAI,CAAC,GAAG,SAAS,CAMzC"}
+{"version":3,"file":"getPeerDependencyFromEditor.d.ts","sourceRoot":"","sources":["../src/getPeerDependencyFromEditor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAC7C,OAAO,KAAK,EACV,cAAc,EACd,qBAAqB,EACtB,MAAM,+BAA+B,CAAC;AAGvC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,2BAA2B,CACzC,IAAI,SAAS,cAAc,GAAG,KAAK,EAEnC,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,GACrB,qBAAqB,CAAC,IAAI,CAAC,GAAG,SAAS,CAMzC"}

package/dist/getPlanDependencyFromEditor.d.ts

@@ -6,12 +6,12 @@ import { AnyLexicalPlan, LexicalPlanDependency } from '@etrepum/lexical-builder-
  *
  * This is useful in the implementation of a LexicalNode or in other
  * situations where you have an editor reference but it's not easy to
- * pass the config or {@link RegisterState} around.
+ * pass the config or {@link PlanRegisterState} around.
  *
  * It will throw if the Editor was not built using this Plan.
  *
- * @param editor The editor that was built using plan
- * @param plan The concrete reference to a Plan used to build this editor
+ * @param editor - The editor that was built using plan
+ * @param plan - The concrete reference to a Plan used to build this editor
  * @returns The config and output for that Plan
  */
 export declare function getPlanDependencyFromEditor<Plan extends AnyLexicalPlan>(editor: LexicalEditor, plan: Plan): LexicalPlanDependency<Plan>;

package/dist/getPlanDependencyFromEditor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getPlanDependencyFromEditor.d.ts","sourceRoot":"","sources":["../src/getPlanDependencyFromEditor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EACL,cAAc,EACd,qBAAqB,EACtB,MAAM,+BAA+B,CAAC;AAIvC;;;;;;;;;;;;GAYG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,SAAS,cAAc,EACrE,MAAM,EAAE,aAAa,EACrB,IAAI,EAAE,IAAI,GACT,qBAAqB,CAAC,IAAI,CAAC,CAS7B"}
+{"version":3,"file":"getPlanDependencyFromEditor.d.ts","sourceRoot":"","sources":["../src/getPlanDependencyFromEditor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAC7C,OAAO,KAAK,EACV,cAAc,EACd,qBAAqB,EACtB,MAAM,+BAA+B,CAAC;AAIvC;;;;;;;;;;;;GAYG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,SAAS,cAAc,EACrE,MAAM,EAAE,aAAa,EACrB,IAAI,EAAE,IAAI,GACT,qBAAqB,CAAC,IAAI,CAAC,CAS7B"}

package/dist/index.d.ts

@@ -8,7 +8,7 @@
 export { PACKAGE_VERSION } from './PACKAGE_VERSION';
 export { configPlan, definePlan, provideOutput, declarePeerDependency, } from '@etrepum/lexical-builder-core';
 export { LexicalBuilder, buildEditorFromPlans } from './LexicalBuilder';
-export { type AnyLexicalPlan, type AnyLexicalPlanArgument, type LexicalEditorWithDispose, type InitialEditorStateType, type LexicalPlan, type LexicalPlanArgument, type LexicalPlanConfig, type LexicalPlanName, type LexicalPlanOutput, type LexicalPlanInit, type OutputComponentPlan, type LexicalPlanDependency, type NormalizedLexicalPlanArgument, type PlanConfigBase, type RegisterState, type NormalizedPeerDependency, } from '@etrepum/lexical-builder-core';
+export { type AnyLexicalPlan, type AnyLexicalPlanArgument, type LexicalEditorWithDispose, type InitialEditorStateType, type LexicalPlan, type LexicalPlanArgument, type LexicalPlanConfig, type LexicalPlanName, type LexicalPlanOutput, type LexicalPlanInit, type OutputComponentPlan, type LexicalPlanDependency, type NormalizedLexicalPlanArgument, type PlanConfigBase, type PlanRegisterState, type NormalizedPeerDependency, } from '@etrepum/lexical-builder-core';
 export { safeCast } from '@etrepum/lexical-builder-core';
 export { shallowMergeConfig } from '@etrepum/lexical-builder-core';
 export { getPlanDependencyFromEditor } from './getPlanDependencyFromEditor';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EACL,UAAU,EACV,UAAU,EACV,aAAa,EACb,qBAAqB,GACtB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AACxE,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAC3B,KAAK,wBAAwB,EAC7B,KAAK,sBAAsB,EAC3B,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACxB,KAAK,qBAAqB,EAC1B,KAAK,6BAA6B,EAClC,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,wBAAwB,GAC9B,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AACnE,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,qBAAqB,EAAE,KAAK,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAC1E,OAAO,EAAE,gBAAgB,EAAE,KAAK,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAE/E,OAAO,EAAE,KAAK,eAAe,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACtE,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAChF,OAAO,EAAE,KAAK,aAAa,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAChE,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EACL,cAAc,EACd,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,GAC3B,MAAM,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EACL,UAAU,EACV,UAAU,EACV,aAAa,EACb,qBAAqB,GACtB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AACxE,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAC3B,KAAK,wBAAwB,EAC7B,KAAK,sBAAsB,EAC3B,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACxB,KAAK,qBAAqB,EAC1B,KAAK,6BAA6B,EAClC,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,wBAAwB,GAC9B,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AACzD,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AACnE,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,2BAA2B,EAAE,MAAM,+BAA+B,CAAC;AAC5E,OAAO,EAAE,qBAAqB,EAAE,KAAK,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAC1E,OAAO,EAAE,gBAAgB,EAAE,KAAK,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAE/E,OAAO,EAAE,KAAK,eAAe,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AACtE,OAAO,EAAE,KAAK,YAAY,EAAE,KAAK,YAAY,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAChF,OAAO,EAAE,KAAK,aAAa,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAChE,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EACL,cAAc,EACd,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,GAC3B,MAAM,kBAAkB,CAAC"}

package/dist/index.js

@@ -9,7 +9,7 @@ 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.28-nightly.20240705.0";
+const PACKAGE_VERSION = "0.0.28";
 function invariant(cond, message, ...args) {
   if (cond) {
     return;
@@ -29,84 +29,205 @@ function deepThemeMergeInPlace(a, b) {
   }
   return b;
 }
+const PlanRepStateIds = {
+  unmarked: 0,
+  temporary: 1,
+  permanent: 2,
+  configured: 3,
+  initialized: 4,
+  registered: 5,
+  afterInitialization: 6
+};
+function isExactlyUnmarkedPlanRepState(state) {
+  return state.id === PlanRepStateIds.unmarked;
+}
+function isExactlyTemporaryPlanRepState(state) {
+  return state.id === PlanRepStateIds.temporary;
+}
+function isExactlyPermanentPlanRepState(state) {
+  return state.id === PlanRepStateIds.permanent;
+}
+function isInitializedPlanRepState(state) {
+  return state.id >= PlanRepStateIds.initialized;
+}
+function isConfiguredPlanRepState(state) {
+  return state.id >= PlanRepStateIds.configured;
+}
+function isRegisteredPlanRepState(state) {
+  return state.id >= PlanRepStateIds.registered;
+}
+function isAfterInitializationState(state) {
+  return state.id >= PlanRepStateIds.afterInitialization;
+}
+function applyTemporaryMark(state) {
+  invariant(
+    isExactlyUnmarkedPlanRepState(state),
+    "LexicalBuilder: Can not apply a temporary mark to state"
+  );
+  return Object.assign(state, { id: PlanRepStateIds.temporary });
+}
+function applyPermanentMark(state) {
+  invariant(
+    isExactlyTemporaryPlanRepState(state),
+    "LexicalBuilder: Can not apply a permanent mark to state"
+  );
+  return Object.assign(state, { id: PlanRepStateIds.permanent });
+}
+function applyConfiguredState(state, config, registerState) {
+  return Object.assign(state, {
+    id: PlanRepStateIds.configured,
+    config,
+    registerState
+  });
+}
+function applyInitializedState(state, initResult, registerState) {
+  return Object.assign(state, {
+    id: PlanRepStateIds.initialized,
+    initResult,
+    registerState
+  });
+}
+function applyRegisteredState(state, cleanup) {
+  return Object.assign(state, {
+    id: PlanRepStateIds.registered,
+    output: cleanup ? cleanup.output : void 0
+  });
+}
+function applyAfterInitializationState(state) {
+  return Object.assign(state, { id: PlanRepStateIds.afterInitialization });
+}
+const emptySet = /* @__PURE__ */ new Set();
 class PlanRep {
   constructor(builder, plan) {
     __publicField(this, "builder");
     __publicField(this, "configs");
-    __publicField(this, "_config");
     __publicField(this, "_dependency");
     __publicField(this, "_output");
     __publicField(this, "_peerNameSet");
-    __publicField(this, "_registerState");
-    __publicField(this, "_initResult");
     __publicField(this, "plan");
+    __publicField(this, "state");
     this.builder = builder;
     this.plan = plan;
     this.configs = /* @__PURE__ */ new Set();
+    this.state = { id: PlanRepStateIds.unmarked };
   }
-  afterInitialization(editor, signal) {
-    if (!this.plan.afterInitialization) {
-      return void 0;
-    }
-    return this.plan.afterInitialization(
-      editor,
-      this.getConfig(),
-      this.getRegisterState(signal)
+  afterInitialization(editor) {
+    const state = this.state;
+    invariant(
+      state.id === PlanRepStateIds.registered,
+      "PlanRep: afterInitialization called in state id %s (expected %s registered)",
+      String(state.id),
+      String(PlanRepStateIds.registered)
     );
-  }
-  register(editor, signal) {
-    if (!this.plan.register) {
-      this._output = void 0;
-      return void 0;
+    let rval;
+    if (this.plan.afterInitialization) {
+      rval = this.plan.afterInitialization(
+        editor,
+        state.config,
+        state.registerState
+      );
     }
+    this.state = applyAfterInitializationState(state);
+    return rval;
+  }
+  register(editor) {
+    const state = this.state;
     invariant(
-      this._registerState !== void 0,
-      "PlanRep: register called before init"
+      state.id === PlanRepStateIds.initialized,
+      "PlanRep: register called in state id %s (expected %s initialized)",
+      String(state.id),
+      String(PlanRepStateIds.initialized)
     );
-    const cleanup = this.plan.register(
-      editor,
-      this.getConfig(),
-      this.getRegisterState(signal)
-    );
-    this._output = cleanup.output;
+    let cleanup;
+    if (this.plan.register) {
+      cleanup = this.plan.register(
+        editor,
+        state.config,
+        state.registerState
+      );
+    }
+    this.state = applyRegisteredState(state, cleanup);
     return cleanup;
   }
   init(editorConfig, signal) {
-    const config = this.getConfig();
-    const registerState = this.getRegisterState(signal);
+    const initialState = this.state;
+    invariant(
+      isExactlyPermanentPlanRepState(initialState),
+      "LexicalBuilder: Can not configure from state id %s",
+      String(initialState.id)
+    );
+    const initState = {
+      signal,
+      getDirectDependentNames: this.getDirectDependentNames.bind(this),
+      getPeerNameSet: this.getPeerNameSet.bind(this),
+      getPeer: this.getInitPeer.bind(this),
+      getDependency: this.getInitDependency.bind(this)
+    };
+    const registerState = {
+      ...initState,
+      getPeer: this.getPeer.bind(this),
+      getDependency: this.getDependency.bind(this),
+      getInitResult: this.getInitResult.bind(this)
+    };
+    const state = applyConfiguredState(
+      initialState,
+      this.mergeConfigs(),
+      initState
+    );
+    this.state = state;
+    let initResult;
     if (this.plan.init) {
-      this._initResult = this.plan.init(
+      initResult = this.plan.init(
         editorConfig,
-        config,
-        registerState
+        state.config,
+        initState
       );
     }
+    this.state = applyInitializedState(state, initResult, registerState);
   }
   getInitResult() {
     invariant(
-      "_initResult" in this,
-      "PlanRep: getInitResult() called for Plan %s but no result was set",
+      this.plan.init !== void 0,
+      "PlanRep: getInitResult() called for Plan %s that does not define init",
       this.plan.name
     );
-    return this._initResult;
-  }
-  getRegisterState(signal) {
-    if (!this._registerState) {
-      this._registerState = {
-        getPeer: this.getPeer.bind(this),
-        getDependency: this.getDependency.bind(this),
-        getDirectDependentNames: this.getDirectDependentNames.bind(this),
-        getPeerNameSet: this.getPeerNameSet.bind(this),
-        getInitResult: this.getInitResult.bind(this),
-        signal
-      };
-    }
-    return this._registerState;
+    const state = this.state;
+    invariant(
+      isInitializedPlanRepState(state),
+      "PlanRep: getInitResult() called for PlanRep in state id %s < %s (initialized)",
+      String(state.id),
+      String(PlanRepStateIds.initialized)
+    );
+    return state.initResult;
+  }
+  getInitPeer(name) {
+    const rep = this.builder.planNameMap.get(name);
+    return rep ? rep.getPlanInitDependency() : void 0;
+  }
+  getPlanInitDependency() {
+    const state = this.state;
+    invariant(
+      isConfiguredPlanRepState(state),
+      "LexicalPlanBuilder: getPlanInitDependency called in state id %s (expected >= %s configured)",
+      String(state.id),
+      String(PlanRepStateIds.configured)
+    );
+    return { config: state.config };
   }
   getPeer(name) {
     const rep = this.builder.planNameMap.get(name);
     return rep ? rep.getPlanDependency() : void 0;
   }
+  getInitDependency(dep) {
+    const rep = this.builder.getPlanRep(dep);
+    invariant(
+      rep !== void 0,
+      "LexicalPlanBuilder: Plan %s missing dependency plan %s to be in registry",
+      this.plan.name,
+      dep.name
+    );
+    return rep.getPlanInitDependency();
+  }
   getDependency(dep) {
     const rep = this.builder.getPlanRep(dep);
     invariant(
@@ -117,11 +238,18 @@ class PlanRep {
     );
     return rep.getPlanDependency();
   }
-  getDirectDependentNames() {
-    return Array.from(
-      this.builder.reverseEdges.get(this.plan) || [],
-      (plan) => plan.name
+  getState() {
+    const state = this.state;
+    invariant(
+      isAfterInitializationState(state),
+      "PlanRep getState called in state id %s (expected %s afterInitialization)",
+      String(state.id),
+      String(PlanRepStateIds.afterInitialization)
     );
+    return state;
+  }
+  getDirectDependentNames() {
+    return this.builder.incomingEdges.get(this.plan.name) || emptySet;
   }
   getPeerNameSet() {
     let s = this._peerNameSet;
@@ -133,29 +261,26 @@ class PlanRep {
   }
   getPlanDependency() {
     if (!this._dependency) {
+      const state = this.state;
       invariant(
-        "_output" in this,
+        isRegisteredPlanRepState(state),
         "Plan %s used as a dependency before registration",
         this.plan.name
       );
       this._dependency = {
-        config: this.getConfig(),
-        output: this._output
+        config: state.config,
+        output: state.output
       };
     }
     return this._dependency;
   }
-  getConfig() {
-    if (this._config === void 0) {
-      let config = this.plan.config || {};
-      const mergeConfig = this.plan.mergeConfig ? this.plan.mergeConfig.bind(this.plan) : shallowMergeConfig;
-      for (const cfg of this.configs) {
-        config = mergeConfig(config, cfg);
-      }
-      this._config = config;
-      return config;
+  mergeConfigs() {
+    let config = this.plan.config || {};
+    const mergeConfig = this.plan.mergeConfig ? this.plan.mergeConfig.bind(this.plan) : shallowMergeConfig;
+    for (const cfg of this.configs) {
+      config = mergeConfig(config, cfg);
     }
-    return this._config;
+    return config;
   }
 }
 const HISTORY_MERGE_OPTIONS = { tag: "history-merge" };
@@ -184,7 +309,9 @@ const InitialStatePlan = definePlan({
     const $initialEditorState = state.getInitResult();
     switch (typeof $initialEditorState) {
       case "function": {
-        editor.update(() => $initialEditorState(editor), updateOptions);
+        editor.update(() => {
+          $initialEditorState(editor);
+        }, updateOptions);
         break;
       }
       case "string": {
@@ -204,14 +331,8 @@ const InitialStatePlan = definePlan({
   }
 });
 const builderSymbol = Symbol.for("@etrepum/lexical-builder");
-function buildEditorFromPlans(plan, ...plans) {
-  const builder = new LexicalBuilder();
-  builder.addPlan(InitialStatePlan);
-  builder.addPlan(plan);
-  for (const otherPlan of plans) {
-    builder.addPlan(otherPlan);
-  }
-  return builder.buildEditor();
+function buildEditorFromPlans(...plans) {
+  return LexicalBuilder.fromPlans(plans).buildEditor();
 }
 function noop() {
 }
@@ -221,22 +342,34 @@ function defaultOnError(err) {
 function maybeWithBuilder(editor) {
   return editor;
 }
+function normalizePlanArgument(arg) {
+  return Array.isArray(arg) ? arg : configPlan(arg);
+}
 class LexicalBuilder {
-  constructor() {
-    __publicField(this, "phases");
-    __publicField(this, "planMap");
+  constructor(roots) {
+    __publicField(this, "roots");
     __publicField(this, "planNameMap");
-    __publicField(this, "reverseEdges");
-    __publicField(this, "addStack");
+    __publicField(this, "outgoingConfigEdges");
+    __publicField(this, "incomingEdges");
     __publicField(this, "conflicts");
+    __publicField(this, "_sortedPlanReps");
     __publicField(this, "PACKAGE_VERSION");
-    this.phases = [/* @__PURE__ */ new Map()];
-    this.planMap = /* @__PURE__ */ new Map();
+    this.outgoingConfigEdges = /* @__PURE__ */ new Map();
+    this.incomingEdges = /* @__PURE__ */ new Map();
     this.planNameMap = /* @__PURE__ */ new Map();
     this.conflicts = /* @__PURE__ */ new Map();
-    this.reverseEdges = /* @__PURE__ */ new Map();
-    this.addStack = /* @__PURE__ */ new Set();
     this.PACKAGE_VERSION = PACKAGE_VERSION;
+    this.roots = roots;
+    for (const plan of roots) {
+      this.addPlan(plan);
+    }
+  }
+  static fromPlans(plans) {
+    const roots = [normalizePlanArgument(InitialStatePlan)];
+    for (const plan of plans) {
+      roots.push(normalizePlanArgument(plan));
+    }
+    return new LexicalBuilder(roots);
   }
   /** Look up the editor that was created by this LexicalBuilder or throw */
   static fromEditor(editor) {
@@ -259,7 +392,11 @@ class LexicalBuilder {
   }
   buildEditor() {
     const controller = new AbortController();
-    const { $initialEditorState, onError, ...editorConfig } = this.buildCreateEditorArgs(controller.signal);
+    const {
+      $initialEditorState: _$initialEditorState,
+      onError,
+      ...editorConfig
+    } = this.buildCreateEditorArgs(controller.signal);
     let disposeOnce = noop;
     function dispose() {
       try {
@@ -271,15 +408,17 @@ class LexicalBuilder {
     const editor = Object.assign(
       createEditor({
         ...editorConfig,
-        ...onError ? { onError: (err) => {
-          onError(err, editor);
-        } } : {}
+        ...onError ? {
+          onError: (err) => {
+            onError(err, editor);
+          }
+        } : {}
       }),
       { [builderSymbol]: this, dispose, [Symbol.dispose]: dispose }
     );
     disposeOnce = mergeRegister(
       () => {
-        delete maybeWithBuilder(editor)[builderSymbol];
+        maybeWithBuilder(editor)[builderSymbol] = void 0;
       },
       () => {
         editor.setRootElement(null);
@@ -289,36 +428,54 @@ class LexicalBuilder {
     return editor;
   }
   getPlanRep(plan) {
-    const pair = this.planMap.get(plan);
-    if (pair) {
-      const rep = pair[1];
+    const rep = this.planNameMap.get(plan.name);
+    if (rep) {
+      invariant(
+        rep.plan === plan,
+        "LexicalBuilder: A registered plan with name %s exists but does not match the given plan",
+        plan.name
+      );
       return rep;
     }
   }
-  addPlan(arg, parent) {
-    let plan;
-    let configs;
-    if (Array.isArray(arg)) {
-      [plan, ...configs] = arg;
+  addEdge(fromPlanName, toPlanName, configs) {
+    const outgoing = this.outgoingConfigEdges.get(fromPlanName);
+    if (outgoing) {
+      outgoing.set(toPlanName, configs);
+    } else {
+      this.outgoingConfigEdges.set(
+        fromPlanName,
+        /* @__PURE__ */ new Map([[toPlanName, configs]])
+      );
+    }
+    const incoming = this.incomingEdges.get(toPlanName);
+    if (incoming) {
+      incoming.add(fromPlanName);
     } else {
-      plan = arg;
-      configs = [];
+      this.incomingEdges.set(toPlanName, /* @__PURE__ */ new Set([fromPlanName]));
     }
+  }
+  addPlan(arg) {
+    invariant(
+      this._sortedPlanReps === void 0,
+      "LexicalBuilder: addPlan called after finalization"
+    );
+    const normalized = normalizePlanArgument(arg);
+    const [plan] = normalized;
     invariant(
       typeof plan.name === "string",
       "LexicalBuilder: plan name must be string, not %s",
       typeof plan.name
     );
-    if (parent) {
-      let edgeSet = this.reverseEdges.get(plan);
-      if (!edgeSet) {
-        edgeSet = /* @__PURE__ */ new Set();
-        this.reverseEdges.set(plan, edgeSet);
-      }
-      edgeSet.add(parent);
-    }
-    let [phase, planRep] = this.planMap.get(plan) || [0, void 0];
+    let planRep = this.planNameMap.get(plan.name);
+    invariant(
+      planRep === void 0 || planRep.plan === plan,
+      "LexicalBuilder: Multiple plans registered with name %s, names must be unique",
+      plan.name
+    );
     if (!planRep) {
+      planRep = new PlanRep(this, plan);
+      this.planNameMap.set(plan.name, planRep);
       const hasConflict = this.conflicts.get(plan.name);
       if (typeof hasConflict === "string") {
         invariant(
@@ -337,83 +494,98 @@ class LexicalBuilder {
         );
         this.conflicts.set(name, plan.name);
       }
-      invariant(
-        !this.addStack.has(plan),
-        "LexicalBuilder: Circular dependency detected for Plan %s from %s",
-        plan.name,
-        (parent == null ? void 0 : parent.name) || "[unknown]"
-      );
-      this.addStack.add(plan);
       for (const dep of plan.dependencies || []) {
-        phase = Math.max(phase, 1 + this.addPlan(dep, plan));
+        const normDep = normalizePlanArgument(dep);
+        this.addEdge(plan.name, normDep[0].name, normDep.slice(1));
+        this.addPlan(normDep);
       }
-      for (const [depName, cfg] of plan.peerDependencies || []) {
-        const dep = this.planNameMap.get(depName);
-        if (dep) {
-          phase = Math.max(
-            phase,
-            1 + this.addPlan(
-              configPlan(
-                dep.plan,
-                cfg || {}
-              ),
-              plan
-            )
-          );
-        }
+      for (const [depName, config] of plan.peerDependencies || []) {
+        this.addEdge(plan.name, depName, config ? [config] : []);
       }
-      invariant(
-        this.phases.length >= phase,
-        "LexicalBuilder: Expected phase to be no greater than phases.length"
-      );
-      if (this.phases.length === phase) {
-        this.phases.push(/* @__PURE__ */ new Map());
+    }
+  }
+  sortedPlanReps() {
+    if (this._sortedPlanReps) {
+      return this._sortedPlanReps;
+    }
+    const sortedPlanReps = [];
+    const visit = (rep, fromPlanName) => {
+      let mark = rep.state;
+      if (isExactlyPermanentPlanRepState(mark)) {
+        return;
       }
-      planRep = new PlanRep(this, plan);
+      const planName = rep.plan.name;
       invariant(
-        !this.planNameMap.has(plan.name),
-        "LexicalBuilder: Multiple plans registered with name %s, names must be unique",
-        plan.name
-      );
-      this.planMap.set(plan, [phase, planRep]);
-      this.planNameMap.set(plan.name, planRep);
-      const currentPhaseMap = this.phases[phase];
-      invariant(
-        currentPhaseMap !== void 0,
-        "LexicalBuilder: Expecting phase map for phase %s",
-        String(phase)
+        isExactlyUnmarkedPlanRepState(mark),
+        "LexicalBuilder: Circular dependency detected for Plan %s from %s",
+        planName,
+        fromPlanName || "[unknown]"
       );
-      currentPhaseMap.set(plan, planRep);
-      this.addStack.delete(plan);
+      mark = applyTemporaryMark(mark);
+      rep.state = mark;
+      const outgoingConfigEdges = this.outgoingConfigEdges.get(planName);
+      if (outgoingConfigEdges) {
+        for (const toPlanName of outgoingConfigEdges.keys()) {
+          const toRep = this.planNameMap.get(toPlanName);
+          if (toRep) {
+            visit(toRep, planName);
+          }
+        }
+      }
+      mark = applyPermanentMark(mark);
+      rep.state = mark;
+      sortedPlanReps.push(rep);
+    };
+    for (const rep of this.planNameMap.values()) {
+      if (isExactlyUnmarkedPlanRepState(rep.state)) {
+        visit(rep);
+      }
     }
-    for (const config of configs) {
-      planRep.configs.add(config);
+    for (const rep of sortedPlanReps) {
+      for (const [toPlanName, configs] of this.outgoingConfigEdges.get(
+        rep.plan.name
+      ) || []) {
+        if (configs.length > 0) {
+          const toRep = this.planNameMap.get(toPlanName);
+          if (toRep) {
+            for (const config of configs) {
+              toRep.configs.add(config);
+            }
+          }
+        }
+      }
     }
-    return phase;
-  }
-  *sortedPlanReps() {
-    for (const phase of this.phases) {
-      yield* phase.values();
+    for (const [plan, ...configs] of this.roots) {
+      if (configs.length > 0) {
+        const toRep = this.planNameMap.get(plan.name);
+        invariant(
+          toRep !== void 0,
+          "LexicalBuilder: Expecting existing PlanRep for %s",
+          plan.name
+        );
+        for (const config of configs) {
+          toRep.configs.add(config);
+        }
+      }
     }
+    this._sortedPlanReps = sortedPlanReps;
+    return this._sortedPlanReps;
   }
   registerEditor(editor, controller) {
     const cleanups = [];
-    const signal = controller.signal;
-    const planReps = [];
-    for (const planRep of this.sortedPlanReps()) {
-      const cleanup = planRep.register(editor, signal);
+    const planReps = this.sortedPlanReps();
+    for (const planRep of planReps) {
+      const cleanup = planRep.register(editor);
       if (cleanup) {
         cleanups.push(cleanup);
       }
-      planReps.push(planRep);
     }
     for (const planRep of planReps) {
-      const cleanup = planRep.afterInitialization(editor, signal);
+      const cleanup = planRep.afterInitialization(editor);
       if (cleanup) {
         cleanups.push(cleanup);
       }
     }
-    planReps.length = 0;
     return () => {
       for (let i = cleanups.length - 1; i >= 0; i--) {
         const cleanupFun = cleanups[i];
@@ -435,7 +607,7 @@ class LexicalBuilder {
     const htmlExport = /* @__PURE__ */ new Map();
     const htmlImport = {};
     const theme = {};
-    const planReps = [...this.sortedPlanReps()];
+    const planReps = this.sortedPlanReps();
     for (const planRep of planReps) {
       const { plan } = planRep;
       if (plan.onError !== void 0) {
@@ -538,7 +710,7 @@ function getKnownTypesAndNodes(config) {
 }
 const AutoFocusPlan = definePlan({
   config: safeCast({}),
-  name: "@etrepum/lexical-builder/AutoFocusPlan",
+  name: "@etrepum/lexical-builder/AutoFocus",
   register(editor, { defaultSelection }) {
     return editor.registerRootListener((rootElement) => {
       editor.focus(
@@ -589,7 +761,7 @@ const HistoryPlan = definePlan({
     createInitialHistoryState: createEmptyHistoryState,
     delay: 300
   }),
-  name: "@etrepum/lexical-builder/HistoryPlan",
+  name: "@etrepum/lexical-builder/History",
   register(editor, { delay, createInitialHistoryState }) {
     return registerHistory(editor, createInitialHistoryState(), delay);
   }

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../src/PACKAGE_VERSION.ts","../src/shared/invariant.ts","../src/deepThemeMergeInPlace.ts","../src/PlanRep.ts","../src/InitialStatePlan.ts","../src/LexicalBuilder.ts","../src/getPlanDependencyFromEditor.ts","../src/getPeerDependencyFromEditor.ts","../src/config.ts","../src/AutoFocusPlan.ts","../src/disabledToggle.ts","../src/DragonPlan.ts","../src/HistoryPlan.ts","../src/PlainTextPlan.ts","../src/RichTextPlan.ts"],"sourcesContent":["/** The build version of this package (e.g. \"0.16.0\") */\nexport const PACKAGE_VERSION: string = import.meta.env.PACKAGE_VERSION;\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n// invariant(condition, message) will refine types based on \"condition\", and\n// if \"condition\" is false will throw an error. This function is special-cased\n// in flow itself, so we can't name it anything else.\nexport default function invariant(\n  cond?: boolean,\n  message?: string,\n  ...args: string[]\n): asserts cond {\n  if (cond) {\n    return;\n  }\n\n  throw new Error(\n    args.reduce((msg, arg) => msg.replace(\"%s\", String(arg)), message || \"\"),\n  );\n}\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n/**\n * Recursively merge the given theme configuration in-place.\n *\n * @returns If `a` and `b` are both objects (and `b` is not an Array) then\n * all keys in `b` are merged into `a` then `a` is returned.\n * Otherwise `b` is returned.\n *\n * @example\n * ```ts\n * const a = { a: \"a\", nested: { a: 1 } };\n * const b = { b: \"b\", nested: { b: 2 } };\n * const rval = deepThemeMergeInPlace(a, b);\n * expect(a).toBe(rval);\n * expect(a).toEqual({ a: \"a\", b: \"b\", nested: { a: 1, b: 2 } });\n * ```\n */\nexport function deepThemeMergeInPlace(a: unknown, b: unknown) {\n  if (\n    a &&\n    b &&\n    !Array.isArray(b) &&\n    typeof a === \"object\" &&\n    typeof b === \"object\"\n  ) {\n    const aObj = a as Record<string, unknown>;\n    const bObj = b as Record<string, unknown>;\n    for (const k in bObj) {\n      aObj[k] = deepThemeMergeInPlace(aObj[k], bObj[k]);\n    }\n    return a;\n  }\n  return b;\n}\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport type { LexicalBuilder } from \"./LexicalBuilder\";\nimport type {\n  AnyLexicalPlan,\n  InitialEditorConfig,\n  LexicalPlanConfig,\n  LexicalPlanDependency,\n  LexicalPlanInit,\n  LexicalPlanOutput,\n  RegisterState,\n} from \"@etrepum/lexical-builder-core\";\n\nimport invariant from \"./shared/invariant\";\n\nimport { shallowMergeConfig } from \"@etrepum/lexical-builder-core\";\nimport type { LexicalEditor } from \"lexical\";\n\nconst noop = () => {};\n/**\n * @internal\n */\nexport class PlanRep<Plan extends AnyLexicalPlan> {\n  builder: LexicalBuilder;\n  configs: Set<Partial<LexicalPlanConfig<Plan>>>;\n  _config?: LexicalPlanConfig<Plan>;\n  _dependency?: LexicalPlanDependency<Plan>;\n  _output?: LexicalPlanOutput<Plan>;\n  _peerNameSet?: Set<string>;\n  _registerState?: RegisterState<LexicalPlanInit<Plan>>;\n  _initResult?: LexicalPlanInit<Plan>;\n  plan: Plan;\n  constructor(builder: LexicalBuilder, plan: Plan) {\n    this.builder = builder;\n    this.plan = plan;\n    this.configs = new Set();\n  }\n  afterInitialization(\n    editor: LexicalEditor,\n    signal: AbortSignal,\n  ): undefined | (() => void) {\n    if (!this.plan.afterInitialization) {\n      return undefined;\n    }\n    return this.plan.afterInitialization(\n      editor,\n      this.getConfig(),\n      this.getRegisterState(signal),\n    );\n  }\n  register(\n    editor: LexicalEditor,\n    signal: AbortSignal,\n  ): undefined | (() => void) {\n    if (!this.plan.register) {\n      this._output = undefined;\n      return undefined;\n    }\n    invariant(\n      this._registerState !== undefined,\n      \"PlanRep: register called before init\",\n    );\n    const cleanup = this.plan.register(\n      editor,\n      this.getConfig(),\n      this.getRegisterState(signal),\n    );\n    this._output = cleanup.output as LexicalPlanOutput<Plan>;\n    return cleanup;\n  }\n  init(editorConfig: InitialEditorConfig, signal: AbortSignal) {\n    const config = this.getConfig();\n    const registerState = this.getRegisterState(signal);\n    if (this.plan.init) {\n      this._initResult = this.plan.init(\n        editorConfig,\n        config,\n        registerState as RegisterState<never>,\n      );\n    }\n  }\n  getInitResult(): LexicalPlanInit<Plan> {\n    invariant(\n      \"_initResult\" in this,\n      \"PlanRep: getInitResult() called for Plan %s but no result was set\",\n      this.plan.name,\n    );\n    return this._initResult!;\n  }\n  getRegisterState(signal: AbortSignal): RegisterState<LexicalPlanInit<Plan>> {\n    if (!this._registerState) {\n      this._registerState = {\n        getPeer: this.getPeer.bind(this),\n        getDependency: this.getDependency.bind(this),\n        getDirectDependentNames: this.getDirectDependentNames.bind(this),\n        getPeerNameSet: this.getPeerNameSet.bind(this),\n        getInitResult: this.getInitResult.bind(this),\n        signal,\n      };\n    }\n    return this._registerState;\n  }\n  getPeer<PeerPlan extends AnyLexicalPlan = never>(\n    name: PeerPlan[\"name\"],\n  ): undefined | LexicalPlanDependency<PeerPlan> {\n    const rep = this.builder.planNameMap.get(name);\n    return rep\n      ? (rep.getPlanDependency() as LexicalPlanDependency<PeerPlan>)\n      : undefined;\n  }\n  getDependency<Dependency extends AnyLexicalPlan>(\n    dep: Dependency,\n  ): LexicalPlanDependency<Dependency> {\n    const rep = this.builder.getPlanRep(dep);\n    invariant(\n      rep !== undefined,\n      \"LexicalPlanBuilder: Plan %s missing dependency plan %s to be in registry\",\n      this.plan.name,\n      dep.name,\n    );\n    return rep.getPlanDependency();\n  }\n\n  getDirectDependentNames() {\n    return Array.from(\n      this.builder.reverseEdges.get(this.plan) || [],\n      (plan) => plan.name,\n    );\n  }\n\n  getPeerNameSet() {\n    let s = this._peerNameSet;\n    if (!s) {\n      s = new Set((this.plan.peerDependencies || []).map(([name]) => name));\n      this._peerNameSet = s;\n    }\n    return s;\n  }\n\n  getPlanDependency(): LexicalPlanDependency<Plan> {\n    if (!this._dependency) {\n      invariant(\n        \"_output\" in this,\n        \"Plan %s used as a dependency before registration\",\n        this.plan.name,\n      );\n      this._dependency = {\n        config: this.getConfig(),\n        output: this._output!,\n      };\n    }\n    return this._dependency;\n  }\n  getConfig(): LexicalPlanConfig<Plan> {\n    if (this._config === undefined) {\n      let config = this.plan.config || {};\n      const mergeConfig = this.plan.mergeConfig\n        ? this.plan.mergeConfig.bind(this.plan)\n        : shallowMergeConfig;\n      for (const cfg of this.configs) {\n        config = mergeConfig(config, cfg);\n      }\n      this._config = config;\n      return config;\n    }\n    return this._config;\n  }\n}\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport { definePlan, safeCast } from \"@etrepum/lexical-builder-core\";\n\nimport {\n  $createParagraphNode,\n  $getRoot,\n  LineBreakNode,\n  ParagraphNode,\n  RootNode,\n  TabNode,\n  TextNode,\n  type LexicalEditor,\n  type EditorSetOptions,\n  // TODO https://github.com/facebook/lexical/pull/6332\n  // type EditorUpdateOptions\n} from \"lexical\";\n\n// TODO https://github.com/facebook/lexical/pull/6332\ntype EditorUpdateOptions = NonNullable<Parameters<LexicalEditor[\"update\"]>[1]>;\nconst HISTORY_MERGE_OPTIONS = { tag: \"history-merge\" };\n\nfunction $defaultInitializer() {\n  const root = $getRoot();\n  if (root.isEmpty()) {\n    root.append($createParagraphNode());\n  }\n}\n\nexport interface InitialStateConfig {\n  updateOptions: EditorUpdateOptions;\n  setOptions: EditorSetOptions;\n}\n\nexport const InitialStatePlan = definePlan({\n  name: \"@etrepum/lexical-builder/InitialState\",\n  // These are automatically added by createEditor, we add them here so they are\n  // visible during planRep.init so plans can see all known types before the\n  // editor is created.\n  // (excluding ArtificialNode__DO_NOT_USE because it isn't really public API\n  // and shouldn't change anything)\n  nodes: [RootNode, TextNode, LineBreakNode, TabNode, ParagraphNode],\n  config: safeCast<InitialStateConfig>({\n    updateOptions: HISTORY_MERGE_OPTIONS,\n    setOptions: HISTORY_MERGE_OPTIONS,\n  }),\n  init({ $initialEditorState = $defaultInitializer }) {\n    return $initialEditorState;\n  },\n  afterInitialization(editor, { updateOptions, setOptions }, state) {\n    const $initialEditorState = state.getInitResult();\n    switch (typeof $initialEditorState) {\n      case \"function\": {\n        editor.update(() => $initialEditorState(editor), updateOptions);\n        break;\n      }\n      case \"string\": {\n        const parsedEditorState = editor.parseEditorState($initialEditorState);\n        editor.setEditorState(parsedEditorState, setOptions);\n        break;\n      }\n      case \"object\": {\n        if ($initialEditorState) {\n          editor.setEditorState($initialEditorState, setOptions);\n        }\n        break;\n      }\n    }\n    return () => {};\n  },\n});\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\nimport type {\n  AnyLexicalPlan,\n  AnyLexicalPlanArgument,\n  LexicalEditorWithDispose,\n  InitialEditorConfig,\n  LexicalPlanConfig,\n} from \"@etrepum/lexical-builder-core\";\nimport {\n  type LexicalEditor,\n  createEditor,\n  type CreateEditorArgs,\n  type EditorThemeClasses,\n  type HTMLConfig,\n  type KlassConstructor,\n  type LexicalNode,\n} from \"lexical\";\nimport { mergeRegister } from \"@lexical/utils\";\nimport { configPlan } from \"@etrepum/lexical-builder-core\";\nimport invariant from \"./shared/invariant\";\nimport { deepThemeMergeInPlace } from \"./deepThemeMergeInPlace\";\nimport { PlanRep } from \"./PlanRep\";\nimport { PACKAGE_VERSION } from \"./PACKAGE_VERSION\";\nimport { InitialStatePlan } from \"./InitialStatePlan\";\n\n/** @internal Use a well-known symbol for dev tools purposes */\nexport const builderSymbol = Symbol.for(\"@etrepum/lexical-builder\");\n\n/**\n * Build a LexicalEditor by combining together one or more plans, optionally\n * overriding some of their configuration.\n *\n * @param plan A plan argument (a plan, or a plan with config overrides)\n * @param plans Optional additional plan arguments\n * @returns An editor handle\n *\n * @example A single root plan with multiple dependencies\n * ```ts\n * const editor = buildEditorFromPlans(\n *   definePlan({\n *     name: \"[root]\",\n *     dependencies: [\n *       RichTextPlan,\n *       configPlan(EmojiPlan, { emojiBaseUrl: \"/assets/emoji\" }),\n *     ],\n *     register: (editor: LexicalEditor) => {\n *       console.log(\"Editor Created\");\n *       return () => console.log(\"Editor Disposed\");\n *     },\n *   }),\n * );\n * ```\n * @example A very similar minimal configuration without the register hook\n * ```ts\n * const editor = buildEditorFromPlans(\n *   RichTextPlan,\n *   configPlan(EmojiPlan, { emojiBaseUrl: \"/assets/emoji\" }),\n * );\n * ```\n */\nexport function buildEditorFromPlans(\n  plan: AnyLexicalPlanArgument,\n  ...plans: AnyLexicalPlanArgument[]\n): LexicalEditorWithDispose {\n  const builder = new LexicalBuilder();\n  builder.addPlan(InitialStatePlan);\n  builder.addPlan(plan);\n  for (const otherPlan of plans) {\n    builder.addPlan(otherPlan);\n  }\n  return builder.buildEditor();\n}\n\n/** @internal */\nfunction noop() {}\n\n/** Throw the given Error */\nfunction defaultOnError(err: Error) {\n  throw err;\n}\n\ninterface WithBuilder {\n  [builderSymbol]?: LexicalBuilder;\n}\n\n/** @internal */\nfunction maybeWithBuilder(editor: LexicalEditor): LexicalEditor & WithBuilder {\n  return editor;\n}\n\n/** @internal */\nexport class LexicalBuilder {\n  phases: Map<AnyLexicalPlan, PlanRep<AnyLexicalPlan>>[];\n  planMap: Map<AnyLexicalPlan, [number, PlanRep<AnyLexicalPlan>]>;\n  planNameMap: Map<string, PlanRep<AnyLexicalPlan>>;\n  reverseEdges: Map<AnyLexicalPlan, Set<AnyLexicalPlan>>;\n  addStack: Set<AnyLexicalPlan>;\n  conflicts: Map<string, string>;\n  PACKAGE_VERSION: string;\n\n  constructor() {\n    // closure compiler can't handle class initializers\n    this.phases = [new Map()];\n    this.planMap = new Map();\n    this.planNameMap = new Map();\n    this.conflicts = new Map();\n    this.reverseEdges = new Map();\n    this.addStack = new Set();\n    this.PACKAGE_VERSION = PACKAGE_VERSION;\n  }\n\n  /** Look up the editor that was created by this LexicalBuilder or throw */\n  static fromEditor(editor: LexicalEditor): LexicalBuilder {\n    const builder = maybeWithBuilder(editor)[builderSymbol];\n    invariant(\n      builder && typeof builder === \"object\",\n      \"LexicalBuilder.fromEditor: The given editor was not created with LexicalBuilder, or has been disposed\",\n    );\n    // The dev tools variant of this will relax some of these invariants\n    invariant(\n      builder.PACKAGE_VERSION === PACKAGE_VERSION,\n      \"LexicalBuilder.fromEditor: The given editor was created with LexicalBuilder %s but this version is %s. A project should have exactly one copy of LexicalBuilder\",\n      builder.PACKAGE_VERSION,\n      PACKAGE_VERSION,\n    );\n    invariant(\n      builder instanceof LexicalBuilder,\n      \"LexicalBuilder.fromEditor: There are multiple copies of the same version of LexicalBuilder in your project, and this editor was created with another one. Your project, or one of its dependencies, has its package.json and/or bundler configured incorrectly.\",\n    );\n    return builder;\n  }\n\n  buildEditor(): LexicalEditorWithDispose {\n    const controller = new AbortController();\n    const { $initialEditorState, onError, ...editorConfig } =\n      this.buildCreateEditorArgs(controller.signal);\n    let disposeOnce = noop;\n    function dispose() {\n      try {\n        disposeOnce();\n      } finally {\n        disposeOnce = noop;\n      }\n    }\n    const editor: LexicalEditorWithDispose & WithBuilder = Object.assign(\n      createEditor({\n        ...editorConfig,\n        ...(onError ? { onError: (err) => { onError(err, editor); } } : {}),\n      }),\n      { [builderSymbol]: this, dispose, [Symbol.dispose]: dispose },\n    );\n    disposeOnce = mergeRegister(\n      () => {\n        delete maybeWithBuilder(editor)[builderSymbol];\n      },\n      () => { editor.setRootElement(null); },\n      this.registerEditor(editor, controller),\n    );\n    return editor;\n  }\n\n  getPlanRep<Plan extends AnyLexicalPlan>(\n    plan: Plan,\n  ): PlanRep<Plan> | undefined {\n    const pair = this.planMap.get(plan);\n    if (pair) {\n      const rep: PlanRep<AnyLexicalPlan> = pair[1];\n      return rep as PlanRep<Plan>;\n    }\n  }\n\n  addPlan(arg: AnyLexicalPlanArgument, parent?: AnyLexicalPlan): number {\n    let plan: AnyLexicalPlan;\n    let configs: unknown[];\n    if (Array.isArray(arg)) {\n      [plan, ...configs] = arg;\n    } else {\n      plan = arg;\n      configs = [];\n    }\n    invariant(\n      typeof plan.name === \"string\",\n      \"LexicalBuilder: plan name must be string, not %s\",\n      typeof plan.name,\n    );\n    // Track incoming dependencies\n    if (parent) {\n      let edgeSet = this.reverseEdges.get(plan);\n      if (!edgeSet) {\n        edgeSet = new Set();\n        this.reverseEdges.set(plan, edgeSet);\n      }\n      edgeSet.add(parent);\n    }\n    let [phase, planRep] = this.planMap.get(plan) || [0, undefined];\n    if (!planRep) {\n      const hasConflict = this.conflicts.get(plan.name);\n      if (typeof hasConflict === \"string\") {\n        invariant(\n          false,\n          \"LexicalBuilder: plan %s conflicts with %s\",\n          plan.name,\n          hasConflict,\n        );\n      }\n      for (const name of plan.conflictsWith || []) {\n        invariant(\n          !this.planNameMap.has(name),\n          \"LexicalBuilder: plan %s conflicts with %s\",\n          plan.name,\n          name,\n        );\n        this.conflicts.set(name, plan.name);\n      }\n      invariant(\n        !this.addStack.has(plan),\n        \"LexicalBuilder: Circular dependency detected for Plan %s from %s\",\n        plan.name,\n        parent?.name || \"[unknown]\",\n      );\n      this.addStack.add(plan);\n      for (const dep of plan.dependencies || []) {\n        phase = Math.max(phase, 1 + this.addPlan(dep, plan));\n      }\n      for (const [depName, cfg] of plan.peerDependencies || []) {\n        const dep = this.planNameMap.get(depName);\n        if (dep) {\n          phase = Math.max(\n            phase,\n            1 +\n              this.addPlan(\n                configPlan(\n                  dep.plan,\n                  (cfg || {}) as LexicalPlanConfig<typeof dep.plan>,\n                ),\n                plan,\n              ),\n          );\n        }\n      }\n      invariant(\n        this.phases.length >= phase,\n        \"LexicalBuilder: Expected phase to be no greater than phases.length\",\n      );\n      if (this.phases.length === phase) {\n        this.phases.push(new Map());\n      }\n      planRep = new PlanRep(this, plan);\n      invariant(\n        !this.planNameMap.has(plan.name),\n        \"LexicalBuilder: Multiple plans registered with name %s, names must be unique\",\n        plan.name,\n      );\n      this.planMap.set(plan, [phase, planRep]);\n      this.planNameMap.set(plan.name, planRep);\n      const currentPhaseMap = this.phases[phase];\n      invariant(\n        currentPhaseMap !== undefined,\n        \"LexicalBuilder: Expecting phase map for phase %s\",\n        String(phase),\n      );\n      currentPhaseMap.set(plan, planRep);\n      this.addStack.delete(plan);\n    }\n    for (const config of configs) {\n      planRep.configs.add(config as Partial<LexicalPlanConfig<AnyLexicalPlan>>);\n    }\n    return phase;\n  }\n\n  *sortedPlanReps() {\n    for (const phase of this.phases) {\n      yield* phase.values();\n    }\n  }\n\n  registerEditor(\n    editor: LexicalEditor,\n    controller: AbortController,\n  ): () => void {\n    const cleanups: (() => void)[] = [];\n    const signal = controller.signal;\n    const planReps: PlanRep<AnyLexicalPlan>[] = [];\n    for (const planRep of this.sortedPlanReps()) {\n      const cleanup = planRep.register(editor, signal);\n      if (cleanup) {\n        cleanups.push(cleanup);\n      }\n      planReps.push(planRep);\n    }\n    for (const planRep of planReps) {\n      const cleanup = planRep.afterInitialization(editor, signal);\n      if (cleanup) {\n        cleanups.push(cleanup);\n      }\n    }\n    planReps.length = 0;\n    return () => {\n      for (let i = cleanups.length - 1; i >= 0; i--) {\n        const cleanupFun = cleanups[i];\n        invariant(\n          cleanupFun !== undefined,\n          \"LexicalBuilder: Expecting cleanups[%s] to be defined\",\n          String(i),\n        );\n        cleanupFun();\n      }\n      cleanups.length = 0;\n      controller.abort();\n    };\n  }\n\n  buildCreateEditorArgs(signal: AbortSignal) {\n    const config: InitialEditorConfig = {};\n    const nodes = new Set<NonNullable<CreateEditorArgs[\"nodes\"]>[number]>();\n    const replacedNodes = new Map<\n      KlassConstructor<typeof LexicalNode>,\n      PlanRep<AnyLexicalPlan>\n    >();\n    const htmlExport: NonNullable<HTMLConfig[\"export\"]> = new Map();\n    const htmlImport: NonNullable<HTMLConfig[\"import\"]> = {};\n    const theme: EditorThemeClasses = {};\n    const planReps = [...this.sortedPlanReps()];\n    for (const planRep of planReps) {\n      const { plan } = planRep;\n      if (plan.onError !== undefined) {\n        config.onError = plan.onError;\n      }\n      if (plan.disableEvents !== undefined) {\n        config.disableEvents = plan.disableEvents;\n      }\n      if (plan.editable !== undefined) {\n        config.editable = plan.editable;\n      }\n      if (plan.namespace !== undefined) {\n        config.namespace = plan.namespace;\n      }\n      if (plan.$initialEditorState !== undefined) {\n        config.$initialEditorState = plan.$initialEditorState;\n      }\n      if (plan.nodes) {\n        for (const node of plan.nodes) {\n          if (typeof node !== \"function\") {\n            const conflictPlan = replacedNodes.get(node.replace);\n            if (conflictPlan) {\n              invariant(\n                false,\n                \"LexicalBuilder: Plan %s can not register replacement for node %s because %s already did\",\n                plan.name,\n                node.replace.name,\n                conflictPlan.plan.name,\n              );\n            }\n            replacedNodes.set(node.replace, planRep);\n          }\n          nodes.add(node);\n        }\n      }\n      if (plan.html) {\n        if (plan.html.export) {\n          for (const [k, v] of plan.html.export.entries()) {\n            htmlExport.set(k, v);\n          }\n        }\n        if (plan.html.import) {\n          Object.assign(htmlImport, plan.html.import);\n        }\n      }\n      if (plan.theme) {\n        deepThemeMergeInPlace(theme, plan.theme);\n      }\n    }\n    if (Object.keys(theme).length > 0) {\n      config.theme = theme;\n    }\n    if (nodes.size) {\n      config.nodes = [...nodes];\n    }\n    const hasImport = Object.keys(htmlImport).length > 0;\n    const hasExport = htmlExport.size > 0;\n    if (hasImport || hasExport) {\n      config.html = {};\n      if (hasImport) {\n        config.html.import = htmlImport;\n      }\n      if (hasExport) {\n        config.html.export = htmlExport;\n      }\n    }\n    for (const planRep of planReps) {\n      planRep.init(config, signal);\n    }\n    if (!config.onError) {\n      config.onError = defaultOnError;\n    }\n    return config;\n  }\n}\n","import { LexicalEditor } from \"lexical\";\nimport {\n  AnyLexicalPlan,\n  LexicalPlanDependency,\n} from \"@etrepum/lexical-builder-core\";\nimport { LexicalBuilder } from \"./LexicalBuilder\";\nimport invariant from \"./shared/invariant\";\n\n/**\n * Get the finalized config and output of a Plan that was used to build the editor.\n *\n * This is useful in the implementation of a LexicalNode or in other\n * situations where you have an editor reference but it's not easy to\n * pass the config or {@link RegisterState} around.\n *\n * It will throw if the Editor was not built using this Plan.\n *\n * @param editor The editor that was built using plan\n * @param plan The concrete reference to a Plan used to build this editor\n * @returns The config and output for that Plan\n */\nexport function getPlanDependencyFromEditor<Plan extends AnyLexicalPlan>(\n  editor: LexicalEditor,\n  plan: Plan,\n): LexicalPlanDependency<Plan> {\n  const builder = LexicalBuilder.fromEditor(editor);\n  const rep = builder.getPlanRep(plan);\n  invariant(\n    rep !== undefined,\n    \"getPlanFromEditor: Plan %s was not built when creating this editor\",\n    plan.name,\n  );\n  return rep.getPlanDependency();\n}\n","import { LexicalEditor } from \"lexical\";\nimport {\n  AnyLexicalPlan,\n  LexicalPlanDependency,\n} from \"@etrepum/lexical-builder-core\";\nimport { LexicalBuilder } from \"./LexicalBuilder\";\n\n/**\n * Get the finalized config and output of a Plan that was used to build the\n * editor by name.\n *\n * This can be used from the implementation of a LexicalNode or in other\n * situation where you have an editor reference but it's not easy to pass the\n * config around. Use this version if you do not have a concrete reference to\n * the Plan for some reason (e.g. it is an optional peer dependency).\n *\n * Both the explicit Plan type and the name are required.\n *\n *  @example\n * ```tsx\n * getPeerDependencyFromEditor<typeof import(\"@some/plan\").SomePlan>(editor, \"@some/plan\");\n * ```\n\n * @param editor The editor that may have been built using plan\n * @param planName The name of the Plan\n * @returns The config and output of the Plan or undefined\n */\nexport function getPeerDependencyFromEditor<\n  Plan extends AnyLexicalPlan = never,\n>(\n  editor: LexicalEditor,\n  planName: Plan[\"name\"],\n): LexicalPlanDependency<Plan> | undefined {\n  const builder = LexicalBuilder.fromEditor(editor);\n  const peer = builder.planNameMap.get(planName);\n  return peer\n    ? (peer.getPlanDependency() as LexicalPlanDependency<Plan>)\n    : undefined;\n}\n","import { InitialEditorConfig } from \"@etrepum/lexical-builder-core\";\nimport { KlassConstructor, LexicalNode } from \"lexical\";\n\nexport interface KnownTypesAndNodes {\n  types: Set<string>;\n  nodes: Set<KlassConstructor<typeof LexicalNode>>;\n}\nexport function getKnownTypesAndNodes(config: InitialEditorConfig) {\n  const types: KnownTypesAndNodes[\"types\"] = new Set();\n  const nodes: KnownTypesAndNodes[\"nodes\"] = new Set();\n  for (const klassOrReplacement of config.nodes ?? []) {\n    const klass =\n      typeof klassOrReplacement === \"function\"\n        ? klassOrReplacement\n        : klassOrReplacement.replace;\n    types.add(klass.getType());\n    nodes.add(klass);\n  }\n  return { types, nodes };\n}\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport { definePlan, safeCast } from \"@etrepum/lexical-builder-core\";\n\nexport interface AutoFocusConfig {\n  /**\n   * Where to move the selection when the editor is focused and there is no\n   * existing selection. Can be \"rootStart\" or \"rootEnd\" (the default).\n   */\n  defaultSelection?: \"rootStart\" | \"rootEnd\";\n}\n\n/**\n * A Plan to focus the LexicalEditor when the root element is set\n * (typically only when the editor is first created).\n */\nexport const AutoFocusPlan = definePlan({\n  config: safeCast<AutoFocusConfig>({}),\n  name: \"@etrepum/lexical-builder/AutoFocusPlan\",\n  register(editor, { defaultSelection }) {\n    return editor.registerRootListener((rootElement) => {\n      editor.focus(\n        () => {\n          // If we try and move selection to the same point with setBaseAndExtent, it won't\n          // trigger a re-focus on the element. So in the case this occurs, we'll need to correct it.\n          // Normally this is fine, Selection API !== Focus API, but fore the intents of the naming\n          // of this plugin, which should preserve focus too.\n          const activeElement = document.activeElement;\n          if (\n            rootElement !== null &&\n            (activeElement === null || !rootElement.contains(activeElement))\n          ) {\n            // Note: preventScroll won't work in Webkit.\n            rootElement.focus({ preventScroll: true });\n          }\n        },\n        { defaultSelection },\n      );\n    });\n  },\n});\n","export interface DisabledToggleOptions {\n  disabled?: boolean;\n  register: () => () => void;\n}\nexport interface DisabledToggleOutput {\n  isDisabled: () => boolean;\n  setDisabled: (disabled: boolean) => void;\n}\nexport function disabledToggle(\n  opts: DisabledToggleOptions,\n): [DisabledToggleOutput, () => void] {\n  let cleanup: null | (() => void) = null;\n  function isDisabled(): boolean {\n    return cleanup !== null;\n  }\n  function setDisabled(disabled: boolean): void {\n    if (!disabled && cleanup === null) {\n      cleanup = opts.register();\n    } else if (disabled && cleanup !== null) {\n      cleanup();\n      cleanup = null;\n    }\n  }\n  setDisabled(Boolean(opts.disabled));\n  return [\n    { isDisabled, setDisabled },\n    () => {\n      setDisabled(false);\n    },\n  ];\n}\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport { registerDragonSupport } from \"@lexical/dragon\";\nimport {\n  definePlan,\n  provideOutput,\n  safeCast,\n} from \"@etrepum/lexical-builder-core\";\nimport { disabledToggle } from \"./disabledToggle\";\n\nexport interface DragonConfig {\n  disabled: boolean;\n}\nexport interface DragonOutput {\n  isDisabled: () => boolean;\n  setDisabled: (disabled: boolean) => void;\n}\n\n/**\n * Add Dragon speech to text input support to the editor, via the\n * \\@lexical/dragon module.\n */\nexport const DragonPlan = definePlan({\n  name: \"@lexical/dragon\",\n  config: safeCast<DragonConfig>({ disabled: false }),\n  register: (editor, config) =>\n    provideOutput<DragonOutput>(\n      ...disabledToggle({\n        disabled: config.disabled,\n        register: () => registerDragonSupport(editor),\n      }),\n    ),\n});\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\nimport {\n  createEmptyHistoryState,\n  type HistoryState,\n  registerHistory,\n} from \"@lexical/history\";\n\nimport { definePlan } from \"@etrepum/lexical-builder-core\";\nimport { safeCast } from \"@etrepum/lexical-builder-core\";\n\nexport interface HistoryConfig {\n  /**\n   * The time (in milliseconds) the editor should delay generating a new history stack,\n   * instead of merging the current changes with the current stack. The default is 300ms.\n   */\n  delay: number;\n  /**\n   * The initial history state, the default is {@link createEmptyHistoryState}.\n   */\n  createInitialHistoryState: () => HistoryState;\n}\n\n/**\n * Registers necessary listeners to manage undo/redo history stack and related\n * editor commands, via the @lexical/history module.\n */\nexport const HistoryPlan = definePlan({\n  config: safeCast<HistoryConfig>({\n    createInitialHistoryState: createEmptyHistoryState,\n    delay: 300,\n  }),\n  name: \"@etrepum/lexical-builder/HistoryPlan\",\n  register(editor, { delay, createInitialHistoryState }) {\n    return registerHistory(editor, createInitialHistoryState(), delay);\n  },\n});\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\nimport { registerPlainText } from \"@lexical/plain-text\";\nimport { definePlan } from \"@etrepum/lexical-builder-core\";\nimport { DragonPlan } from \"./DragonPlan\";\n\n/**\n * A plan to register \\@lexical/plain-text behavior\n */\nexport const PlainTextPlan = definePlan({\n  conflictsWith: [\"@lexical/rich-text\"],\n  name: \"@lexical/plain-text\",\n  dependencies: [DragonPlan],\n  register: registerPlainText,\n});\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport { HeadingNode, QuoteNode, registerRichText } from \"@lexical/rich-text\";\nimport { definePlan } from \"@etrepum/lexical-builder-core\";\nimport { DragonPlan } from \"./DragonPlan\";\n\n/**\n * A plan to register \\@lexical/rich-text behavior and nodes\n * ({@link HeadingNode}, {@link QuoteNode})\n */\nexport const RichTextPlan = definePlan({\n  conflictsWith: [\"@lexical/plain-text\"],\n  name: \"@lexical/rich-text\",\n  nodes: [HeadingNode, QuoteNode],\n  dependencies: [DragonPlan],\n  register: registerRichText,\n});\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.js","sources":["../src/PACKAGE_VERSION.ts","../src/shared/invariant.ts","../src/deepThemeMergeInPlace.ts","../src/PlanRep.ts","../src/InitialStatePlan.ts","../src/LexicalBuilder.ts","../src/getPlanDependencyFromEditor.ts","../src/getPeerDependencyFromEditor.ts","../src/config.ts","../src/AutoFocusPlan.ts","../src/disabledToggle.ts","../src/DragonPlan.ts","../src/HistoryPlan.ts","../src/PlainTextPlan.ts","../src/RichTextPlan.ts"],"sourcesContent":["/** The build version of this package (e.g. \"0.16.0\") */\nexport const PACKAGE_VERSION: string = import.meta.env.PACKAGE_VERSION;\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n// invariant(condition, message) will refine types based on \"condition\", and\n// if \"condition\" is false will throw an error. This function is special-cased\n// in flow itself, so we can't name it anything else.\nexport default function invariant(\n  cond?: boolean,\n  message?: string,\n  ...args: string[]\n): asserts cond {\n  if (cond) {\n    return;\n  }\n\n  throw new Error(\n    args.reduce((msg, arg) => msg.replace(\"%s\", String(arg)), message || \"\"),\n  );\n}\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\n/**\n * Recursively merge the given theme configuration in-place.\n *\n * @returns If `a` and `b` are both objects (and `b` is not an Array) then\n * all keys in `b` are merged into `a` then `a` is returned.\n * Otherwise `b` is returned.\n *\n * @example\n * ```ts\n * const a = { a: \"a\", nested: { a: 1 } };\n * const b = { b: \"b\", nested: { b: 2 } };\n * const rval = deepThemeMergeInPlace(a, b);\n * expect(a).toBe(rval);\n * expect(a).toEqual({ a: \"a\", b: \"b\", nested: { a: 1, b: 2 } });\n * ```\n */\nexport function deepThemeMergeInPlace(a: unknown, b: unknown) {\n  if (\n    a &&\n    b &&\n    !Array.isArray(b) &&\n    typeof a === \"object\" &&\n    typeof b === \"object\"\n  ) {\n    const aObj = a as Record<string, unknown>;\n    const bObj = b as Record<string, unknown>;\n    for (const k in bObj) {\n      aObj[k] = deepThemeMergeInPlace(aObj[k], bObj[k]);\n    }\n    return a;\n  }\n  return b;\n}\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport type {\n  AnyLexicalPlan,\n  InitialEditorConfig,\n  LexicalPlanConfig,\n  LexicalPlanDependency,\n  LexicalPlanInit,\n  LexicalPlanOutput,\n  RegisterCleanup,\n  PlanInitState,\n  PlanRegisterState,\n} from \"@etrepum/lexical-builder-core\";\nimport { shallowMergeConfig } from \"@etrepum/lexical-builder-core\";\nimport type { LexicalEditor } from \"lexical\";\nimport invariant from \"./shared/invariant\";\nimport type { LexicalBuilder } from \"./LexicalBuilder\";\n\nexport const PlanRepStateIds = {\n  unmarked: 0,\n  temporary: 1,\n  permanent: 2,\n  configured: 3,\n  initialized: 4,\n  registered: 5,\n  afterInitialization: 6,\n} as const;\ninterface UnmarkedState {\n  id: (typeof PlanRepStateIds)[\"unmarked\"];\n}\ninterface TemporaryState extends Omit<UnmarkedState, \"id\"> {\n  id: (typeof PlanRepStateIds)[\"temporary\"];\n}\ninterface PermanentState extends Omit<TemporaryState, \"id\"> {\n  id: (typeof PlanRepStateIds)[\"permanent\"];\n}\ninterface ConfiguredState<Plan extends AnyLexicalPlan>\n  extends Omit<PermanentState, \"id\"> {\n  id: (typeof PlanRepStateIds)[\"configured\"];\n  config: LexicalPlanConfig<Plan>;\n  registerState: PlanInitState;\n}\ninterface InitializedState<Plan extends AnyLexicalPlan>\n  extends Omit<ConfiguredState<Plan>, \"id\" | \"registerState\"> {\n  id: (typeof PlanRepStateIds)[\"initialized\"];\n  initResult: LexicalPlanInit<Plan>;\n  registerState: PlanRegisterState<LexicalPlanInit<Plan>>;\n}\ninterface RegisteredState<Plan extends AnyLexicalPlan>\n  extends Omit<InitializedState<Plan>, \"id\"> {\n  id: (typeof PlanRepStateIds)[\"registered\"];\n  output: LexicalPlanOutput<Plan>;\n}\ninterface AfterInitializationState<Plan extends AnyLexicalPlan>\n  extends Omit<RegisteredState<Plan>, \"id\"> {\n  id: (typeof PlanRepStateIds)[\"afterInitialization\"];\n}\n\nexport type PlanRepState<Plan extends AnyLexicalPlan> =\n  | UnmarkedState\n  | TemporaryState\n  | PermanentState\n  | ConfiguredState<Plan>\n  | InitializedState<Plan>\n  | RegisteredState<Plan>\n  | AfterInitializationState<Plan>;\n\nexport function isExactlyUnmarkedPlanRepState<Plan extends AnyLexicalPlan>(\n  state: PlanRepState<Plan>,\n): state is UnmarkedState {\n  return state.id === PlanRepStateIds.unmarked;\n}\nfunction isExactlyTemporaryPlanRepState<Plan extends AnyLexicalPlan>(\n  state: PlanRepState<Plan>,\n): state is TemporaryState {\n  return state.id === PlanRepStateIds.temporary;\n}\nexport function isExactlyPermanentPlanRepState<Plan extends AnyLexicalPlan>(\n  state: PlanRepState<Plan>,\n): state is PermanentState {\n  return state.id === PlanRepStateIds.permanent;\n}\nfunction isInitializedPlanRepState<Plan extends AnyLexicalPlan>(\n  state: PlanRepState<Plan>,\n): state is\n  | InitializedState<Plan>\n  | RegisteredState<Plan>\n  | AfterInitializationState<Plan> {\n  return state.id >= PlanRepStateIds.initialized;\n}\nfunction isConfiguredPlanRepState<Plan extends AnyLexicalPlan>(\n  state: PlanRepState<Plan>,\n): state is\n  | ConfiguredState<Plan>\n  | InitializedState<Plan>\n  | RegisteredState<Plan>\n  | AfterInitializationState<Plan> {\n  return state.id >= PlanRepStateIds.configured;\n}\nfunction isRegisteredPlanRepState<Plan extends AnyLexicalPlan>(\n  state: PlanRepState<Plan>,\n): state is RegisteredState<Plan> | AfterInitializationState<Plan> {\n  return state.id >= PlanRepStateIds.registered;\n}\nfunction isAfterInitializationState<Plan extends AnyLexicalPlan>(\n  state: PlanRepState<Plan>,\n): state is AfterInitializationState<Plan> {\n  return state.id >= PlanRepStateIds.afterInitialization;\n}\nexport function applyTemporaryMark<Plan extends AnyLexicalPlan>(\n  state: PlanRepState<Plan>,\n): TemporaryState {\n  invariant(\n    isExactlyUnmarkedPlanRepState(state),\n    \"LexicalBuilder: Can not apply a temporary mark to state\",\n  );\n  return Object.assign(state, { id: PlanRepStateIds.temporary });\n}\nexport function applyPermanentMark<Plan extends AnyLexicalPlan>(\n  state: PlanRepState<Plan>,\n): PermanentState {\n  invariant(\n    isExactlyTemporaryPlanRepState(state),\n    \"LexicalBuilder: Can not apply a permanent mark to state\",\n  );\n  return Object.assign(state, { id: PlanRepStateIds.permanent });\n}\nexport function applyConfiguredState<Plan extends AnyLexicalPlan>(\n  state: PermanentState,\n  config: LexicalPlanConfig<Plan>,\n  registerState: PlanInitState,\n): ConfiguredState<Plan> {\n  return Object.assign(state, {\n    id: PlanRepStateIds.configured,\n    config,\n    registerState,\n  });\n}\nexport function applyInitializedState<Plan extends AnyLexicalPlan>(\n  state: ConfiguredState<Plan>,\n  initResult: LexicalPlanInit<Plan>,\n  registerState: PlanRegisterState<Plan>,\n): InitializedState<Plan> {\n  return Object.assign(state, {\n    id: PlanRepStateIds.initialized,\n    initResult,\n    registerState,\n  });\n}\nexport function applyRegisteredState<Plan extends AnyLexicalPlan>(\n  state: InitializedState<Plan>,\n  cleanup?: RegisterCleanup<LexicalPlanOutput<Plan>> | undefined,\n) {\n  return Object.assign(state, {\n    id: PlanRepStateIds.registered,\n    output: cleanup ? cleanup.output : undefined,\n  });\n}\nexport function applyAfterInitializationState<Plan extends AnyLexicalPlan>(\n  state: RegisteredState<Plan>,\n): AfterInitializationState<Plan> {\n  return Object.assign(state, { id: PlanRepStateIds.afterInitialization });\n}\n\nconst emptySet: ReadonlySet<string> = new Set();\n\n/**\n * @internal\n */\nexport class PlanRep<Plan extends AnyLexicalPlan> {\n  builder: LexicalBuilder;\n  configs: Set<Partial<LexicalPlanConfig<Plan>>>;\n  _dependency?: LexicalPlanDependency<Plan>;\n  _output?: LexicalPlanOutput<Plan>;\n  _peerNameSet?: Set<string>;\n  plan: Plan;\n  state: PlanRepState<Plan>;\n  constructor(builder: LexicalBuilder, plan: Plan) {\n    this.builder = builder;\n    this.plan = plan;\n    this.configs = new Set();\n    this.state = { id: PlanRepStateIds.unmarked };\n  }\n\n  afterInitialization(editor: LexicalEditor): undefined | (() => void) {\n    const state = this.state;\n    invariant(\n      state.id === PlanRepStateIds.registered,\n      \"PlanRep: afterInitialization called in state id %s (expected %s registered)\",\n      String(state.id),\n      String(PlanRepStateIds.registered),\n    );\n    let rval: undefined | (() => void);\n    if (this.plan.afterInitialization) {\n      rval = this.plan.afterInitialization(\n        editor,\n        state.config,\n        state.registerState,\n      );\n    }\n    this.state = applyAfterInitializationState(state);\n    return rval;\n  }\n  register(editor: LexicalEditor): undefined | (() => void) {\n    const state = this.state;\n    invariant(\n      state.id === PlanRepStateIds.initialized,\n      \"PlanRep: register called in state id %s (expected %s initialized)\",\n      String(state.id),\n      String(PlanRepStateIds.initialized),\n    );\n    let cleanup: undefined | RegisterCleanup<LexicalPlanOutput<Plan>>;\n    if (this.plan.register) {\n      cleanup = this.plan.register(\n        editor,\n        state.config,\n        state.registerState,\n      ) as RegisterCleanup<LexicalPlanOutput<Plan>>;\n    }\n    this.state = applyRegisteredState(state, cleanup);\n    return cleanup;\n  }\n  init(editorConfig: InitialEditorConfig, signal: AbortSignal) {\n    const initialState = this.state;\n    invariant(\n      isExactlyPermanentPlanRepState(initialState),\n      \"LexicalBuilder: Can not configure from state id %s\",\n      String(initialState.id),\n    );\n    const initState: PlanInitState = {\n      signal,\n      getDirectDependentNames: this.getDirectDependentNames.bind(this),\n      getPeerNameSet: this.getPeerNameSet.bind(this),\n      getPeer: this.getInitPeer.bind(this),\n      getDependency: this.getInitDependency.bind(this),\n    };\n    const registerState: PlanRegisterState<Plan> = {\n      ...initState,\n      getPeer: this.getPeer.bind(this),\n      getDependency: this.getDependency.bind(this),\n      getInitResult: this.getInitResult.bind(this),\n    };\n    const state = applyConfiguredState(\n      initialState,\n      this.mergeConfigs(),\n      initState,\n    );\n    this.state = state;\n    let initResult: LexicalPlanInit<Plan> | undefined;\n    if (this.plan.init) {\n      initResult = this.plan.init(\n        editorConfig,\n        state.config,\n        initState,\n      ) as LexicalPlanInit<Plan>;\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion -- false positive\n    this.state = applyInitializedState(state, initResult!, registerState);\n  }\n  getInitResult(): LexicalPlanInit<Plan> {\n    invariant(\n      this.plan.init !== undefined,\n      \"PlanRep: getInitResult() called for Plan %s that does not define init\",\n      this.plan.name,\n    );\n    const state = this.state;\n    invariant(\n      isInitializedPlanRepState(state),\n      \"PlanRep: getInitResult() called for PlanRep in state id %s < %s (initialized)\",\n      String(state.id),\n      String(PlanRepStateIds.initialized),\n    );\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return -- any\n    return state.initResult;\n  }\n\n  getInitPeer<PeerPlan extends AnyLexicalPlan = never>(\n    name: PeerPlan[\"name\"],\n  ): undefined | Omit<LexicalPlanDependency<PeerPlan>, \"output\"> {\n    const rep = this.builder.planNameMap.get(name);\n    return rep ? rep.getPlanInitDependency() : undefined;\n  }\n\n  getPlanInitDependency(): Omit<LexicalPlanDependency<Plan>, \"output\"> {\n    const state = this.state;\n    invariant(\n      isConfiguredPlanRepState(state),\n      \"LexicalPlanBuilder: getPlanInitDependency called in state id %s (expected >= %s configured)\",\n      String(state.id),\n      String(PlanRepStateIds.configured),\n    );\n    return { config: state.config };\n  }\n\n  getPeer<PeerPlan extends AnyLexicalPlan = never>(\n    name: PeerPlan[\"name\"],\n  ): undefined | LexicalPlanDependency<PeerPlan> {\n    const rep = this.builder.planNameMap.get(name);\n    return rep\n      ? (rep.getPlanDependency() as LexicalPlanDependency<PeerPlan>)\n      : undefined;\n  }\n\n  getInitDependency<Dependency extends AnyLexicalPlan>(\n    dep: Dependency,\n  ): Omit<LexicalPlanDependency<Dependency>, \"output\"> {\n    const rep = this.builder.getPlanRep(dep);\n    invariant(\n      rep !== undefined,\n      \"LexicalPlanBuilder: Plan %s missing dependency plan %s to be in registry\",\n      this.plan.name,\n      dep.name,\n    );\n    return rep.getPlanInitDependency();\n  }\n\n  getDependency<Dependency extends AnyLexicalPlan>(\n    dep: Dependency,\n  ): LexicalPlanDependency<Dependency> {\n    const rep = this.builder.getPlanRep(dep);\n    invariant(\n      rep !== undefined,\n      \"LexicalPlanBuilder: Plan %s missing dependency plan %s to be in registry\",\n      this.plan.name,\n      dep.name,\n    );\n    return rep.getPlanDependency();\n  }\n\n  getState(): AfterInitializationState<Plan> {\n    const state = this.state;\n    invariant(\n      isAfterInitializationState(state),\n      \"PlanRep getState called in state id %s (expected %s afterInitialization)\",\n      String(state.id),\n      String(PlanRepStateIds.afterInitialization),\n    );\n    return state;\n  }\n\n  getDirectDependentNames(): ReadonlySet<string> {\n    return this.builder.incomingEdges.get(this.plan.name) || emptySet;\n  }\n\n  getPeerNameSet(): ReadonlySet<string> {\n    let s = this._peerNameSet;\n    if (!s) {\n      s = new Set((this.plan.peerDependencies || []).map(([name]) => name));\n      this._peerNameSet = s;\n    }\n    return s;\n  }\n\n  getPlanDependency(): LexicalPlanDependency<Plan> {\n    if (!this._dependency) {\n      const state = this.state;\n      invariant(\n        isRegisteredPlanRepState(state),\n        \"Plan %s used as a dependency before registration\",\n        this.plan.name,\n      );\n      this._dependency = {\n        config: state.config,\n        output: state.output,\n      };\n    }\n    return this._dependency;\n  }\n  mergeConfigs(): LexicalPlanConfig<Plan> {\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- LexicalPlanConfig<Plan> is any\n    let config: LexicalPlanConfig<Plan> = this.plan.config || {};\n    const mergeConfig = this.plan.mergeConfig\n      ? this.plan.mergeConfig.bind(this.plan)\n      : shallowMergeConfig;\n    for (const cfg of this.configs) {\n      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment -- LexicalPlanConfig<Plan> is any\n      config = mergeConfig(config, cfg);\n    }\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return -- any\n    return config;\n  }\n}\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport { definePlan, safeCast } from \"@etrepum/lexical-builder-core\";\nimport {\n  $createParagraphNode,\n  $getRoot,\n  LineBreakNode,\n  ParagraphNode,\n  RootNode,\n  TabNode,\n  TextNode,\n  type EditorSetOptions,\n  type EditorUpdateOptions,\n} from \"lexical\";\n\nconst HISTORY_MERGE_OPTIONS = { tag: \"history-merge\" };\n\nfunction $defaultInitializer() {\n  const root = $getRoot();\n  if (root.isEmpty()) {\n    root.append($createParagraphNode());\n  }\n}\n\nexport interface InitialStateConfig {\n  updateOptions: EditorUpdateOptions;\n  setOptions: EditorSetOptions;\n}\n\nexport const InitialStatePlan = definePlan({\n  name: \"@etrepum/lexical-builder/InitialState\",\n  // These are automatically added by createEditor, we add them here so they are\n  // visible during planRep.init so plans can see all known types before the\n  // editor is created.\n  // (excluding ArtificialNode__DO_NOT_USE because it isn't really public API\n  // and shouldn't change anything)\n  nodes: [RootNode, TextNode, LineBreakNode, TabNode, ParagraphNode],\n  config: safeCast<InitialStateConfig>({\n    updateOptions: HISTORY_MERGE_OPTIONS,\n    setOptions: HISTORY_MERGE_OPTIONS,\n  }),\n  init({ $initialEditorState = $defaultInitializer }) {\n    return $initialEditorState;\n  },\n  afterInitialization(editor, { updateOptions, setOptions }, state) {\n    const $initialEditorState = state.getInitResult();\n    switch (typeof $initialEditorState) {\n      case \"function\": {\n        editor.update(() => {\n          $initialEditorState(editor);\n        }, updateOptions);\n        break;\n      }\n      case \"string\": {\n        const parsedEditorState = editor.parseEditorState($initialEditorState);\n        editor.setEditorState(parsedEditorState, setOptions);\n        break;\n      }\n      case \"object\": {\n        if ($initialEditorState) {\n          editor.setEditorState($initialEditorState, setOptions);\n        }\n        break;\n      }\n      default: {\n        /* noop */\n      }\n    }\n    return () => {\n      /* noop */\n    };\n  },\n});\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\nimport type {\n  AnyLexicalPlan,\n  AnyLexicalPlanArgument,\n  LexicalEditorWithDispose,\n  InitialEditorConfig,\n  LexicalPlanConfig,\n} from \"@etrepum/lexical-builder-core\";\nimport {\n  type LexicalEditor,\n  createEditor,\n  type CreateEditorArgs,\n  type EditorThemeClasses,\n  type HTMLConfig,\n  type KlassConstructor,\n  type LexicalNode,\n} from \"lexical\";\nimport { mergeRegister } from \"@lexical/utils\";\nimport { configPlan } from \"@etrepum/lexical-builder-core\";\nimport invariant from \"./shared/invariant\";\nimport { deepThemeMergeInPlace } from \"./deepThemeMergeInPlace\";\nimport {\n  PlanRep,\n  applyPermanentMark,\n  applyTemporaryMark,\n  isExactlyPermanentPlanRepState,\n  isExactlyUnmarkedPlanRepState,\n} from \"./PlanRep\";\nimport { PACKAGE_VERSION } from \"./PACKAGE_VERSION\";\nimport { InitialStatePlan } from \"./InitialStatePlan\";\n\n/** @internal Use a well-known symbol for dev tools purposes */\nexport const builderSymbol = Symbol.for(\"@etrepum/lexical-builder\");\n\n/**\n * Build a LexicalEditor by combining together one or more plans, optionally\n * overriding some of their configuration.\n *\n * @param plans - Plan arguments (plans or plans with config overrides)\n * @returns An editor handle\n *\n * @example A single root plan with multiple dependencies\n * ```ts\n * const editor = buildEditorFromPlans(\n *   definePlan({\n *     name: \"[root]\",\n *     dependencies: [\n *       RichTextPlan,\n *       configPlan(EmojiPlan, { emojiBaseUrl: \"/assets/emoji\" }),\n *     ],\n *     register: (editor: LexicalEditor) => {\n *       console.log(\"Editor Created\");\n *       return () => console.log(\"Editor Disposed\");\n *     },\n *   }),\n * );\n * ```\n * @example A very similar minimal configuration without the register hook\n * ```ts\n * const editor = buildEditorFromPlans(\n *   RichTextPlan,\n *   configPlan(EmojiPlan, { emojiBaseUrl: \"/assets/emoji\" }),\n * );\n * ```\n */\nexport function buildEditorFromPlans(\n  ...plans: AnyLexicalPlanArgument[]\n): LexicalEditorWithDispose {\n  return LexicalBuilder.fromPlans(plans).buildEditor();\n}\n\n/** @internal */\nfunction noop() {\n  /*empty*/\n}\n\n/** Throw the given Error */\nfunction defaultOnError(err: Error) {\n  throw err;\n}\n\ninterface WithBuilder {\n  [builderSymbol]?: LexicalBuilder | undefined;\n}\n\n/** @internal */\nfunction maybeWithBuilder(editor: LexicalEditor): LexicalEditor & WithBuilder {\n  return editor;\n}\n\ntype AnyNormalizedLexicalPlanArgument = ReturnType<\n  typeof normalizePlanArgument\n>;\nfunction normalizePlanArgument(arg: AnyLexicalPlanArgument) {\n  return Array.isArray(arg) ? arg : configPlan(arg);\n}\n\n/** @internal */\nexport class LexicalBuilder {\n  roots: readonly AnyNormalizedLexicalPlanArgument[];\n  planNameMap: Map<string, PlanRep<AnyLexicalPlan>>;\n  outgoingConfigEdges: Map<\n    string,\n    Map<string, LexicalPlanConfig<AnyLexicalPlan>[]>\n  >;\n  incomingEdges: Map<string, Set<string>>;\n  conflicts: Map<string, string>;\n  _sortedPlanReps?: readonly PlanRep<AnyLexicalPlan>[];\n  PACKAGE_VERSION: string;\n\n  constructor(roots: AnyNormalizedLexicalPlanArgument[]) {\n    this.outgoingConfigEdges = new Map();\n    this.incomingEdges = new Map();\n    this.planNameMap = new Map();\n    this.conflicts = new Map();\n    this.PACKAGE_VERSION = PACKAGE_VERSION;\n    this.roots = roots;\n    for (const plan of roots) {\n      this.addPlan(plan);\n    }\n  }\n\n  static fromPlans(plans: AnyLexicalPlanArgument[]): LexicalBuilder {\n    const roots = [normalizePlanArgument(InitialStatePlan)];\n    for (const plan of plans) {\n      roots.push(normalizePlanArgument(plan));\n    }\n    return new LexicalBuilder(roots);\n  }\n\n  /** Look up the editor that was created by this LexicalBuilder or throw */\n  static fromEditor(editor: LexicalEditor): LexicalBuilder {\n    const builder = maybeWithBuilder(editor)[builderSymbol];\n    invariant(\n      builder && typeof builder === \"object\",\n      \"LexicalBuilder.fromEditor: The given editor was not created with LexicalBuilder, or has been disposed\",\n    );\n    // The dev tools variant of this will relax some of these invariants\n    invariant(\n      builder.PACKAGE_VERSION === PACKAGE_VERSION,\n      \"LexicalBuilder.fromEditor: The given editor was created with LexicalBuilder %s but this version is %s. A project should have exactly one copy of LexicalBuilder\",\n      builder.PACKAGE_VERSION,\n      PACKAGE_VERSION,\n    );\n    invariant(\n      builder instanceof LexicalBuilder,\n      \"LexicalBuilder.fromEditor: There are multiple copies of the same version of LexicalBuilder in your project, and this editor was created with another one. Your project, or one of its dependencies, has its package.json and/or bundler configured incorrectly.\",\n    );\n    return builder;\n  }\n\n  buildEditor(): LexicalEditorWithDispose {\n    const controller = new AbortController();\n    const {\n      $initialEditorState: _$initialEditorState,\n      onError,\n      ...editorConfig\n    } = this.buildCreateEditorArgs(controller.signal);\n    let disposeOnce = noop;\n    function dispose() {\n      try {\n        disposeOnce();\n      } finally {\n        disposeOnce = noop;\n      }\n    }\n    const editor: LexicalEditorWithDispose & WithBuilder = Object.assign(\n      createEditor({\n        ...editorConfig,\n        ...(onError\n          ? {\n              onError: (err) => {\n                onError(err, editor);\n              },\n            }\n          : {}),\n      }),\n      { [builderSymbol]: this, dispose, [Symbol.dispose]: dispose },\n    );\n    disposeOnce = mergeRegister(\n      () => {\n        maybeWithBuilder(editor)[builderSymbol] = undefined;\n      },\n      () => {\n        editor.setRootElement(null);\n      },\n      this.registerEditor(editor, controller),\n    );\n    return editor;\n  }\n\n  getPlanRep<Plan extends AnyLexicalPlan>(\n    plan: Plan,\n  ): PlanRep<Plan> | undefined {\n    const rep = this.planNameMap.get(plan.name);\n    if (rep) {\n      invariant(\n        rep.plan === plan,\n        \"LexicalBuilder: A registered plan with name %s exists but does not match the given plan\",\n        plan.name,\n      );\n      return rep as PlanRep<Plan>;\n    }\n  }\n\n  addEdge(\n    fromPlanName: string,\n    toPlanName: string,\n    configs: LexicalPlanConfig<AnyLexicalPlan>[],\n  ) {\n    const outgoing = this.outgoingConfigEdges.get(fromPlanName);\n    if (outgoing) {\n      outgoing.set(toPlanName, configs);\n    } else {\n      this.outgoingConfigEdges.set(\n        fromPlanName,\n        new Map([[toPlanName, configs]]),\n      );\n    }\n    const incoming = this.incomingEdges.get(toPlanName);\n    if (incoming) {\n      incoming.add(fromPlanName);\n    } else {\n      this.incomingEdges.set(toPlanName, new Set([fromPlanName]));\n    }\n  }\n\n  addPlan(arg: AnyLexicalPlanArgument) {\n    invariant(\n      this._sortedPlanReps === undefined,\n      \"LexicalBuilder: addPlan called after finalization\",\n    );\n    const normalized = normalizePlanArgument(arg);\n    const [plan] = normalized;\n    invariant(\n      typeof plan.name === \"string\",\n      \"LexicalBuilder: plan name must be string, not %s\",\n      typeof plan.name,\n    );\n    let planRep = this.planNameMap.get(plan.name);\n    invariant(\n      planRep === undefined || planRep.plan === plan,\n      \"LexicalBuilder: Multiple plans registered with name %s, names must be unique\",\n      plan.name,\n    );\n    if (!planRep) {\n      planRep = new PlanRep(this, plan);\n      this.planNameMap.set(plan.name, planRep);\n      const hasConflict = this.conflicts.get(plan.name);\n      if (typeof hasConflict === \"string\") {\n        invariant(\n          false,\n          \"LexicalBuilder: plan %s conflicts with %s\",\n          plan.name,\n          hasConflict,\n        );\n      }\n      for (const name of plan.conflictsWith || []) {\n        invariant(\n          !this.planNameMap.has(name),\n          \"LexicalBuilder: plan %s conflicts with %s\",\n          plan.name,\n          name,\n        );\n        this.conflicts.set(name, plan.name);\n      }\n      for (const dep of plan.dependencies || []) {\n        const normDep = normalizePlanArgument(dep);\n        this.addEdge(plan.name, normDep[0].name, normDep.slice(1));\n        this.addPlan(normDep);\n      }\n      for (const [depName, config] of plan.peerDependencies || []) {\n        this.addEdge(plan.name, depName, config ? [config] : []);\n      }\n    }\n  }\n\n  sortedPlanReps(): readonly PlanRep<AnyLexicalPlan>[] {\n    if (this._sortedPlanReps) {\n      return this._sortedPlanReps;\n    }\n    // depth-first search based topological DAG sort\n    // https://en.wikipedia.org/wiki/Topological_sorting\n    const sortedPlanReps: PlanRep<AnyLexicalPlan>[] = [];\n    const visit = (rep: PlanRep<AnyLexicalPlan>, fromPlanName?: string) => {\n      let mark = rep.state;\n      if (isExactlyPermanentPlanRepState(mark)) {\n        return;\n      }\n      const planName = rep.plan.name;\n      invariant(\n        isExactlyUnmarkedPlanRepState(mark),\n        \"LexicalBuilder: Circular dependency detected for Plan %s from %s\",\n        planName,\n        fromPlanName || \"[unknown]\",\n      );\n      mark = applyTemporaryMark(mark);\n      rep.state = mark;\n      const outgoingConfigEdges = this.outgoingConfigEdges.get(planName);\n      if (outgoingConfigEdges) {\n        for (const toPlanName of outgoingConfigEdges.keys()) {\n          const toRep = this.planNameMap.get(toPlanName);\n          // may be undefined for an optional peer dependency\n          if (toRep) {\n            visit(toRep, planName);\n          }\n        }\n      }\n      mark = applyPermanentMark(mark);\n      rep.state = mark;\n      sortedPlanReps.push(rep);\n    };\n    for (const rep of this.planNameMap.values()) {\n      if (isExactlyUnmarkedPlanRepState(rep.state)) {\n        visit(rep);\n      }\n    }\n    for (const rep of sortedPlanReps) {\n      for (const [toPlanName, configs] of this.outgoingConfigEdges.get(\n        rep.plan.name,\n      ) || []) {\n        if (configs.length > 0) {\n          const toRep = this.planNameMap.get(toPlanName);\n          if (toRep) {\n            for (const config of configs) {\n              // eslint-disable-next-line @typescript-eslint/no-unsafe-argument -- any\n              toRep.configs.add(config);\n            }\n          }\n        }\n      }\n    }\n    for (const [plan, ...configs] of this.roots) {\n      if (configs.length > 0) {\n        const toRep = this.planNameMap.get(plan.name);\n        invariant(\n          toRep !== undefined,\n          \"LexicalBuilder: Expecting existing PlanRep for %s\",\n          plan.name,\n        );\n        for (const config of configs) {\n          toRep.configs.add(config);\n        }\n      }\n    }\n    this._sortedPlanReps = sortedPlanReps;\n    return this._sortedPlanReps;\n  }\n\n  registerEditor(\n    editor: LexicalEditor,\n    controller: AbortController,\n  ): () => void {\n    const cleanups: (() => void)[] = [];\n    const planReps = this.sortedPlanReps();\n    for (const planRep of planReps) {\n      const cleanup = planRep.register(editor);\n      if (cleanup) {\n        cleanups.push(cleanup);\n      }\n    }\n    for (const planRep of planReps) {\n      const cleanup = planRep.afterInitialization(editor);\n      if (cleanup) {\n        cleanups.push(cleanup);\n      }\n    }\n    return () => {\n      for (let i = cleanups.length - 1; i >= 0; i--) {\n        const cleanupFun = cleanups[i];\n        invariant(\n          cleanupFun !== undefined,\n          \"LexicalBuilder: Expecting cleanups[%s] to be defined\",\n          String(i),\n        );\n        cleanupFun();\n      }\n      cleanups.length = 0;\n      controller.abort();\n    };\n  }\n\n  buildCreateEditorArgs(signal: AbortSignal) {\n    const config: InitialEditorConfig = {};\n    const nodes = new Set<NonNullable<CreateEditorArgs[\"nodes\"]>[number]>();\n    const replacedNodes = new Map<\n      KlassConstructor<typeof LexicalNode>,\n      PlanRep<AnyLexicalPlan>\n    >();\n    const htmlExport: NonNullable<HTMLConfig[\"export\"]> = new Map();\n    const htmlImport: NonNullable<HTMLConfig[\"import\"]> = {};\n    const theme: EditorThemeClasses = {};\n    const planReps = this.sortedPlanReps();\n    for (const planRep of planReps) {\n      const { plan } = planRep;\n      if (plan.onError !== undefined) {\n        config.onError = plan.onError;\n      }\n      if (plan.disableEvents !== undefined) {\n        config.disableEvents = plan.disableEvents;\n      }\n      if (plan.editable !== undefined) {\n        config.editable = plan.editable;\n      }\n      if (plan.namespace !== undefined) {\n        config.namespace = plan.namespace;\n      }\n      if (plan.$initialEditorState !== undefined) {\n        config.$initialEditorState = plan.$initialEditorState;\n      }\n      if (plan.nodes) {\n        for (const node of plan.nodes) {\n          if (typeof node !== \"function\") {\n            const conflictPlan = replacedNodes.get(node.replace);\n            if (conflictPlan) {\n              invariant(\n                false,\n                \"LexicalBuilder: Plan %s can not register replacement for node %s because %s already did\",\n                plan.name,\n                node.replace.name,\n                conflictPlan.plan.name,\n              );\n            }\n            replacedNodes.set(node.replace, planRep);\n          }\n          nodes.add(node);\n        }\n      }\n      if (plan.html) {\n        if (plan.html.export) {\n          for (const [k, v] of plan.html.export.entries()) {\n            htmlExport.set(k, v);\n          }\n        }\n        if (plan.html.import) {\n          Object.assign(htmlImport, plan.html.import);\n        }\n      }\n      if (plan.theme) {\n        deepThemeMergeInPlace(theme, plan.theme);\n      }\n    }\n    if (Object.keys(theme).length > 0) {\n      config.theme = theme;\n    }\n    if (nodes.size) {\n      config.nodes = [...nodes];\n    }\n    const hasImport = Object.keys(htmlImport).length > 0;\n    const hasExport = htmlExport.size > 0;\n    if (hasImport || hasExport) {\n      config.html = {};\n      if (hasImport) {\n        config.html.import = htmlImport;\n      }\n      if (hasExport) {\n        config.html.export = htmlExport;\n      }\n    }\n    for (const planRep of planReps) {\n      planRep.init(config, signal);\n    }\n    if (!config.onError) {\n      config.onError = defaultOnError;\n    }\n    return config;\n  }\n}\n","import type { LexicalEditor } from \"lexical\";\nimport type {\n  AnyLexicalPlan,\n  LexicalPlanDependency,\n} from \"@etrepum/lexical-builder-core\";\nimport { LexicalBuilder } from \"./LexicalBuilder\";\nimport invariant from \"./shared/invariant\";\n\n/**\n * Get the finalized config and output of a Plan that was used to build the editor.\n *\n * This is useful in the implementation of a LexicalNode or in other\n * situations where you have an editor reference but it's not easy to\n * pass the config or {@link PlanRegisterState} around.\n *\n * It will throw if the Editor was not built using this Plan.\n *\n * @param editor - The editor that was built using plan\n * @param plan - The concrete reference to a Plan used to build this editor\n * @returns The config and output for that Plan\n */\nexport function getPlanDependencyFromEditor<Plan extends AnyLexicalPlan>(\n  editor: LexicalEditor,\n  plan: Plan,\n): LexicalPlanDependency<Plan> {\n  const builder = LexicalBuilder.fromEditor(editor);\n  const rep = builder.getPlanRep(plan);\n  invariant(\n    rep !== undefined,\n    \"getPlanFromEditor: Plan %s was not built when creating this editor\",\n    plan.name,\n  );\n  return rep.getPlanDependency();\n}\n","import type { LexicalEditor } from \"lexical\";\nimport type {\n  AnyLexicalPlan,\n  LexicalPlanDependency,\n} from \"@etrepum/lexical-builder-core\";\nimport { LexicalBuilder } from \"./LexicalBuilder\";\n\n/**\n * Get the finalized config and output of a Plan that was used to build the\n * editor by name.\n *\n * This can be used from the implementation of a LexicalNode or in other\n * situation where you have an editor reference but it's not easy to pass the\n * config around. Use this version if you do not have a concrete reference to\n * the Plan for some reason (e.g. it is an optional peer dependency).\n *\n * Both the explicit Plan type and the name are required.\n *\n *  @example\n * ```tsx\n * getPeerDependencyFromEditor<typeof import(\"@some/plan\").SomePlan>(editor, \"@some/plan\");\n * ```\n\n * @param editor - The editor that may have been built using plan\n * @param planName - The name of the Plan\n * @returns The config and output of the Plan or undefined\n */\nexport function getPeerDependencyFromEditor<\n  Plan extends AnyLexicalPlan = never,\n>(\n  editor: LexicalEditor,\n  planName: Plan[\"name\"],\n): LexicalPlanDependency<Plan> | undefined {\n  const builder = LexicalBuilder.fromEditor(editor);\n  const peer = builder.planNameMap.get(planName);\n  return peer\n    ? (peer.getPlanDependency() as LexicalPlanDependency<Plan>)\n    : undefined;\n}\n","import type { InitialEditorConfig } from \"@etrepum/lexical-builder-core\";\nimport type { KlassConstructor, LexicalNode } from \"lexical\";\n\nexport interface KnownTypesAndNodes {\n  types: Set<string>;\n  nodes: Set<KlassConstructor<typeof LexicalNode>>;\n}\nexport function getKnownTypesAndNodes(config: InitialEditorConfig) {\n  const types: KnownTypesAndNodes[\"types\"] = new Set();\n  const nodes: KnownTypesAndNodes[\"nodes\"] = new Set();\n  for (const klassOrReplacement of config.nodes ?? []) {\n    const klass =\n      typeof klassOrReplacement === \"function\"\n        ? klassOrReplacement\n        : klassOrReplacement.replace;\n    types.add(klass.getType());\n    nodes.add(klass);\n  }\n  return { types, nodes };\n}\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport { definePlan, safeCast } from \"@etrepum/lexical-builder-core\";\n\nexport interface AutoFocusConfig {\n  /**\n   * Where to move the selection when the editor is focused and there is no\n   * existing selection. Can be \"rootStart\" or \"rootEnd\" (the default).\n   */\n  defaultSelection?: \"rootStart\" | \"rootEnd\";\n}\n\n/**\n * A Plan to focus the LexicalEditor when the root element is set\n * (typically only when the editor is first created).\n */\nexport const AutoFocusPlan = definePlan({\n  config: safeCast<AutoFocusConfig>({}),\n  name: \"@etrepum/lexical-builder/AutoFocus\",\n  register(editor, { defaultSelection }) {\n    return editor.registerRootListener((rootElement) => {\n      editor.focus(\n        () => {\n          // If we try and move selection to the same point with setBaseAndExtent, it won't\n          // trigger a re-focus on the element. So in the case this occurs, we'll need to correct it.\n          // Normally this is fine, Selection API !== Focus API, but fore the intents of the naming\n          // of this plugin, which should preserve focus too.\n          const activeElement = document.activeElement;\n          if (\n            rootElement !== null &&\n            (activeElement === null || !rootElement.contains(activeElement))\n          ) {\n            // Note: preventScroll won't work in Webkit.\n            rootElement.focus({ preventScroll: true });\n          }\n        },\n        { defaultSelection },\n      );\n    });\n  },\n});\n","export interface DisabledToggleOptions {\n  disabled?: boolean;\n  register: () => () => void;\n}\nexport interface DisabledToggleOutput {\n  isDisabled: () => boolean;\n  setDisabled: (disabled: boolean) => void;\n}\nexport function disabledToggle(\n  opts: DisabledToggleOptions,\n): [DisabledToggleOutput, () => void] {\n  let cleanup: null | (() => void) = null;\n  function isDisabled(): boolean {\n    return cleanup !== null;\n  }\n  function setDisabled(disabled: boolean): void {\n    if (!disabled && cleanup === null) {\n      cleanup = opts.register();\n    } else if (disabled && cleanup !== null) {\n      cleanup();\n      cleanup = null;\n    }\n  }\n  setDisabled(Boolean(opts.disabled));\n  return [\n    { isDisabled, setDisabled },\n    () => {\n      setDisabled(false);\n    },\n  ];\n}\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport { registerDragonSupport } from \"@lexical/dragon\";\nimport {\n  definePlan,\n  provideOutput,\n  safeCast,\n} from \"@etrepum/lexical-builder-core\";\nimport { disabledToggle } from \"./disabledToggle\";\n\nexport interface DragonConfig {\n  disabled: boolean;\n}\nexport interface DragonOutput {\n  isDisabled: () => boolean;\n  setDisabled: (disabled: boolean) => void;\n}\n\n/**\n * Add Dragon speech to text input support to the editor, via the\n * \\@lexical/dragon module.\n */\nexport const DragonPlan = definePlan({\n  name: \"@lexical/dragon\",\n  config: safeCast<DragonConfig>({ disabled: false }),\n  register: (editor, config) =>\n    provideOutput<DragonOutput>(\n      ...disabledToggle({\n        disabled: config.disabled,\n        register: () => registerDragonSupport(editor),\n      }),\n    ),\n});\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\nimport {\n  createEmptyHistoryState,\n  type HistoryState,\n  registerHistory,\n} from \"@lexical/history\";\nimport { definePlan, safeCast } from \"@etrepum/lexical-builder-core\";\n\nexport interface HistoryConfig {\n  /**\n   * The time (in milliseconds) the editor should delay generating a new history stack,\n   * instead of merging the current changes with the current stack. The default is 300ms.\n   */\n  delay: number;\n  /**\n   * The initial history state, the default is {@link createEmptyHistoryState}.\n   */\n  createInitialHistoryState: () => HistoryState;\n}\n\n/**\n * Registers necessary listeners to manage undo/redo history stack and related\n * editor commands, via the \\@lexical/history module.\n */\nexport const HistoryPlan = definePlan({\n  config: safeCast<HistoryConfig>({\n    createInitialHistoryState: createEmptyHistoryState,\n    delay: 300,\n  }),\n  name: \"@etrepum/lexical-builder/History\",\n  register(editor, { delay, createInitialHistoryState }) {\n    return registerHistory(editor, createInitialHistoryState(), delay);\n  },\n});\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\nimport { registerPlainText } from \"@lexical/plain-text\";\nimport { definePlan } from \"@etrepum/lexical-builder-core\";\nimport { DragonPlan } from \"./DragonPlan\";\n\n/**\n * A plan to register \\@lexical/plain-text behavior\n */\nexport const PlainTextPlan = definePlan({\n  conflictsWith: [\"@lexical/rich-text\"],\n  name: \"@lexical/plain-text\",\n  dependencies: [DragonPlan],\n  register: registerPlainText,\n});\n","/**\n * Copyright (c) Meta Platforms, Inc. and affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n *\n */\n\nimport { HeadingNode, QuoteNode, registerRichText } from \"@lexical/rich-text\";\nimport { definePlan } from \"@etrepum/lexical-builder-core\";\nimport { DragonPlan } from \"./DragonPlan\";\n\n/**\n * A plan to register \\@lexical/rich-text behavior and nodes\n * ({@link HeadingNode}, {@link QuoteNode})\n */\nexport const RichTextPlan = definePlan({\n  conflictsWith: [\"@lexical/plain-text\"],\n  name: \"@lexical/rich-text\",\n  nodes: [HeadingNode, QuoteNode],\n  dependencies: [DragonPlan],\n  register: registerRichText,\n});\n"],"names":[],"mappings":"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"}

package/package.json

@@ -18,7 +18,7 @@
     "test:watch": "vitest",
     "lint": "eslint"
   },
-  "version": "0.0.28-nightly.20240705.0",
+  "version": "0.0.28",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -53,6 +53,7 @@
     "tslib": "^2.6.2",
     "typescript": "^5.4.5",
     "vite": "^5.2.11",
+    "vite-plugin-dts": "^3.9.1",
     "vite-plugin-package-version": "^1.1.0",
     "vitest": "^1.6.0"
   },