@shelamkoff/rector 1.0.0

package/dist/core/EditorFacade.d.ts

@@ -0,0 +1,154 @@
+/**
+ * @typedef {Object} EditorFacadeDeps
+ * @property {import('./types.js').IBlockManager} blocks Live block collection.
+ * @property {import('./types.js').ISelectionManager} selection Selection service.
+ * @property {import('./types.js').IEventBus} events Internal event bus.
+ * @property {string} defaultBlockType Fallback block type for insertions.
+ * @property {import('./CommandDispatcher.js').CommandDispatcher} commands Command boundary.
+ * @property {import('./DocumentSchema.js').DocumentSchema} documentSchema Document validator and migrator.
+ * @property {import('./Diagnostics.js').Diagnostics} diagnostics Diagnostic reporter.
+ * @property {import('./DocumentSnapshotStore.js').DocumentSnapshotStore} snapshots Document snapshot store.
+ * @property {import('./PublicEditorApi.js').EditorBlocksApi} publicBlocks Public block API.
+ * @property {import('./PublicEditorApi.js').EditorEventSubscriptions} publicEvents Public event subscriptions.
+ * @property {boolean} readOnly Initial interaction mode.
+ * @property {import('./types.js').IInlinePluginRegistry} [inlinePluginRegistry] Inline plugin registry.
+ * @property {import('./types.js').InlinePluginContext} [inlinePluginCtx] Inline plugin runtime context.
+ * @property {import('./types.js').ICrossBlockSelection} [crossBlockSelection] Cross-block selection service.
+ */
+export class EditorFacade {
+    /**
+     * @param {HTMLElement} rootEl
+     * @param {EditorFacadeDeps} deps
+     */
+    constructor(rootEl: HTMLElement, deps: EditorFacadeDeps);
+    /**
+     * Register a module for cleanup on destroy.
+     * @param {{ destroy(): void }} module
+     */
+    registerDestroyable(module: {
+        destroy(): void;
+    }): void;
+    /** @param {import('./UndoManager.js').UndoManager} history */
+    configureHistory(history: import("./UndoManager.js").UndoManager): void;
+    /** @param {(readOnly: boolean) => void} transition */
+    configureReadOnlyTransition(transition: (readOnly: boolean) => void): void;
+    /**
+     * Mark the editor as ready.
+     */
+    markReady(): void;
+    get isReady(): boolean;
+    get blocks(): import("./PublicEditorApi.js").EditorBlocksApi;
+    get events(): import("./PublicEditorApi.js").EditorEventSubscriptions;
+    get rootElement(): HTMLElement;
+    get readOnly(): boolean;
+    get canUndo(): boolean;
+    get canRedo(): boolean;
+    undo(): boolean;
+    redo(): boolean;
+    /** @param {boolean} readOnly */
+    setReadOnly(readOnly: boolean): void;
+    /**
+     * Save editor content.
+     *
+     * Each block's raw `data` is post-processed through the plugin's
+     * `mapTextFields` hook to tokenize any committed inline-widget spans
+     * (e.g. mentions). Widget data is lifted into the block-level `inline`
+     * map keyed by each widget's stable instance id — `data` ends up
+     * carrying only `{{<id>}}` text placeholders, polymorphically
+     * reconstructible on load.
+     *
+     * @returns {import('./types.js').EditorDocument}
+     */
+    save(): import("./types.js").EditorDocument;
+    /**
+     * Render data into the editor, replacing existing content.
+     * @param {import('./types.js').EditorDocument} data
+     * @param {{ blockId: string, offset: number }} [caret] - optional caret position to restore
+     * @param {{ focus?: boolean, notifyChange?: boolean }} [options]
+     */
+    render(data: import("./types.js").EditorDocument, caret?: {
+        blockId: string;
+        offset: number;
+    }, options?: {
+        focus?: boolean;
+        notifyChange?: boolean;
+    }): void;
+    /**
+     * Clear all blocks and insert an empty default block.
+     */
+    clear(): void;
+    /**
+     * Focus the editor (first block or current block).
+     */
+    focus(): void;
+    /**
+     * Insert an inline plugin widget at the current caret position.
+     * @param {string} type
+     * @param {Record<string, string>} [data]
+     * @returns {boolean} whether editor DOM was changed
+     */
+    insertInlinePlugin(type: string, data?: Record<string, string>): boolean;
+    /**
+     * Destroy the editor and clean up all modules.
+     */
+    destroy(): void;
+    #private;
+}
+export type EditorFacadeDeps = {
+    /**
+     * Live block collection.
+     */
+    blocks: import("./types.js").IBlockManager;
+    /**
+     * Selection service.
+     */
+    selection: import("./types.js").ISelectionManager;
+    /**
+     * Internal event bus.
+     */
+    events: import("./types.js").IEventBus;
+    /**
+     * Fallback block type for insertions.
+     */
+    defaultBlockType: string;
+    /**
+     * Command boundary.
+     */
+    commands: import("./CommandDispatcher.js").CommandDispatcher;
+    /**
+     * Document validator and migrator.
+     */
+    documentSchema: import("./DocumentSchema.js").DocumentSchema;
+    /**
+     * Diagnostic reporter.
+     */
+    diagnostics: import("./Diagnostics.js").Diagnostics;
+    /**
+     * Document snapshot store.
+     */
+    snapshots: import("./DocumentSnapshotStore.js").DocumentSnapshotStore;
+    /**
+     * Public block API.
+     */
+    publicBlocks: import("./PublicEditorApi.js").EditorBlocksApi;
+    /**
+     * Public event subscriptions.
+     */
+    publicEvents: import("./PublicEditorApi.js").EditorEventSubscriptions;
+    /**
+     * Initial interaction mode.
+     */
+    readOnly: boolean;
+    /**
+     * Inline plugin registry.
+     */
+    inlinePluginRegistry?: import("./types.js").IInlinePluginRegistry;
+    /**
+     * Inline plugin runtime context.
+     */
+    inlinePluginCtx?: import("./types.js").InlinePluginContext;
+    /**
+     * Cross-block selection service.
+     */
+    crossBlockSelection?: import("./types.js").ICrossBlockSelection;
+};

