@unicom-cloud/ui 0.8.109 → 0.8.111

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

@@ -0,0 +1,217 @@
+import type Block from '../blots/block.js';
+import type { BlockEmbed } from '../blots/block.js';
+import type Scroll from '../blots/scroll.js';
+import type { Op } from '../delta/index.js';
+import Delta from '../delta/index.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 * as Parchment from '../parchment/index.js';
+import Composition from './composition.js';
+import Editor from './editor.js';
+import type { EmitterSource } from './emitter.js';
+import Emitter from './emitter.js';
+import type { DebugLevel } from './logger.js';
+import Module from './module.js';
+import type { Bounds } from './selection.js';
+import Selection, { Range } from './selection.js';
+import type { ThemeConstructor } from './theme.js';
+import Theme from './theme.js';
+import type { Rect, ScrollRectIntoViewOptions } from './utils/scrollRectIntoView.js';
+declare const globalRegistry: Parchment.Registry;
+/**
+ * Options for initializing a Rich instance
+ */
+export interface RichOptions {
+    theme?: string;
+    debug?: DebugLevel | boolean;
+    registry?: Parchment.Registry;
+    /**
+     * Whether to disable the editing
+     * @default false
+     */
+    readOnly?: boolean;
+    /**
+     * Placeholder text to display when the editor is empty
+     * @default ""
+     */
+    placeholder?: string;
+    bounds?: HTMLElement | string | null;
+    modules?: Record<string, unknown>;
+    /**
+     * A list of formats that are recognized and can exist within the editor contents.
+     * `null` means all formats are allowed.
+     * @default null
+     */
+    formats?: string[] | null;
+}
+/**
+ * Similar to RichOptions, but with all properties expanded to their default values,
+ * and all selectors resolved to HTMLElements.
+ */
+export interface ExpandedRichOptions extends Omit<RichOptions, 'theme' | 'formats'> {
+    theme: ThemeConstructor;
+    registry: Parchment.Registry;
+    container: HTMLElement;
+    modules: Record<string, unknown>;
+    bounds?: HTMLElement | null;
+    readOnly: boolean;
+}
+declare class Rich {
+    static DEFAULTS: {
+        bounds: null;
+        modules: {
+            clipboard: boolean;
+            keyboard: boolean;
+            history: boolean;
+            uploader: boolean;
+        };
+        placeholder: string;
+        readOnly: false;
+        registry: Parchment.Registry;
+        theme: string;
+    };
+    static events: {
+        readonly EDITOR_CHANGE: "editor-change";
+        readonly SCROLL_BEFORE_UPDATE: "scroll-before-update";
+        readonly SCROLL_BLOT_MOUNT: "scroll-blot-mount";
+        readonly SCROLL_BLOT_UNMOUNT: "scroll-blot-unmount";
+        readonly SCROLL_OPTIMIZE: "scroll-optimize";
+        readonly SCROLL_UPDATE: "scroll-update";
+        readonly SCROLL_EMBED_UPDATE: "scroll-embed-update";
+        readonly SELECTION_CHANGE: "selection-change";
+        readonly TEXT_CHANGE: "text-change";
+        readonly COMPOSITION_BEFORE_START: "composition-before-start";
+        readonly COMPOSITION_START: "composition-start";
+        readonly COMPOSITION_BEFORE_END: "composition-before-end";
+        readonly COMPOSITION_END: "composition-end";
+    };
+    static sources: {
+        readonly API: "api";
+        readonly SILENT: "silent";
+        readonly USER: "user";
+    };
+    static imports: Record<string, unknown>;
+    static debug(limit: DebugLevel | boolean): void;
+    static find(node: Node, bubble?: boolean): Parchment.Blot | Rich | null;
+    static import(name: 'core/module'): typeof Module;
+    static import(name: `themes/${string}`): typeof Theme;
+    static import(name: '../parchment'): typeof Parchment;
+    static import(name: 'delta'): typeof Delta;
+    static import(name: string): unknown;
+    static register(targets: Record<string, Parchment.RegistryDefinition | Record<string, unknown> | Theme | Module | Function>, overwrite?: boolean): void;
+    static register(target: Parchment.RegistryDefinition, overwrite?: boolean): void;
+    static register(path: string, target: any, overwrite?: boolean): void;
+    container: HTMLElement;
+    root: HTMLDivElement;
+    scroll: Scroll;
+    emitter: Emitter;
+    protected allowReadOnlyEdits: boolean;
+    editor: Editor;
+    composition: Composition;
+    selection: Selection;
+    theme: Theme;
+    keyboard: Keyboard;
+    clipboard: Clipboard;
+    history: History;
+    uploader: Uploader;
+    options: ExpandedRichOptions;
+    constructor(container: HTMLElement | string, options?: RichOptions);
+    addContainer(container: string, refNode?: Node | null): HTMLDivElement;
+    addContainer(container: HTMLElement, refNode?: Node | null): HTMLElement;
+    blur(): void;
+    deleteText(range: Range, source?: EmitterSource): Delta;
+    deleteText(index: number, length: number, source?: EmitterSource): Delta;
+    disable(): void;
+    editReadOnly<T>(modifier: () => T): T;
+    enable(enabled?: boolean): void;
+    focus(options?: {
+        preventScroll?: boolean;
+    }): void;
+    format(name: string, value: unknown, source?: EmitterSource): Delta;
+    formatLine(index: number, length: number, formats: Record<string, unknown>, source?: EmitterSource): Delta;
+    formatLine(index: number, length: number, name: string, value?: unknown, source?: EmitterSource): Delta;
+    formatText(range: Range, name: string, value: unknown, source?: EmitterSource): Delta;
+    formatText(index: number, length: number, name: string, value: unknown, source?: EmitterSource): Delta;
+    formatText(index: number, length: number, formats: Record<string, unknown>, source?: EmitterSource): Delta;
+    getBounds(index: number | Range, length?: number): Bounds | null;
+    getContents(index?: number, length?: number): Delta;
+    getFormat(index?: number, length?: number): {
+        [format: string]: unknown;
+    };
+    getFormat(range?: Range): {
+        [format: string]: unknown;
+    };
+    getIndex(blot: Parchment.Blot): number;
+    getLength(): number;
+    getLeaf(index: number): [Parchment.LeafBlot | null, number];
+    getLine(index: number): [Block | BlockEmbed | null, number];
+    getLines(range: Range): (Block | BlockEmbed)[];
+    getLines(index?: number, length?: number): (Block | BlockEmbed)[];
+    getModule(name: string): unknown;
+    getSelection(focus: true): Range;
+    getSelection(focus?: boolean): Range | null;
+    getSemanticHTML(range: Range): string;
+    getSemanticHTML(index?: number, length?: number): string;
+    getText(range?: Range): string;
+    getText(index?: number, length?: number): string;
+    hasFocus(): boolean;
+    insertEmbed(index: number, embed: string, value: unknown, source?: EmitterSource): Delta;
+    insertText(index: number, text: string, source?: EmitterSource): Delta;
+    insertText(index: number, text: string, formats: Record<string, unknown>, source?: EmitterSource): Delta;
+    insertText(index: number, text: string, name: string, value: unknown, source?: EmitterSource): Delta;
+    isEnabled(): boolean;
+    off(...args: Parameters<(typeof Emitter)['prototype']['off']>): void;
+    on(event: (typeof Emitter)['events']['TEXT_CHANGE'], handler: (delta: Delta, oldContent: Delta, source: EmitterSource) => void): Emitter;
+    on(event: (typeof Emitter)['events']['SELECTION_CHANGE'], handler: (range: Range, oldRange: Range, source: EmitterSource) => void): Emitter;
+    on(event: (typeof Emitter)['events']['EDITOR_CHANGE'], handler: (...args: [
+        (typeof Emitter)['events']['TEXT_CHANGE'],
+        Delta,
+        Delta,
+        EmitterSource
+    ] | [
+        (typeof Emitter)['events']['SELECTION_CHANGE'],
+        Range,
+        Range,
+        EmitterSource
+    ]) => void): Emitter;
+    on(event: string, ...args: unknown[]): Emitter;
+    once(...args: Parameters<(typeof Emitter)['prototype']['once']>): void;
+    removeFormat(index: number, length: number, source?: EmitterSource): Delta;
+    scrollRectIntoView(rect: Rect, options?: ScrollRectIntoViewOptions): void;
+    /**
+     * @deprecated Use Rich#scrollSelectionIntoView() instead.
+     */
+    scrollIntoView(): void;
+    /**
+     * Scroll the current selection into the visible area.
+     * If the selection is already visible, no scrolling will occur.
+     */
+    scrollSelectionIntoView(options?: ScrollRectIntoViewOptions): void;
+    setContents(delta: Delta | Op[], source?: EmitterSource): Delta;
+    setSelection(range: Range | null, source?: EmitterSource): void;
+    setSelection(index: number, source?: EmitterSource): void;
+    setSelection(index: number, length?: number, source?: EmitterSource): void;
+    setSelection(index: number, source?: EmitterSource): void;
+    setText(text: string, source?: EmitterSource): Delta;
+    update(source?: EmitterSource): void;
+    updateContents(delta: Delta | Op[], source?: EmitterSource): Delta;
+}
+declare function expandConfig(containerOrSelector: HTMLElement | string, options: RichOptions): ExpandedRichOptions;
+type NormalizedIndexLength = [
+    number,
+    number,
+    Record<string, unknown>,
+    EmitterSource
+];
+declare function overload(index: number, source?: EmitterSource): NormalizedIndexLength;
+declare function overload(index: number, length: number, source?: EmitterSource): NormalizedIndexLength;
+declare function overload(index: number, length: number, format: string, value: unknown, source?: EmitterSource): NormalizedIndexLength;
+declare function overload(index: number, length: number, format: Record<string, unknown>, source?: EmitterSource): NormalizedIndexLength;
+declare function overload(range: Range, source?: EmitterSource): NormalizedIndexLength;
+declare function overload(range: Range, format: string, value: unknown, source?: EmitterSource): NormalizedIndexLength;
+declare function overload(range: Range, format: Record<string, unknown>, source?: EmitterSource): NormalizedIndexLength;
+export { Parchment, Range };
+export type { Bounds, DebugLevel, EmitterSource };
+export { Rich as default, expandConfig, globalRegistry, overload };

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

