@adminforth/rich-editor 1.0.16 → 1.0.17

package/custom/node_modules/parchment/src/blot/embed.ts

@@ -1,34 +0,0 @@
-import type { Formattable, Root } from './abstract/blot.js';
-import LeafBlot from './abstract/leaf.js';
-
-class EmbedBlot extends LeafBlot implements Formattable {
-  public static formats(_domNode: HTMLElement, _scroll: Root): any {
-    return undefined;
-  }
-
-  public format(name: string, value: any): void {
-    // super.formatAt wraps, which is what we want in general,
-    // but this allows subclasses to overwrite for formats
-    // that just apply to particular embeds
-    super.formatAt(0, this.length(), name, value);
-  }
-
-  public formatAt(
-    index: number,
-    length: number,
-    name: string,
-    value: any,
-  ): void {
-    if (index === 0 && length === this.length()) {
-      this.format(name, value);
-    } else {
-      super.formatAt(index, length, name, value);
-    }
-  }
-
-  public formats(): { [index: string]: any } {
-    return this.statics.formats(this.domNode, this.scroll);
-  }
-}
-
-export default EmbedBlot;

package/custom/node_modules/parchment/src/blot/inline.ts

@@ -1,159 +0,0 @@
-import Attributor from '../attributor/attributor.js';
-import AttributorStore from '../attributor/store.js';
-import Scope from '../scope.js';
-import type {
-  Blot,
-  BlotConstructor,
-  Formattable,
-  Parent,
-  Root,
-} from './abstract/blot.js';
-import LeafBlot from './abstract/leaf.js';
-import ParentBlot from './abstract/parent.js';
-
-// Shallow object comparison
-function isEqual(
-  obj1: Record<string, unknown>,
-  obj2: Record<string, unknown>,
-): boolean {
-  if (Object.keys(obj1).length !== Object.keys(obj2).length) {
-    return false;
-  }
-  for (const prop in obj1) {
-    if (obj1[prop] !== obj2[prop]) {
-      return false;
-    }
-  }
-  return true;
-}
-
-class InlineBlot extends ParentBlot implements Formattable {
-  public static allowedChildren: BlotConstructor[] = [InlineBlot, LeafBlot];
-  public static blotName = 'inline';
-  public static scope = Scope.INLINE_BLOT;
-  public static tagName: string | string[] = 'SPAN';
-
-  static create(value?: unknown) {
-    return super.create(value) as HTMLElement;
-  }
-
-  public static formats(domNode: HTMLElement, scroll: Root): any {
-    const match = scroll.query(InlineBlot.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();
-    }
-    return undefined;
-  }
-
-  protected attributes: AttributorStore;
-
-  constructor(scroll: Root, domNode: Node) {
-    super(scroll, domNode);
-    this.attributes = new AttributorStore(this.domNode);
-  }
-
-  public format(name: string, value: any): void {
-    if (name === this.statics.blotName && !value) {
-      this.children.forEach((child) => {
-        if (!(child instanceof InlineBlot)) {
-          child = child.wrap(InlineBlot.blotName, true);
-        }
-        this.attributes.copy(child as InlineBlot);
-      });
-      this.unwrap();
-    } else {
-      const format = this.scroll.query(name, Scope.INLINE);
-      if (format == null) {
-        return;
-      }
-      if (format instanceof Attributor) {
-        this.attributes.attribute(format, value);
-      } 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.formats()[name] != null ||
-      this.scroll.query(name, Scope.ATTRIBUTE)
-    ) {
-      const blot = this.isolate(index, length) as InlineBlot;
-      blot.format(name, value);
-    } else {
-      super.formatAt(index, length, name, value);
-    }
-  }
-
-  public optimize(context: { [key: string]: any }): void {
-    super.optimize(context);
-    const formats = this.formats();
-    if (Object.keys(formats).length === 0) {
-      return this.unwrap(); // unformatted span
-    }
-    const next = this.next;
-    if (
-      next instanceof InlineBlot &&
-      next.prev === this &&
-      isEqual(formats, next.formats())
-    ) {
-      next.moveChildren(this);
-      next.remove();
-    }
-  }
-
-  public replaceWith(name: string | Blot, value?: any): Blot {
-    const replacement = super.replaceWith(name, value) as InlineBlot;
-    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();
-    }
-  }
-
-  public wrap(name: string | Parent, value?: any): Parent {
-    const wrapper = super.wrap(name, value);
-    if (wrapper instanceof InlineBlot) {
-      this.attributes.move(wrapper);
-    }
-    return wrapper;
-  }
-}
-
-export default InlineBlot;

package/custom/node_modules/parchment/src/blot/scroll.ts

