@unicom-cloud/ui 0.8.108 → 0.8.110

package/types/pc/rich-text/modules/toolbar.d.ts

@@ -0,0 +1,24 @@
+import Module from '../core/module.js';
+import Rich from '../core/rich.js';
+import type { Range } from '../core/selection.js';
+type Handler = (this: Toolbar, value: any) => void;
+export type ToolbarConfig = Array<string[] | Array<string | Record<string, unknown>>>;
+export interface ToolbarProps {
+    container?: HTMLElement | ToolbarConfig | null;
+    handlers?: Record<string, Handler>;
+    option?: number;
+    module?: boolean;
+    theme?: boolean;
+}
+declare class Toolbar extends Module<ToolbarProps> {
+    static DEFAULTS: ToolbarProps;
+    container?: HTMLElement | null;
+    controls: [string, HTMLElement][];
+    handlers: Record<string, Handler>;
+    constructor(rich: Rich, options: Partial<ToolbarProps>);
+    addHandler(format: string, handler: Handler): void;
+    attach(input: HTMLElement): void;
+    update(range: Range | null): void;
+}
+declare function addControls(container: HTMLElement, groups: (string | Record<string, unknown>)[][] | (string | Record<string, unknown>)[]): void;
+export { addControls, Toolbar as default };

package/types/pc/rich-text/modules/uiNode.d.ts

@@ -0,0 +1,19 @@
+import Module from '../core/module.js';
+import Rich from '../core/rich.js';
+export declare const TTL_FOR_VALID_SELECTION_CHANGE = 100;
+declare class UINode extends Module {
+    isListening: boolean;
+    selectionChangeDeadline: number;
+    constructor(rich: Rich, options: Record<string, never>);
+    private handleArrowKeys;
+    private handleNavigationShortcuts;
+    /**
+     * We only listen to the `selectionchange` event when
+     * there is an intention of moving the caret to the beginning using shortcuts.
+     * This is primarily implemented to prevent infinite loops, as we are changing
+     * the selection within the handler of a `selectionchange` event.
+     */
+    private ensureListeningToSelectionChange;
+    private handleSelectionChange;
+}
+export default UINode;

package/types/pc/rich-text/modules/uploader.d.ts

@@ -0,0 +1,15 @@
+import Module from '../core/module.js';
+import type Rich from '../core/rich.js';
+import type { Range } from '../core/selection.js';
+interface UploaderOptions {
+    mimetypes: string[];
+    handler: (this: {
+        rich: Rich;
+    }, range: Range, files: File[]) => void;
+}
+declare class Uploader extends Module<UploaderOptions> {
+    static DEFAULTS: UploaderOptions;
+    constructor(rich: Rich, options: Partial<UploaderOptions>);
+    upload(range: Range, files: FileList | File[]): void;
+}
+export default Uploader;

package/types/pc/rich-text/parchment/attributor/attributor.d.ts

@@ -0,0 +1,17 @@
+import Scope from '../scope.js';
+export interface AttributorOptions {
+    scope?: Scope;
+    whitelist?: string[];
+}
+export default class Attributor {
+    readonly attrName: string;
+    readonly keyName: string;
+    static keys(node: HTMLElement): string[];
+    scope: Scope;
+    whitelist: string[] | undefined;
+    constructor(attrName: string, keyName: string, options?: AttributorOptions);
+    add(node: HTMLElement, value: any): boolean;
+    canAdd(_node: HTMLElement, value: any): boolean;
+    remove(node: HTMLElement): void;
+    value(node: HTMLElement): any;
+}

package/types/pc/rich-text/parchment/attributor/class.d.ts

@@ -0,0 +1,8 @@
+import Attributor from './attributor.js';
+declare class ClassAttributor extends Attributor {
+    static keys(node: HTMLElement): string[];
+    add(node: HTMLElement, value: any): boolean;
+    remove(node: HTMLElement): void;
+    value(node: HTMLElement): any;
+}
+export default ClassAttributor;

package/types/pc/rich-text/parchment/attributor/store.d.ts