@@ -0,0 +1,74 @@
+import type Cursor from '../blots/cursor.js';
+import type Scroll from '../blots/scroll.js';
+import type { EmitterSource } from './emitter.js';
+import Emitter from './emitter.js';
+type NativeRange = AbstractRange;
+interface NormalizedRange {
+    start: {
+        node: NativeRange['startContainer'];
+        offset: NativeRange['startOffset'];
+    };
+    end: {
+        node: NativeRange['endContainer'];
+        offset: NativeRange['endOffset'];
+    };
+    native: NativeRange;
+}
+export interface Bounds {
+    bottom: number;
+    height: number;
+    left: number;
+    right: number;
+    top: number;
+    width: number;
+}
+export declare class Range {
+    index: number;
+    length: number;
+    constructor(index: number, length?: number);
+}
+declare class Selection {
+    scroll: Scroll;
+    emitter: Emitter;
+    composing: boolean;
+    mouseDown: boolean;
+    root: HTMLElement;
+    cursor: Cursor;
+    savedRange: Range;
+    lastRange: Range | null;
+    lastNative: NormalizedRange | null;
+    constructor(scroll: Scroll, emitter: Emitter);
+    handleComposition(): void;
+    handleDragging(): void;
+    focus(): void;
+    format(format: string, value: unknown): void;
+    getBounds(index: number, length?: number): DOMRect | {
+        bottom: number;
+        height: number;
+        left: number;
+        right: number;
+        top: number;
+        width: number;
+    } | null;
+    getNativeRange(): NormalizedRange | null;
+    getRange(): [Range, NormalizedRange] | [null, null];
+    hasFocus(): boolean;
+    normalizedToRange(range: NormalizedRange): Range;
+    normalizeNative(nativeRange: NativeRange): {
+        start: {
+            node: Node;
+            offset: number;
+        };
+        end: {
+            node: Node;
+            offset: number;
+        };
+        native: AbstractRange;
+    } | null;
+    rangeToNative(range: Range): [Node | null, number, Node | null, number];
+    setNativeRange(startNode: Node | null, startOffset?: number, endNode?: Node | null, endOffset?: number | undefined, force?: boolean): void;
+    setRange(range: Range | null, force: boolean, source?: EmitterSource): void;
+    setRange(range: Range | null, source?: EmitterSource): void;
+    update(source?: EmitterSource): void;
+}
+export default Selection;

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

