@adminforth/rich-editor 1.0.7 → 1.0.9

package/dist/node_modules/parchment/src/blot/abstract/parent.ts

@@ -1,400 +0,0 @@
-import LinkedList from '../../collection/linked-list.js';
-import ParchmentError from '../../error.js';
-import Scope from '../../scope.js';
-import type { Blot, BlotConstructor, Parent, Root } from './blot.js';
-import ShadowBlot from './shadow.js';
-
-function makeAttachedBlot(node: Node, scroll: Root): Blot {
-  const found = scroll.find(node);
-  if (found) return found;
-  try {
-    return scroll.create(node);
-  } catch (e) {
-    const blot = scroll.create(Scope.INLINE);
-    Array.from(node.childNodes).forEach((child: Node) => {
-      blot.domNode.appendChild(child);
-    });
-    if (node.parentNode) {
-      node.parentNode.replaceChild(blot.domNode, node);
-    }
-    blot.attach();
-    return blot;
-  }
-}
-
-class ParentBlot extends ShadowBlot implements Parent {
-  /**
-   * Whitelist array of Blots that can be direct children.
-   */
-  public static allowedChildren?: BlotConstructor[];
-
-  /**
-   * Default child blot to be inserted if this blot becomes empty.
-   */
-  public static defaultChild?: BlotConstructor;
-  public static uiClass = '';
-
-  public children!: LinkedList<Blot>;
-  public domNode!: HTMLElement;
-  public uiNode: HTMLElement | null = null;
-
-  constructor(scroll: Root, domNode: Node) {
-    super(scroll, domNode);
-    this.build();
-  }
-
-  public appendChild(other: Blot): void {
-    this.insertBefore(other);
-  }
-
-  public attach(): void {
-    super.attach();
-    this.children.forEach((child) => {
-      child.attach();
-    });
-  }
-
-  public attachUI(node: HTMLElement): void {
-    if (this.uiNode != null) {
-      this.uiNode.remove();
-    }
-    this.uiNode = node;
-    if (ParentBlot.uiClass) {
-      this.uiNode.classList.add(ParentBlot.uiClass);
-    }
-    this.uiNode.setAttribute('contenteditable', 'false');
-    this.domNode.insertBefore(this.uiNode, this.domNode.firstChild);
-  }
-
-  /**
-   * Called during construction, should fill its own children LinkedList.
-   */
-  public build(): void {
-    this.children = new LinkedList<Blot>();
-    // Need to be reversed for if DOM nodes already in order
-    Array.from(this.domNode.childNodes)
-      .filter((node: Node) => node !== this.uiNode)
-      .reverse()
-      .forEach((node: Node) => {
-        try {
-          const child = makeAttachedBlot(node, this.scroll);
-          this.insertBefore(child, this.children.head || undefined);
-        } catch (err) {
-          if (err instanceof ParchmentError) {
-            return;
-          } else {
-            throw err;
-          }
-        }
-      });
-  }
-
-  public deleteAt(index: number, length: number): void {
-    if (index === 0 && length === this.length()) {
-      return this.remove();
-    }
-    this.children.forEachAt(index, length, (child, offset, childLength) => {
-      child.deleteAt(offset, childLength);
-    });
-  }
-
-  public descendant<T extends Blot>(
-    criteria: new (...args: any[]) => T,
-    index: number,
-  ): [T | null, number];
-  public descendant(
-    criteria: (blot: Blot) => boolean,
-    index: number,
-  ): [Blot | null, number];
-  public descendant(criteria: any, index = 0): [Blot | null, number] {
-    const [child, offset] = this.children.find(index);
-    if (
-      (criteria.blotName == null && criteria(child)) ||
-      (criteria.blotName != null && child instanceof criteria)
-    ) {
-      return [child as any, offset];
-    } else if (child instanceof ParentBlot) {
-      return child.descendant(criteria, offset);
-    } else {
-      return [null, -1];
-    }
-  }
-
-  public descendants<T extends Blot>(
-    criteria: new (...args: any[]) => T,
-    index?: number,
-    length?: number,
-  ): T[];
-  public descendants(
-    criteria: (blot: Blot) => boolean,
-    index?: number,
-    length?: number,
-  ): Blot[];
-  public descendants(
-    criteria: any,
-    index = 0,
-    length: number = Number.MAX_VALUE,
-  ): Blot[] {
-    let descendants: Blot[] = [];
-    let lengthLeft = length;
-    this.children.forEachAt(
-      index,
-      length,
-      (child: Blot, childIndex: number, childLength: number) => {
-        if (
-          (criteria.blotName == null && criteria(child)) ||
-          (criteria.blotName != null && child instanceof criteria)
-        ) {
-          descendants.push(child);
-        }
-        if (child instanceof ParentBlot) {
-          descendants = descendants.concat(
-            child.descendants(criteria, childIndex, lengthLeft),
-          );
-        }
-        lengthLeft -= childLength;
-      },
-    );
-    return descendants;
-  }
-
-  public detach(): void {
-    this.children.forEach((child) => {
-      child.detach();
-    });
-    super.detach();
-  }
-
-  public enforceAllowedChildren(): void {
-    let done = false;
-    this.children.forEach((child: Blot) => {
-      if (done) {
-        return;
-      }
-      const allowed = this.statics.allowedChildren.some(
-        (def: BlotConstructor) => child instanceof def,
-      );
-      if (allowed) {
-        return;
-      }
-      if (child.statics.scope === Scope.BLOCK_BLOT) {
-        if (child.next != null) {
-          this.splitAfter(child);
-        }
-        if (child.prev != null) {
-          this.splitAfter(child.prev);
-        }
-        child.parent.unwrap();
-        done = true;
-      } else if (child instanceof ParentBlot) {
-        child.unwrap();
-      } else {
-        child.remove();
-      }
-    });
-  }
-
-  public formatAt(
-    index: number,
-    length: number,
-    name: string,
-    value: any,
-  ): void {
-    this.children.forEachAt(index, length, (child, offset, childLength) => {
-      child.formatAt(offset, childLength, name, value);
-    });
-  }
-
-  public insertAt(index: number, value: string, def?: any): void {
-    const [child, offset] = this.children.find(index);
-    if (child) {
-      child.insertAt(offset, value, def);
-    } else {
-      const blot =
-        def == null
-          ? this.scroll.create('text', value)
-          : this.scroll.create(value, def);
-      this.appendChild(blot);
-    }
-  }
-
-  public insertBefore(childBlot: Blot, refBlot?: Blot | null): void {
-    if (childBlot.parent != null) {
-      childBlot.parent.children.remove(childBlot);
-    }
-    let refDomNode: Node | null = null;
-    this.children.insertBefore(childBlot, refBlot || null);
-    childBlot.parent = this;
-    if (refBlot != null) {
-      refDomNode = refBlot.domNode;
-    }
-    if (
-      this.domNode.parentNode !== childBlot.domNode ||
-      this.domNode.nextSibling !== refDomNode
-    ) {
-      this.domNode.insertBefore(childBlot.domNode, refDomNode);
-    }
-    childBlot.attach();
-  }
-
-  public length(): number {
-    return this.children.reduce((memo, child) => {
-      return memo + child.length();
-    }, 0);
-  }
-
-  public moveChildren(targetParent: Parent, refNode?: Blot | null): void {
-    this.children.forEach((child) => {
-      targetParent.insertBefore(child, refNode);
-    });
-  }
-
-  public optimize(context?: { [key: string]: any }): void {
-    super.optimize(context);
-    this.enforceAllowedChildren();
-    if (this.uiNode != null && this.uiNode !== this.domNode.firstChild) {
-      this.domNode.insertBefore(this.uiNode, this.domNode.firstChild);
-    }
-    if (this.children.length === 0) {
-      if (this.statics.defaultChild != null) {
-        const child = this.scroll.create(this.statics.defaultChild.blotName);
-        this.appendChild(child);
-        // TODO double check if necessary
-        // child.optimize(context);
-      } else {
-        this.remove();
-      }
-    }
-  }
-
-  public path(index: number, inclusive = false): [Blot, number][] {
-    const [child, offset] = this.children.find(index, inclusive);
-    const position: [Blot, number][] = [[this, index]];
-    if (child instanceof ParentBlot) {
-      return position.concat(child.path(offset, inclusive));
-    } else if (child != null) {
-      position.push([child, offset]);
-    }
-    return position;
-  }
-
-  public removeChild(child: Blot): void {
-    this.children.remove(child);
-  }
-
-  public replaceWith(name: string | Blot, value?: any): Blot {
-    const replacement =
-      typeof name === 'string' ? this.scroll.create(name, value) : name;
-    if (replacement instanceof ParentBlot) {
-      this.moveChildren(replacement);
-    }
-    return super.replaceWith(replacement);
-  }
-
-  public split(index: number, force = false): Blot | null {
-    if (!force) {
-      if (index === 0) {
-        return this;
-      }
-      if (index === this.length()) {
-        return this.next;
-      }
-    }
-    const after = this.clone() as ParentBlot;
-    if (this.parent) {
-      this.parent.insertBefore(after, this.next || undefined);
-    }
-    this.children.forEachAt(index, this.length(), (child, offset, _length) => {
-      const split = child.split(offset, force);
-      if (split != null) {
-        after.appendChild(split);
-      }
-    });
-    return after;
-  }
-
-  public splitAfter(child: Blot): Parent {
-    const after = this.clone() as ParentBlot;
-    while (child.next != null) {
-      after.appendChild(child.next);
-    }
-    if (this.parent) {
-      this.parent.insertBefore(after, this.next || undefined);
-    }
-    return after;
-  }
-
-  public unwrap(): void {
-    if (this.parent) {
-      this.moveChildren(this.parent, this.next || undefined);
-    }
-    this.remove();
-  }
-
-  public update(
-    mutations: MutationRecord[],
-    _context: { [key: string]: any },
-  ): void {
-    const addedNodes: Node[] = [];
-    const removedNodes: Node[] = [];
-    mutations.forEach((mutation) => {
-      if (mutation.target === this.domNode && mutation.type === 'childList') {
-        addedNodes.push(...mutation.addedNodes);
-        removedNodes.push(...mutation.removedNodes);
-      }
-    });
-    removedNodes.forEach((node: Node) => {
-      // Check node has actually been removed
-      // One exception is Chrome does not immediately remove IFRAMEs
-      // from DOM but MutationRecord is correct in its reported removal
-      if (
-        node.parentNode != null &&
-        // @ts-expect-error Fix me later
-        node.tagName !== 'IFRAME' &&
-        document.body.compareDocumentPosition(node) &
-          Node.DOCUMENT_POSITION_CONTAINED_BY
-      ) {
-        return;
-      }
-      const blot = this.scroll.find(node);
-      if (blot == null) {
-        return;
-      }
-      if (
-        blot.domNode.parentNode == null ||
-        blot.domNode.parentNode === this.domNode
-      ) {
-        blot.detach();
-      }
-    });
-    addedNodes
-      .filter((node) => {
-        return node.parentNode === this.domNode && node !== this.uiNode;
-      })
-      .sort((a, b) => {
-        if (a === b) {
-          return 0;
-        }
-        if (a.compareDocumentPosition(b) & Node.DOCUMENT_POSITION_FOLLOWING) {
-          return 1;
-        }
-        return -1;
-      })
-      .forEach((node) => {
-        let refBlot: Blot | null = null;
-        if (node.nextSibling != null) {
-          refBlot = this.scroll.find(node.nextSibling);
-        }
-        const blot = makeAttachedBlot(node, this.scroll);
-        if (blot.next !== refBlot || blot.next == null) {
-          if (blot.parent != null) {
-            blot.parent.removeChild(this);
-          }
-          this.insertBefore(blot, refBlot || undefined);
-        }
-      });
-    this.enforceAllowedChildren();
-  }
-}
-
-export default ParentBlot;

