@thomasfosterau/effect-richtext 0.0.0-stage → 0.1.0

package/dist/view/capturekeys.js

@@ -0,0 +1,282 @@
+import { AllSelection, NodeSelection, Selection, TextSelection } from "../state/selection.js";
+import { chrome, gecko, mac, safari, windows } from "./browser.js";
+import { domIndex, hasBlockDesc, isElt, selectionCollapsed } from "./dom.js";
+import { selectionToDOM } from "./selection.js";
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
+// src/view/capturekeys.ts
+/**
+* A backdrop key mapping that suppresses keys with dangerous default
+* effects and handles block-level cursor motion.
+*
+* @internal
+*/
+function moveSelectionBlock(state, dir) {
+	const { $anchor, $head } = state.selection;
+	const $side = dir > 0 ? $anchor.max($head) : $anchor.min($head);
+	const $start = !$side.parent.inlineContent ? $side : $side.depth ? state.doc.resolveUnsafe(dir > 0 ? $side.afterUnsafe() : $side.beforeUnsafe()) : null;
+	return $start && Selection.findFromOrNull($start, dir);
+}
+function apply(view, sel) {
+	view.dispatchInternal(view.state.tr.setSelectionUnsafe(sel).scrollIntoView());
+	return true;
+}
+function selectHorizontally(view, dir, mods) {
+	const sel = view.state.selection;
+	if (sel instanceof TextSelection) {
+		if (mods.indexOf("s") > -1) {
+			const { $head } = sel, node = $head.textOffset ? null : dir < 0 ? $head.nodeBeforeOrNull : $head.nodeAfterOrNull;
+			if (!node || node.isText || !node.isLeaf) return false;
+			const $newHead = view.state.doc.resolveUnsafe($head.pos + node.nodeSize * (dir < 0 ? -1 : 1));
+			return apply(view, new TextSelection(sel.$anchor, $newHead));
+		} else if (!sel.empty) return false;
+		else if (view.endOfTextblock(dir > 0 ? "forward" : "backward")) {
+			const next = moveSelectionBlock(view.state, dir);
+			if (next && next instanceof NodeSelection) return apply(view, next);
+			return false;
+		} else if (!(mac && mods.indexOf("m") > -1)) {
+			const $head = sel.$head, node = $head.textOffset ? null : dir < 0 ? $head.nodeBeforeOrNull : $head.nodeAfterOrNull;
+			let desc;
+			if (!node || node.isText) return false;
+			const nodePos = dir < 0 ? $head.pos - node.nodeSize : $head.pos;
+			if (!(node.isAtom || (desc = view.docView.descAt(nodePos)) && !desc.contentDOM)) return false;
+			if (NodeSelection.isSelectable(node)) return apply(view, new NodeSelection(dir < 0 ? view.state.doc.resolveUnsafe($head.pos - node.nodeSize) : $head));
+			else return apply(view, new TextSelection(view.state.doc.resolveUnsafe(dir < 0 ? nodePos : nodePos + node.nodeSize)));
+		}
+		return false;
+	} else if (sel instanceof NodeSelection && sel.node.isInline) return apply(view, new TextSelection(dir > 0 ? sel.$to : sel.$from));
+	else {
+		const next = moveSelectionBlock(view.state, dir);
+		if (next) return apply(view, next);
+		return false;
+	}
+}
+function nodeLen(node) {
+	return node.nodeType == 3 ? node.nodeValue.length : node.childNodes.length;
+}
+function isIgnorable(dom, dir) {
+	const desc = dom.pmViewDesc;
+	return desc ? desc.size == 0 && (dir < 0 || dom.nextSibling || dom.nodeName != "BR") : isElt(dom) && dom.contentEditable == "false";
+}
+function skipIgnoredNodes(view, dir) {
+	if (dir < 0) skipIgnoredNodesBefore(view);
+	else skipIgnoredNodesAfter(view);
+	return false;
+}
+function skipIgnoredNodesBefore(view) {
+	const sel = view.domSelectionRange();
+	let node = sel.focusNode, offset = sel.focusOffset;
+	if (!node) return;
+	let moveNode, moveOffset, force = false;
+	if (gecko && node.nodeType == 1 && offset < nodeLen(node) && isIgnorable(node.childNodes[offset], -1)) force = true;
+	for (;;) if (offset > 0) {
+		if (node.nodeType != 1) break;
+		else {
+			const before = node.childNodes[offset - 1];
+			if (isIgnorable(before, -1)) {
+				moveNode = node;
+				moveOffset = --offset;
+			} else if (before.nodeType == 3) {
+				node = before;
+				offset = node.nodeValue.length;
+			} else break;
+		}
+	} else if (isBlockNode(node)) break;
+	else {
+		let prev = node.previousSibling;
+		while (prev && isIgnorable(prev, -1)) {
+			moveNode = node.parentNode;
+			moveOffset = domIndex(prev);
+			prev = prev.previousSibling;
+		}
+		if (!prev) {
+			node = node.parentNode;
+			if (node == view.dom) break;
+			offset = 0;
+		} else {
+			node = prev;
+			offset = nodeLen(node);
+		}
+	}
+	if (force) setSelFocus(view, node, offset);
+	else if (moveNode) setSelFocus(view, moveNode, moveOffset);
+}
+function skipIgnoredNodesAfter(view) {
+	const sel = view.domSelectionRange();
+	let node = sel.focusNode, offset = sel.focusOffset;
+	if (!node) return;
+	let len = nodeLen(node);
+	let moveNode, moveOffset;
+	for (;;) if (offset < len) {
+		if (node.nodeType != 1) break;
+		const after = node.childNodes[offset];
+		if (isIgnorable(after, 1)) {
+			moveNode = node;
+			moveOffset = ++offset;
+		} else break;
+	} else if (isBlockNode(node)) break;
+	else {
+		let next = node.nextSibling;
+		while (next && isIgnorable(next, 1)) {
+			moveNode = next.parentNode;
+			moveOffset = domIndex(next) + 1;
+			next = next.nextSibling;
+		}
+		if (!next) {
+			node = node.parentNode;
+			if (node == view.dom) break;
+			offset = len = 0;
+		} else {
+			node = next;
+			offset = 0;
+			len = nodeLen(node);
+		}
+	}
+	if (moveNode) setSelFocus(view, moveNode, moveOffset);
+}
+function isBlockNode(dom) {
+	const desc = dom.pmViewDesc;
+	return desc && desc.node && desc.node.isBlock;
+}
+function textNodeAfter(node, offset) {
+	while (node && offset == node.childNodes.length && !hasBlockDesc(node)) {
+		offset = domIndex(node) + 1;
+		node = node.parentNode;
+	}
+	while (node && offset < node.childNodes.length) {
+		const next = node.childNodes[offset];
+		if (next.nodeType == 3) return next;
+		if (next.nodeType == 1 && next.contentEditable == "false") break;
+		node = next;
+		offset = 0;
+	}
+}
+function textNodeBefore(node, offset) {
+	while (node && !offset && !hasBlockDesc(node)) {
+		offset = domIndex(node);
+		node = node.parentNode;
+	}
+	while (node && offset) {
+		const next = node.childNodes[offset - 1];
+		if (next.nodeType == 3) return next;
+		if (next.nodeType == 1 && next.contentEditable == "false") break;
+		node = next;
+		offset = node.childNodes.length;
+	}
+}
+function setSelFocus(view, node, offset) {
+	if (node.nodeType != 3) {
+		let before, after;
+		if (after = textNodeAfter(node, offset)) {
+			node = after;
+			offset = 0;
+		} else if (before = textNodeBefore(node, offset)) {
+			node = before;
+			offset = before.nodeValue.length;
+		}
+	}
+	const sel = view.domSelection(), range = view.domSelectionRange();
+	if (!sel) return;
+	if (selectionCollapsed(range)) sel.collapse(node, offset);
+	else if (sel.extend) {
+		sel.collapse(range.anchorNode, range.anchorOffset);
+		sel.extend(node, offset);
+	}
+	view.domObserver.setCurSelection();
+	const { state } = view;
+	setTimeout(() => {
+		if (view.state == state) selectionToDOM(view);
+	}, 50);
+}
+function findDirection(view, pos) {
+	const $pos = view.state.doc.resolveUnsafe(pos);
+	if (!(chrome || windows) && $pos.parent.inlineContent) {
+		const coords = view.coordsAtPos(pos);
+		if (pos > $pos.start()) {
+			const before = view.coordsAtPos(pos - 1);
+			const mid = (before.top + before.bottom) / 2;
+			if (mid > coords.top && mid < coords.bottom && Math.abs(before.left - coords.left) > 1) return before.left < coords.left ? "ltr" : "rtl";
+		}
+		if (pos < $pos.end()) {
+			const after = view.coordsAtPos(pos + 1);
+			const mid = (after.top + after.bottom) / 2;
+			if (mid > coords.top && mid < coords.bottom && Math.abs(after.left - coords.left) > 1) return after.left > coords.left ? "ltr" : "rtl";
+		}
+	}
+	const depths = $pos.depth > 0 ? Arr.range(1, $pos.depth).reverse() : [];
+	const blockDOM = Arr.findFirst(depths, (d) => $pos.node(d).isBlock).pipe(Option.flatMap((d) => view.nodeDOM($pos.beforeUnsafe(d))), Option.filter(isElt));
+	return getComputedStyle(Option.getOrElse(blockDOM, () => view.dom)).direction == "rtl" ? "rtl" : "ltr";
+}
+function selectVertically(view, dir, mods) {
+	const sel = view.state.selection;
+	if (sel instanceof TextSelection && !sel.empty || mods.indexOf("s") > -1) return false;
+	if (mac && mods.indexOf("m") > -1) return false;
+	const { $from, $to } = sel;
+	if (!$from.parent.inlineContent || view.endOfTextblock(dir < 0 ? "up" : "down")) {
+		const next = moveSelectionBlock(view.state, dir);
+		if (next && next instanceof NodeSelection) return apply(view, next);
+	}
+	if (!$from.parent.inlineContent) {
+		const side = dir < 0 ? $from : $to;
+		const beyond = sel instanceof AllSelection ? Selection.near(side, dir) : Selection.findFromOrNull(side, dir);
+		return beyond ? apply(view, beyond) : false;
+	}
+	return false;
+}
+function stopNativeHorizontalDelete(view, dir) {
+	if (!(view.state.selection instanceof TextSelection)) return true;
+	const { $anchor, $head, empty } = view.state.selection;
+	if (!$head.sameParent($anchor)) return true;
+	if (!empty) return false;
+	if (view.endOfTextblock(dir > 0 ? "forward" : "backward")) return true;
+	const nextNode = !$head.textOffset && (dir < 0 ? $head.nodeBeforeOrNull : $head.nodeAfterOrNull);
+	if (nextNode && !nextNode.isText) {
+		const tr = view.state.tr;
+		if (dir < 0) tr.deleteUnsafe($head.pos - nextNode.nodeSize, $head.pos);
+		else tr.deleteUnsafe($head.pos, $head.pos + nextNode.nodeSize);
+		view.dispatchInternal(tr);
+		return true;
+	}
+	return false;
+}
+function switchEditable(view, node, state) {
+	view.domObserver.stop();
+	node.contentEditable = state;
+	view.domObserver.start();
+}
+function safariDownArrowBug(view) {
+	if (!safari || view.state.selection.$head.parentOffset > 0) return false;
+	const { focusNode, focusOffset } = view.domSelectionRange();
+	if (focusNode && focusNode.nodeType == 1 && focusOffset == 0 && focusNode.firstChild && focusNode.firstChild.contentEditable == "false") {
+		const child = focusNode.firstChild;
+		switchEditable(view, child, "true");
+		setTimeout(() => switchEditable(view, child, "false"), 20);
+	}
+	return false;
+}
+function getMods(event) {
+	let result = "";
+	if (event.ctrlKey) result += "c";
+	if (event.metaKey) result += "m";
+	if (event.altKey) result += "a";
+	if (event.shiftKey) result += "s";
+	return result;
+}
+/** @internal */
+function captureKeyDown(view, event) {
+	const code = event.keyCode, mods = getMods(event);
+	if (code == 8 || mac && code == 72 && mods == "c") return stopNativeHorizontalDelete(view, -1) || skipIgnoredNodes(view, -1);
+	else if (code == 46 && !event.shiftKey || mac && code == 68 && mods == "c") return stopNativeHorizontalDelete(view, 1) || skipIgnoredNodes(view, 1);
+	else if (code == 13 || code == 27) return true;
+	else if (code == 37 || mac && code == 66 && mods == "c") {
+		const dir = code == 37 ? findDirection(view, view.state.selection.from) == "ltr" ? -1 : 1 : -1;
+		return selectHorizontally(view, dir, mods) || skipIgnoredNodes(view, dir);
+	} else if (code == 39 || mac && code == 70 && mods == "c") {
+		const dir = code == 39 ? findDirection(view, view.state.selection.from) == "ltr" ? 1 : -1 : 1;
+		return selectHorizontally(view, dir, mods) || skipIgnoredNodes(view, dir);
+	} else if (code == 38 || mac && code == 80 && mods == "c") return selectVertically(view, -1, mods) || skipIgnoredNodes(view, -1);
+	else if (code == 40 || mac && code == 78 && mods == "c") return safariDownArrowBug(view) || selectVertically(view, 1, mods) || skipIgnoredNodes(view, 1);
+	else if (mods == (mac ? "m" : "c") && (code == 66 || code == 73 || code == 89 || code == 90)) return true;
+	return false;
+}
+export { captureKeyDown };