@@ -0,0 +1,32 @@
+import type Rich from '../core.js';
+import type Clipboard from '../modules/clipboard.js';
+import type History from '../modules/history.js';
+import type Keyboard from '../modules/keyboard.js';
+import type { ToolbarProps } from '../modules/toolbar.js';
+import type Uploader from '../modules/uploader.js';
+export interface ThemeOptions {
+    modules: Record<string, unknown> & {
+        toolbar?: null | ToolbarProps;
+    };
+}
+declare class Theme {
+    protected rich: Rich;
+    protected options: ThemeOptions;
+    static DEFAULTS: ThemeOptions;
+    static themes: {
+        default: typeof Theme;
+    };
+    modules: ThemeOptions['modules'];
+    constructor(rich: Rich, options: ThemeOptions);
+    init(): void;
+    addModule(name: 'clipboard'): Clipboard;
+    addModule(name: 'keyboard'): Keyboard;
+    addModule(name: 'uploader'): Uploader;
+    addModule(name: 'history'): History;
+    addModule(name: string): unknown;
+}
+export interface ThemeConstructor {
+    new (rich: Rich, options: unknown): Theme;
+    DEFAULTS: ThemeOptions;
+}
+export default Theme;

package/types/pc/rich-text/core/utils/createRegistryWithFormats.d.ts