package/dist/node_modules/parchment/src/blot/abstract/shadow.ts

@@ -1,188 +0,0 @@
-import ParchmentError from '../../error.js';
-import Registry from '../../registry.js';
-import Scope from '../../scope.js';
-import type {
-  Blot,
-  BlotConstructor,
-  Formattable,
-  Parent,
-  Root,
-} from './blot.js';
-
-class ShadowBlot implements Blot {
-  public static blotName = 'abstract';
-  public static className: string;
-  public static requiredContainer: BlotConstructor;
-  public static scope: Scope;
-  public static tagName: string | string[];
-
-  public static create(rawValue?: unknown): Node {
-    if (this.tagName == null) {
-      throw new ParchmentError('Blot definition missing tagName');
-    }
-    let node: HTMLElement;
-    let value: string | number | undefined;
-    if (Array.isArray(this.tagName)) {
-      if (typeof rawValue === 'string') {
-        value = rawValue.toUpperCase();
-        if (parseInt(value, 10).toString() === value) {
-          value = parseInt(value, 10);
-        }
-      } else if (typeof rawValue === 'number') {
-        value = rawValue;
-      }
-      if (typeof value === 'number') {
-        node = document.createElement(this.tagName[value - 1]);
-      } else if (value && this.tagName.indexOf(value) > -1) {
-        node = document.createElement(value);
-      } else {
-        node = document.createElement(this.tagName[0]);
-      }
-    } else {
-      node = document.createElement(this.tagName);
-    }
-    if (this.className) {
-      node.classList.add(this.className);
-    }
-    return node;
-  }
-
-  public prev: Blot | null;
-  public next: Blot | null;
-  // @ts-expect-error Fix me later
-  public parent: Parent;
-
-  // Hack for accessing inherited static methods
-  get statics(): any {
-    return this.constructor;
-  }
-  constructor(
-    public scroll: Root,
-    public domNode: Node,
-  ) {
-    Registry.blots.set(domNode, this);
-    this.prev = null;
-    this.next = null;
-  }
-
-  public attach(): void {
-    // Nothing to do
-  }
-
-  public clone(): Blot {
-    const domNode = this.domNode.cloneNode(false);
-    return this.scroll.create(domNode);
-  }
-
-  public detach(): void {
-    if (this.parent != null) {
-      this.parent.removeChild(this);
-    }
-    Registry.blots.delete(this.domNode);
-  }
-
-  public deleteAt(index: number, length: number): void {
-    const blot = this.isolate(index, length);
-    blot.remove();
-  }
-
-  public formatAt(
-    index: number,
-    length: number,
-    name: string,
-    value: any,
-  ): void {
-    const blot = this.isolate(index, length);
-    if (this.scroll.query(name, Scope.BLOT) != null && value) {
-      blot.wrap(name, value);
-    } else if (this.scroll.query(name, Scope.ATTRIBUTE) != null) {
-      const parent = this.scroll.create(this.statics.scope) as Parent &
-        Formattable;
-      blot.wrap(parent);
-      parent.format(name, value);
-    }
-  }
-
-  public insertAt(index: number, value: string, def?: any): void {
-    const blot =
-      def == null
-        ? this.scroll.create('text', value)
-        : this.scroll.create(value, def);
-    const ref = this.split(index);
-    this.parent.insertBefore(blot, ref || undefined);
-  }
-
-  public isolate(index: number, length: number): Blot {
-    const target = this.split(index);
-    if (target == null) {
-      throw new Error('Attempt to isolate at end');
-    }
-    target.split(length);
-    return target;
-  }
-
-  public length(): number {
-    return 1;
-  }
-
-  public offset(root: Blot = this.parent): number {
-    if (this.parent == null || this === root) {
-      return 0;
-    }
-    return this.parent.children.offset(this) + this.parent.offset(root);
-  }
-
-  public optimize(_context?: { [key: string]: any }): void {
-    if (
-      this.statics.requiredContainer &&
-      !(this.parent instanceof this.statics.requiredContainer)
-    ) {
-      this.wrap(this.statics.requiredContainer.blotName);
-    }
-  }
-
-  public remove(): void {
-    if (this.domNode.parentNode != null) {
-      this.domNode.parentNode.removeChild(this.domNode);
-    }
-    this.detach();
-  }
-
-  public replaceWith(name: string | Blot, value?: any): Blot {
-    const replacement =
-      typeof name === 'string' ? this.scroll.create(name, value) : name;
-    if (this.parent != null) {
-      this.parent.insertBefore(replacement, this.next || undefined);
-      this.remove();
-    }
-    return replacement;
-  }
-
-  public split(index: number, _force?: boolean): Blot | null {
-    return index === 0 ? this : this.next;
-  }
-
-  public update(
-    _mutations: MutationRecord[],
-    _context: { [key: string]: any },
-  ): void {
-    // Nothing to do by default
-  }
-
-  public wrap(name: string | Parent, value?: any): Parent {
-    const wrapper =
-      typeof name === 'string'
-        ? (this.scroll.create(name, value) as Parent)
-        : name;
-    if (this.parent != null) {
-      this.parent.insertBefore(wrapper, this.next || undefined);
-    }
-    if (typeof wrapper.appendChild !== 'function') {
-      throw new ParchmentError(`Cannot wrap ${name}`);
-    }
-    wrapper.appendChild(this);
-    return wrapper;
-  }
-}
-
-export default ShadowBlot;