@@ -0,0 +1,15 @@
+import type { Formattable } from '../blot/abstract/blot.js';
+import Attributor from './attributor.js';
+declare class AttributorStore {
+    private attributes;
+    private domNode;
+    constructor(domNode: HTMLElement);
+    attribute(attribute: Attributor, value: any): void;
+    build(): void;
+    copy(target: Formattable): void;
+    move(target: Formattable): void;
+    values(): {
+        [key: string]: any;
+    };
+}
+export default AttributorStore;

package/types/pc/rich-text/parchment/attributor/style.d.ts

@@ -0,0 +1,8 @@
+import Attributor from './attributor.js';
+declare class StyleAttributor extends Attributor {
+    static keys(node: HTMLElement): string[];
+    add(node: HTMLElement, value: any): boolean;
+    remove(node: HTMLElement): void;
+    value(node: HTMLElement): any;
+}
+export default StyleAttributor;

package/types/pc/rich-text/parchment/blot/abstract/blot.d.ts

@@ -0,0 +1,115 @@
+import type LinkedList from '../../collection/linked-list.js';
+import type LinkedNode from '../../collection/linked-node.js';
+import type { RegistryDefinition } from '../../registry.js';
+import Scope from '../../scope.js';
+export interface BlotConstructor {
+    new (...args: any[]): Blot;
+    /**
+     * Creates corresponding DOM node
+     */
+    create(value?: any): Node;
+    blotName: string;
+    tagName: string | string[];
+    scope: Scope;
+    className?: string;
+    requiredContainer?: BlotConstructor;
+    allowedChildren?: BlotConstructor[];
+    defaultChild?: BlotConstructor;
+}
+/**
+ * Blots are the basic building blocks of a Parchment document.
+ *
+ * Several basic implementations such as Block, Inline, and Embed are provided.
+ * In general you will want to extend one of these, instead of building from scratch.
+ * After implementation, blots need to be registered before usage.
+ *
+ * At the very minimum a Blot must be named with a static blotName and associated with either a tagName or className.
+ * If a Blot is defined with both a tag and class, the class takes precedence, but the tag may be used as a fallback.
+ * Blots must also have a scope, which determine if it is inline or block.
+ */
+export interface Blot extends LinkedNode {
+    scroll: Root;
+    parent: Parent;
+    prev: Blot | null;
+    next: Blot | null;
+    domNode: Node;
+    statics: BlotConstructor;
+    attach(): void;
+    clone(): Blot;
+    detach(): void;
+    isolate(index: number, length: number): Blot;
+    /**
+     * For leaves, length of blot's value()
+     * For parents, sum of children's values
+     */
+    length(): number;
+    /**
+     * Returns offset between this blot and an ancestor's
+     */
+    offset(root?: Blot): number;
+    remove(): void;
+    replaceWith(name: string, value: any): Blot;
+    replaceWith(replacement: Blot): Blot;
+    split(index: number, force?: boolean): Blot | null;
+    wrap(name: string, value?: any): Parent;
+    wrap(wrapper: Parent): Parent;
+    deleteAt(index: number, length: number): void;
+    formatAt(index: number, length: number, name: string, value: any): void;
+    insertAt(index: number, value: string, def?: any): void;
+    /**
+     * Called after update cycle completes. Cannot change the value or length
+     * of the document, and any DOM operation must reduce complexity of the DOM
+     * tree. A shared context object is passed through all blots.
+     */
+    optimize(context: {
+        [key: string]: any;
+    }): void;
+    optimize(mutations: MutationRecord[], context: {
+        [key: string]: any;
+    }): void;
+    /**
+     * Called when blot changes, with the mutation records of its change.
+     * Internal records of the blot values can be updated, and modifications of
+     * the blot itself is permitted. Can be trigger from user change or API call.
+     * A shared context object is passed through all blots.
+     */
+    update(mutations: MutationRecord[], context: {
+        [key: string]: any;
+    }): void;
+}
+export interface Parent extends Blot {
+    children: LinkedList<Blot>;
+    domNode: HTMLElement;
+    appendChild(child: Blot): void;
+    descendant<T>(type: new () => T, index: number): [T, number];
+    descendant<T>(matcher: (blot: Blot) => boolean, index: number): [T, number];
+    descendants<T>(type: new () => T, index: number, length: number): T[];
+    descendants<T>(matcher: (blot: Blot) => boolean, index: number, length: number): T[];
+    insertBefore(child: Blot, refNode?: Blot | null): void;
+    moveChildren(parent: Parent, refNode?: Blot | null): void;
+    path(index: number, inclusive?: boolean): [Blot, number][];
+    removeChild(child: Blot): void;
+    unwrap(): void;
+}
+export interface Root extends Parent {
+    create(input: Node | string | Scope, value?: any): Blot;
+    find(node: Node | null, bubble?: boolean): Blot | null;
+    query(query: string | Node | Scope, scope?: Scope): RegistryDefinition | null;
+}
+export interface Formattable extends Blot {
+    /**
+     * Apply format to blot. Should not pass onto child or other blot.
+     */
+    format(name: string, value: any): void;
+    /**
+     * Return formats represented by blot, including from Attributors.
+     */
+    formats(): {
+        [index: string]: any;
+    };
+}
+export interface Leaf extends Blot {
+    index(node: Node, offset: number): number;
+    position(index: number, inclusive: boolean): [Node, number];
+    value(): any;
+}