@@ -0,0 +1,5 @@
+import { Registry } from '../../parchment';
+declare const createRegistryWithFormats: (formats: string[], sourceRegistry: Registry, debug: {
+    error: (errorMessage: string) => void;
+}) => Registry;
+export default createRegistryWithFormats;

package/types/pc/rich-text/core/utils/scrollRectIntoView.d.ts

@@ -0,0 +1,11 @@
+export type Rect = {
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+};
+export interface ScrollRectIntoViewOptions {
+    smooth?: boolean;
+}
+declare const scrollRectIntoView: (root: HTMLElement, targetRect: Rect, options?: ScrollRectIntoViewOptions) => void;
+export default scrollRectIntoView;

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

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

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

@@ -0,0 +1,10 @@
+interface AttributeMap {
+    [key: string]: unknown;
+}
+declare namespace AttributeMap {
+    function compose(a?: AttributeMap, b?: AttributeMap, keepNull?: boolean): AttributeMap | undefined;
+    function diff(a?: AttributeMap, b?: AttributeMap): AttributeMap | undefined;
+    function invert(attr?: AttributeMap, base?: AttributeMap): AttributeMap;
+    function transform(a: AttributeMap | undefined, b: AttributeMap | undefined, priority?: boolean): AttributeMap | undefined;
+}
+export default AttributeMap;

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

@@ -0,0 +1,11 @@
+import AttributeMap from './AttributeMap';
+interface Op {
+    insert?: string | Record<string, unknown>;
+    delete?: number;
+    retain?: number | Record<string, unknown>;
+    attributes?: AttributeMap;
+}
+declare namespace Op {
+    function length(op: Op): number;
+}
+export default Op;

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

@@ -0,0 +1,13 @@
+import Op from './Op';
+export default class Iterator {
+    ops: Op[];
+    index: number;
+    offset: number;
+    constructor(ops: Op[]);
+    hasNext(): boolean;
+    next(length?: number): Op;
+    peek(): Op;
+    peekLength(): number;
+    peekType(): string;
+    rest(): Op[];
+}

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

@@ -0,0 +1,45 @@
+import diff from '@unicom-cloud/utils/diff';
+import AttributeMap from './AttributeMap';
+import Op from './Op';
+import OpIterator from './OpIterator';
+interface EmbedHandler<T> {
+    compose(a: T, b: T, keepNull: boolean): T;
+    invert(a: T, b: T): T;
+    transform(a: T, b: T, priority: boolean): T;
+}
+declare class Delta {
+    static Op: typeof Op;
+    static OpIterator: typeof OpIterator;
+    static AttributeMap: typeof AttributeMap;
+    private static handlers;
+    static registerEmbed<T>(embedType: string, handler: EmbedHandler<T>): void;
+    static unregisterEmbed(embedType: string): void;
+    private static getHandler;
+    ops: Op[];
+    constructor(ops?: Op[] | {
+        ops: Op[];
+    });
+    insert(arg: string | Record<string, unknown>, attributes?: AttributeMap | null): this;
+    delete(length: number): this;
+    retain(length: number | Record<string, unknown>, attributes?: AttributeMap | null): this;
+    push(newOp: Op): this;
+    chop(): this;
+    filter(predicate: (op: Op, index: number) => boolean): Op[];
+    forEach(predicate: (op: Op, index: number) => void): void;
+    map<T>(predicate: (op: Op, index: number) => T): T[];
+    partition(predicate: (op: Op) => boolean): [Op[], Op[]];
+    reduce<T>(predicate: (accum: T, curr: Op, index: number) => T, initialValue: T): T;
+    changeLength(): number;
+    length(): number;
+    slice(start?: number, end?: number): Delta;
+    compose(other: Delta): Delta;
+    concat(other: Delta): Delta;
+    diff(other: Delta, cursor?: number | diff.CursorInfo): Delta;
+    eachLine(predicate: (line: Delta, attributes: AttributeMap, index: number) => boolean | void, newline?: string): void;
+    invert(base: Delta): Delta;
+    transform(index: number, priority?: boolean): number;
+    transform(other: Delta, priority?: boolean): Delta;
+    transformPosition(index: number, priority?: boolean): number;
+}
+export default Delta;
+export { AttributeMap, Op, OpIterator };

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