@@ -1,216 +0,0 @@
-import Registry, { type RegistryDefinition } from '../registry.js';
-import Scope from '../scope.js';
-import type { Blot, BlotConstructor, Root } from './abstract/blot.js';
-import ContainerBlot from './abstract/container.js';
-import ParentBlot from './abstract/parent.js';
-import BlockBlot from './block.js';
-
-const OBSERVER_CONFIG = {
-  attributes: true,
-  characterData: true,
-  characterDataOldValue: true,
-  childList: true,
-  subtree: true,
-};
-
-const MAX_OPTIMIZE_ITERATIONS = 100;
-
-class ScrollBlot extends ParentBlot implements Root {
-  public static blotName = 'scroll';
-  public static defaultChild = BlockBlot;
-  public static allowedChildren: BlotConstructor[] = [BlockBlot, ContainerBlot];
-  public static scope = Scope.BLOCK_BLOT;
-  public static tagName = 'DIV';
-
-  public observer: MutationObserver;
-
-  constructor(
-    public registry: Registry,
-    node: HTMLDivElement,
-  ) {
-    // @ts-expect-error scroll is the root with no parent
-    super(null, node);
-    this.scroll = this;
-    this.build();
-    this.observer = new MutationObserver((mutations: MutationRecord[]) => {
-      this.update(mutations);
-    });
-    this.observer.observe(this.domNode, OBSERVER_CONFIG);
-    this.attach();
-  }
-
-  public create(input: Node | string | Scope, value?: any): Blot {
-    return this.registry.create(this, input, value);
-  }
-
-  public find(node: Node | null, bubble = false): Blot | null {
-    const blot = this.registry.find(node, bubble);
-    if (!blot) {
-      return null;
-    }
-    if (blot.scroll === this) {
-      return blot;
-    }
-    return bubble ? this.find(blot.scroll.domNode.parentNode, true) : null;
-  }
-
-  public query(
-    query: string | Node | Scope,
-    scope: Scope = Scope.ANY,
-  ): RegistryDefinition | null {
-    return this.registry.query(query, scope);
-  }
-
-  public register(...definitions: RegistryDefinition[]) {
-    return this.registry.register(...definitions);
-  }
-
-  public build(): void {
-    if (this.scroll == null) {
-      return;
-    }
-    super.build();
-  }
-
-  public detach(): void {
-    super.detach();
-    this.observer.disconnect();
-  }
-
-  public deleteAt(index: number, length: number): void {
-    this.update();
-    if (index === 0 && length === this.length()) {
-      this.children.forEach((child) => {
-        child.remove();
-      });
-    } else {
-      super.deleteAt(index, length);
-    }
-  }
-
-  public formatAt(
-    index: number,
-    length: number,
-    name: string,
-    value: any,
-  ): void {
-    this.update();
-    super.formatAt(index, length, name, value);
-  }
-
-  public insertAt(index: number, value: string, def?: any): void {
-    this.update();
-    super.insertAt(index, value, def);
-  }
-
-  public optimize(context?: { [key: string]: any }): void;
-  public optimize(
-    mutations: MutationRecord[],
-    context: { [key: string]: any },
-  ): void;
-  public optimize(mutations: any = [], context: any = {}): void {
-    super.optimize(context);
-    const mutationsMap = context.mutationsMap || new WeakMap();
-    // We must modify mutations directly, cannot make copy and then modify
-    let records = Array.from(this.observer.takeRecords());
-    // Array.push currently seems to be implemented by a non-tail recursive function
-    // so we cannot just mutations.push.apply(mutations, this.observer.takeRecords());
-    while (records.length > 0) {
-      mutations.push(records.pop());
-    }
-    const mark = (blot: Blot | null, markParent = true): void => {
-      if (blot == null || blot === this) {
-        return;
-      }
-      if (blot.domNode.parentNode == null) {
-        return;
-      }
-      if (!mutationsMap.has(blot.domNode)) {
-        mutationsMap.set(blot.domNode, []);
-      }
-      if (markParent) {
-        mark(blot.parent);
-      }
-    };
-    const optimize = (blot: Blot): void => {
-      // Post-order traversal
-      if (!mutationsMap.has(blot.domNode)) {
-        return;
-      }
-      if (blot instanceof ParentBlot) {
-        blot.children.forEach(optimize);
-      }
-      mutationsMap.delete(blot.domNode);
-      blot.optimize(context);
-    };
-    let remaining = mutations;
-    for (let i = 0; remaining.length > 0; i += 1) {
-      if (i >= MAX_OPTIMIZE_ITERATIONS) {
-        throw new Error('[Parchment] Maximum optimize iterations reached');
-      }
-      remaining.forEach((mutation: MutationRecord) => {
-        const blot = this.find(mutation.target, true);
-        if (blot == null) {
-          return;
-        }
-        if (blot.domNode === mutation.target) {
-          if (mutation.type === 'childList') {
-            mark(this.find(mutation.previousSibling, false));
-            Array.from(mutation.addedNodes).forEach((node: Node) => {
-              const child = this.find(node, false);
-              mark(child, false);
-              if (child instanceof ParentBlot) {
-                child.children.forEach((grandChild: Blot) => {
-                  mark(grandChild, false);
-                });
-              }
-            });
-          } else if (mutation.type === 'attributes') {
-            mark(blot.prev);
-          }
-        }
-        mark(blot);
-      });
-      this.children.forEach(optimize);
-      remaining = Array.from(this.observer.takeRecords());
-      records = remaining.slice();
-      while (records.length > 0) {
-        mutations.push(records.pop());
-      }
-    }
-  }
-
-  public update(
-    mutations?: MutationRecord[],
-    context: { [key: string]: any } = {},
-  ): void {
-    mutations = mutations || this.observer.takeRecords();
-    const mutationsMap = new WeakMap();
-    mutations
-      .map((mutation: MutationRecord) => {
-        const blot = this.find(mutation.target, true);
-        if (blot == null) {
-          return null;
-        }
-        if (mutationsMap.has(blot.domNode)) {
-          mutationsMap.get(blot.domNode).push(mutation);
-          return null;
-        } else {
-          mutationsMap.set(blot.domNode, [mutation]);
-          return blot;
-        }
-      })
-      .forEach((blot: Blot | null) => {
-        if (blot != null && blot !== this && mutationsMap.has(blot.domNode)) {
-          blot.update(mutationsMap.get(blot.domNode) || [], context);
-        }
-      });
-    context.mutationsMap = mutationsMap;
-    if (mutationsMap.has(this.domNode)) {
-      super.update(mutationsMap.get(this.domNode), context);
-    }
-    this.optimize(mutations, context);
-  }
-}
-
-export default ScrollBlot;