package/types/pc/rich-text/parchment/blot/abstract/container.d.ts

@@ -0,0 +1,18 @@
+import Scope from '../../scope.js';
+import BlockBlot from '../block.js';
+import ParentBlot from './parent.js';
+declare class ContainerBlot extends ParentBlot {
+    static blotName: string;
+    static scope: Scope;
+    static tagName: string | string[];
+    prev: BlockBlot | ContainerBlot | null;
+    next: BlockBlot | ContainerBlot | null;
+    checkMerge(): boolean;
+    deleteAt(index: number, length: number): void;
+    formatAt(index: number, length: number, name: string, value: any): void;
+    insertAt(index: number, value: string, def?: any): void;
+    optimize(context: {
+        [key: string]: any;
+    }): void;
+}
+export default ContainerBlot;

package/types/pc/rich-text/parchment/blot/abstract/leaf.d.ts

@@ -0,0 +1,29 @@
+import Scope from '../../scope.js';
+import type { Leaf } from './blot.js';
+import ShadowBlot from './shadow.js';
+declare class LeafBlot extends ShadowBlot implements Leaf {
+    static scope: Scope;
+    /**
+     * Returns the value represented by domNode if it is this Blot's type
+     * No checking that domNode can represent this Blot type is required so
+     * applications needing it should check externally before calling.
+     */
+    static value(_domNode: Node): any;
+    /**
+     * Given location represented by node and offset from DOM Selection Range,
+     * return index to that location.
+     */
+    index(node: Node, offset: number): number;
+    /**
+     * Given index to location within blot, return node and offset representing
+     * that location, consumable by DOM Selection Range
+     */
+    position(index: number, _inclusive?: boolean): [Node, number];
+    /**
+     * Return value represented by this blot
+     * Should not change without interaction from API or
+     * user change detectable by update()
+     */
+    value(): any;
+}
+export default LeafBlot;

package/types/pc/rich-text/parchment/blot/abstract/parent.d.ts

