@unicom-cloud/ui 0.8.111 → 0.8.113

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

@@ -1,6 +1,6 @@
 import { CSSProperties } from 'react';
-import type { EmitterSource } from './core/emitter';
-import Delta from './delta';
+import type { EmitterSource } from './lib/core';
+import type Delta from './lib/delta';
 /**
  * @title RichText
  */
@@ -10,6 +10,7 @@ export interface RichTextProps {
     readOnly?: boolean;
     defaultValue?: object | string;
     value?: object | string;
+    options?: object;
     onChange?: (value: Delta, delta: Delta, preValue: Delta, source: EmitterSource) => void;
     onTextChange?: (delta: Delta, preValue: Delta, source: EmitterSource) => void;
     onSelectionChange?: (...args: any[]) => void;

package/types/pc/rich-text/{blots → lib/blots}/scroll.d.ts

@@ -31,16 +31,10 @@ declare class Scroll extends ScrollBlot {
     leaf(index: number): [LeafBlot | null, number];
     line(index: number): [Block | BlockEmbed | null, number];
     lines(index?: number, length?: number): (Block | BlockEmbed)[];
-    optimize(context?: {
-        [key: string]: any;
-    }): void;
-    optimize(mutations?: MutationRecord[], context?: {
-        [key: string]: any;
-    }): void;
+    optimize(mutations?: never[], context?: {}): void;
     path(index: number): [Blot, number][];
     remove(): void;
-    update(source?: EmitterSource): void;
-    update(mutations?: MutationRecord[]): void;
+    update(mutations?: MutationRecord[] | EmitterSource): void;
     updateEmbedAt(index: number, key: string, change: unknown): void;
     protected handleDragStart(event: DragEvent): void;
     private deltaToRenderBlocks;

package/types/pc/rich-text/{core → lib/core}/editor.d.ts

@@ -1,5 +1,5 @@
 import type Scroll from '../blots/scroll.js';
-import Delta from '../delta';
+import Delta from '../delta/index.js';
 import { Range } from './selection.js';
 type SelectionInfo = {
     newRange: Range;

package/types/pc/rich-text/{core → lib/core}/emitter.d.ts

@@ -1,4 +1,5 @@
-declare class Emitter {
+import EmitterBase from '@unicom-cloud/utils/emitter';
+declare class Emitter extends EmitterBase {
     static events: {
         readonly EDITOR_CHANGE: "editor-change";
         readonly SCROLL_BEFORE_UPDATE: "scroll-before-update";
@@ -24,12 +25,10 @@ declare class Emitter {
         handler: Function;
     }[]>;
     constructor();
-    private emitter;
     on(...args: any[]): void;
     once(...args: any[]): void;
     emit(...args: unknown[]): boolean;
     off(...args: any[]): void;
-    offAll(...args: any[]): void;
     handleDOM(event: Event, ...args: unknown[]): void;
     listenDOM(eventName: string, node: Node, handler: EventListener): void;
 }

package/types/pc/rich-text/{core → lib/core}/rich.d.ts

@@ -1,7 +1,7 @@
 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 type { OpProps } from '../delta/index.js';
 import Delta from '../delta/index.js';
 import type Clipboard from '../modules/clipboard.js';
 import type History from '../modules/history.js';
@@ -95,10 +95,6 @@ declare class Rich {
     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;
@@ -118,11 +114,9 @@ declare class Rich {
     uploader: Uploader;
     options: ExpandedRichOptions;
     constructor(container: HTMLElement | string, options?: RichOptions);
-    addContainer(container: string, refNode?: Node | null): HTMLDivElement;
-    addContainer(container: HTMLElement, refNode?: Node | null): HTMLElement;
+    addContainer(container: string | HTMLElement, refNode?: Node | null, parentElement?: HTMLElement): HTMLDivElement | HTMLElement;
     blur(): void;
-    deleteText(range: Range, source?: EmitterSource): Delta;
-    deleteText(index: number, length: number, source?: EmitterSource): Delta;
+    deleteText(index: number | Range, length?: number | EmitterSource, source?: EmitterSource): Delta;
     disable(): void;
     editReadOnly<T>(modifier: () => T): T;
     enable(enabled?: boolean): void;
@@ -130,11 +124,8 @@ declare class Rich {
         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;
+    formatLine(index: number, length: number, name: string | Record<string, unknown>, value?: unknown | EmitterSource, source?: EmitterSource): Delta;
+    formatText(index: number | Range, length: number | string, name: string | unknown, value?: unknown | EmitterSource, source?: EmitterSource): Delta;
     getBounds(index: number | Range, length?: number): Bounds | null;
     getContents(index?: number, length?: number): Delta;
     getFormat(index?: number, length?: number): {
@@ -147,36 +138,17 @@ declare class Rich {
     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)[];
+    getLines(index?: Range | 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;
+    getSemanticHTML(index?: Range | number, length?: number): string;
+    getText(index?: Range | 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;
+    insertText(index: number, text: string, name?: string | Record<string, unknown> | EmitterSource, 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;
+    on(...args: Parameters<(typeof Emitter)['prototype']['on']>): Emitter;
     once(...args: Parameters<(typeof Emitter)['prototype']['once']>): void;
     removeFormat(index: number, length: number, source?: EmitterSource): Delta;
     scrollRectIntoView(rect: Rect, options?: ScrollRectIntoViewOptions): void;
@@ -189,14 +161,11 @@ declare class Rich {
      * 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;
+    setContents(delta: Delta | OpProps[], source?: EmitterSource): Delta;
+    setSelection(index: Range | null | number, length?: EmitterSource | number, source?: EmitterSource): void;
     setText(text: string, source?: EmitterSource): Delta;
     update(source?: EmitterSource): void;
-    updateContents(delta: Delta | Op[], source?: EmitterSource): Delta;
+    updateContents(delta: Delta | OpProps[], source?: EmitterSource): Delta;
 }
 declare function expandConfig(containerOrSelector: HTMLElement | string, options: RichOptions): ExpandedRichOptions;
 type NormalizedIndexLength = [
@@ -205,13 +174,7 @@ type NormalizedIndexLength = [
     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;
+declare function overload(index: Range | number, length?: number | string | Record<string, unknown> | EmitterSource, name?: string | unknown | Record<string, unknown> | EmitterSource, value?: unknown | EmitterSource, source?: EmitterSource): NormalizedIndexLength;
 export { Parchment, Range };
 export type { Bounds, DebugLevel, EmitterSource };
 export { Rich as default, expandConfig, globalRegistry, overload };

package/types/pc/rich-text/{core → lib/core}/selection.d.ts

@@ -42,14 +42,7 @@ declare class Selection {
     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;
+    getBounds(index: number, length?: number): Bounds | null;
     getNativeRange(): NormalizedRange | null;
     getRange(): [Range, NormalizedRange] | [null, null];
     hasFocus(): boolean;
@@ -66,6 +59,7 @@ declare class Selection {
         native: AbstractRange;
     } | null;
     rangeToNative(range: Range): [Node | null, number, Node | null, number];
+    setSelectionByNode(node: any): void;
     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;

package/types/pc/rich-text/{core → lib/core}/theme.d.ts

@@ -4,14 +4,17 @@ 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';
+import Tooltip from '../ui/tooltip.js';
 export interface ThemeOptions {
     modules: Record<string, unknown> & {
         toolbar?: null | ToolbarProps;
     };
+    bounds?: HTMLElement;
 }
 declare class Theme {
     protected rich: Rich;
     protected options: ThemeOptions;
+    tooltip?: Tooltip;
     static DEFAULTS: ThemeOptions;
     static themes: {
         default: typeof Theme;

package/types/pc/rich-text/{core.d.ts → lib/core.d.ts}

@@ -1,6 +1,6 @@
 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';
+import Delta, { AttributeMap, Op, OpIterator } from './delta/index.js';
 export { default as Module } from './core/module.js';
 export { AttributeMap, Delta, Op, OpIterator, Parchment, Range };
 export type { Bounds, DebugLevel, EmitterSource, ExpandedRichOptions, RichOptions, };

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

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

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

@@ -0,0 +1,13 @@
+import type { AttributeMapProps } from './AttributeMap';
+interface OpProps {
+    insert?: string | Record<string, unknown>;
+    delete?: number;
+    retain?: number | Record<string, unknown>;
+    attributes?: AttributeMapProps;
+}
+declare function length(op: OpProps): number;
+export type { OpProps };
+declare const _default: {
+    length: typeof length;
+};
+export default _default;

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

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

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

@@ -0,0 +1,53 @@
+import type { AttributeMapProps } from './AttributeMap';
+import AttributeMap from './AttributeMap';
+import type { OpProps } from './Op';
+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: {
+        length: (op: OpProps) => number;
+    };
+    static OpIterator: typeof OpIterator;
+    static AttributeMap: {
+        compose: (a?: AttributeMapProps, b?: AttributeMapProps, keepNull?: boolean) => AttributeMapProps | undefined;
+        diff: (a?: AttributeMapProps, b?: AttributeMapProps) => AttributeMapProps | undefined;
+        invert: (attr?: AttributeMapProps, base?: AttributeMapProps) => AttributeMapProps;
+        transform: (a: AttributeMapProps | undefined, b: AttributeMapProps | undefined, priority?: boolean) => AttributeMapProps | undefined;
+    };
+    private static handlers;
+    static registerEmbed<T>(embedType: string, handler: EmbedHandler<T>): void;
+    static unregisterEmbed(embedType: string): void;
+    private static getHandler;
+    ops: OpProps[];
+    constructor(ops?: OpProps[] | {
+        ops: OpProps[];
+    });
+    insert(arg: string | Record<string, unknown>, attributes?: AttributeMapProps | null): this;
+    delete(length: number): this;
+    retain(length: number | Record<string, unknown>, attributes?: AttributeMapProps | null): this;
+    push(newOp: OpProps): this;
+    chop(): this;
+    filter(predicate: (op: OpProps, index: number) => boolean): OpProps[];
+    forEach(predicate: (op: OpProps, index: number) => void): void;
+    map<T>(predicate: (op: OpProps, index: number) => T): T[];
+    partition(predicate: (op: OpProps) => boolean): [OpProps[], OpProps[]];
+    reduce<T>(predicate: (accum: T, curr: OpProps, 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: AttributeMapProps, 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, AttributeMapProps, Op, OpIterator, OpProps };

package/types/pc/rich-text/lib/diff/index.d.ts

@@ -0,0 +1,40 @@
+export default diff;
+/**
+ * This library modifies the diff-patch-match library by Neil Fraser
+ * by removing the patch and match functionality and certain advanced
+ * options in the diff function. The original license is as follows:
+ *
+ * ===
+ *
+ * Diff Match and Patch
+ *
+ * Copyright 2006 Google Inc.
+ * http://code.google.com/p/google-diff-match-patch/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * The data structure representing a diff is an array of tuples:
+ * [[DIFF_DELETE, 'Hello'], [DIFF_INSERT, 'Goodbye'], [DIFF_EQUAL, ' world.']]
+ * which means: delete 'Hello', add 'Goodbye' and keep ' world.'
+ */
+declare let DIFF_DELETE: number;
+declare let DIFF_EQUAL: number;
+declare let DIFF_INSERT: number;
+declare function diff(text1: any, text2: any, cursor_pos: any, cleanup: any): any[];
+declare namespace diff {
+    export { DIFF_INSERT as INSERT };
+    export { DIFF_DELETE as DELETE };
+    export { DIFF_EQUAL as EQUAL };
+}
+export { DIFF_DELETE as DELETE, DIFF_EQUAL as EQUAL, DIFF_INSERT as INSERT };

package/types/pc/rich-text/{formats → lib/formats}/bold.d.ts

@@ -5,7 +5,7 @@ declare class Bold extends Inline {
     static create(): HTMLElement;
     static formats(): boolean;
     optimize(context: {
-        [key: string]: any;
+        [key: string]: unknown;
     }): void;
 }
 export default Bold;

package/types/pc/rich-text/{formats → lib/formats}/font.d.ts

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

package/types/pc/rich-text/lib/formats/hr.d.ts

@@ -0,0 +1,5 @@
+import { BlockEmbed } from '../blots/block.js';
+declare class Hr extends BlockEmbed {
+    static create(value: any): HTMLHRElement;
+}
+export default Hr;

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

@@ -0,0 +1,27 @@
+/**
+ * Custom module for quilljs to allow user to resize <img> elements
+ * (Works on Chrome, Edge, Safari and replaces Firefox's native resize behavior)
+ */
+export default class ImageResize {
+    constructor(rich: any, options?: {});
+    rich: any;
+    options: any;
+    moduleClasses: any;
+    modules: any[];
+    initializeModules: () => void;
+    onUpdate: () => void;
+    removeModules: () => void;
+    handleClick: (evt: any) => void;
+    show: (img: any) => void;
+    img: any;
+    setSelectionByNode: () => void;
+    showOverlay: () => void;
+    overlay: HTMLDivElement | undefined;
+    overlayClickHanlder: () => void;
+    hideOverlay: () => void;
+    repositionElements: () => void;
+    hide: () => void;
+    destroy: () => void;
+    checkImage: (evt: any) => void;
+    rootScroll: (e: any) => void;
+}

package/types/pc/rich-text/lib/formats/image-resize/modules/BaseModule.d.ts

@@ -0,0 +1,10 @@
+export class BaseModule {
+    constructor(resizer: any);
+    overlay: any;
+    img: any;
+    options: any;
+    requestUpdate: any;
+    onCreate: () => void;
+    onDestroy: () => void;
+    onUpdate: () => void;
+}

package/types/pc/rich-text/lib/formats/image-resize/modules/DisplaySize.d.ts

@@ -0,0 +1,5 @@
+export class DisplaySize extends BaseModule {
+    display: HTMLDivElement | undefined;
+    getCurrentSize: () => any[];
+}
+import { BaseModule } from './BaseModule';

package/types/pc/rich-text/lib/formats/image-resize/modules/Resize.d.ts

@@ -0,0 +1,13 @@
+export class Resize extends BaseModule {
+    boxes: any[] | undefined;
+    positionBoxes: () => void;
+    addBox: (cursor: any) => void;
+    handleMousedown: (evt: any) => void;
+    dragBox: any;
+    dragStartX: any;
+    preDragWidth: any;
+    handleMouseup: () => void;
+    handleDrag: (evt: any) => void;
+    setCursor: (value: any) => void;
+}
+import { BaseModule } from './BaseModule';

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

@@ -0,0 +1,7 @@
+declare namespace _default {
+    let modules: string[];
+    let overlayStyles: {};
+    let handleStyles: {};
+    let displayStyles: {};
+}
+export default _default;

package/types/pc/rich-text/lib/formats/liOl.d.ts

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

package/types/pc/rich-text/lib/formats/liUl.d.ts

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

package/types/pc/rich-text/lib/formats/lineHeight.d.ts

@@ -0,0 +1,3 @@
+import { StyleAttributor } from '../parchment';
+declare const LineHeight: StyleAttributor;
+export default LineHeight;

package/types/pc/rich-text/{formats → lib/formats}/list.d.ts

@@ -2,6 +2,7 @@ import Block from '../blots/block.js';
 import Container from '../blots/container.js';
 import type Scroll from '../blots/scroll.js';
 declare class ListContainer extends Container {
+    static create(value: string): HTMLElement;
 }
 declare class ListItem extends Block {
     static create(value: string): HTMLElement;

package/types/pc/rich-text/{formats → lib/formats}/table.d.ts

@@ -1,6 +1,6 @@
 import Block from '../blots/block.js';
 import Container from '../blots/container.js';
-import type { LinkedList } from '../parchment';
+import type { LinkedList } from '../parchment/index.js';
 declare class TableCell extends Block {
     static blotName: string;
     static tagName: string;
@@ -11,7 +11,7 @@ declare class TableCell extends Block {
     format(name: string, value: string): void;
     row(): TableRow;
     rowOffset(): number;
-    table(): import("../parchment").Parent;
+    table(): import("../parchment/index.js").Parent;
 }
 declare class TableRow extends Container {
     static blotName: string;
@@ -23,7 +23,7 @@ declare class TableRow extends Container {
         [key: string]: any;
     }): void;
     rowOffset(): number;
-    table(): import("../parchment").Parent;
+    table(): import("../parchment/index.js").Parent;
 }
 declare class TableBody extends Container {
     static blotName: string;

package/types/pc/rich-text/{modules → lib/modules}/clipboard.d.ts

@@ -2,8 +2,8 @@ import type { EmitterSource } from '../core/emitter.js';
 import Module from '../core/module.js';
 import Rich from '../core/rich.js';
 import type { Range } from '../core/selection.js';
-import Delta from '../delta';
-import type { ScrollBlot } from '../parchment';
+import Delta from '../delta/index.js';
+import type { ScrollBlot } from '../parchment/index.js';
 type Selector = string | Node['TEXT_NODE'] | Node['ELEMENT_NODE'];
 type Matcher = (node: Node, delta: Delta, scroll: ScrollBlot) => Delta;
 interface ClipboardOptions {

package/types/pc/rich-text/{modules → lib/modules}/history.d.ts

@@ -2,7 +2,7 @@ import type Scroll from '../blots/scroll.js';
 import Module from '../core/module.js';
 import Rich from '../core/rich.js';
 import type { Range } from '../core/selection.js';
-import type Delta from '../delta';
+import type Delta from '../delta/index.js';
 export interface HistoryOptions {
     userOnly: boolean;
     delay: number;

package/types/pc/rich-text/{modules → lib/modules}/keyboard.d.ts

@@ -2,7 +2,7 @@ import type { BlockEmbed } from '../blots/block.js';
 import Module from '../core/module.js';
 import Rich from '../core/rich.js';
 import type { Range } from '../core/selection.js';
-import type { BlockBlot } from '../parchment';
+import type { BlockBlot } from '../parchment/index.js';
 declare const SHORTKEY: string;
 export interface Context {
     collapsed: boolean;

package/types/pc/rich-text/{modules → lib/modules}/syntax.d.ts

@@ -1,9 +1,9 @@
 import Inline from '../blots/inline.js';
 import Module from '../core/module.js';
 import Rich from '../core/rich.js';
-import Delta from '../delta';
+import Delta from '../delta/index.js';
 import CodeBlock, { CodeBlockContainer } from '../formats/code.js';
-import type { Blot, ScrollBlot } from '../parchment';
+import type { Blot, ScrollBlot } from '../parchment/index.js';
 declare class CodeToken extends Inline {
     static formats(node: Element, scroll: ScrollBlot): any;
     constructor(scroll: ScrollBlot, domNode: Node, value: unknown);

package/types/pc/rich-text/{modules → lib/modules}/tableEmbed.d.ts

@@ -1,11 +1,11 @@
 import Module from '../core/module.js';
-import type { Op } from '../delta';
-import Delta from '../delta';
+import type { OpProps } from '../delta/index.js';
+import Delta from '../delta/index.js';
 export type CellData = {
     content?: Delta['ops'];
     attributes?: Record<string, unknown>;
 };
-export type TableRowColumnOp = Omit<Op, 'insert'> & {
+export type TableRowColumnOp = Omit<OpProps, 'insert'> & {
     insert?: {
         id: string;
     };

package/types/pc/rich-text/{modules → lib/modules}/toolbar.d.ts

@@ -1,7 +1,7 @@
 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;
+type Handler = (this: Toolbar, value: any, e?: PointerEvent) => void;
 export type ToolbarConfig = Array<string[] | Array<string | Record<string, unknown>>>;
 export interface ToolbarProps {
     container?: HTMLElement | ToolbarConfig | null;

package/types/pc/rich-text/{parchment → lib/parchment}/attributor/attributor.d.ts

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