@thomasfosterau/effect-richtext 0.0.0-stage → 0.1.0

package/dist/model/schema.js

@@ -0,0 +1,451 @@
+import { attempt } from "../internal/attempt.js";
+import { showJson } from "../internal/json.js";
+import { ContentMatch } from "./content.js";
+import { AttributeError, ContentError, SchemaDefinitionError, isModelError } from "./errors.js";
+import { Fragment } from "./fragment.js";
+import { markFromJSON, nodeFromJSON } from "./json.js";
+import { Mark } from "./mark.js";
+import { Node, TextNode } from "./node.js";
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
+import * as S from "effect/Schema";
+import * as Rec from "effect/Record";
+import * as SchemaAST from "effect/SchemaAST";
+// src/model/schema.ts
+/** @internal */
+var Attribute = class {
+	constructor(typeName, attrName, definition) {
+		const options = S.isSchema(definition) ? { schema: definition } : definition;
+		this.hasDefault = Object.prototype.hasOwnProperty.call(options, "default");
+		this.default = options.default;
+		this.schema = options.schema;
+		this.is = options.schema ? S.is(options.schema) : void 0;
+		this.identityCodec = !options.schema || SchemaAST.toEncoded(options.schema.ast) === options.schema.ast;
+		this.validate = typeof options.validate === "string" ? validateType(typeName, attrName, options.validate) : options.validate;
+	}
+	get isRequired() {
+		return !this.hasDefault;
+	}
+};
+function validateType(typeName, attrName, type) {
+	const types = type.split("|");
+	return (value) => {
+		const name = value === null ? "null" : typeof value;
+		if (types.indexOf(name) < 0) throw new AttributeError({ message: `Expected value of type ${types.join(",")} for attribute ${attrName} on type ${typeName}, got ${name}` });
+	};
+}
+const identityAttrs = (attrs) => Arr.every(Rec.values(attrs), (a) => a.identityCodec);
+function initAttrs(typeName, attrs) {
+	const result = Object.create(null);
+	if (attrs) for (const name in attrs) result[name] = new Attribute(typeName, name, attrs[name]);
+	return result;
+}
+function defaultAttrs(attrs) {
+	const defaults = Object.create(null);
+	for (const attrName in attrs) {
+		const attr = attrs[attrName];
+		if (!attr.hasDefault) return Option.none();
+		defaults[attrName] = attr.default;
+	}
+	return Option.some(defaults);
+}
+/** @internal */
+function computeAttrs(attrs, value, type, typeName, decoded = false) {
+	const built = Object.create(null);
+	for (const name in attrs) {
+		const attr = attrs[name];
+		let given = value && value[name];
+		if (given === void 0) {
+			if (attr.hasDefault) given = attr.default;
+			else throw new AttributeError({ message: "No value supplied for attribute " + name });
+		} else {
+			if (attr.validate) attr.validate(given);
+			if (!decoded && attr.is && !attr.is(given)) throw new AttributeError({ message: `Invalid value for attribute ${name} on ${type} of type ${typeName}: ${showJson(given)}` });
+		}
+		built[name] = given;
+	}
+	return built;
+}
+/** @internal */
+function checkAttrs(attrs, values, type, typeName) {
+	for (const name in values) if (!(name in attrs)) throw new AttributeError({ message: `Unsupported attribute ${name} for ${type} of type ${typeName}` });
+	for (const name in attrs) {
+		const attr = attrs[name];
+		if (attr.validate) attr.validate(values[name]);
+		if (attr.is && !attr.is(values[name])) throw new AttributeError({ message: `Invalid value for attribute ${name} on ${type} of type ${typeName}: ${showJson(values[name])}` });
+	}
+}
+/**
+* Node types are objects allocated once per schema and used to tag
+* `Node` instances. They contain information about the node type, such
+* as its name and what kind of node it represents.
+*
+* @since 0.1.0
+* @category models
+*/
+var NodeType = class {
+	/** @internal */
+	constructor(name, schema, spec) {
+		this.name = name;
+		this.schema = schema;
+		this.spec = spec;
+		this.markSet = null;
+		this.groups = spec.group ? spec.group.split(" ") : [];
+		this.attrs = initAttrs(name, spec.attrs);
+		this.defaultAttrs = Option.getOrNull(defaultAttrs(this.attrs));
+		this.identityAttrs = identityAttrs(this.attrs);
+		this.isBlock = !(spec.inline || name === "text");
+		this.isText = name === "text";
+	}
+	/** True if this is an inline type. */
+	get isInline() {
+		return !this.isBlock;
+	}
+	/** True if this is a textblock type, a block that contains inline content. */
+	get isTextblock() {
+		return this.isBlock && this.inlineContent;
+	}
+	/** True for node types that allow no content. */
+	get isLeaf() {
+		return this.contentMatch === ContentMatch.empty;
+	}
+	/** True when this node is an atom, i.e. when it does not have directly editable content. */
+	get isAtom() {
+		return this.isLeaf || !!this.spec.atom;
+	}
+	/** Return true when this node type is part of the given group. */
+	isInGroup(group) {
+		return this.groups.indexOf(group) > -1;
+	}
+	/** The node type's whitespace option. */
+	get whitespace() {
+		return this.spec.whitespace || (this.spec.code ? "pre" : "normal");
+	}
+	/** Tells you whether this node type has any required attributes. */
+	hasRequiredAttrs() {
+		for (const n in this.attrs) if (this.attrs[n].isRequired) return true;
+		return false;
+	}
+	/** Indicates whether this node allows some of the same content as the given node type. */
+	compatibleContent(other) {
+		return this === other || this.contentMatch.compatible(other.contentMatch);
+	}
+	/** @internal */
+	computeAttrs(attrs) {
+		if (!attrs && this.defaultAttrs) return this.defaultAttrs;
+		return computeAttrs(this.attrs, attrs, "node", this.name);
+	}
+	create(attrs, content, marks) {
+		return attempt(() => this.createUnsafe(attrs, content, marks), isModelError);
+	}
+	createUnsafe(attrs, content, marks) {
+		if (this.isText) throw new ContentError({ message: "NodeType.create can't construct text nodes" });
+		return new Node(this, this.computeAttrs(attrs), Fragment.from(content), Mark.setFrom(marks));
+	}
+	/**
+	* Like `createUnsafe`, for attributes already decoded by their Schemas.
+	*
+	* @internal
+	*/
+	createDecodedUnsafe(attrs, content, marks) {
+		if (this.isText) throw new ContentError({ message: "NodeType.create can't construct text nodes" });
+		return new Node(this, this.computeDecodedAttrs(attrs), content, Mark.setFrom(marks));
+	}
+	computeDecodedAttrs(attrs) {
+		return Option.isSome(attrs) ? computeAttrs(this.attrs, attrs.value, "node", this.name, true) : this.computeAttrs(Option.getOrNull(attrs));
+	}
+	createChecked(attrs, content, marks) {
+		return attempt(() => this.createCheckedUnsafe(attrs, content, marks), isModelError);
+	}
+	createCheckedUnsafe(attrs, content, marks) {
+		const frag = Fragment.from(content);
+		this.checkContent(frag);
+		return new Node(this, this.computeAttrs(attrs), frag, Mark.setFrom(marks));
+	}
+	createAndFill(attrs, content, marks) {
+		return attempt(() => {
+			const node = this.createAndFillOrNull(attrs, content, marks);
+			if (!node) throw new ContentError({ message: `Content does not fit node type ${this.name} and cannot be filled` });
+			return node;
+		}, isModelError);
+	}
+	/** @internal */
+	createAndFillOrNull(attrs, content, marks) {
+		const computed = this.computeAttrs(attrs);
+		let frag = Fragment.from(content);
+		if (frag.size) {
+			const before = this.contentMatch.fillBeforeOrNull(frag);
+			if (!before) return null;
+			frag = before.append(frag);
+		}
+		const matched = this.contentMatch.matchFragmentOrNull(frag);
+		const after = matched && matched.fillBeforeOrNull(Fragment.empty, true);
+		if (!after) return null;
+		return new Node(this, computed, frag.append(after), Mark.setFrom(marks));
+	}
+	/** Returns true if the given fragment is valid content for this node type. */
+	validContent(content) {
+		const result = this.contentMatch.matchFragmentOrNull(content);
+		if (!result || !result.validEnd) return false;
+		for (let i = 0; i < content.childCount; i++) if (!this.allowsMarks(content.content[i].marks)) return false;
+		return true;
+	}
+	/** @internal */
+	checkContent(content) {
+		if (!this.validContent(content)) throw new ContentError({ message: `Invalid content for node ${this.name}: ${content.toString().slice(0, 50)}` });
+	}
+	/** @internal */
+	checkAttrs(attrs) {
+		checkAttrs(this.attrs, attrs, "node", this.name);
+	}
+	/** Check whether the given mark type is allowed in this node. */
+	allowsMarkType(markType) {
+		return this.markSet === null || this.markSet.indexOf(markType) > -1;
+	}
+	/** Test whether the given set of marks are allowed in this node. */
+	allowsMarks(marks) {
+		if (this.markSet === null) return true;
+		for (let i = 0; i < marks.length; i++) if (!this.allowsMarkType(marks[i].type)) return false;
+		return true;
+	}
+	/** Removes the marks that are not allowed in this node from the given set. */
+	allowedMarks(marks) {
+		if (this.allowsMarks(marks)) return marks;
+		const kept = marks.filter((mark) => this.allowsMarkType(mark.type));
+		return kept.length ? kept : Mark.none;
+	}
+	/** @internal */
+	toString() {
+		return `NodeType(${this.name})`;
+	}
+};
+const isAttributeError = (u) => u instanceof AttributeError;
+/**
+* Like nodes, marks are tagged with type objects, which are
+* instantiated once per schema.
+*
+* @since 0.1.0
+* @category models
+*/
+var MarkType = class {
+	/** @internal */
+	constructor(name, rank, schema, spec) {
+		this.name = name;
+		this.rank = rank;
+		this.schema = schema;
+		this.spec = spec;
+		this.attrs = initAttrs(name, spec.attrs);
+		this.identityAttrs = identityAttrs(this.attrs);
+		this.instance = Option.map(defaultAttrs(this.attrs), (defaults) => new Mark(this, defaults));
+	}
+	create(attrs) {
+		return attempt(() => this.createUnsafe(attrs), isAttributeError);
+	}
+	createUnsafe(attrs) {
+		if (!attrs && Option.isSome(this.instance)) return this.instance.value;
+		return new Mark(this, computeAttrs(this.attrs, attrs, "mark", this.name));
+	}
+	/**
+	* Like `createUnsafe`, for attributes already decoded by their Schemas.
+	*
+	* @internal
+	*/
+	createDecodedUnsafe(attrs) {
+		return Option.isSome(attrs) ? new Mark(this, computeAttrs(this.attrs, attrs.value, "mark", this.name, true)) : this.createUnsafe();
+	}
+	/**
+	* When there is a mark of this type in the given set, a new set
+	* without it is returned. Otherwise, the input set is returned.
+	*/
+	removeFromSet(set) {
+		for (let i = 0; i < set.length; i++) if (set[i].type === this) {
+			set = set.slice(0, i).concat(set.slice(i + 1));
+			i--;
+		}
+		return set;
+	}
+	/** Find a mark of this type in the given set. */
+	isInSet(set) {
+		return Option.fromNullishOr(this.findInSet(set));
+	}
+	/** @internal */
+	findInSet(set) {
+		for (let i = 0; i < set.length; i++) if (set[i].type === this) return set[i];
+	}
+	/** @internal */
+	checkAttrs(attrs) {
+		checkAttrs(this.attrs, attrs, "mark", this.name);
+	}
+	/** Queries whether a given mark type is excluded by this one. */
+	excludes(other) {
+		return this.excluded.indexOf(other) > -1;
+	}
+	/** @internal */
+	toString() {
+		return `MarkType(${this.name})`;
+	}
+};
+/**
+* A document schema. Holds node and mark type objects for the nodes and
+* marks that may occur in conforming documents, and provides
+* functionality for creating and deserializing such documents.
+*
+* @since 0.1.0
+* @category models
+*/
+var DocSchema = class DocSchema {
+	/** @internal */
+	constructor(spec) {
+		this.cached = Object.create(null);
+		this.spec = {
+			...spec,
+			nodes: spec.nodes,
+			marks: spec.marks ?? {}
+		};
+		const nodes = Object.create(null);
+		for (const name in this.spec.nodes) nodes[name] = new NodeType(name, this, this.spec.nodes[name]);
+		const topType = this.spec.topNode || "doc";
+		if (!nodes[topType]) throw new SchemaDefinitionError({ message: "Schema is missing its top node type ('" + topType + "')" });
+		if (!nodes.text) throw new SchemaDefinitionError({ message: "Every schema needs a 'text' type" });
+		for (const _ in nodes.text.attrs) throw new SchemaDefinitionError({ message: "The text node type should not have attributes" });
+		const marks = Object.create(null);
+		let rank = 0;
+		for (const name in this.spec.marks) marks[name] = new MarkType(name, rank++, this, this.spec.marks[name]);
+		this.nodes = nodes;
+		this.marks = marks;
+		let linebreak = Option.none();
+		for (const prop in nodes) {
+			if (prop in marks) throw new SchemaDefinitionError({ message: prop + " can not be both a node and a mark" });
+			const type = nodes[prop];
+			const markExpr = type.spec.marks;
+			type.contentMatch = ContentMatch.compile(type.spec.content, nodes, prop);
+			type.inlineContent = type.contentMatch.inlineContent;
+			if (type.spec.linebreakReplacement) {
+				if (Option.isSome(linebreak)) throw new SchemaDefinitionError({ message: "Multiple linebreak nodes defined" });
+				if (!type.isInline || !type.isLeaf) throw new SchemaDefinitionError({ message: "Linebreak replacement nodes must be inline leaf nodes" });
+				linebreak = Option.some(type);
+			}
+			type.markSet = markExpr === "_" ? null : markExpr ? gatherMarks(this, markExpr.split(" ")) : markExpr === "" || !type.inlineContent ? [] : null;
+		}
+		for (const prop in marks) {
+			const type = marks[prop];
+			const excl = type.spec.excludes;
+			type.excluded = excl == null ? [type] : excl === "" ? [] : gatherMarks(this, excl.split(" "));
+		}
+		this.linebreakReplacement = linebreak;
+		this.topNodeType = nodes[topType];
+	}
+	/**
+	* Construct a schema from a schema specification. A spec with literal
+	* names is also checked statically (`SchemaSpecCheck`): an unknown
+	* content, `marks` or `excludes` reference, a missing top or `text`
+	* node, a name used by both a node and a mark, a `default` outside its
+	* `schema` or an unknown `validate` type name fails to compile, where the
+	* runtime would fail with a `SchemaDefinitionError`.
+	*/
+	static make(spec) {
+		return attempt(() => new DocSchema(spec), (u) => u instanceof SchemaDefinitionError);
+	}
+	/** Like `make`, but throws a `SchemaDefinitionError` for invalid specs. */
+	static makeUnsafe(spec) {
+		return new DocSchema(spec);
+	}
+	node(type, attrs, content, marks) {
+		return attempt(() => this.nodeUnsafe(type, attrs, content, marks), isModelError);
+	}
+	nodeUnsafe(type, attrs, content, marks) {
+		let nodeType;
+		if (typeof type === "string") nodeType = this.nodeType(type);
+		else if (!(type instanceof NodeType)) throw new ContentError({ message: "Invalid node type: " + type });
+		else if (type.schema !== this) throw new ContentError({ message: "Node type from different schema used (" + type.name + ")" });
+		else nodeType = type;
+		return nodeType.createCheckedUnsafe(attrs, content, marks);
+	}
+	/**
+	* Create a text node in the schema. Fails for empty strings, since
+	* empty text nodes are not allowed.
+	*/
+	text(text, marks) {
+		return attempt(() => this.textUnsafe(text, marks), (u) => u instanceof ContentError);
+	}
+	/** Like `text`, but throws a `ContentError` for empty strings. */
+	textUnsafe(text, marks) {
+		const type = this.nodes.text;
+		return new TextNode(type, type.defaultAttrs, text, Mark.setFrom(marks));
+	}
+	mark(type, attrs) {
+		return attempt(() => this.markUnsafe(type, attrs), isAttributeError);
+	}
+	markUnsafe(type, attrs) {
+		const markType = typeof type === "string" ? this.marks[type] : type;
+		if (!markType) throw new AttributeError({ message: "Unknown mark type: " + String(type) });
+		return markType.createUnsafe(attrs);
+	}
+	/** Deserialize a node from its JSON representation. */
+	nodeFromJSON(value) {
+		return attempt(() => nodeFromJSON(this, value), isModelError);
+	}
+	/** Like `nodeFromJSON`, but throws on failure. */
+	nodeFromJSONUnsafe(value) {
+		return nodeFromJSON(this, value);
+	}
+	/** Deserialize a mark from its JSON representation. */
+	markFromJSON(value) {
+		return attempt(() => markFromJSON(this, value), isModelError);
+	}
+	/** Like `markFromJSON`, but throws on failure. */
+	markFromJSONUnsafe(value) {
+		return markFromJSON(this, value);
+	}
+	/** @internal */
+	nodeType(name) {
+		const found = this.nodes[name];
+		if (!found) throw new ContentError({ message: "Unknown node type: " + name });
+		return found;
+	}
+};
+function gatherMarks(schema, marks) {
+	const found = [];
+	for (let i = 0; i < marks.length; i++) {
+		const name = marks[i];
+		const mark = schema.marks[name];
+		let ok = mark;
+		if (mark) found.push(mark);
+		else for (const prop in schema.marks) {
+			const mark = schema.marks[prop];
+			if (name === "_" || mark.spec.group && mark.spec.group.split(" ").indexOf(name) > -1) found.push(ok = mark);
+		}
+		if (!ok) throw new SchemaDefinitionError({ message: "Unknown mark type: '" + marks[i] + "'" });
+	}
+	return found;
+}
+/**
+* Construct a schema from a specification.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const make = DocSchema.make;
+/**
+* Construct a schema from a specification, throwing on invalid specs.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const makeUnsafe = DocSchema.makeUnsafe;
+/**
+* Identity helper that gives a node spec's callbacks access to
+* precisely typed attributes.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const nodeSpec = (spec) => spec;
+/**
+* Identity helper for mark specs.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const markSpec = (spec) => spec;
+export { Attribute, DocSchema, MarkType, NodeType, checkAttrs, computeAttrs, make, makeUnsafe, markSpec, nodeSpec };

package/dist/model/to_dom.d.ts

@@ -0,0 +1,169 @@
+import { DOMSpecError } from "./errors.js";
+import { Fragment } from "./fragment.js";
+import { Mark } from "./mark.js";
+import { Node } from "./node.js";
+import { AnySchema, Attrs } from "./schema.js";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+/**
+ * A description of a DOM structure. Can be either a DOM node, a
+ * `{dom, contentDOM}` object, or an array.
+ *
+ * An array describes a DOM element. The first value in the array
+ * should be a string—the name of the DOM element, optionally prefixed
+ * by a namespace URL and a space. If the second element is plain
+ * object, it is interpreted as a set of attributes for the element.
+ * Any elements after that (including the 2nd if it's not an attribute
+ * object) are interpreted as children of the DOM elements, and must
+ * either be valid `DOMOutputSpec` values, strings (for text nodes), or
+ * the number zero ("hole"), which marks where the node's content goes.
+ * A hole should be the only child element in its parent node.
+ *
+ * Plain arrays are accepted as well as tuples, because TypeScript does
+ * not always infer a tuple for an array literal returned from a `toDOM`
+ * callback; the shape is validated when the spec is rendered.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type DOMOutputSpec = Element | {
+  readonly dom: Element;
+  readonly contentDOM?: HTMLElement | undefined;
+} | readonly [string, ...Array<any>] | ReadonlyArray<any>;
+/**
+ * The result of rendering a [`DOMOutputSpec`](#DOMOutputSpec). When
+ * the spec contained a hole, `contentDOM` points at the element that
+ * should hold the content.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface RenderedSpec {
+  readonly dom: globalThis.Node;
+  readonly contentDOM?: HTMLElement | undefined;
+}
+/**
+ * Options accepted by the serialization methods. When not running in
+ * an environment with a global `document`, pass one explicitly.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface SerializeOptions {
+  readonly document?: Document | undefined;
+}
+/**
+ * A function serializing a node to a [`DOMOutputSpec`](#DOMOutputSpec).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type NodeSerializer<Sc extends AnySchema = AnySchema> = (node: Node<Sc, any>) => DOMOutputSpec;
+/**
+ * A function serializing a mark to a [`DOMOutputSpec`](#DOMOutputSpec).
+ * `inline` tells it whether the mark's content is inline content.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type MarkSerializer<Sc extends AnySchema = AnySchema> = (mark: Mark<Sc, any>, inline: boolean) => DOMOutputSpec;
+/**
+ * A DOM serializer knows how to convert nodes and marks of various
+ * types to DOM nodes.
+ *
+ * The serialization methods are synchronous and infallible for valid
+ * specs. An invalid output spec returned by a `toDOM` function is a
+ * programming error: the serialization methods then throw a
+ * `DOMSpecError` (a defect). Use [`renderSpec`](#DOMSerializer.renderSpec)
+ * to check specs in the Effect error channel.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class DOMSerializer<Sc extends AnySchema = AnySchema> {
+  /** The node serialization functions. */
+  readonly nodes: {
+    readonly [node: string]: NodeSerializer<Sc>;
+  };
+  /** The mark serialization functions. */
+  readonly marks: {
+    readonly [mark: string]: MarkSerializer<Sc> | null | undefined;
+  };
+  /**
+   * Create a serializer. `nodes` should map node names to functions
+   * that take a node and return a description of the corresponding
+   * DOM. `marks` does the same for mark names, but also gets an
+   * argument that tells it whether the mark's content is block or
+   * inline content (for typical use, it'll always be inline). A mark
+   * serializer may be `null` to indicate that marks of that type
+   * should not be serialized.
+   */
+  constructor(
+  /** The node serialization functions. */
+  nodes: {
+    readonly [node: string]: NodeSerializer<Sc>;
+  },
+  /** The mark serialization functions. */
+  marks: {
+    readonly [mark: string]: MarkSerializer<Sc> | null | undefined;
+  });
+  /**
+   * Serialize the content of this fragment to a DOM fragment. When
+   * not in the browser, the `document` option, containing a DOM
+   * document, should be passed so that the serializer can create
+   * nodes.
+   *
+   * Throws a `DOMSpecError` (as a defect) for invalid output specs.
+   */
+  serializeFragment(fragment: Fragment<Sc, any>, options?: SerializeOptions, target?: HTMLElement | DocumentFragment): HTMLElement | DocumentFragment;
+  /** @internal */
+  serializeNodeInner(node: Node<Sc, any>, options: SerializeOptions): globalThis.Node;
+  /**
+   * Serialize this node to a DOM node. This can be useful when you
+   * need to serialize a part of a document, as opposed to the whole
+   * document. To serialize a whole document, use
+   * [`serializeFragment`](#DOMSerializer.serializeFragment) on its
+   * `content`.
+   *
+   * Throws a `DOMSpecError` (as a defect) for invalid output specs.
+   */
+  serializeNode(node: Node<Sc, any>, options?: SerializeOptions): globalThis.Node;
+  /**
+   * Serialize a mark. Returns `None` when there is no serializer for
+   * the mark's type.
+   *
+   * Throws a `DOMSpecError` (as a defect) for invalid output specs.
+   */
+  serializeMark(mark: Mark<Sc, any>, inline: boolean, options?: SerializeOptions): Option.Option<RenderedSpec>;
+  /** @internal */
+  serializeMarkOrNull(mark: Mark<Sc, any>, inline: boolean, options?: SerializeOptions): RenderedSpec | null;
+  /**
+   * Render an [output spec](#DOMOutputSpec) to a DOM node. If the spec
+   * has a hole (zero) in it, `contentDOM` will point at the node with
+   * the hole. Fails with a `DOMSpecError` for invalid specs.
+   */
+  static renderSpec(doc: Document, structure: DOMOutputSpec, xmlNS?: string | null): Effect.Effect<RenderedSpec, DOMSpecError>;
+  /**
+   * Like `renderSpec`, but throws a `DOMSpecError` for invalid specs.
+   * When `blockArraysIn` (usually the attributes of the node or mark
+   * being rendered) is given, arrays found in it are refused as specs.
+   */
+  static renderSpecUnsafe(doc: Document, structure: DOMOutputSpec, xmlNS?: string | null, blockArraysIn?: Attrs): RenderedSpec;
+  /**
+   * Build a serializer using the [`toDOM`](#NodeSpec.toDOM) properties
+   * in a schema's node and mark specs. The result is cached on the
+   * schema.
+   */
+  static fromSchema<Sc extends AnySchema>(schema: Sc): DOMSerializer<Sc>;
+  /**
+   * Gather the serializers in a schema's node specs into an object.
+   * This can be useful as a base to build a custom serializer from.
+   */
+  static nodesFromSchema<Sc extends AnySchema>(schema: Sc): {
+    [node: string]: NodeSerializer<Sc>;
+  };
+  /** Gather the serializers in a schema's mark specs into an object. */
+  static marksFromSchema<Sc extends AnySchema>(schema: Sc): {
+    [mark: string]: MarkSerializer<Sc>;
+  };
+}