@@ -0,0 +1,50 @@
+import LinkedList from '../../collection/linked-list.js';
+import type { Blot, BlotConstructor, Parent, Root } from './blot.js';
+import ShadowBlot from './shadow.js';
+declare class ParentBlot extends ShadowBlot implements Parent {
+    /**
+     * Whitelist array of Blots that can be direct children.
+     */
+    static allowedChildren?: BlotConstructor[];
+    /**
+     * Default child blot to be inserted if this blot becomes empty.
+     */
+    static defaultChild?: BlotConstructor;
+    static uiClass: string;
+    children: LinkedList<Blot>;
+    domNode: HTMLElement;
+    uiNode: HTMLElement | null;
+    constructor(scroll: Root, domNode: Node);
+    appendChild(other: Blot): void;
+    attach(): void;
+    attachUI(node: HTMLElement): void;
+    /**
+     * Called during construction, should fill its own children LinkedList.
+     */
+    build(): void;
+    deleteAt(index: number, length: number): void;
+    descendant<T extends Blot>(criteria: new (...args: any[]) => T, index: number): [T | null, number];
+    descendant(criteria: (blot: Blot) => boolean, index: number): [Blot | null, number];
+    descendants<T extends Blot>(criteria: new (...args: any[]) => T, index?: number, length?: number): T[];
+    descendants(criteria: (blot: Blot) => boolean, index?: number, length?: number): Blot[];
+    detach(): void;
+    enforceAllowedChildren(): void;
+    formatAt(index: number, length: number, name: string, value: any): void;
+    insertAt(index: number, value: string, def?: any): void;
+    insertBefore(childBlot: Blot, refBlot?: Blot | null): void;
+    length(): number;
+    moveChildren(targetParent: Parent, refNode?: Blot | null): void;
+    optimize(context?: {
+        [key: string]: any;
+    }): void;
+    path(index: number, inclusive?: boolean): [Blot, number][];
+    removeChild(child: Blot): void;
+    replaceWith(name: string | Blot, value?: any): Blot;
+    split(index: number, force?: boolean): Blot | null;
+    splitAfter(child: Blot): Parent;
+    unwrap(): void;
+    update(mutations: MutationRecord[], _context: {
+        [key: string]: any;
+    }): void;
+}
+export default ParentBlot;

package/types/pc/rich-text/parchment/blot/abstract/shadow.d.ts

@@ -0,0 +1,37 @@
+import Scope from '../../scope.js';
+import type { Blot, BlotConstructor, Parent, Root } from './blot.js';
+declare class ShadowBlot implements Blot {
+    scroll: Root;
+    domNode: Node;
+    static blotName: string;
+    static className: string;
+    static requiredContainer: BlotConstructor;
+    static scope: Scope;
+    static tagName: string | string[];
+    static create(rawValue?: unknown): Node;
+    prev: Blot | null;
+    next: Blot | null;
+    parent: Parent;
+    get statics(): any;
+    constructor(scroll: Root, domNode: Node);
+    attach(): void;
+    clone(): Blot;
+    detach(): void;
+    deleteAt(index: number, length: number): void;
+    formatAt(index: number, length: number, name: string, value: any): void;
+    insertAt(index: number, value: string, def?: any): void;
+    isolate(index: number, length: number): Blot;
+    length(): number;
+    offset(root?: Blot): number;
+    optimize(_context?: {
+        [key: string]: any;
+    }): void;
+    remove(): void;
+    replaceWith(name: string | Blot, value?: any): Blot;
+    split(index: number, _force?: boolean): Blot | null;
+    update(_mutations: MutationRecord[], _context: {
+        [key: string]: any;
+    }): void;
+    wrap(name: string | Parent, value?: any): Parent;
+}
+export default ShadowBlot;

package/types/pc/rich-text/parchment/blot/block.d.ts

@@ -0,0 +1,25 @@
+import AttributorStore from '../attributor/store.js';
+import Scope from '../scope.js';
+import type { Blot, BlotConstructor, Formattable, Root } from './abstract/blot.js';
+import ParentBlot from './abstract/parent.js';
+declare class BlockBlot extends ParentBlot implements Formattable {
+    static blotName: string;
+    static scope: Scope;
+    static tagName: string | string[];
+    static allowedChildren: BlotConstructor[];
+    static create(value?: unknown): HTMLElement;
+    static formats(domNode: HTMLElement, scroll: Root): any;
+    protected attributes: AttributorStore;
+    constructor(scroll: Root, domNode: Node);
+    format(name: string, value: any): void;
+    formats(): {
+        [index: string]: any;
+    };
+    formatAt(index: number, length: number, name: string, value: any): void;
+    insertAt(index: number, value: string, def?: any): void;
+    replaceWith(name: string | Blot, value?: any): Blot;
+    update(mutations: MutationRecord[], context: {
+        [key: string]: any;
+    }): void;
+}
+export default BlockBlot;

package/types/pc/rich-text/parchment/blot/embed.d.ts