package/dist/view/clipboard.d.ts

@@ -0,0 +1,8 @@
+import { ResolvedPos } from "../model/resolvedpos.js";
+import { Slice } from "../model/replace.js";
+import "../model.js";
+import { EditorView } from "./view.js";
+type AnyView = EditorView<any, any, any>;
+/** @internal */
+export declare function parseFromClipboard(view: AnyView, text: string, html: string | null, plainText: boolean, $context: ResolvedPos<any>): Slice<any> | null;
+export {};

package/dist/view/clipboard.js

@@ -0,0 +1,245 @@
+import { DOMParser } from "../model/from_dom.js";
+import { DOMSerializer } from "../model/to_dom.js";
+import { Fragment } from "../model/fragment.js";
+import { Slice } from "../model/replace.js";
+import { parseJson, stringifyJson } from "../internal/json.js";
+import { chrome, webkit } from "./browser.js";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+// src/view/clipboard.ts
+/**
+* Clipboard serialization and parsing.
+*
+* @internal
+*/
+/** @internal */
+function serializeForClipboard(view, slice) {
+	view.someProp("transformCopied", (f) => {
+		slice = f(slice, view);
+	});
+	const context = [];
+	let { content, openEnd, openStart } = slice;
+	while (openStart > 1 && openEnd > 1 && content.childCount == 1 && content.content[0].childCount == 1) {
+		openStart--;
+		openEnd--;
+		const node = content.content[0];
+		context.push(node.type.name, node.attrs != node.type.defaultAttrs ? node.attrs : null);
+		content = node.content;
+	}
+	const serializer = view.someProp("clipboardSerializer") || DOMSerializer.fromSchema(view.state.schema);
+	const doc = detachedDoc(), wrap = doc.createElement("div");
+	wrap.appendChild(serializer.serializeFragment(content, { document: doc }));
+	let firstChild = wrap.firstChild, needsWrap, wrappers = 0;
+	while (firstChild && firstChild.nodeType == 1 && (needsWrap = wrapMap[firstChild.nodeName.toLowerCase()])) {
+		for (let i = needsWrap.length - 1; i >= 0; i--) {
+			const wrapper = doc.createElement(needsWrap[i]);
+			while (wrap.firstChild) wrapper.appendChild(wrap.firstChild);
+			wrap.appendChild(wrapper);
+			wrappers++;
+		}
+		firstChild = wrap.firstChild;
+	}
+	if (firstChild && firstChild.nodeType == 1) firstChild.setAttribute("data-pm-slice", `${openStart} ${openEnd}${wrappers ? ` -${wrappers}` : ""} ${Option.getOrElse(stringifyJson(context), () => "[]")}`);
+	return {
+		dom: wrap,
+		text: view.someProp("clipboardTextSerializer", (f) => f(slice, view)) || slice.content.textBetween(0, slice.content.size, "\n\n"),
+		slice
+	};
+}
+/** @internal */
+function parseFromClipboard(view, text, html, plainText, $context) {
+	const inCode = $context.parent.type.spec.code;
+	let dom, slice;
+	if (!html && !text) return null;
+	const asText = !!text && (plainText || inCode || !html);
+	if (asText) {
+		view.someProp("transformPastedText", (f) => {
+			text = f(text, !!(inCode || plainText), view);
+		});
+		if (inCode) {
+			slice = new Slice(Fragment.from(view.state.schema.textUnsafe(text.replace(/\r\n?/g, "\n"))), 0, 0);
+			view.someProp("transformPasted", (f) => {
+				slice = f(slice, view, true);
+			});
+			return slice;
+		}
+		const parsed = view.someProp("clipboardTextParser", (f) => f(text, $context, plainText, view));
+		if (parsed) slice = parsed;
+		else {
+			const marks = $context.marks();
+			const { schema } = view.state, serializer = DOMSerializer.fromSchema(schema);
+			dom = document.createElement("div");
+			text.split(/(?:\r\n?|\n)+/).forEach((block) => {
+				const p = dom.appendChild(document.createElement("p"));
+				if (block) p.appendChild(serializer.serializeNode(schema.textUnsafe(block, marks)));
+			});
+		}
+	} else {
+		view.someProp("transformPastedHTML", (f) => {
+			html = f(html, view);
+		});
+		dom = readHTML(html);
+		if (webkit) restoreReplacedSpaces(dom);
+	}
+	const contextNode = dom && dom.querySelector("[data-pm-slice]");
+	const sliceData = contextNode && /^(\d+) (\d+)(?: -(\d+))? (.*)/.exec(contextNode.getAttribute("data-pm-slice") || "");
+	if (sliceData && sliceData[3]) for (let i = +sliceData[3]; i > 0; i--) {
+		let child = dom.firstChild;
+		while (child && child.nodeType != 1) child = child.nextSibling;
+		if (!child) break;
+		dom = child;
+	}
+	if (!slice) slice = (view.someProp("clipboardParser") || view.someProp("domParser") || DOMParser.fromSchema(view.state.schema)).parseSliceUnsafe(dom, {
+		preserveWhitespace: !!(asText || sliceData),
+		context: $context,
+		ruleFromNode(dom) {
+			if (dom.nodeName == "BR" && !dom.nextSibling && dom.parentNode && !inlineParents.test(dom.parentNode.nodeName)) return { ignore: true };
+			return null;
+		}
+	});
+	if (sliceData) slice = addContext(closeSlice(slice, +sliceData[1], +sliceData[2]), sliceData[4]);
+	else {
+		slice = Slice.maxOpen(normalizeSiblings(slice.content, $context), true);
+		if (slice.openStart || slice.openEnd) {
+			let openStart = 0, openEnd = 0;
+			for (let node = slice.content.content[0]; openStart < slice.openStart && !node.type.spec.isolating; openStart++, node = node.content.content[0]);
+			for (let node = slice.content.content[slice.content.childCount - 1]; openEnd < slice.openEnd && !node.type.spec.isolating; openEnd++, node = node.content.content[node.childCount - 1]);
+			slice = closeSlice(slice, openStart, openEnd);
+		}
+	}
+	view.someProp("transformPasted", (f) => {
+		slice = f(slice, view, asText);
+	});
+	return slice;
+}
+const inlineParents = /^(a|abbr|acronym|b|cite|code|del|em|i|ins|kbd|label|output|q|ruby|s|samp|span|strong|sub|sup|time|u|tt|var)$/i;
+function normalizeSiblings(fragment, $context) {
+	if (fragment.childCount < 2) return fragment;
+	for (let d = $context.depth; d >= 0; d--) {
+		let match = $context.node(d).contentMatchAtUnsafe($context.index(d));
+		let lastWrap, result = [];
+		fragment.forEach((node) => {
+			if (!result) return;
+			const wrap = match.findWrappingOrNull(node.type);
+			let inLast;
+			if (!wrap) return result = null;
+			if (inLast = result.length && lastWrap.length && addToSibling(wrap, lastWrap, node, result[result.length - 1], 0)) result[result.length - 1] = inLast;
+			else {
+				if (result.length) result[result.length - 1] = closeRight(result[result.length - 1], lastWrap.length);
+				const wrapped = withWrappers(node, wrap);
+				result.push(wrapped);
+				match = match.matchTypeOrNull(wrapped.type);
+				lastWrap = wrap;
+			}
+		});
+		if (result) return Fragment.from(result);
+	}
+	return fragment;
+}
+function withWrappers(node, wrap, from = 0) {
+	for (let i = wrap.length - 1; i >= from; i--) node = wrap[i].createUnsafe(null, Fragment.from(node));
+	return node;
+}
+function addToSibling(wrap, lastWrap, node, sibling, depth) {
+	if (depth < wrap.length && depth < lastWrap.length && wrap[depth] == lastWrap[depth]) {
+		const inner = addToSibling(wrap, lastWrap, node, sibling.content.content[sibling.childCount - 1], depth + 1);
+		if (inner) return sibling.copy(sibling.content.replaceChild(sibling.childCount - 1, inner));
+		if (sibling.contentMatchAtUnsafe(sibling.childCount).matchTypeOrNull(depth == wrap.length - 1 ? node.type : wrap[depth + 1])) return sibling.copy(sibling.content.append(Fragment.from(withWrappers(node, wrap, depth + 1))));
+	}
+}
+function closeRight(node, depth) {
+	if (depth == 0) return node;
+	const fragment = node.content.replaceChild(node.childCount - 1, closeRight(node.content.content[node.childCount - 1], depth - 1));
+	const fill = node.contentMatchAtUnsafe(node.childCount).fillBeforeOrNull(Fragment.empty, true);
+	return node.copy(fragment.append(fill));
+}
+function closeRange(fragment, side, from, to, depth, openEnd) {
+	const node = side < 0 ? fragment.content[0] : fragment.content[fragment.childCount - 1];
+	let inner = node.content;
+	if (fragment.childCount > 1) openEnd = 0;
+	if (depth < to - 1) inner = closeRange(inner, side, from, to, depth + 1, openEnd);
+	if (depth >= from) inner = side < 0 ? node.contentMatchAtUnsafe(0).fillBeforeOrNull(inner, openEnd <= depth).append(inner) : inner.append(node.contentMatchAtUnsafe(node.childCount).fillBeforeOrNull(Fragment.empty, true));
+	return fragment.replaceChild(side < 0 ? 0 : fragment.childCount - 1, node.copy(inner));
+}
+function closeSlice(slice, openStart, openEnd) {
+	if (openStart < slice.openStart) slice = new Slice(closeRange(slice.content, -1, openStart, slice.openStart, 0, slice.openEnd), openStart, slice.openEnd);
+	if (openEnd < slice.openEnd) slice = new Slice(closeRange(slice.content, 1, openEnd, slice.openEnd, 0, 0), slice.openStart, openEnd);
+	return slice;
+}
+const wrapMap = {
+	thead: ["table"],
+	tbody: ["table"],
+	tfoot: ["table"],
+	caption: ["table"],
+	colgroup: ["table"],
+	col: ["table", "colgroup"],
+	tr: ["table", "tbody"],
+	td: [
+		"table",
+		"tbody",
+		"tr"
+	],
+	th: [
+		"table",
+		"tbody",
+		"tr"
+	]
+};
+function detachedDoc() {
+	return document.implementation.createHTMLDocument("title");
+}
+let _policy = null;
+function maybeWrapTrusted(html) {
+	const trustedTypes = window.trustedTypes;
+	if (!trustedTypes) return html;
+	if (!_policy) {
+		const fallback = trustedTypes.defaultPolicy;
+		_policy = fallback && Predicate.isFunction(fallback.createHTML) ? fallback : trustedTypes.createPolicy("ProseMirrorClipboard", { createHTML: (s) => s });
+	}
+	return _policy.createHTML(html);
+}
+function readHTML(html) {
+	const metas = /^(\s*<meta [^>]*>)*/.exec(html);
+	if (metas) html = html.slice(metas[0].length);
+	const doc = detachedDoc();
+	let elt = doc.body;
+	const firstTag = /<([a-z][^>\s]+)/i.exec(html);
+	let wrap;
+	if (wrap = firstTag && wrapMap[firstTag[1].toLowerCase()]) html = wrap.map((n) => "<" + n + ">").join("") + html + wrap.map((n) => "</" + n + ">").reverse().join("");
+	elt.innerHTML = maybeWrapTrusted(html);
+	if (wrap) for (let i = 0; i < wrap.length; i++) elt = elt.querySelector(wrap[i]) || elt;
+	const root = elt;
+	Array.from(doc.styleSheets).forEach((sheet) => Array.from(sheet.cssRules).forEach((rule) => {
+		if (rule instanceof CSSStyleRule) root.querySelectorAll(rule.selectorText).forEach((match) => {
+			match.style.cssText += rule.style.cssText;
+		});
+	}));
+	return elt;
+}
+function restoreReplacedSpaces(dom) {
+	const nodes = dom.querySelectorAll(chrome ? "span:not([class]):not([style])" : "span.Apple-converted-space");
+	for (let i = 0; i < nodes.length; i++) {
+		const node = nodes[i];
+		if (node.childNodes.length == 1 && node.textContent == "\xA0" && node.parentNode) node.parentNode.replaceChild(dom.ownerDocument.createTextNode(" "), node);
+	}
+}
+function addContext(slice, context) {
+	if (!slice.size) return slice;
+	const schema = slice.content.content[0].type.schema;
+	const array = Option.getOrUndefined(parseJson(context));
+	if (!Array.isArray(array)) return slice;
+	let { content, openEnd, openStart } = slice;
+	for (let i = array.length - 2; i >= 0; i -= 2) {
+		const type = schema.nodes[array[i]];
+		if (!type || type.hasRequiredAttrs()) break;
+		try {
+			content = Fragment.from(type.createUnsafe(array[i + 1], content));
+		} catch {
+			break;
+		}
+		openStart++;
+		openEnd++;
+	}
+	return new Slice(content, openStart, openEnd);
+}
+export { parseFromClipboard, serializeForClipboard };