opentiny 6.9.0 → 6.9.1

package/src/core/main/ts/schema/ValidChildrenRuleParser.ts

@@ -1,51 +0,0 @@
-import { Arr, Optional } from '@ephox/katamari';
-
-import * as SchemaUtils from './SchemaUtils';
-
-export type ValidChildrenOperation = 'replace' | 'add' | 'remove';
-
-export interface ValidChild {
-  readonly preset: boolean;
-  readonly name: string;
-}
-
-export interface ValidChildrenRule {
-  readonly operation: ValidChildrenOperation;
-  readonly name: string;
-  readonly validChildren: ValidChild[];
-}
-
-const prefixToOperation = (prefix: string): ValidChildrenOperation => prefix === '-' ? 'remove' : 'add';
-
-export const parseValidChild = (name: string): Optional<{ preset: boolean; name: string }> => {
-  // see: https://html.spec.whatwg.org/#valid-custom-element-name
-  const validChildRegExp = /^(@?)([A-Za-z0-9_\-.\u00b7\u00c0-\u00d6\u00d8-\u00f6\u00f8-\u037d\u037f-\u1fff\u200c-\u200d\u203f-\u2040\u2070-\u218f\u2c00-\u2fef\u3001-\ud7ff\uf900-\ufdcf\ufdf0-\ufffd]+)$/;
-
-  return Optional.from(validChildRegExp.exec(name)).map((matches) => ({
-    preset: matches[1] === '@',
-    name: matches[2]
-  }));
-};
-
-export const parseValidChildrenRules = (value: string): ValidChildrenRule[] => {
-  // see: https://html.spec.whatwg.org/#valid-custom-element-name
-  const childRuleRegExp = /^([+\-]?)([A-Za-z0-9_\-.\u00b7\u00c0-\u00d6\u00d8-\u00f6\u00f8-\u037d\u037f-\u1fff\u200c-\u200d\u203f-\u2040\u2070-\u218f\u2c00-\u2fef\u3001-\ud7ff\uf900-\ufdcf\ufdf0-\ufffd]+)\[([^\]]+)]$/; // from w3c's custom grammar (above)
-
-  return Arr.bind(SchemaUtils.split(value, ','), (rule) => {
-    const matches = childRuleRegExp.exec(rule);
-
-    if (matches) {
-      const prefix = matches[1];
-      const operation = prefix ? prefixToOperation(prefix) : 'replace';
-      const name = matches[2];
-      const validChildren = Arr.bind(SchemaUtils.split(matches[3], '|'), (validChild) =>
-        parseValidChild(validChild).toArray()
-      );
-
-      return [{ operation, name, validChildren }];
-    } else {
-      return [];
-    }
-  });
-};
-

package/src/core/main/ts/schema/ValidElementsRuleParser.ts

