@thomasfosterau/effect-richtext 0.0.0 → 0.1.0

package/dist/model/from_dom.js

@@ -0,0 +1,618 @@
+import { attempt } from "../internal/attempt.js";
+import { SchemaDefinitionError, isModelError } from "./errors.js";
+import { Fragment } from "./fragment.js";
+import { Mark } from "./mark.js";
+import { Slice } from "./replace.js";
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
+// src/model/from_dom.ts
+/**
+* DOM parsing, ported from ProseMirror's `DOMParser`.
+*
+* @since 0.1.0
+*/
+function isTagRule(rule) {
+	return rule.tag != null;
+}
+function isStyleRule(rule) {
+	return rule.style != null;
+}
+const ruleOrigin = /* @__PURE__ */ new WeakMap();
+const originOf = (rule) => ruleOrigin.get(rule) ?? rule;
+function withAttrs(rule, attrs) {
+	const result = {
+		...rule,
+		attrs: attrs || void 0
+	};
+	ruleOrigin.set(result, originOf(rule));
+	return result;
+}
+/**
+* A DOM parser represents a strategy for parsing DOM content into a
+* document conforming to a given schema. Its behavior is defined by an
+* array of [rules](#ParseRule).
+*
+* @since 0.1.0
+* @category models
+*/
+var DOMParser = class DOMParser {
+	/**
+	* Create a parser that targets the given schema, using the given
+	* parsing rules.
+	*/
+	constructor(schema, rules) {
+		this.schema = schema;
+		this.rules = rules;
+		this.tags = [];
+		this.styles = [];
+		const matchedStyles = [];
+		const tags = [], styles = [];
+		rules.forEach((rule) => {
+			if (isTagRule(rule)) tags.push(rule);
+			else if (isStyleRule(rule)) {
+				const prop = /[^=]*/.exec(rule.style)[0];
+				if (matchedStyles.indexOf(prop) < 0) matchedStyles.push(prop);
+				styles.push(rule);
+			}
+		});
+		this.tags = tags;
+		this.styles = styles;
+		this.matchedStyles = matchedStyles;
+		this.normalizeLists = !tags.some((r) => {
+			if (!/^(ul|ol)\b/.test(r.tag) || !r.node) return false;
+			const node = schema.nodes[r.node];
+			return !!node && !!node.contentMatch.matchTypeOrNull(node);
+		});
+	}
+	/** Parse a document from the content of a DOM node. */
+	parse(dom, options = {}) {
+		return attempt(() => this.parseUnsafe(dom, options), isModelError);
+	}
+	/** Like `parse`, but throws a `ModelError` on failure. */
+	parseUnsafe(dom, options = {}) {
+		const context = new ParseContext(this, options, false);
+		context.addAll(dom, Mark.none, options.from, options.to);
+		return context.finish();
+	}
+	/**
+	* Parses the content of the given DOM node, like
+	* [`parse`](#DOMParser.parse), and takes the same set of options.
+	* But unlike that method, which produces a whole node, this one
+	* returns a slice that is open at the sides, meaning that the schema
+	* constraints aren't applied to the start of nodes to the left of
+	* the input and the end of nodes at the end.
+	*/
+	parseSlice(dom, options = {}) {
+		return attempt(() => this.parseSliceUnsafe(dom, options), isModelError);
+	}
+	/** Like `parseSlice`, but throws a `ModelError` on failure. */
+	parseSliceUnsafe(dom, options = {}) {
+		const context = new ParseContext(this, options, true);
+		context.addAll(dom, Mark.none, options.from, options.to);
+		return Slice.maxOpen(context.finish());
+	}
+	/**
+	* Find the first tag rule (after `after`, when given) that matches
+	* the given DOM node in the given context. When the rule has a
+	* `getAttrs` function, the returned rule is a copy whose `attrs` hold
+	* the computed attributes.
+	*/
+	matchTag(dom, context, after) {
+		return Option.fromNullishOr(this.matchTagOrNull(dom, context ?? new ParseContext(this, {}, false), after));
+	}
+	/** @internal */
+	matchTagOrNull(dom, context, after) {
+		for (let i = after ? this.tags.indexOf(originOf(after)) + 1 : 0; i < this.tags.length; i++) {
+			const rule = this.tags[i];
+			if (matches(dom, rule.tag) && (rule.namespace === void 0 || dom.namespaceURI == rule.namespace) && (!rule.context || context.matchesContext(rule.context))) {
+				if (rule.getAttrs) {
+					const result = rule.getAttrs(dom);
+					if (result === false) continue;
+					return withAttrs(rule, result);
+				}
+				return rule;
+			}
+		}
+		return null;
+	}
+	/**
+	* Find the first style rule (after `after`, when given) that matches
+	* the given style property and value in the given context.
+	*/
+	matchStyle(prop, value, context, after) {
+		return Option.fromNullishOr(this.matchStyleOrNull(prop, value, context ?? new ParseContext(this, {}, false), after));
+	}
+	/** @internal */
+	matchStyleOrNull(prop, value, context, after) {
+		for (let i = after ? this.styles.indexOf(originOf(after)) + 1 : 0; i < this.styles.length; i++) {
+			const rule = this.styles[i], style = rule.style;
+			if (style.indexOf(prop) != 0 || rule.context && !context.matchesContext(rule.context) || style.length > prop.length && (style.charCodeAt(prop.length) != 61 || style.slice(prop.length + 1) != value)) continue;
+			if (rule.getAttrs) {
+				const result = rule.getAttrs(value);
+				if (result === false) continue;
+				return withAttrs(rule, result);
+			}
+			return rule;
+		}
+		return null;
+	}
+	/**
+	* Gather the parse rules from a schema's node and mark specs,
+	* ordered by priority (and schema order for equal priorities). Rules
+	* without a `node`/`mark` get the name of the type they were defined
+	* on.
+	*/
+	static schemaRules(schema) {
+		const result = [];
+		function insert(rule) {
+			const priority = rule.priority == null ? 50 : rule.priority;
+			let i = 0;
+			for (; i < result.length; i++) {
+				const next = result[i];
+				if ((next.priority == null ? 50 : next.priority) < priority) break;
+			}
+			result.splice(i, 0, rule);
+		}
+		for (const name in schema.marks) {
+			const rules = schema.marks[name].spec.parseDOM;
+			if (rules) rules.forEach((r) => {
+				const rule = { ...r };
+				if (!(rule.mark || rule.ignore || rule.clearMark)) rule.mark = name;
+				insert(rule);
+			});
+		}
+		for (const name in schema.nodes) {
+			const rules = schema.nodes[name].spec.parseDOM;
+			if (rules) rules.forEach((r) => {
+				const rule = { ...r };
+				if (!(rule.node || rule.ignore || rule.mark)) rule.node = name;
+				insert(rule);
+			});
+		}
+		return result;
+	}
+	/**
+	* Construct a DOM parser using the parsing rules listed in a schema's
+	* node specs, reordered by priority. The parser is cached on the
+	* schema.
+	*/
+	static fromSchema(schema) {
+		return schema.cached.domParser || (schema.cached.domParser = new DOMParser(schema, DOMParser.schemaRules(schema)));
+	}
+};
+const blockTags = {
+	address: true,
+	article: true,
+	aside: true,
+	blockquote: true,
+	body: true,
+	canvas: true,
+	dd: true,
+	div: true,
+	dl: true,
+	fieldset: true,
+	figcaption: true,
+	figure: true,
+	footer: true,
+	form: true,
+	h1: true,
+	h2: true,
+	h3: true,
+	h4: true,
+	h5: true,
+	h6: true,
+	header: true,
+	hgroup: true,
+	hr: true,
+	li: true,
+	noscript: true,
+	ol: true,
+	output: true,
+	p: true,
+	pre: true,
+	section: true,
+	table: true,
+	tfoot: true,
+	ul: true
+};
+const ignoreTags = {
+	head: true,
+	noscript: true,
+	object: true,
+	script: true,
+	style: true,
+	title: true
+};
+const listTags = {
+	ol: true,
+	ul: true
+};
+const hasOwn = (table, key) => Object.prototype.hasOwnProperty.call(table, key);
+const OPT_PRESERVE_WS = 1;
+const OPT_PRESERVE_WS_FULL = 2;
+const OPT_OPEN_LEFT = 4;
+function wsOptionsFor(type, preserveWhitespace, base) {
+	if (preserveWhitespace != null) return (preserveWhitespace ? OPT_PRESERVE_WS : 0) | (preserveWhitespace === "full" ? OPT_PRESERVE_WS_FULL : 0);
+	return type && type.whitespace == "pre" ? 3 : base & -5;
+}
+var NodeContext = class {
+	constructor(type, attrs, marks, solid, match, options) {
+		this.type = type;
+		this.attrs = attrs;
+		this.marks = marks;
+		this.solid = solid;
+		this.options = options;
+		this.content = [];
+		this.activeMarks = Mark.none;
+		this.match = match || (options & OPT_OPEN_LEFT ? null : type.contentMatch);
+	}
+	findWrapping(node) {
+		if (!this.match) {
+			if (!this.type) return [];
+			const fill = this.type.contentMatch.fillBeforeOrNull(Fragment.from(node));
+			if (fill) this.match = this.type.contentMatch.matchFragmentOrNull(fill);
+			else {
+				const start = this.type.contentMatch;
+				const wrap = start.findWrappingOrNull(node.type);
+				if (wrap) {
+					this.match = start;
+					return wrap;
+				} else return null;
+			}
+		}
+		return this.match.findWrappingOrNull(node.type);
+	}
+	finish(openEnd) {
+		if (!(this.options & OPT_PRESERVE_WS)) {
+			const last = this.content[this.content.length - 1];
+			let m;
+			if (last && last.isText && (m = /[ \t\r\n\f]+$/.exec(last.text))) {
+				const text = last;
+				if (text.text.length == m[0].length) this.content.pop();
+				else this.content[this.content.length - 1] = text.withText(text.text.slice(0, text.text.length - m[0].length));
+			}
+		}
+		let content = Fragment.from(this.content);
+		if (!openEnd && this.match) content = content.append(this.match.fillBeforeOrNull(Fragment.empty, true));
+		return this.type ? this.type.createUnsafe(this.attrs, content, this.marks) : content;
+	}
+	inlineContext(node) {
+		if (this.type) return this.type.inlineContent;
+		if (this.content.length) return this.content[0].isInline;
+		return !!node.parentNode && !hasOwn(blockTags, node.parentNode.nodeName.toLowerCase());
+	}
+};
+/** @internal */
+var ParseContext = class {
+	constructor(parser, options, isOpen) {
+		this.parser = parser;
+		this.options = options;
+		this.isOpen = isOpen;
+		this.open = 0;
+		this.localPreserveWS = false;
+		const topNode = options.topNode;
+		let topContext;
+		const topOptions = wsOptionsFor(null, options.preserveWhitespace, 0) | (isOpen ? OPT_OPEN_LEFT : 0);
+		if (topNode) topContext = new NodeContext(topNode.type, topNode.attrs, Mark.none, true, options.topMatch || topNode.type.contentMatch, topOptions);
+		else if (isOpen) topContext = new NodeContext(null, null, Mark.none, true, null, topOptions);
+		else topContext = new NodeContext(parser.schema.topNodeType, null, Mark.none, true, null, topOptions);
+		this.nodes = [topContext];
+		this.find = options.findPositions;
+		this.needsBlock = false;
+	}
+	get top() {
+		return this.nodes[this.open];
+	}
+	addDOM(dom, marks) {
+		if (dom.nodeType == 3) this.addTextNode(dom, marks);
+		else if (dom.nodeType == 1) this.addElement(dom, marks);
+	}
+	addTextNode(dom, marks) {
+		let value = dom.nodeValue;
+		const top = this.top;
+		const preserveWS = top.options & OPT_PRESERVE_WS_FULL ? "full" : this.localPreserveWS || (top.options & OPT_PRESERVE_WS) > 0;
+		const schema = this.parser.schema;
+		const linebreak = Option.getOrNull(schema.linebreakReplacement);
+		if (preserveWS === "full" || top.inlineContext(dom) || /[^ \t\r\n\f]/.test(value)) {
+			if (!preserveWS) {
+				value = value.replace(/[ \t\r\n\f]+/g, " ");
+				if (/^[ \t\r\n\f]/.test(value) && this.open == this.nodes.length - 1) {
+					const nodeBefore = top.content[top.content.length - 1];
+					const domNodeBefore = dom.previousSibling;
+					if (!nodeBefore || domNodeBefore && domNodeBefore.nodeName == "BR" || nodeBefore.isText && /[ \t\r\n\f]$/.test(nodeBefore.text)) value = value.slice(1);
+				}
+			} else if (preserveWS === "full") value = value.replace(/\r\n?/g, "\n");
+			else if (linebreak && /[\r\n]/.test(value) && this.top.findWrapping(linebreak.createUnsafe())) {
+				const lines = value.split(/\r?\n|\r/);
+				for (let i = 0; i < lines.length; i++) {
+					if (i) this.insertNode(linebreak.createUnsafe(), marks, true);
+					if (lines[i]) this.insertNode(schema.textUnsafe(lines[i]), marks, !/\S/.test(lines[i]));
+				}
+				value = "";
+			} else value = value.replace(/\r?\n|\r/g, " ");
+			if (value) this.insertNode(schema.textUnsafe(value), marks, !/\S/.test(value));
+			this.findInText(dom);
+		} else this.findInside(dom);
+	}
+	addElement(dom, marks, matchAfter) {
+		const outerWS = this.localPreserveWS;
+		let top = this.top;
+		if (dom.tagName == "PRE" || /pre/.test(dom.style && dom.style.whiteSpace)) this.localPreserveWS = true;
+		const name = dom.nodeName.toLowerCase();
+		let ruleID;
+		if (hasOwn(listTags, name) && this.parser.normalizeLists) normalizeList(dom);
+		const rule = this.options.ruleFromNode && this.options.ruleFromNode(dom) || (ruleID = this.parser.matchTagOrNull(dom, this, matchAfter));
+		out: if (rule ? rule.ignore : hasOwn(ignoreTags, name)) {
+			this.findInside(dom);
+			this.ignoreFallback(dom, marks);
+		} else if (!rule || rule.skip || rule.closeParent) {
+			if (rule && rule.closeParent) this.open = Math.max(0, this.open - 1);
+			else if (rule && rule.skip.nodeType) dom = rule.skip;
+			let sync = false;
+			const oldNeedsBlock = this.needsBlock;
+			if (hasOwn(blockTags, name)) {
+				if (top.content.length && top.content[0].isInline && this.open) {
+					this.open--;
+					top = this.top;
+				}
+				sync = true;
+				if (!top.type) this.needsBlock = true;
+			} else if (!dom.firstChild) {
+				this.leafFallback(dom, marks);
+				break out;
+			}
+			const innerMarks = rule && rule.skip ? marks : this.readStyles(dom, marks);
+			if (innerMarks) this.addAll(dom, innerMarks);
+			if (sync) this.sync(top);
+			this.needsBlock = oldNeedsBlock;
+		} else {
+			const innerMarks = this.readStyles(dom, marks);
+			if (innerMarks) this.addElementByRule(dom, rule, innerMarks, rule.consuming === false ? ruleID ?? void 0 : void 0);
+		}
+		this.localPreserveWS = outerWS;
+	}
+	leafFallback(dom, marks) {
+		if (dom.nodeName == "BR" && this.top.type && this.top.type.inlineContent) this.addTextNode(dom.ownerDocument.createTextNode("\n"), marks);
+	}
+	ignoreFallback(dom, marks) {
+		if (dom.nodeName == "BR" && (!this.top.type || !this.top.type.inlineContent)) this.findPlace(this.parser.schema.textUnsafe("-"), marks, true);
+	}
+	readStyles(dom, marks) {
+		const styles = dom.style;
+		if (styles && styles.length) for (let i = 0; i < this.parser.matchedStyles.length; i++) {
+			const name = this.parser.matchedStyles[i], value = styles.getPropertyValue(name);
+			if (value) for (let after = void 0;;) {
+				const rule = this.parser.matchStyleOrNull(name, value, this, after);
+				if (!rule) break;
+				if (rule.ignore) return null;
+				if (rule.clearMark) marks = marks.filter((m) => !rule.clearMark(m));
+				else marks = marks.concat(markType(this.parser.schema, rule.mark).createUnsafe(rule.attrs));
+				if (rule.consuming === false) after = rule;
+				else break;
+			}
+		}
+		return marks;
+	}
+	addElementByRule(dom, rule, marks, continueAfter) {
+		let sync = false, nodeType;
+		if (rule.node) {
+			nodeType = this.parser.schema.nodeType(rule.node);
+			if (!nodeType.isLeaf) {
+				const inner = this.enter(nodeType, rule.attrs || null, marks, rule.preserveWhitespace);
+				if (inner) {
+					sync = true;
+					marks = inner;
+				}
+			} else if (!this.insertNode(nodeType.createUnsafe(rule.attrs), marks, dom.nodeName == "BR")) this.leafFallback(dom, marks);
+		} else marks = marks.concat(markType(this.parser.schema, rule.mark).createUnsafe(rule.attrs));
+		const startIn = this.top;
+		if (nodeType && nodeType.isLeaf) this.findInside(dom);
+		else if (continueAfter) this.addElement(dom, marks, continueAfter);
+		else if (rule.getContent) {
+			this.findInside(dom);
+			rule.getContent(dom, this.parser.schema).forEach((node) => this.insertNode(node, marks, false));
+		} else {
+			let contentDOM = dom;
+			if (typeof rule.contentElement == "string") contentDOM = dom.querySelector(rule.contentElement);
+			else if (typeof rule.contentElement == "function") contentDOM = rule.contentElement(dom);
+			else if (rule.contentElement) contentDOM = rule.contentElement;
+			this.findAround(dom, contentDOM, true);
+			this.addAll(contentDOM, marks);
+			this.findAround(dom, contentDOM, false);
+		}
+		if (sync && this.sync(startIn)) this.open--;
+	}
+	addAll(parent, marks, startIndex, endIndex) {
+		let index = startIndex || 0;
+		for (let dom = startIndex ? parent.childNodes[startIndex] : parent.firstChild, end = endIndex == null ? null : parent.childNodes[endIndex]; dom != end; dom = dom.nextSibling, ++index) {
+			this.findAtPoint(parent, index);
+			this.addDOM(dom, marks);
+		}
+		this.findAtPoint(parent, index);
+	}
+	findPlace(node, marks, cautious) {
+		let route, sync;
+		for (let depth = this.open, penalty = 0; depth >= 0; depth--) {
+			const cx = this.nodes[depth];
+			const found = cx.findWrapping(node);
+			if (found && (!route || route.length > found.length + penalty)) {
+				route = found;
+				sync = cx;
+				if (!found.length) break;
+			}
+			if (cx.solid) {
+				if (cautious) break;
+				penalty += 2;
+			}
+		}
+		if (!route) return null;
+		this.sync(sync);
+		for (let i = 0; i < route.length; i++) marks = this.enterInner(route[i], null, marks, false);
+		return marks;
+	}
+	insertNode(node, marks, cautious) {
+		if (node.isInline && this.needsBlock && !this.top.type) {
+			const block = this.textblockFromContext();
+			if (block) marks = this.enterInner(block, null, marks);
+		}
+		const innerMarks = this.findPlace(node, marks, cautious);
+		if (innerMarks) {
+			this.closeExtra();
+			const top = this.top;
+			if (top.match) top.match = top.match.matchTypeOrNull(node.type);
+			let nodeMarks = Mark.none;
+			for (const m of innerMarks.concat(node.marks)) if (top.type ? top.type.allowsMarkType(m.type) : markMayApply(m.type, node.type)) nodeMarks = m.addToSet(nodeMarks);
+			top.content.push(node.mark(nodeMarks));
+			return true;
+		}
+		return false;
+	}
+	enter(type, attrs, marks, preserveWS) {
+		let innerMarks = this.findPlace(type.createUnsafe(attrs), marks, false);
+		if (innerMarks) innerMarks = this.enterInner(type, attrs, marks, true, preserveWS);
+		return innerMarks;
+	}
+	enterInner(type, attrs, marks, solid = false, preserveWS) {
+		this.closeExtra();
+		const top = this.top;
+		top.match = top.match && top.match.matchTypeOrNull(type);
+		let options = wsOptionsFor(type, preserveWS, top.options);
+		if (top.options & OPT_OPEN_LEFT && Arr.isReadonlyArrayEmpty(top.content)) options |= OPT_OPEN_LEFT;
+		let applyMarks = Mark.none;
+		marks = marks.filter((m) => {
+			if (top.type ? top.type.allowsMarkType(m.type) : markMayApply(m.type, type)) {
+				applyMarks = m.addToSet(applyMarks);
+				return false;
+			}
+			return true;
+		});
+		this.nodes.push(new NodeContext(type, attrs, applyMarks, solid, null, options));
+		this.open++;
+		return marks;
+	}
+	closeExtra(openEnd = false) {
+		let i = this.nodes.length - 1;
+		if (i > this.open) {
+			for (; i > this.open; i--) this.nodes[i - 1].content.push(this.nodes[i].finish(openEnd));
+			this.nodes.length = this.open + 1;
+		}
+	}
+	finish() {
+		this.open = 0;
+		this.closeExtra(this.isOpen);
+		return this.nodes[0].finish(!!(this.isOpen || this.options.topOpen));
+	}
+	sync(to) {
+		for (let i = this.open; i >= 0; i--) if (this.nodes[i] == to) {
+			this.open = i;
+			return true;
+		} else if (this.localPreserveWS) this.nodes[i].options |= OPT_PRESERVE_WS;
+		return false;
+	}
+	get currentPos() {
+		this.closeExtra();
+		let pos = 0;
+		for (let i = this.open; i >= 0; i--) {
+			const content = this.nodes[i].content;
+			for (let j = content.length - 1; j >= 0; j--) pos += content[j].nodeSize;
+			if (i) pos++;
+		}
+		return pos;
+	}
+	findAtPoint(parent, offset) {
+		if (this.find) {
+			for (let i = 0; i < this.find.length; i++) if (this.find[i].node == parent && this.find[i].offset == offset) this.find[i].pos = this.currentPos;
+		}
+	}
+	findInside(parent) {
+		if (this.find) {
+			for (let i = 0; i < this.find.length; i++) if (this.find[i].pos == null && parent.nodeType == 1 && parent.contains(this.find[i].node)) this.find[i].pos = this.currentPos;
+		}
+	}
+	findAround(parent, content, before) {
+		if (parent != content && this.find) {
+			for (let i = 0; i < this.find.length; i++) if (this.find[i].pos == null && parent.nodeType == 1 && parent.contains(this.find[i].node)) {
+				if (content.compareDocumentPosition(this.find[i].node) & (before ? 2 : 4)) this.find[i].pos = this.currentPos;
+			}
+		}
+	}
+	findInText(textNode) {
+		if (this.find) {
+			for (let i = 0; i < this.find.length; i++) if (this.find[i].node == textNode) this.find[i].pos = this.currentPos - (textNode.nodeValue.length - this.find[i].offset);
+		}
+	}
+	matchesContext(context) {
+		if (context.indexOf("|") > -1) return context.split(/\s*\|\s*/).some(this.matchesContext, this);
+		const parts = context.split("/");
+		const option = this.options.context;
+		const useRoot = !this.isOpen && (!option || option.parent.type == this.nodes[0].type);
+		const minDepth = -(option ? option.depth + 1 : 0) + (useRoot ? 0 : 1);
+		const match = (i, depth) => {
+			for (; i >= 0; i--) {
+				const part = parts[i];
+				if (part == "") {
+					if (i == parts.length - 1 || i == 0) continue;
+					for (; depth >= minDepth; depth--) if (match(i - 1, depth)) return true;
+					return false;
+				} else {
+					const next = depth > 0 || depth == 0 && useRoot ? this.nodes[depth].type : option && depth >= minDepth ? option.node(depth - minDepth).type : null;
+					if (!next || next.name != part && !next.isInGroup(part)) return false;
+					depth--;
+				}
+			}
+			return true;
+		};
+		return match(parts.length - 1, this.open);
+	}
+	textblockFromContext() {
+		const $context = this.options.context;
+		if ($context) for (let d = $context.depth; d >= 0; d--) {
+			const deflt = $context.node(d).contentMatchAtUnsafe($context.indexAfter(d)).defaultTypeOrNull;
+			if (deflt && deflt.isTextblock && deflt.defaultAttrs) return deflt;
+		}
+		const nodes = this.parser.schema.nodes;
+		for (const name in nodes) {
+			const type = nodes[name];
+			if (type.isTextblock && type.defaultAttrs) return type;
+		}
+	}
+};
+function markType(schema, name) {
+	const type = name === void 0 ? void 0 : schema.marks[name];
+	if (!type) throw new SchemaDefinitionError({ message: `Parse rule refers to unknown mark type ${String(name)}` });
+	return type;
+}
+function normalizeList(dom) {
+	for (let child = dom.firstChild, prevItem = null; child; child = child.nextSibling) {
+		const name = child.nodeType == 1 ? child.nodeName.toLowerCase() : null;
+		if (name && hasOwn(listTags, name) && prevItem) {
+			prevItem.appendChild(child);
+			child = prevItem;
+		} else if (name == "li") prevItem = child;
+		else if (name) prevItem = null;
+	}
+}
+function matches(dom, selector) {
+	const f = dom.matches || dom.msMatchesSelector || dom.webkitMatchesSelector || dom.mozMatchesSelector;
+	return !!f && f.call(dom, selector);
+}
+function markMayApply(markType, nodeType) {
+	const nodes = nodeType.schema.nodes;
+	for (const name in nodes) {
+		const parent = nodes[name];
+		if (!parent.allowsMarkType(markType)) continue;
+		const seen = [];
+		const scan = (match) => {
+			seen.push(match);
+			for (let i = 0; i < match.next.length; i++) {
+				const { next, type } = match.next[i];
+				if (type == nodeType) return true;
+				if (seen.indexOf(next) < 0 && scan(next)) return true;
+			}
+			return false;
+		};
+		if (scan(parent.contentMatch)) return true;
+	}
+	return false;
+}
+export { DOMParser };