@@ -0,0 +1,5 @@
+import { Attributor, ClassAttributor, StyleAttributor } from '../parchment';
+declare const AlignAttribute: Attributor;
+declare const AlignClass: ClassAttributor;
+declare const AlignStyle: StyleAttributor;
+export { AlignAttribute, AlignClass, AlignStyle };

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

@@ -0,0 +1,5 @@
+import { ClassAttributor } from '../parchment';
+import { ColorAttributor } from './color.js';
+declare const BackgroundClass: ClassAttributor;
+declare const BackgroundStyle: ColorAttributor;
+export { BackgroundClass, BackgroundStyle };

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

@@ -0,0 +1,6 @@
+import Block from '../blots/block.js';
+declare class Blockquote extends Block {
+    static blotName: string;
+    static tagName: string;
+}
+export default Blockquote;

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

@@ -0,0 +1,11 @@
+import Inline from '../blots/inline.js';
+declare class Bold extends Inline {
+    static blotName: string;
+    static tagName: string[];
+    static create(): HTMLElement;
+    static formats(): boolean;
+    optimize(context: {
+        [key: string]: any;
+    }): void;
+}
+export default Bold;

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

@@ -0,0 +1,15 @@
+import Block from '../blots/block.js';
+import Container from '../blots/container.js';
+import Inline from '../blots/inline.js';
+declare class CodeBlockContainer extends Container {
+    static create(value: string): Element;
+    code(index: number, length: number): string;
+    html(index: number, length: number): string;
+}
+declare class CodeBlock extends Block {
+    static TAB: string;
+    static register(): void;
+}
+declare class Code extends Inline {
+}
+export { Code, CodeBlockContainer, CodeBlock as default };

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

@@ -0,0 +1,7 @@
+import { ClassAttributor, StyleAttributor } from '../parchment';
+declare class ColorAttributor extends StyleAttributor {
+    value(domNode: HTMLElement): string;
+}
+declare const ColorClass: ClassAttributor;
+declare const ColorStyle: ColorAttributor;
+export { ColorAttributor, ColorClass, ColorStyle };

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

@@ -0,0 +1,5 @@
+import { Attributor, ClassAttributor, StyleAttributor } from '../parchment';
+declare const DirectionAttribute: Attributor;
+declare const DirectionClass: ClassAttributor;
+declare const DirectionStyle: StyleAttributor;
+export { DirectionAttribute, DirectionClass, DirectionStyle };

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

@@ -0,0 +1,7 @@
+import { ClassAttributor, StyleAttributor } from '../parchment';
+declare const FontClass: ClassAttributor;
+declare class FontStyleAttributor extends StyleAttributor {
+    value(node: HTMLElement): any;
+}
+declare const FontStyle: FontStyleAttributor;
+export { FontClass, FontStyle };

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

@@ -0,0 +1,10 @@
+import Embed from '../blots/embed.js';
+declare class Formula extends Embed {
+    static blotName: string;
+    static className: string;
+    static tagName: string;
+    static create(value: string): Element;
+    static value(domNode: Element): string | null;
+    html(): string;
+}
+export default Formula;

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

@@ -0,0 +1,7 @@
+import Block from '../blots/block.js';
+declare class Header extends Block {
+    static blotName: string;
+    static tagName: string[];
+    static formats(domNode: Element): number;
+}
+export default Header;

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