package/dist/core/EditorFacade.js

@@ -0,0 +1,361 @@
+import { EditorEvent } from './editorEvents.js'
+import { hydrateInlinePlugins } from './hydrateInlinePlugins.js'
+import { insertInlinePluginAtCaret } from './inlinePluginInsert.js'
+
+/**
+ * @typedef {Object} EditorFacadeDeps
+ * @property {import('./types').IBlockManager} blocks Live block collection.
+ * @property {import('./types').ISelectionManager} selection Selection service.
+ * @property {import('./types').IEventBus} events Internal event bus.
+ * @property {string} defaultBlockType Fallback block type for insertions.
+ * @property {import('./CommandDispatcher').CommandDispatcher} commands Command boundary.
+ * @property {import('./DocumentSchema').DocumentSchema} documentSchema Document validator and migrator.
+ * @property {import('./Diagnostics').Diagnostics} diagnostics Diagnostic reporter.
+ * @property {import('./DocumentSnapshotStore').DocumentSnapshotStore} snapshots Document snapshot store.
+ * @property {import('./PublicEditorApi').EditorBlocksApi} publicBlocks Public block API.
+ * @property {import('./PublicEditorApi').EditorEventSubscriptions} publicEvents Public event subscriptions.
+ * @property {boolean} readOnly Initial interaction mode.
+ * @property {import('./types').IInlinePluginRegistry} [inlinePluginRegistry] Inline plugin registry.
+ * @property {import('./types').InlinePluginContext} [inlinePluginCtx] Inline plugin runtime context.
+ * @property {import('./types').ICrossBlockSelection} [crossBlockSelection] Cross-block selection service.
+ */
+
+export class EditorFacade {
+  /** @type {HTMLElement} */
+  #rootEl
+
+  /** @type {import('./types').IBlockManager} */
+  #blocks
+
+  /** @type {import('./PublicEditorApi').EditorBlocksApi} */
+  #publicBlocks
+
+  /** @type {import('./types').ISelectionManager} */
+  #selection
+
+  /** @type {import('./types').IEventBus} */
+  #events
+
+  /** @type {import('./PublicEditorApi').EditorEventSubscriptions} */
+  #publicEvents
+
+  /** @type {import('./DocumentSnapshotStore').DocumentSnapshotStore} */
+  #snapshots
+
+  /** @type {import('./DocumentSchema').DocumentSchema} */
+  #documentSchema
+
+  /** @type {import('./CommandDispatcher').CommandDispatcher} */
+  #commands
+
+  /** @type {import('./Diagnostics').Diagnostics} */
+  #diagnostics
+
+  /** @type {boolean} */
+  #ready = false
+
+  /** @type {string} */
+  #defaultBlockType
+
+  /** @type {Array<{ destroy(): void }>} */
+  #destroyables = []
+
+  /** @type {import('./types').IInlinePluginRegistry | null} */
+  #inlinePluginRegistry
+
+  /** @type {import('./types').InlinePluginContext | null} */
+  #inlinePluginCtx
+
+  /** @type {import('./types').ICrossBlockSelection | null} */
+  #crossBlockSelection
+
+  /** @type {import('./UndoManager').UndoManager | null} */
+  #history = null
+
+  /** @type {boolean} */
+  #readOnly
+
+  /** @type {((readOnly: boolean) => void) | null} */
+  #readOnlyTransition = null
+
+  /**
+   * @param {HTMLElement} rootEl
+   * @param {EditorFacadeDeps} deps
+   */
+  constructor(rootEl, deps) {
+    const {
+      blocks,
+      selection,
+      events,
+      defaultBlockType,
+      commands,
+      documentSchema,
+      diagnostics,
+      snapshots,
+      publicBlocks,
+      publicEvents,
+      readOnly,
+      inlinePluginRegistry,
+      inlinePluginCtx,
+      crossBlockSelection,
+    } = deps
+    this.#rootEl = rootEl
+    this.#blocks = blocks
+    this.#selection = selection
+    this.#events = events
+    this.#commands = commands
+    this.#documentSchema = documentSchema
+    this.#diagnostics = diagnostics
+    this.#snapshots = snapshots
+    this.#publicBlocks = publicBlocks
+    this.#publicEvents = publicEvents
+    this.#defaultBlockType = defaultBlockType
+    this.#inlinePluginRegistry = inlinePluginRegistry ?? null
+    this.#inlinePluginCtx = inlinePluginCtx ?? null
+    this.#crossBlockSelection = crossBlockSelection ?? null
+    this.#readOnly = readOnly
+  }
+
+  /**
+   * Register a module for cleanup on destroy.
+   * @param {{ destroy(): void }} module
+   */
+  registerDestroyable(module) {
+    this.#destroyables.push(module)
+  }
+
+  /** @param {import('./UndoManager').UndoManager} history */
+  configureHistory(history) {
+    this.#history = history
+  }
+
+  /** @param {(readOnly: boolean) => void} transition */
+  configureReadOnlyTransition(transition) {
+    this.#readOnlyTransition = transition
+  }
+
+  /**
+   * Mark the editor as ready.
+   */
+  markReady() {
+    this.#ready = true
+  }
+
+  get isReady() {
+    return this.#ready
+  }
+
+  get blocks() {
+    return this.#publicBlocks
+  }
+
+  get events() {
+    return this.#publicEvents
+  }
+
+  get rootElement() {
+    return this.#rootEl
+  }
+
+  get readOnly() {
+    return this.#readOnly
+  }
+
+  get canUndo() {
+    return !this.#readOnly && Boolean(this.#history?.canUndo)
+  }
+
+  get canRedo() {
+    return !this.#readOnly && Boolean(this.#history?.canRedo)
+  }
+
+  undo() {
+    if (this.#readOnly) return false
+    return this.#history?.undo() ?? false
+  }
+
+  redo() {
+    if (this.#readOnly) return false
+    return this.#history?.redo() ?? false
+  }
+
+  /** @param {boolean} readOnly */
+  setReadOnly(readOnly) {
+    if (typeof readOnly !== 'boolean') throw new TypeError('setReadOnly() requires a boolean')
+    if (readOnly === this.#readOnly) return
+    if (!this.#readOnlyTransition) throw new Error('Editor read-only transition is not configured')
+    this.#readOnlyTransition(readOnly)
+    this.#readOnly = readOnly
+    this.#events.emit(EditorEvent.READ_ONLY_CHANGED, { readOnly })
+    this.#events.emit(EditorEvent.HISTORY_CHANGED, {
+      canUndo: this.canUndo,
+      canRedo: this.canRedo,
+    })
+  }
+
+  /**
+   * Save editor content.
+   *
+   * Each block's raw `data` is post-processed through the plugin's
+   * `mapTextFields` hook to tokenize any committed inline-widget spans
+   * (e.g. mentions). Widget data is lifted into the block-level `inline`
+   * map keyed by each widget's stable instance id — `data` ends up
+   * carrying only `{{<id>}}` text placeholders, polymorphically
+   * reconstructible on load.
+   *
+   * @returns {import('./types').EditorDocument}
+   */
+  save() {
+    return this.#snapshots.save()
+  }
+
+  /**
+   * Render data into the editor, replacing existing content.
+   * @param {import('./types').EditorDocument} data
+   * @param {{ blockId: string, offset: number }} [caret] - optional caret position to restore
+   * @param {{ focus?: boolean, notifyChange?: boolean }} [options]
+   */
+  render(data, caret, options = {}) {
+    const startedAt = this.#diagnostics.enabled ? this.#diagnostics.now() : 0
+    const normalized = this.#documentSchema.normalize(data)
+    const replacement = this.#blocks.prepareReplacement(
+      normalized.blocks,
+      this.#defaultBlockType,
+      'EditorFacade',
+    )
+
+    try {
+      if (this.#inlinePluginRegistry && this.#inlinePluginCtx && this.#inlinePluginRegistry.size > 0) {
+        for (const block of replacement.blocks) {
+          hydrateInlinePlugins(block.contentElement, this.#inlinePluginRegistry, this.#inlinePluginCtx)
+        }
+      }
+    } catch (error) {
+      replacement.dispose()
+      throw error
+    }
+
+    this.#events.emit(EditorEvent.UNDO_BATCH_START)
+    try {
+      // Clear transient selection state before replacing content.
+      // Without this, InlineToolbar refuses to hide (checks crossBlockSelection.range)
+      // and CSS highlights remain painted on detached DOM nodes.
+      if (this.#crossBlockSelection) this.#crossBlockSelection.deactivate(this.#rootEl)
+      this.#blocks.clearSelection()
+
+      replacement.commit({ notifyChange: options.notifyChange })
+      this.#snapshots.setDocumentVersion(normalized.version)
+
+      // Restore caret position
+      if (caret) {
+        const targetBlock = this.#blocks.getBlockById(caret.blockId)
+        if (targetBlock) {
+          const idx = this.#blocks.getBlockIndex(caret.blockId)
+          if (idx >= 0) this.#blocks.setCurrentIndex(idx)
+          targetBlock.focus()
+          this.#selection.setCaretToOffset(caret.blockId, caret.offset)
+          return
+        }
+      }
+
+      // Mode transitions rebuild plugin DOM without stealing browser focus.
+      this.#blocks.setCurrentIndex(0)
+      if (options.focus === false) return
+
+      // Fallback: focus first block
+      const first = this.#blocks.getBlockByIndex(0)
+      if (first) {
+        first.focus()
+        this.#selection.setCaretToBlock(first.id, 'end')
+      }
+    } finally {
+      this.#events.emit(EditorEvent.UNDO_BATCH_END)
+      if (startedAt) {
+        const durationMs = this.#diagnostics.now() - startedAt
+        if (durationMs >= this.#diagnostics.threshold('renderMs')) {
+          this.#diagnostics.emit('render.slow', { durationMs })
+        }
+      }
+    }
+  }
+
+  /**
+   * Clear all blocks and insert an empty default block.
+   */
+  clear() {
+    const replacement = this.#blocks.prepareReplacement(undefined, this.#defaultBlockType, 'EditorFacade.clear')
+    this.#events.emit(EditorEvent.UNDO_BATCH_START)
+    try {
+      replacement.commit()
+      this.#blocks.setCurrentIndex(0)
+    } finally {
+      this.#events.emit(EditorEvent.UNDO_BATCH_END)
+    }
+  }
+
+  /**
+   * Focus the editor (first block or current block).
+   */
+  focus() {
+    const block = this.#blocks.getCurrentBlock() || this.#blocks.getBlockByIndex(0)
+    if (block) {
+      block.focus()
+    }
+  }
+
+  /**
+   * Insert an inline plugin widget at the current caret position.
+   * @param {string} type
+   * @param {Record<string, string>} [data]
+   * @returns {boolean} whether editor DOM was changed
+   */
+  insertInlinePlugin(type, data = {}) {
+    if (this.#readOnly || !this.#inlinePluginRegistry || !this.#inlinePluginCtx) return false
+
+    const selection = window.getSelection()
+    const range = selection?.rangeCount ? selection.getRangeAt(0) : null
+    if (!range || !this.#rootEl.contains(range.commonAncestorContainer)) return false
+    const block = this.#blocks.getBlockByChildNode(range.commonAncestorContainer)
+    if (
+      !block
+      || typeof block.plugin.mapTextFields !== 'function'
+      || !this.#inlinePluginRegistry.get(type)
+    ) return false
+
+    return this.#commands.runForBlock(block, () => insertInlinePluginAtCaret(
+      this.#inlinePluginRegistry,
+      this.#inlinePluginCtx,
+      type,
+      data,
+      this.#rootEl,
+    ))
+  }
+
+  /**
+   * Destroy the editor and clean up all modules.
+   */
+  destroy() {
+    // Blocks own plugin-created DOM, listeners and external instances. Release
+    // them while plugin registries, shared styles and editor services are still
+    // alive; shared ownership is released by the destroyables below.
+    this.#blocks.clear()
+
+    for (let i = this.#destroyables.length - 1; i >= 0; i--) {
+      try {
+        this.#destroyables[i]?.destroy()
+      } catch (err) {
+        this.#diagnostics.emit('cleanup.failed', {
+          operation: this.#destroyables[i]?.constructor?.name || 'destroyable',
+          errorName: this.#diagnostics.errorName(err),
+        })
+        console.warn('[EditorFacade] Error destroying module:', err)
+      }
+    }
+    this.#destroyables = []
+    this.#events.emit(EditorEvent.DESTROYED)
+    this.#events.clear()
+
+    this.#rootEl.remove()
+    this.#ready = false
+  }
+}

package/dist/core/EditorHolderOwnership.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Claim an editor holder until the returned lease is destroyed.
+ *
+ * The WeakMap does not keep detached holders alive, while the private token
+ * prevents an old lease from releasing a newer editor accidentally.
+ *
+ * @param {HTMLElement} holder
+ * @returns {{ destroy(): void }}
+ */
+export function claimEditorHolder(holder: HTMLElement): {
+    destroy(): void;
+};

package/dist/core/EditorHolderOwnership.js

@@ -0,0 +1,28 @@
+const activeHolders = new WeakMap()
+
+/**
+ * Claim an editor holder until the returned lease is destroyed.
+ *
+ * The WeakMap does not keep detached holders alive, while the private token
+ * prevents an old lease from releasing a newer editor accidentally.
+ *
+ * @param {HTMLElement} holder
+ * @returns {{ destroy(): void }}
+ */
+export function claimEditorHolder(holder) {
+  if (activeHolders.has(holder)) {
+    throw new Error('The editor holder already owns a live editor instance')
+  }
+
+  const token = Object.freeze({})
+  activeHolders.set(holder, token)
+  let released = false
+
+  return {
+    destroy() {
+      if (released) return
+      released = true
+      if (activeHolders.get(holder) === token) activeHolders.delete(holder)
+    },
+  }
+}

package/dist/core/I18n.d.ts

@@ -0,0 +1,147 @@
+/**
+ * Translation dictionary with:
+ *  - fallback chain (primary → fallback language → key)
+ *  - explicit `has()` for missing-key detection
+ *  - plural rules per language (CLDR categories)
+ *  - scoped sub-instances for plugin namespacing
+ *  - immutable freeze after init
+ *  - dev-mode warnings on missing keys
+ *
+ * Architecturally: ONE instance per editor, shared by core and all plugins.
+ * Plugins receive a `ScopedI18n` wrapper that auto-prefixes keys with their
+ * type (e.g. `plugin.heading.*`), so plugin code uses short local keys
+ * without worrying about cross-plugin collisions.
+ */
+export class I18n {
+    /**
+     * @param {Partial<I18nMessages>} [messages]   primary locale (e.g. ru)
+     * @param {Partial<I18nMessages>} [fallback]   fallback locale (e.g. en) used when a key is missing in primary
+     * @param {string} [lang]                       language code for plural rules ('en', 'ru', ...)
+     */
+    constructor(messages?: Partial<I18nMessages>, fallback?: Partial<I18nMessages>, lang?: string);
+    /**
+     * Merge additional messages into the primary dictionary.
+     * Plugins call this to register their own keys at runtime.
+     * Throws after `freeze()`.
+     *
+     * @param {Partial<I18nMessages>} messages
+     */
+    merge(messages: Partial<I18nMessages>): void;
+    /**
+     * Merge additional messages into the fallback dictionary.
+     * Used so plugin English locales become the fallback for other languages.
+     * Throws after `freeze()`.
+     *
+     * @param {Partial<I18nMessages>} messages
+     */
+    mergeFallback(messages: Partial<I18nMessages>): void;
+    /**
+     * Lock the dictionary against further mutation. Called by `createEditor`
+     * after all plugins have registered. Subsequent `merge()` calls throw,
+     * and the underlying objects are deep-frozen.
+     */
+    freeze(): void;
+    /**
+     * @returns {boolean} true if the i18n dictionary has been frozen
+     */
+    get isFrozen(): boolean;
+    /**
+     * Check whether a key resolves to anything (primary or fallback).
+     * Use this to distinguish "missing" from "intentionally returns the key".
+     *
+     * @param {MessageKey | (string & {})} key
+     * @returns {boolean}
+     */
+    has(key: MessageKey | (string & {})): boolean;
+    /**
+     * Resolve a translation key with optional `{name}` interpolation.
+     *
+     * Resolution order:
+     *  1. primary dictionary
+     *  2. fallback dictionary (if set)
+     *  3. `defaultValue` from options (if provided)
+     *  4. the key itself, verbatim
+     *
+     * For string values, returns the interpolated message.
+     * For plural-form values (object with `one`/`few`/`many`/`other`), returns the
+     * `other` form interpolated — callers wanting count-aware selection should use `plural()`.
+     *
+     * @param {MessageKey | (string & {})} key
+     * @param {Record<string, string | number>} [params] interpolation params
+     * @returns {string}
+     */
+    t(key: MessageKey | (string & {}), params?: Record<string, string | number>): string;
+    /**
+     * Resolve a key as a pluralized message.
+     *
+     * The locale value should be a `PluralForms` object (`{ one, few, many, other }`).
+     * If it's a plain string, it's interpolated with `{count}` like a regular message.
+     *
+     * The plural form is chosen by CLDR rules for the current language. `count` is
+     * automatically merged into `params` so messages can use `{count}`.
+     *
+     * @param {MessageKey | (string & {})} key
+     * @param {number} count
+     * @param {Record<string, string | number>} [params]
+     * @returns {string}
+     */
+    plural(key: MessageKey | (string & {}), count: number, params?: Record<string, string | number>): string;
+    /**
+     * Create a scoped wrapper that auto-prefixes every key with `prefix.`
+     * (e.g. `i18n.scope('plugin.heading')` makes `t('title')` resolve `plugin.heading.title`).
+     *
+     * Backward-compat: keys that already start with `prefix.` are passed through
+     * untouched, so legacy plugin code using full keys keeps working alongside
+     * new code using short keys.
+     *
+     * @param {string} prefix
+     * @returns {ScopedI18n}
+     */
+    scope(prefix: string): ScopedI18n;
+    #private;
+}
+/**
+ * Plugin-facing i18n wrapper. Auto-prefixes every key with the plugin's
+ * namespace, so plugin code can write `_t('title')` instead of
+ * `_t('plugin.heading.title')`.
+ *
+ * Backward-compat: if a caller passes a key that already starts with the
+ * prefix, it's left untouched. This lets old code coexist with new code
+ * during incremental migration.
+ */
+export class ScopedI18n {
+    /**
+     * @param {I18n} parent
+     * @param {string} prefix
+     */
+    constructor(parent: I18n, prefix: string);
+    /**
+     * @param {string} key
+     * @param {Record<string, string | number>} [params]
+     * @returns {string}
+     */
+    t(key: string, params?: Record<string, string | number>): string;
+    /**
+     * @param {string} key
+     * @returns {boolean}
+     */
+    has(key: string): boolean;
+    /**
+     * @param {string} key
+     * @param {number} count
+     * @param {Record<string, string | number>} [params]
+     * @returns {string}
+     */
+    plural(key: string, count: number, params?: Record<string, string | number>): string;
+    /**
+     * Create a sub-scope under the current prefix.
+     * @param {string} sub
+     * @returns {ScopedI18n}
+     */
+    scope(sub: string): ScopedI18n;
+    #private;
+}
+export type I18nMessages = import("./types.js").I18nMessages;
+export type MessageKey = import("./types.js").MessageKey;
+export type PluralForms = import("./types.js").PluralForms;
+export type LocaleValue = import("./types.js").LocaleValue;