@@ -0,0 +1,11 @@
+import type { Formattable, Root } from './abstract/blot.js';
+import LeafBlot from './abstract/leaf.js';
+declare class EmbedBlot extends LeafBlot implements Formattable {
+    static formats(_domNode: HTMLElement, _scroll: Root): any;
+    format(name: string, value: any): void;
+    formatAt(index: number, length: number, name: string, value: any): void;
+    formats(): {
+        [index: string]: any;
+    };
+}
+export default EmbedBlot;

package/types/pc/rich-text/parchment/blot/inline.d.ts

@@ -0,0 +1,28 @@
+import AttributorStore from '../attributor/store.js';
+import Scope from '../scope.js';
+import type { Blot, BlotConstructor, Formattable, Parent, Root } from './abstract/blot.js';
+import ParentBlot from './abstract/parent.js';
+declare class InlineBlot extends ParentBlot implements Formattable {
+    static allowedChildren: BlotConstructor[];
+    static blotName: string;
+    static scope: Scope;
+    static tagName: string | string[];
+    static create(value?: unknown): HTMLElement;
+    static formats(domNode: HTMLElement, scroll: Root): any;
+    protected attributes: AttributorStore;
+    constructor(scroll: Root, domNode: Node);
+    format(name: string, value: any): void;
+    formats(): {
+        [index: string]: any;
+    };
+    formatAt(index: number, length: number, name: string, value: any): void;
+    optimize(context: {
+        [key: string]: any;
+    }): void;
+    replaceWith(name: string | Blot, value?: any): Blot;
+    update(mutations: MutationRecord[], context: {
+        [key: string]: any;
+    }): void;
+    wrap(name: string | Parent, value?: any): Parent;
+}
+export default InlineBlot;

package/types/pc/rich-text/parchment/blot/scroll.d.ts

@@ -0,0 +1,34 @@
+import Registry, { type RegistryDefinition } from '../registry.js';
+import Scope from '../scope.js';
+import type { Blot, BlotConstructor, Root } from './abstract/blot.js';
+import ParentBlot from './abstract/parent.js';
+import BlockBlot from './block.js';
+declare class ScrollBlot extends ParentBlot implements Root {
+    registry: Registry;
+    static blotName: string;
+    static defaultChild: typeof BlockBlot;
+    static allowedChildren: BlotConstructor[];
+    static scope: Scope;
+    static tagName: string;
+    observer: MutationObserver;
+    constructor(registry: Registry, node: HTMLDivElement);
+    create(input: Node | string | Scope, value?: any): Blot;
+    find(node: Node | null, bubble?: boolean): Blot | null;
+    query(query: string | Node | Scope, scope?: Scope): RegistryDefinition | null;
+    register(...definitions: RegistryDefinition[]): RegistryDefinition[];
+    build(): void;
+    detach(): void;
+    deleteAt(index: number, length: number): void;
+    formatAt(index: number, length: number, name: string, value: any): void;
+    insertAt(index: number, value: string, def?: any): void;
+    optimize(context?: {
+        [key: string]: any;
+    }): void;
+    optimize(mutations: MutationRecord[], context: {
+        [key: string]: any;
+    }): void;
+    update(mutations?: MutationRecord[], context?: {
+        [key: string]: any;
+    }): void;
+}
+export default ScrollBlot;

package/types/pc/rich-text/parchment/blot/text.d.ts

@@ -0,0 +1,26 @@
+import Scope from '../scope.js';
+import type { Blot, Leaf, Root } from './abstract/blot.js';
+import LeafBlot from './abstract/leaf.js';
+declare class TextBlot extends LeafBlot implements Leaf {
+    static readonly blotName = "text";
+    static scope: Scope;
+    static create(value: string): Text;
+    static value(domNode: Text): string;
+    domNode: Text;
+    protected text: string;
+    constructor(scroll: Root, node: Node);
+    deleteAt(index: number, length: number): void;
+    index(node: Node, offset: number): number;
+    insertAt(index: number, value: string, def?: any): void;
+    length(): number;
+    optimize(context: {
+        [key: string]: any;
+    }): void;
+    position(index: number, _inclusive?: boolean): [Node, number];
+    split(index: number, force?: boolean): Blot | null;
+    update(mutations: MutationRecord[], _context: {
+        [key: string]: any;
+    }): void;
+    value(): string;
+}
+export default TextBlot;