package/custom/node_modules/parchment/src/blot/text.ts

@@ -1,100 +0,0 @@
-import Scope from '../scope.js';
-import type { Blot, Leaf, Root } from './abstract/blot.js';
-import LeafBlot from './abstract/leaf.js';
-
-class TextBlot extends LeafBlot implements Leaf {
-  public static readonly blotName = 'text';
-  public static scope = Scope.INLINE_BLOT;
-
-  public static create(value: string): Text {
-    return document.createTextNode(value);
-  }
-
-  public static value(domNode: Text): string {
-    return domNode.data;
-  }
-
-  public domNode!: Text;
-  protected text: string;
-
-  constructor(scroll: Root, node: Node) {
-    super(scroll, node);
-    this.text = this.statics.value(this.domNode);
-  }
-
-  public deleteAt(index: number, length: number): void {
-    this.domNode.data = this.text =
-      this.text.slice(0, index) + this.text.slice(index + length);
-  }
-
-  public index(node: Node, offset: number): number {
-    if (this.domNode === node) {
-      return offset;
-    }
-    return -1;
-  }
-
-  public insertAt(index: number, value: string, def?: any): void {
-    if (def == null) {
-      this.text = this.text.slice(0, index) + value + this.text.slice(index);
-      this.domNode.data = this.text;
-    } else {
-      super.insertAt(index, value, def);
-    }
-  }
-
-  public length(): number {
-    return this.text.length;
-  }
-
-  public optimize(context: { [key: string]: any }): void {
-    super.optimize(context);
-    this.text = this.statics.value(this.domNode);
-    if (this.text.length === 0) {
-      this.remove();
-    } else if (this.next instanceof TextBlot && this.next.prev === this) {
-      this.insertAt(this.length(), (this.next as TextBlot).value());
-      this.next.remove();
-    }
-  }
-
-  public position(index: number, _inclusive = false): [Node, number] {
-    return [this.domNode, index];
-  }
-
-  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.scroll.create(this.domNode.splitText(index));
-    this.parent.insertBefore(after, this.next || undefined);
-    this.text = this.statics.value(this.domNode);
-    return after;
-  }
-
-  public update(
-    mutations: MutationRecord[],
-    _context: { [key: string]: any },
-  ): void {
-    if (
-      mutations.some((mutation) => {
-        return (
-          mutation.type === 'characterData' && mutation.target === this.domNode
-        );
-      })
-    ) {
-      this.text = this.statics.value(this.domNode);
-    }
-  }
-
-  public value(): string {
-    return this.text;
-  }
-}
-
-export default TextBlot;

package/custom/node_modules/parchment/src/collection/linked-list.ts