@@ -0,0 +1,13 @@
+import { EmbedBlot } from '../parchment';
+declare class Image extends EmbedBlot {
+    static blotName: string;
+    static tagName: string;
+    static create(value: string): Element;
+    static formats(domNode: Element): Record<string, string | null>;
+    static match(url: string): boolean;
+    static sanitize(url: string): string;
+    static value(domNode: Element): string | null;
+    domNode: HTMLImageElement;
+    format(name: string, value: string): void;
+}
+export default Image;

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

@@ -0,0 +1,8 @@
+import { ClassAttributor } from '../parchment';
+declare class IndentAttributor extends ClassAttributor {
+    add(node: HTMLElement, value: string | number): boolean;
+    canAdd(node: HTMLElement, value: string): boolean;
+    value(node: HTMLElement): number | undefined;
+}
+declare const IndentClass: IndentAttributor;
+export default IndentClass;

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

@@ -0,0 +1,6 @@
+import Bold from './bold.js';
+declare class Italic extends Bold {
+    static blotName: string;
+    static tagName: string[];
+}
+export default Italic;

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

@@ -0,0 +1,13 @@
+import Inline from '../blots/inline.js';
+declare class Link extends Inline {
+    static blotName: string;
+    static tagName: string;
+    static SANITIZED_URL: string;
+    static PROTOCOL_WHITELIST: string[];
+    static create(value: string): HTMLElement;
+    static formats(domNode: HTMLElement): string | null;
+    static sanitize(url: string): string;
+    format(name: string, value: unknown): void;
+}
+declare function sanitize(url: string, protocols: string[]): boolean;
+export { Link as default, sanitize };

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

@@ -0,0 +1,13 @@
+import Block from '../blots/block.js';
+import Container from '../blots/container.js';
+import type Scroll from '../blots/scroll.js';
+declare class ListContainer extends Container {
+}
+declare class ListItem extends Block {
+    static create(value: string): HTMLElement;
+    static formats(domNode: HTMLElement): string | undefined;
+    static register(): void;
+    constructor(scroll: Scroll, domNode: HTMLElement);
+    format(name: string, value: string): void;
+}
+export { ListItem as default, ListContainer };

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

@@ -0,0 +1,8 @@
+import Inline from '../blots/inline.js';
+declare class Script extends Inline {
+    static blotName: string;
+    static tagName: string[];
+    static create(value: 'super' | 'sub' | (string & {})): HTMLElement;
+    static formats(domNode: HTMLElement): "sub" | "super" | undefined;
+}
+export default Script;

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

@@ -0,0 +1,4 @@
+import { ClassAttributor, StyleAttributor } from '../parchment';
+declare const SizeClass: ClassAttributor;
+declare const SizeStyle: StyleAttributor;
+export { SizeClass, SizeStyle };

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

@@ -0,0 +1,6 @@
+import Bold from './bold.js';
+declare class Strike extends Bold {
+    static blotName: string;
+    static tagName: string[];
+}
+export default Strike;

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

@@ -0,0 +1,45 @@
+import Block from '../blots/block.js';
+import Container from '../blots/container.js';
+import type { LinkedList } from '../parchment';
+declare class TableCell extends Block {
+    static blotName: string;
+    static tagName: string;
+    static create(value: string): HTMLElement;
+    static formats(domNode: HTMLElement): string | null | undefined;
+    next: this | null;
+    cellOffset(): number;
+    format(name: string, value: string): void;
+    row(): TableRow;
+    rowOffset(): number;
+    table(): import("../parchment").Parent;
+}
+declare class TableRow extends Container {
+    static blotName: string;
+    static tagName: string;
+    children: LinkedList<TableCell>;
+    next: this | null;
+    checkMerge(): boolean;
+    optimize(context: {
+        [key: string]: any;
+    }): void;
+    rowOffset(): number;
+    table(): import("../parchment").Parent;
+}
+declare class TableBody extends Container {
+    static blotName: string;
+    static tagName: string;
+    children: LinkedList<TableRow>;
+}
+declare class TableContainer extends Container {
+    static blotName: string;
+    static tagName: string;
+    children: LinkedList<TableBody>;
+    balanceCells(): void;
+    cells(column: number): any[];
+    deleteColumn(index: number): void;
+    insertColumn(index: number): void;
+    insertRow(index: number): void;
+    rows(): any[];
+}
+declare function tableId(): string;
+export { TableBody, TableCell, TableContainer, tableId, TableRow };