package/types/pc/rich-text/parchment/collection/linked-list.d.ts

@@ -0,0 +1,21 @@
+import type LinkedNode from './linked-node.js';
+declare class LinkedList<T extends LinkedNode> {
+    head: T | null;
+    tail: T | null;
+    length: number;
+    constructor();
+    append(...nodes: T[]): void;
+    at(index: number): T | null;
+    contains(node: T): boolean;
+    indexOf(node: T): number;
+    insertBefore(node: T | null, refNode: T | null): void;
+    offset(target: T): number;
+    remove(node: T): void;
+    iterator(curNode?: T | null): () => T | null;
+    find(index: number, inclusive?: boolean): [T | null, number];
+    forEach(callback: (cur: T) => void): void;
+    forEachAt(index: number, length: number, callback: (cur: T, offset: number, length: number) => void): void;
+    map(callback: (cur: T) => any): any[];
+    reduce<M>(callback: (memo: M, cur: T) => M, memo: M): M;
+}
+export default LinkedList;

package/types/pc/rich-text/parchment/collection/linked-node.d.ts

@@ -0,0 +1,6 @@
+interface LinkedNode {
+    prev: LinkedNode | null;
+    next: LinkedNode | null;
+    length(): number;
+}
+export type { LinkedNode as default };

package/types/pc/rich-text/parchment/error.d.ts

@@ -0,0 +1,6 @@
+export default class ParchmentError extends Error {
+    message: string;
+    name: string;
+    stack: string;
+    constructor(message: string);
+}

package/types/pc/rich-text/parchment/index.d.ts

@@ -0,0 +1,21 @@
+import ContainerBlot from './blot/abstract/container.js';
+import LeafBlot from './blot/abstract/leaf.js';
+import ParentBlot from './blot/abstract/parent.js';
+import BlockBlot from './blot/block.js';
+import EmbedBlot from './blot/embed.js';
+import InlineBlot from './blot/inline.js';
+import ScrollBlot from './blot/scroll.js';
+import TextBlot from './blot/text.js';
+import Attributor from './attributor/attributor.js';
+import ClassAttributor from './attributor/class.js';
+import AttributorStore from './attributor/store.js';
+import StyleAttributor from './attributor/style.js';
+import Registry from './registry.js';
+import Scope from './scope.js';
+export { Attributor, AttributorStore, BlockBlot, ClassAttributor, ContainerBlot, EmbedBlot, InlineBlot, LeafBlot, ParentBlot, Registry, Scope, ScrollBlot, StyleAttributor, TextBlot, };
+export type { AttributorOptions } from './attributor/attributor.js';
+export type { Blot, BlotConstructor, Formattable, Leaf, Parent, Root, } from './blot/abstract/blot.js';
+export type { default as ShadowBlot } from './blot/abstract/shadow.js';
+export type { default as LinkedList } from './collection/linked-list.js';
+export type { default as LinkedNode } from './collection/linked-node.js';
+export type { RegistryDefinition, RegistryInterface } from './registry.js';

package/types/pc/rich-text/parchment/registry.d.ts

@@ -0,0 +1,21 @@
+import Attributor from './attributor/attributor.js';
+import { type Blot, type BlotConstructor, type Root } from './blot/abstract/blot.js';
+import Scope from './scope.js';
+export type RegistryDefinition = Attributor | BlotConstructor;
+export interface RegistryInterface {
+    create(scroll: Root, input: Node | string | Scope, value?: any): Blot;
+    query(query: string | Node | Scope, scope: Scope): RegistryDefinition | null;
+    register(...definitions: any[]): any;
+}
+export default class Registry implements RegistryInterface {
+    static blots: WeakMap<Node, Blot>;
+    static find(node?: Node | null, bubble?: boolean): Blot | null;
+    private attributes;
+    private classes;
+    private tags;
+    private types;
+    create(scroll: Root, input: Node | string | Scope, value?: any): Blot;
+    find(node: Node | null, bubble?: boolean): Blot | null;
+    query(query: string | Node | Scope, scope?: Scope): RegistryDefinition | null;
+    register(...definitions: RegistryDefinition[]): RegistryDefinition[];
+}