@@ -1,201 +0,0 @@
-import type LinkedNode from './linked-node.js';
-
-class LinkedList<T extends LinkedNode> {
-  public head: T | null;
-  public tail: T | null;
-  public length: number;
-
-  constructor() {
-    this.head = null;
-    this.tail = null;
-    this.length = 0;
-  }
-
-  public append(...nodes: T[]): void {
-    this.insertBefore(nodes[0], null);
-    if (nodes.length > 1) {
-      const rest = nodes.slice(1);
-      this.append(...rest);
-    }
-  }
-
-  public at(index: number): T | null {
-    const next = this.iterator();
-    let cur = next();
-    while (cur && index > 0) {
-      index -= 1;
-      cur = next();
-    }
-    return cur;
-  }
-
-  public contains(node: T): boolean {
-    const next = this.iterator();
-    let cur = next();
-    while (cur) {
-      if (cur === node) {
-        return true;
-      }
-      cur = next();
-    }
-    return false;
-  }
-
-  public indexOf(node: T): number {
-    const next = this.iterator();
-    let cur = next();
-    let index = 0;
-    while (cur) {
-      if (cur === node) {
-        return index;
-      }
-      index += 1;
-      cur = next();
-    }
-    return -1;
-  }
-
-  public insertBefore(node: T | null, refNode: T | null): void {
-    if (node == null) {
-      return;
-    }
-    this.remove(node);
-    node.next = refNode;
-    if (refNode != null) {
-      node.prev = refNode.prev;
-      if (refNode.prev != null) {
-        refNode.prev.next = node;
-      }
-      refNode.prev = node;
-      if (refNode === this.head) {
-        this.head = node;
-      }
-    } else if (this.tail != null) {
-      this.tail.next = node;
-      node.prev = this.tail;
-      this.tail = node;
-    } else {
-      node.prev = null;
-      this.head = this.tail = node;
-    }
-    this.length += 1;
-  }
-
-  public offset(target: T): number {
-    let index = 0;
-    let cur = this.head;
-    while (cur != null) {
-      if (cur === target) {
-        return index;
-      }
-      index += cur.length();
-      cur = cur.next as T;
-    }
-    return -1;
-  }
-
-  public remove(node: T): void {
-    if (!this.contains(node)) {
-      return;
-    }
-    if (node.prev != null) {
-      node.prev.next = node.next;
-    }
-    if (node.next != null) {
-      node.next.prev = node.prev;
-    }
-    if (node === this.head) {
-      this.head = node.next as T;
-    }
-    if (node === this.tail) {
-      this.tail = node.prev as T;
-    }
-    this.length -= 1;
-  }
-
-  public iterator(curNode: T | null = this.head): () => T | null {
-    // TODO use yield when we can
-    return (): T | null => {
-      const ret = curNode;
-      if (curNode != null) {
-        curNode = curNode.next as T;
-      }
-      return ret;
-    };
-  }
-
-  public find(index: number, inclusive = false): [T | null, number] {
-    const next = this.iterator();
-    let cur = next();
-    while (cur) {
-      const length = cur.length();
-      if (
-        index < length ||
-        (inclusive &&
-          index === length &&
-          (cur.next == null || cur.next.length() !== 0))
-      ) {
-        return [cur, index];
-      }
-      index -= length;
-      cur = next();
-    }
-    return [null, 0];
-  }
-
-  public forEach(callback: (cur: T) => void): void {
-    const next = this.iterator();
-    let cur = next();
-    while (cur) {
-      callback(cur);
-      cur = next();
-    }
-  }
-
-  public forEachAt(
-    index: number,
-    length: number,
-    callback: (cur: T, offset: number, length: number) => void,
-  ): void {
-    if (length <= 0) {
-      return;
-    }
-    const [startNode, offset] = this.find(index);
-    let curIndex = index - offset;
-    const next = this.iterator(startNode);
-    let cur = next();
-    while (cur && curIndex < index + length) {
-      const curLength = cur.length();
-      if (index > curIndex) {
-        callback(
-          cur,
-          index - curIndex,
-          Math.min(length, curIndex + curLength - index),
-        );
-      } else {
-        callback(cur, 0, Math.min(curLength, index + length - curIndex));
-      }
-      curIndex += curLength;
-      cur = next();
-    }
-  }
-
-  public map(callback: (cur: T) => any): any[] {
-    return this.reduce((memo: T[], cur: T) => {
-      memo.push(callback(cur));
-      return memo;
-    }, []);
-  }
-
-  public reduce<M>(callback: (memo: M, cur: T) => M, memo: M): M {
-    const next = this.iterator();
-    let cur = next();
-    while (cur) {
-      memo = callback(memo, cur);
-      cur = next();
-    }
-    return memo;
-  }
-}
-
-export default LinkedList;

package/custom/node_modules/parchment/src/collection/linked-node.ts

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