@@ -1,138 +0,0 @@
-import { Arr, Obj, Optional } from '@ephox/katamari';
-
-import Tools from '../api/util/Tools';
-import { Attribute, AttributePattern, ElementRule, SchemaElement } from './SchemaTypes';
-import * as SchemaUtils from './SchemaUtils';
-
-export interface SchemaElementPair {
-  readonly name: string;
-  readonly element: SchemaElement;
-  readonly aliasName?: string;
-}
-
-const parseValidElementsAttrDataIntoElement = (attrData: string, targetElement: ElementRule) => {
-  const attrRuleRegExp = /^([!\-])?(\w+[\\:]:\w+|[^=~<]+)?(?:([=~<])(.*))?$/;
-  const hasPatternsRegExp = /[*?+]/;
-  const { attributes, attributesOrder } = targetElement;
-
-  return Arr.each(SchemaUtils.split(attrData, '|'), (rule) => {
-    const matches = attrRuleRegExp.exec(rule);
-
-    if (matches) {
-      const attr: Attribute = {};
-      const attrType = matches[1];
-      const attrName = matches[2].replace(/[\\:]:/g, ':');
-      const attrPrefix = matches[3];
-      const value = matches[4];
-
-      // Required
-      if (attrType === '!') {
-        targetElement.attributesRequired = targetElement.attributesRequired || [];
-        targetElement.attributesRequired.push(attrName);
-        attr.required = true;
-      }
-
-      // Denied from global
-      if (attrType === '-') {
-        delete attributes[attrName];
-        attributesOrder.splice(Tools.inArray(attributesOrder, attrName), 1);
-        return;
-      }
-
-      // Default value
-      if (attrPrefix) {
-        if (attrPrefix === '=') { // Default value
-          targetElement.attributesDefault = targetElement.attributesDefault || [];
-          targetElement.attributesDefault.push({ name: attrName, value });
-          attr.defaultValue = value;
-        } else if (attrPrefix === '~') {// Forced value
-          targetElement.attributesForced = targetElement.attributesForced || [];
-          targetElement.attributesForced.push({ name: attrName, value });
-          attr.forcedValue = value;
-        } else if (attrPrefix === '<') { // Required values
-          attr.validValues = Tools.makeMap(value, '?');
-        }
-      }
-
-      // Check for attribute patterns
-      if (hasPatternsRegExp.test(attrName)) {
-        const attrPattern = attr as AttributePattern;
-        targetElement.attributePatterns = targetElement.attributePatterns || [];
-        attrPattern.pattern = SchemaUtils.patternToRegExp(attrName);
-        targetElement.attributePatterns.push(attrPattern);
-      } else {
-        // Add attribute to order list if it doesn't already exist
-        if (!attributes[attrName]) {
-          attributesOrder.push(attrName);
-        }
-
-        attributes[attrName] = attr;
-      }
-    }
-  });
-};
-
-const cloneAttributesInto = (from: SchemaElement, to: SchemaElement) => {
-  Obj.each(from.attributes, (value, key) => {
-    to.attributes[key] = value;
-  });
-
-  to.attributesOrder.push(...from.attributesOrder);
-};
-
-export const parseValidElementsRules = (globalElement: Optional<SchemaElement>, validElements: string): SchemaElementPair[] => {
-  const elementRuleRegExp = /^([#+\-])?([^\[!\/]+)(?:\/([^\[!]+))?(?:(!?)\[([^\]]+)])?$/;
-
-  return Arr.bind(SchemaUtils.split(validElements, ','), (rule) => {
-    const matches = elementRuleRegExp.exec(rule);
-
-    if (matches) {
-      const prefix = matches[1];
-      const elementName = matches[2];
-      const outputName = matches[3];
-      const attrsPrefix = matches[4];
-      const attrData = matches[5];
-
-      const element: SchemaElement = {
-        attributes: {},
-        attributesOrder: []
-      };
-
-      globalElement.each((el) => cloneAttributesInto(el, element));
-
-      if (prefix === '#') {
-        element.paddEmpty = true;
-      } else if (prefix === '-') {
-        element.removeEmpty = true;
-      }
-
-      if (attrsPrefix === '!') {
-        element.removeEmptyAttrs = true;
-      }
-
-      if (attrData) {
-        parseValidElementsAttrDataIntoElement(attrData, element);
-      }
-
-      // Handle substitute elements such as b/strong
-      if (outputName) {
-        element.outputName = elementName;
-      }
-
-      // Mutate the local globalElement option state if we find a global @ rule
-      if (elementName === '@') {
-        // We only care about the first one
-        if (globalElement.isNone()) {
-          globalElement = Optional.some(element);
-        } else {
-          return [];
-        }
-      }
-
-      return [ outputName ? { name: elementName, element, aliasName: outputName } : { name: elementName, element } ];
-    } else {
-      return [];
-    }
-  });
-};
-

package/src/core/main/ts/selection/CaretRangeFromPoint.ts

@@ -1,15 +0,0 @@
-import { SugarElement, Traverse, WindowSelection } from '@ephox/sugar';
-
-const fromPoint = (clientX: number, clientY: number, doc: Document): Range | undefined => {
-  const win = Traverse.defaultView(SugarElement.fromDom(doc));
-  return WindowSelection.getAtPoint(win.dom, clientX, clientY).map((simRange) => {
-    const rng = doc.createRange();
-    rng.setStart(simRange.start.dom, simRange.soffset);
-    rng.setEnd(simRange.finish.dom, simRange.foffset);
-    return rng;
-  }).getOrUndefined();
-};
-
-export {
-  fromPoint
-};

package/src/core/main/ts/selection/DetailsElement.ts

@@ -1,41 +0,0 @@
-import { Arr } from '@ephox/katamari';
-
-import Editor from '../api/Editor';
-import * as Options from '../api/Options';
-
-const preventSummaryToggle = (editor: Editor): void => {
-  editor.on('click', (e) => {
-    if (editor.dom.getParent(e.target, 'details')) {
-      e.preventDefault();
-    }
-  });
-};
-
-const filterDetails = (editor: Editor): void => {
-  editor.parser.addNodeFilter('details', (elms) => {
-    const initialStateOption = Options.getDetailsInitialState(editor);
-    Arr.each(elms, (details) => {
-      if (initialStateOption === 'expanded') {
-        details.attr('open', 'open');
-      } else if (initialStateOption === 'collapsed') {
-        details.attr('open', null);
-      }
-    });
-  });
-
-  editor.serializer.addNodeFilter('details', (elms) => {
-    const serializedStateOption = Options.getDetailsSerializedState(editor);
-    Arr.each(elms, (details) => {
-      if (serializedStateOption === 'expanded') {
-        details.attr('open', 'open');
-      } else if (serializedStateOption === 'collapsed') {
-        details.attr('open', null);
-      }
-    });
-  });
-};
-
-export const setup = (editor: Editor): void => {
-  preventSummaryToggle(editor);
-  filterDetails(editor);
-};

package/src/core/main/ts/selection/EditableRange.ts

@@ -1,9 +0,0 @@
-import DOMUtils from '../api/dom/DOMUtils';
-
-export const isEditableRange = (dom: DOMUtils, rng: Range | StaticRange): boolean => {
-  if (rng.collapsed) {
-    return dom.isEditable(rng.startContainer);
-  } else {
-    return dom.isEditable(rng.startContainer) && dom.isEditable(rng.endContainer);
-  }
-};

package/src/core/main/ts/selection/ElementSelection.ts

@@ -1,148 +0,0 @@
-import { Optional } from '@ephox/katamari';
-import { SugarElement, SugarNode, Traverse } from '@ephox/sugar';
-
-import DOMUtils from '../api/dom/DOMUtils';
-import DomTreeWalker from '../api/dom/TreeWalker';
-import * as NodeType from '../dom/NodeType';
-import { moveEndPoint } from './SelectionUtils';
-
-const getEndpointElement = (
-  root: Element,
-  rng: Range,
-  start: boolean,
-  real: boolean,
-  resolve: (elm: SugarElement<Node>, offset: number) => number
-): Element => {
-  const container = start ? rng.startContainer : rng.endContainer;
-  const offset = start ? rng.startOffset : rng.endOffset;
-
-  return Optional.from(container)
-    .map(SugarElement.fromDom)
-    .map((elm) => !real || !rng.collapsed ? Traverse.child(elm, resolve(elm, offset)).getOr(elm) : elm)
-    .bind((elm) => SugarNode.isElement(elm) ? Optional.some(elm) : Traverse.parent(elm).filter(SugarNode.isElement))
-    .map((elm) => elm.dom)
-    .getOr(root);
-};
-
-const getStart = (root: Element, rng: Range, real: boolean = false): Element =>
-  getEndpointElement(root, rng, true, real, (elm, offset) => Math.min(Traverse.childNodesCount(elm), offset));
-
-const getEnd = (root: Element, rng: Range, real: boolean = false): Element =>
-  getEndpointElement(root, rng, false, real, (elm, offset) => offset > 0 ? offset - 1 : offset);
-
-const skipEmptyTextNodes = (node: Node | null, forwards: boolean): Node | null => {
-  const orig = node;
-
-  while (node && NodeType.isText(node) && node.length === 0) {
-    node = forwards ? node.nextSibling : node.previousSibling;
-  }
-
-  return node || orig;
-};
-
-const getNode = (root: HTMLElement, rng: Range | undefined): HTMLElement => {
-  // Range maybe lost after the editor is made visible again
-  if (!rng) {
-    return root;
-  }
-
-  let startContainer: Node | null = rng.startContainer;
-  let endContainer: Node | null = rng.endContainer;
-  const startOffset = rng.startOffset;
-  const endOffset = rng.endOffset;
-  let node = rng.commonAncestorContainer;
-
-  // Handle selection a image or other control like element such as anchors
-  if (!rng.collapsed) {
-    if (startContainer === endContainer) {
-      if (endOffset - startOffset < 2) {
-        if (startContainer.hasChildNodes()) {
-          node = startContainer.childNodes[startOffset];
-        }
-      }
-    }
-
-    // If the anchor node is a element instead of a text node then return this element
-    // if (tinymce.isWebKit && sel.anchorNode && sel.anchorNode.nodeType == 1)
-    // return sel.anchorNode.childNodes[sel.anchorOffset];
-
-    // Handle cases where the selection is immediately wrapped around a node and return that node instead of it's parent.
-    // This happens when you double click an underlined word in FireFox.
-    if (NodeType.isText(startContainer) && NodeType.isText(endContainer)) {
-      if (startContainer.length === startOffset) {
-        startContainer = skipEmptyTextNodes(startContainer.nextSibling, true);
-      } else {
-        startContainer = startContainer.parentNode;
-      }
-
-      if (endOffset === 0) {
-        endContainer = skipEmptyTextNodes(endContainer.previousSibling, false);
-      } else {
-        endContainer = endContainer.parentNode;
-      }
-
-      if (startContainer && startContainer === endContainer) {
-        node = startContainer;
-      }
-    }
-  }
-
-  const elm = NodeType.isText(node) ? node.parentNode : node;
-  return NodeType.isHTMLElement(elm) ? elm : root;
-};
-
-const getSelectedBlocks = (dom: DOMUtils, rng: Range, startElm?: Element, endElm?: Element): Element[] => {
-  const selectedBlocks: Element[] = [];
-
-  const root = dom.getRoot();
-  const start = dom.getParent(startElm || getStart(root, rng, rng.collapsed), dom.isBlock);
-  const end = dom.getParent(endElm || getEnd(root, rng, rng.collapsed), dom.isBlock);
-
-  if (start && start !== root) {
-    selectedBlocks.push(start);
-  }
-
-  if (start && end && start !== end) {
-    let node: Node | null | undefined;
-
-    const walker = new DomTreeWalker(start, root);
-    while ((node = walker.next()) && node !== end) {
-      if (dom.isBlock(node)) {
-        selectedBlocks.push(node);
-      }
-    }
-  }
-
-  if (end && start !== end && end !== root) {
-    selectedBlocks.push(end);
-  }
-
-  return selectedBlocks;
-};
-
-const select = (dom: DOMUtils, node: Node | null, content?: boolean): Optional<Range> =>
-  Optional.from(node).bind((node) =>
-    Optional.from(node.parentNode).map((parent) => {
-      const idx = dom.nodeIndex(node);
-      const rng = dom.createRng();
-
-      rng.setStart(parent, idx);
-      rng.setEnd(parent, idx + 1);
-
-      // Find first/last text node or BR element
-      if (content) {
-        moveEndPoint(dom, rng, node, true);
-        moveEndPoint(dom, rng, node, false);
-      }
-
-      return rng;
-    })
-  );
-
-export {
-  getStart,
-  getEnd,
-  getNode,
-  getSelectedBlocks,
-  select
-};

package/src/core/main/ts/selection/EventProcessRanges.ts

@@ -1,12 +0,0 @@
-import { Arr } from '@ephox/katamari';
-
-import Editor from '../api/Editor';
-
-const processRanges = (editor: Editor, ranges: Range[]): Range[] => Arr.map(ranges, (range) => {
-  const evt = editor.dispatch('GetSelectionRange', { range });
-  return evt.range !== range ? evt.range : range;
-});
-
-export {
-  processRanges
-};

package/src/core/main/ts/selection/FragmentReader.ts

@@ -1,87 +0,0 @@
-import { Arr, Fun, Obj, Optional, Strings } from '@ephox/katamari';
-import { Compare, Css, Insert, Replication, SelectorFind, SugarElement, SugarFragment, SugarNode, Traverse } from '@ephox/sugar';
-
-import Schema from '../api/html/Schema';
-import * as ElementType from '../dom/ElementType';
-import * as Parents from '../dom/Parents';
-import * as SelectionUtils from './SelectionUtils';
-import * as SimpleTableModel from './SimpleTableModel';
-import * as TableCellSelection from './TableCellSelection';
-
-const findParentListContainer = (parents: SugarElement[]): Optional<SugarElement<HTMLLIElement | HTMLOListElement>> =>
-  Arr.find(parents, (elm) => SugarNode.name(elm) === 'ul' || SugarNode.name(elm) === 'ol');
-
-const getFullySelectedListWrappers = (parents: SugarElement<Node>[], rng: Range) =>
-  Arr.find(parents, (elm) => SugarNode.name(elm) === 'li' && SelectionUtils.hasAllContentsSelected(elm, rng)).fold(
-    Fun.constant([]),
-    (_li) =>
-      findParentListContainer(parents).map((listCont) => {
-        const listElm = SugarElement.fromTag(SugarNode.name(listCont));
-        // Retain any list-style* styles when generating the new fragment
-        const listStyles = Obj.filter(Css.getAllRaw(listCont), (_style, name) => Strings.startsWith(name, 'list-style'));
-        Css.setAll(listElm, listStyles);
-        return [
-          SugarElement.fromTag('li'),
-          listElm
-        ];
-      }).getOr([])
-  );
-
-const wrap = (innerElm: SugarElement<Node>, elms: SugarElement<Node>[]) => {
-  const wrapped = Arr.foldl(elms, (acc, elm) => {
-    Insert.append(elm, acc);
-    return elm;
-  }, innerElm);
-  return elms.length > 0 ? SugarFragment.fromElements([ wrapped ]) : wrapped;
-};
-
-const directListWrappers = (commonAnchorContainer: SugarElement<Node>) => {
-  if (ElementType.isListItem(commonAnchorContainer)) {
-    return Traverse.parent(commonAnchorContainer).filter(ElementType.isList).fold(
-      Fun.constant([]),
-      (listElm) => [ commonAnchorContainer, listElm ]
-    );
-  } else {
-    return ElementType.isList(commonAnchorContainer) ? [ commonAnchorContainer ] : [ ];
-  }
-};
-
-const getWrapElements = (rootNode: SugarElement<Node>, rng: Range, schema: Schema) => {
-  const commonAnchorContainer = SugarElement.fromDom(rng.commonAncestorContainer);
-  const parents = Parents.parentsAndSelf(commonAnchorContainer, rootNode);
-  const wrapElements = Arr.filter(parents, (el) => schema.isWrapper(SugarNode.name(el)));
-  const listWrappers = getFullySelectedListWrappers(parents, rng);
-  const allWrappers = wrapElements.concat(listWrappers.length ? listWrappers : directListWrappers(commonAnchorContainer));
-  return Arr.map(allWrappers, Replication.shallow);
-};
-
-const emptyFragment = () => SugarFragment.fromElements([]);
-
-const getFragmentFromRange = (rootNode: SugarElement<Node>, rng: Range, schema: Schema) =>
-  wrap(SugarElement.fromDom(rng.cloneContents()), getWrapElements(rootNode, rng, schema));
-
-const getParentTable = (rootElm: SugarElement<Node>, cell: SugarElement<HTMLTableCellElement>): Optional<SugarElement<HTMLTableElement>> =>
-  SelectorFind.ancestor(cell, 'table', Fun.curry(Compare.eq, rootElm));
-
-const getTableFragment = (rootNode: SugarElement<Node>, selectedTableCells: SugarElement<HTMLTableCellElement>[]) =>
-  getParentTable(rootNode, selectedTableCells[0]).bind((tableElm) => {
-    const firstCell = selectedTableCells[0];
-    const lastCell = selectedTableCells[selectedTableCells.length - 1];
-    const fullTableModel = SimpleTableModel.fromDom(tableElm);
-
-    return SimpleTableModel.subsection(fullTableModel, firstCell, lastCell).map((sectionedTableModel) =>
-      SugarFragment.fromElements([ SimpleTableModel.toDom(sectionedTableModel) ])
-    );
-  }).getOrThunk(emptyFragment);
-
-const getSelectionFragment = (rootNode: SugarElement<Node>, ranges: Range[], schema: Schema) =>
-  ranges.length > 0 && ranges[0].collapsed ? emptyFragment() : getFragmentFromRange(rootNode, ranges[0], schema);
-
-const read = (rootNode: SugarElement<Element>, ranges: Range[], schema: Schema): SugarElement<Node> => {
-  const selectedCells = TableCellSelection.getCellsFromElementOrRanges(ranges, rootNode);
-  return selectedCells.length > 0 ? getTableFragment(rootNode, selectedCells) : getSelectionFragment(rootNode, ranges, schema);
-};
-
-export {
-  read
-};

package/src/core/main/ts/selection/GetSelectionContent.ts

@@ -1,11 +0,0 @@
-import Editor from '../api/Editor';
-import { Content, ContentFormat, GetSelectionContentArgs } from '../content/ContentTypes';
-import * as Rtc from '../Rtc';
-
-const getContent = (editor: Editor, args: Partial<GetSelectionContentArgs> = {}): Content => {
-  const format: ContentFormat = args.format ? args.format : 'html';
-
-  return Rtc.getSelectedContent(editor, format, args);
-};
-
-export { getContent };

package/src/core/main/ts/selection/GetSelectionContentImpl.ts

@@ -1,104 +0,0 @@
-import { Fun, Optional } from '@ephox/katamari';
-import { SugarElement } from '@ephox/sugar';
-
-import Editor from '../api/Editor';
-import { cleanupBogusElements, cleanupInputNames } from '../content/ContentCleanup';
-import { Content, ContentFormat, GetSelectionContentArgs } from '../content/ContentTypes';
-import { postProcessGetContent, preProcessGetContent } from '../content/PrePostProcess';
-import * as CharType from '../text/CharType';
-import * as Zwsp from '../text/Zwsp';
-import * as EventProcessRanges from './EventProcessRanges';
-import * as FragmentReader from './FragmentReader';
-import * as MultiRange from './MultiRange';
-
-const isCollapsibleWhitespace = (text: string, index: number) => index >= 0 && index < text.length && CharType.isWhiteSpace(text.charAt(index));
-
-const getInnerText = (bin: HTMLElement) => {
-  return Zwsp.trim(bin.innerText);
-};
-
-const getContextNodeName = (parentBlockOpt: Optional<HTMLElement>): string =>
-  parentBlockOpt.map((block) => block.nodeName).getOr('div').toLowerCase();
-
-const getTextContent = (editor: Editor): string =>
-  Optional.from(editor.selection.getRng()).map((rng) => {
-    const parentBlockOpt = Optional.from(editor.dom.getParent<HTMLElement>(rng.commonAncestorContainer, editor.dom.isBlock));
-    const body = editor.getBody();
-
-    const contextNodeName = getContextNodeName(parentBlockOpt);
-
-    const rangeContentClone = SugarElement.fromDom(rng.cloneContents());
-    cleanupBogusElements(rangeContentClone);
-    cleanupInputNames(rangeContentClone);
-
-    const bin = editor.dom.add(body, contextNodeName, {
-      'data-mce-bogus': 'all',
-      'style': 'overflow: hidden; opacity: 0;'
-    }, rangeContentClone.dom);
-
-    const text = getInnerText(bin);
-
-    // textContent will not strip leading/trailing spaces since it doesn't consider how it'll render
-    const nonRenderedText = Zwsp.trim(bin.textContent ?? '');
-    editor.dom.remove(bin);
-
-    if (isCollapsibleWhitespace(nonRenderedText, 0) || isCollapsibleWhitespace(nonRenderedText, nonRenderedText.length - 1)) {
-      // If the bin contains a trailing/leading space, then we need to inspect the parent block to see if we should include the spaces
-      const parentBlock = parentBlockOpt.getOr(body);
-      const parentBlockText = getInnerText(parentBlock);
-      const textIndex = parentBlockText.indexOf(text);
-
-      if (textIndex === -1) {
-        return text;
-      } else {
-        const hasProceedingSpace = isCollapsibleWhitespace(parentBlockText, textIndex - 1);
-        const hasTrailingSpace = isCollapsibleWhitespace(parentBlockText, textIndex + text.length);
-        return (hasProceedingSpace ? ' ' : '') + text + (hasTrailingSpace ? ' ' : '');
-      }
-    } else {
-      return text;
-    }
-  }).getOr('');
-
-const getSerializedContent = (editor: Editor, args: GetSelectionContentArgs): Content => {
-  const rng = editor.selection.getRng(), tmpElm = editor.dom.create('body');
-  const sel = editor.selection.getSel();
-  const ranges = EventProcessRanges.processRanges(editor, MultiRange.getRanges(sel));
-
-  const fragment = args.contextual ? FragmentReader.read(SugarElement.fromDom(editor.getBody()), ranges, editor.schema).dom : rng.cloneContents();
-  if (fragment) {
-    tmpElm.appendChild(fragment);
-  }
-
-  return editor.selection.serializer.serialize(tmpElm, args);
-};
-
-const extractSelectedContent = (editor: Editor, args: GetSelectionContentArgs): Content => {
-  if (args.format === 'text') {
-    return getTextContent(editor);
-  } else {
-    const content = getSerializedContent(editor, args);
-
-    if (args.format === 'tree') {
-      return content;
-    } else {
-      return editor.selection.isCollapsed() ? '' : content as string;
-    }
-  }
-};
-
-const setupArgs = (args: Partial<GetSelectionContentArgs>, format: ContentFormat): GetSelectionContentArgs => ({
-  ...args,
-  format,
-  get: true,
-  selection: true,
-  getInner: true
-});
-
-export const getSelectedContentInternal = (editor: Editor, format: ContentFormat, args: Partial<GetSelectionContentArgs> = {}): Content => {
-  const defaultedArgs = setupArgs(args, format);
-  return preProcessGetContent(editor, defaultedArgs).fold(Fun.identity, (updatedArgs) => {
-    const content = extractSelectedContent(editor, updatedArgs);
-    return postProcessGetContent(editor, content, updatedArgs);
-  });
-};