package/types/pc/rich-text/parchment/scope.d.ts

@@ -0,0 +1,14 @@
+declare enum Scope {
+    TYPE = 3,// 0011 Lower two bits
+    LEVEL = 12,// 1100 Higher two bits
+    ATTRIBUTE = 13,// 1101
+    BLOT = 14,// 1110
+    INLINE = 7,// 0111
+    BLOCK = 11,// 1011
+    BLOCK_BLOT = 10,// 1010
+    INLINE_BLOT = 6,// 0110
+    BLOCK_ATTRIBUTE = 9,// 1001
+    INLINE_ATTRIBUTE = 5,// 0101
+    ANY = 15
+}
+export default Scope;

package/types/pc/rich-text/rich.d.ts

@@ -0,0 +1,5 @@
+import type { Bounds, DebugLevel, EmitterSource, ExpandedRichOptions, RichOptions } from './core.js';
+import Rich from './core.js';
+export { AttributeMap, Delta, Module, Op, OpIterator, Parchment, Range, } from './core.js';
+export type { Bounds, DebugLevel, EmitterSource, ExpandedRichOptions, RichOptions, };
+export default Rich;

package/types/pc/rich-text/themes/base.d.ts

@@ -0,0 +1,35 @@
+import type Rich from '../core/rich.js';
+import type Selection from '../core/selection.js';
+import type { Range } from '../core/selection.js';
+import type { ThemeOptions } from '../core/theme.js';
+import Theme from '../core/theme.js';
+import type Clipboard from '../modules/clipboard.js';
+import type History from '../modules/history.js';
+import type Keyboard from '../modules/keyboard.js';
+import type Uploader from '../modules/uploader.js';
+import Picker from '../ui/picker.js';
+import Tooltip from '../ui/tooltip.js';
+declare class BaseTheme extends Theme {
+    pickers: Picker[];
+    tooltip?: Tooltip;
+    constructor(rich: Rich, options: ThemeOptions);
+    addModule(name: 'clipboard'): Clipboard;
+    addModule(name: 'keyboard'): Keyboard;
+    addModule(name: 'uploader'): Uploader;
+    addModule(name: 'history'): History;
+    addModule(name: 'selection'): Selection;
+    addModule(name: string): unknown;
+    buildButtons(buttons: NodeListOf<HTMLElement>, icons: Record<string, Record<string, string> | string>): void;
+    buildPickers(selects: NodeListOf<HTMLSelectElement>, icons: Record<string, string | Record<string, string>>): void;
+}
+declare class BaseTooltip extends Tooltip {
+    textbox: HTMLInputElement | null;
+    linkRange?: Range;
+    constructor(rich: Rich, boundsContainer?: HTMLElement);
+    listen(): void;
+    cancel(): void;
+    edit(mode?: string, preview?: string | null): void;
+    restoreFocus(): void;
+    save(): void;
+}
+export { BaseTooltip, BaseTheme as default };

package/types/pc/rich-text/themes/bubble.d.ts

@@ -0,0 +1,18 @@
+import Rich from '../core/rich.js';
+import type { Bounds } from '../core/selection.js';
+import type { ThemeOptions } from '../core/theme.js';
+import type Toolbar from '../modules/toolbar.js';
+import BaseTheme, { BaseTooltip } from './base.js';
+declare class BubbleTooltip extends BaseTooltip {
+    static TEMPLATE: string;
+    constructor(rich: Rich, bounds?: HTMLElement);
+    listen(): void;
+    cancel(): void;
+    position(reference: Bounds): number;
+}
+declare class BubbleTheme extends BaseTheme {
+    tooltip: BubbleTooltip;
+    constructor(rich: Rich, options: ThemeOptions);
+    extendToolbar(toolbar: Toolbar): void;
+}
+export { BubbleTooltip, BubbleTheme as default };