@adminforth/rich-editor 1.0.2

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

@@ -0,0 +1,34 @@
+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/dist/node_modules/parchment/src/blot/inline.ts

@@ -0,0 +1,159 @@
+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/dist/node_modules/parchment/src/blot/scroll.ts

@@ -0,0 +1,216 @@
+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/dist/node_modules/parchment/src/blot/text.ts

@@ -0,0 +1,100 @@
+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/dist/node_modules/parchment/src/collection/linked-list.ts

@@ -0,0 +1,201 @@
+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/dist/node_modules/parchment/src/collection/linked-node.ts

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