package/dist/node_modules/parchment/src/blot/block.ts

@@ -1,123 +0,0 @@
-import Attributor from '../attributor/attributor.js';
-import AttributorStore from '../attributor/store.js';
-import Scope from '../scope.js';
-import type {
-  Blot,
-  BlotConstructor,
-  Formattable,
-  Root,
-} from './abstract/blot.js';
-import LeafBlot from './abstract/leaf.js';
-import ParentBlot from './abstract/parent.js';
-import InlineBlot from './inline.js';
-
-class BlockBlot extends ParentBlot implements Formattable {
-  public static blotName = 'block';
-  public static scope = Scope.BLOCK_BLOT;
-  public static tagName: string | string[] = 'P';
-  public static allowedChildren: BlotConstructor[] = [
-    InlineBlot,
-    BlockBlot,
-    LeafBlot,
-  ];
-
-  static create(value?: unknown) {
-    return super.create(value) as HTMLElement;
-  }
-
-  public static formats(domNode: HTMLElement, scroll: Root): any {
-    const match = scroll.query(BlockBlot.blotName);
-    if (
-      match != null &&
-      domNode.tagName === (match as BlotConstructor).tagName
-    ) {
-      return undefined;
-    } else if (typeof this.tagName === 'string') {
-      return true;
-    } else if (Array.isArray(this.tagName)) {
-      return domNode.tagName.toLowerCase();
-    }
-  }
-
-  protected attributes: AttributorStore;
-
-  constructor(scroll: Root, domNode: Node) {
-    super(scroll, domNode);
-    this.attributes = new AttributorStore(this.domNode);
-  }
-
-  public format(name: string, value: any): void {
-    const format = this.scroll.query(name, Scope.BLOCK);
-    if (format == null) {
-      return;
-    } else if (format instanceof Attributor) {
-      this.attributes.attribute(format, value);
-    } else if (name === this.statics.blotName && !value) {
-      this.replaceWith(BlockBlot.blotName);
-    } else if (
-      value &&
-      (name !== this.statics.blotName || this.formats()[name] !== value)
-    ) {
-      this.replaceWith(name, value);
-    }
-  }
-
-  public formats(): { [index: string]: any } {
-    const formats = this.attributes.values();
-    const format = this.statics.formats(this.domNode, this.scroll);
-    if (format != null) {
-      formats[this.statics.blotName] = format;
-    }
-    return formats;
-  }
-
-  public formatAt(
-    index: number,
-    length: number,
-    name: string,
-    value: any,
-  ): void {
-    if (this.scroll.query(name, Scope.BLOCK) != null) {
-      this.format(name, value);
-    } else {
-      super.formatAt(index, length, name, value);
-    }
-  }
-
-  public insertAt(index: number, value: string, def?: any): void {
-    if (def == null || this.scroll.query(value, Scope.INLINE) != null) {
-      // Insert text or inline
-      super.insertAt(index, value, def);
-    } else {
-      const after = this.split(index);
-      if (after != null) {
-        const blot = this.scroll.create(value, def);
-        after.parent.insertBefore(blot, after);
-      } else {
-        throw new Error('Attempt to insertAt after block boundaries');
-      }
-    }
-  }
-
-  public replaceWith(name: string | Blot, value?: any): Blot {
-    const replacement = super.replaceWith(name, value) as BlockBlot;
-    this.attributes.copy(replacement);
-    return replacement;
-  }
-
-  public update(
-    mutations: MutationRecord[],
-    context: { [key: string]: any },
-  ): void {
-    super.update(mutations, context);
-    const attributeChanged = mutations.some(
-      (mutation) =>
-        mutation.target === this.domNode && mutation.type === 'attributes',
-    );
-    if (attributeChanged) {
-      this.attributes.build();
-    }
-  }
-}
-
-export default BlockBlot;