package/dist/model/json.d.ts

@@ -0,0 +1,37 @@
+import { Fragment } from "./fragment.js";
+import { Mark } from "./mark.js";
+import { Node, NodeJSON } from "./node.js";
+import { Slice } from "./replace.js";
+import { AnySchema } from "./schema.js";
+import * as S from "effect/Schema";
+/** @internal */
+export declare function markFromJSON<Sc extends AnySchema>(schema: Sc, json: any): Mark<Sc>;
+/** @internal */
+export declare function nodeFromJSON<Sc extends AnySchema>(schema: Sc, json: any): Node<Sc>;
+/** @internal */
+export declare function fragmentFromJSON<Sc extends AnySchema>(schema: Sc, value: any): Fragment<Sc>;
+/** @internal */
+export declare function sliceFromJSON<Sc extends AnySchema>(schema: Sc, value: any): Slice<Sc>;
+/**
+ * An Effect `Schema` that decodes the JSON representation of a node
+ * into a `Node` of the given document schema (validating structure,
+ * content, and attributes), and encodes nodes back to JSON.
+ *
+ * ```ts skip-type-checking
+ * import { Schema } from "effect"
+ * const doc = yield* Schema.decodeUnknownEffect(NodeFromJSON(mySchema))(json)
+ * ```
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+export declare const NodeFromJSON: <Sc extends AnySchema>(schema: Sc) => S.Codec<Node<Sc>, NodeJSON>;
+/**
+ * An Effect `Schema` for the top-level document of a schema: like
+ * `NodeFromJSON`, but also requires the decoded node to be of the
+ * schema's top node type.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+export declare const DocFromJSON: <Sc extends AnySchema>(schema: Sc) => S.Codec<Node<Sc>, NodeJSON>;