@thomasfosterau/effect-richtext 0.0.0 → 0.1.0

package/dist/compat/transform.js

@@ -0,0 +1,803 @@
+import { isModelError } from "../model/errors.js";
+import { MapResult, Mapping as Mapping$1, StepMap } from "../transform/map.js";
+import { Step as Step$1, StepResult as StepResult$1 } from "../transform/step.js";
+import { AttrStep as AttrStep$1, DocAttrStep as DocAttrStep$1 } from "../transform/attr_step.js";
+import { MarkSetStep as MarkSetStep$1 } from "../transform/mark_set_step.js";
+import { AddMarkStep as AddMarkStep$1, AddNodeMarkStep as AddNodeMarkStep$1, RemoveMarkStep as RemoveMarkStep$1, RemoveNodeMarkStep as RemoveNodeMarkStep$1 } from "../transform/mark_step.js";
+import { ReplaceAroundStep as ReplaceAroundStep$1, ReplaceStep as ReplaceStep$1 } from "../transform/replace_step.js";
+import { canJoin as canJoin$1, canSplit as canSplit$1, dropPoint as dropPoint$1, findWrapping as findWrapping$1, insertPoint as insertPoint$1, joinPoint as joinPoint$1, liftTarget as liftTarget$1 } from "../transform/structure.js";
+import { replaceStep as replaceStep$1 } from "../transform/replace.js";
+import { Transform as Transform$1 } from "../transform/transform.js";
+import { BASE, CORE, TransformError, adopt, callBase, guard, link, registerWrapper, unwrap, unwrapArray, wrap } from "./internal/core.js";
+import { Slice } from "./model.js";
+import * as Option from "effect/Option";
+// src/compat/transform.ts
+/**
+* A `prosemirror-transform`-compatible facade over
+* `@thomasfosterau/effect-richtext/transform`.
+*
+* `Step` can be subclassed exactly like ProseMirror's: a subclass of
+* the facade `Step` is adapted into a core step (see `toCore`), so
+* custom steps work in core transforms, transactions and the history.
+* `StepMap` and `MapResult` are the core classes, whose API already
+* matches ProseMirror's.
+*
+* Ported API surface from prosemirror-transform (MIT, Marijn Haverbeke and others).
+*
+* @since 0.1.0
+*/
+const nullable = (o) => wrap(Option.getOrNull(o));
+/**
+* A mapping represents a pipeline of zero or more step maps.
+*
+* @since 0.1.0
+* @category models
+*/
+var Mapping = class {
+	/** Create a new mapping with the given position maps. */
+	constructor(maps, mirror, from, to) {
+		link(this, new Mapping$1(maps, mirror, from, to));
+	}
+	/** The step maps in this mapping. */
+	get maps() {
+		return this[CORE].maps;
+	}
+	/** @internal */
+	get mirror() {
+		return this[CORE].mirror;
+	}
+	set mirror(value) {
+		this[CORE].mirror = value;
+	}
+	/** The starting position in the `maps` array, used when `map` or `mapResult` is called. */
+	get from() {
+		return this[CORE].from;
+	}
+	set from(value) {
+		this[CORE].from = value;
+	}
+	/** The end position in the `maps` array. */
+	get to() {
+		return this[CORE].to;
+	}
+	set to(value) {
+		this[CORE].to = value;
+	}
+	/** Create a mapping that maps only through a part of this one. */
+	slice(from = 0, to = this.maps.length) {
+		return wrap(this[CORE].slice(from, to));
+	}
+	/** Add a step map to the end of this mapping. */
+	appendMap(map, mirrors) {
+		this[CORE].appendMap(map, mirrors);
+	}
+	/** Add all the step maps in a given mapping to this one (preserving mirroring information). */
+	appendMapping(mapping) {
+		this[CORE].appendMapping(mapping[CORE]);
+	}
+	/** Finds the offset of the step map that mirrors the map at the given offset, in this mapping. */
+	getMirror(n) {
+		return this[CORE].getMirrorOrUndefined(n);
+	}
+	/** @internal */
+	setMirror(n, m) {
+		this[CORE].setMirror(n, m);
+	}
+	/** Append the inverse of the given mapping to this one. */
+	appendMappingInverted(mapping) {
+		this[CORE].appendMappingInverted(mapping[CORE]);
+	}
+	/** Create an inverted version of this mapping. */
+	invert() {
+		return wrap(this[CORE].invert());
+	}
+	/** Map a position through this mapping. */
+	map(pos, assoc = 1) {
+		return this[CORE].map(pos, assoc);
+	}
+	/** Map a position through this mapping, returning a mapping result. */
+	mapResult(pos, assoc = 1) {
+		return this[CORE].mapResult(pos, assoc);
+	}
+};
+registerWrapper(Mapping$1, (core) => adopt(Mapping.prototype, core));
+/**
+* The result of applying a step.
+*
+* @since 0.1.0
+* @category models
+*/
+var StepResult = class StepResult {
+	/** @internal */
+	constructor(doc, failed) {
+		this.doc = doc;
+		this.failed = failed;
+	}
+	/** Create a successful step result. */
+	static ok(doc) {
+		return new StepResult(doc, null);
+	}
+	/** Create a failed step result. */
+	static fail(message) {
+		return new StepResult(null, message);
+	}
+	/** Call `Node.replace` with the given arguments. Create a successful result if it succeeds, and a failed one if it throws a `ReplaceError`. */
+	static fromReplace(doc, from, to, slice) {
+		return fromCoreResult(StepResult$1.fromReplace(doc[CORE], from, to, slice[CORE]));
+	}
+};
+const fromCoreResult = (result) => new StepResult(wrap(result.docOrNull), result.failedOrNull);
+const toCoreResult = (result) => new StepResult$1(unwrap(result.doc), result.failed);
+/**
+* A step object represents an atomic change. Subclass it to define
+* custom steps: subclasses are adapted into core steps automatically.
+*
+* @since 0.1.0
+* @category models
+*/
+var Step = class {
+	constructor() {
+		if (!(this instanceof CoreStep)) link(this, new AdaptedStep(this));
+	}
+	/** Get the step map that represents the changes made by this step. */
+	getMap() {
+		return StepMap.empty;
+	}
+	/** Try to merge this step with another one, to be applied directly after it. */
+	merge(_other) {
+		return null;
+	}
+	/** Deserialize a step from its JSON representation. */
+	static fromJSON(schema, json) {
+		return wrap(guard(() => Step$1.fromJSONUnsafe(schema[CORE], json)));
+	}
+	/** To be able to serialize steps to JSON, each step needs a string ID to attach to its JSON representation. */
+	static jsonID(id, stepClass) {
+		try {
+			Step$1.jsonID(id, { fromJSONUnsafe: (schema, json) => stepClass.fromJSON(wrap(schema), json)[CORE] });
+		} catch (e) {
+			throw new RangeError(e.message);
+		}
+		stepClass.prototype.jsonID = id;
+		return stepClass;
+	}
+};
+/** A core step implemented by a user-defined facade step. @internal */
+var AdaptedStep = class extends Step$1 {
+	constructor(facade) {
+		super();
+		this.facade = facade;
+	}
+	apply(doc) {
+		return toCoreResult(this.facade.apply(wrap(doc)));
+	}
+	getMap() {
+		return this.facade.getMap();
+	}
+	invert(doc) {
+		return this.facade.invert(wrap(doc))[CORE];
+	}
+	map(mapping) {
+		return Option.fromNullishOr(unwrap(this.facade.map(wrap(mapping))));
+	}
+	merge(other) {
+		return Option.fromNullishOr(unwrap(this.facade.merge(wrap(other))));
+	}
+	toJSON() {
+		return this.facade.toJSON();
+	}
+};
+/** Base class of the facades for the core's built-in steps. @internal */
+var CoreStep = class extends Step {
+	apply(doc) {
+		const core = this[CORE];
+		try {
+			return fromCoreResult(callBase(core, "apply", [doc[CORE]]));
+		} catch (e) {
+			if (isModelError(e)) return new StepResult(null, e.message);
+			throw e;
+		}
+	}
+	getMap() {
+		return callBase(this[CORE], "getMap");
+	}
+	invert(doc) {
+		return wrap(guard(() => callBase(this[CORE], "invert", [doc[CORE]])));
+	}
+	map(mapping) {
+		return nullable(callBase(this[CORE], "map", [unwrap(mapping)]));
+	}
+	merge(other) {
+		return nullable(callBase(this[CORE], "merge", [other[CORE]]));
+	}
+	toJSON() {
+		return callBase(this[CORE], "toJSON");
+	}
+};
+const adaptedClasses = /* @__PURE__ */ new WeakMap();
+/**
+* The core class used for instances of a subclass of a built-in step
+* facade: a subclass of the core step class whose methods call the
+* facade's overrides, when it has them. @internal
+*/
+const adaptedStepClass = (CoreClass, FacadeClass) => {
+	let found = adaptedClasses.get(CoreClass);
+	if (!found) {
+		const base = FacadeClass.prototype;
+		found = class extends CoreClass {
+			apply(doc) {
+				return this.facade.apply === base.apply ? super.apply(doc) : toCoreResult(this.facade.apply(wrap(doc)));
+			}
+			getMap() {
+				return this.facade.getMap === base.getMap ? super.getMap() : this.facade.getMap();
+			}
+			invert(doc) {
+				return this.facade.invert === base.invert ? super.invert(doc) : this.facade.invert(wrap(doc))[CORE];
+			}
+			map(mapping) {
+				return this.facade.map === base.map ? super.map(mapping) : Option.fromNullishOr(unwrap(this.facade.map(wrap(mapping))));
+			}
+			merge(other) {
+				return this.facade.merge === base.merge ? super.merge(other) : Option.fromNullishOr(unwrap(this.facade.merge(wrap(other))));
+			}
+			toJSON() {
+				return this.facade.toJSON === base.toJSON ? super.toJSON() : this.facade.toJSON();
+			}
+		};
+		found.prototype[BASE] = CoreClass.prototype;
+		adaptedClasses.set(CoreClass, found);
+	}
+	return found;
+};
+/** Create the core step for a built-in step facade (or a subclass of one). @internal */
+const coreStep = (facade, target, FacadeClass, CoreClass, args) => {
+	if (target === FacadeClass) return new CoreClass(...args);
+	const core = new (adaptedStepClass(CoreClass, FacadeClass))(...args);
+	core.facade = facade;
+	return core;
+};
+/**
+* Replace a part of the document with a slice of new content.
+*
+* @since 0.1.0
+* @category models
+*/
+var ReplaceStep = class ReplaceStep extends CoreStep {
+	/** The given `slice` should fit the 'gap' between `from` and `to`. */
+	constructor(from, to, slice, structure = false) {
+		super();
+		link(this, coreStep(this, new.target, ReplaceStep, ReplaceStep$1, [
+			from,
+			to,
+			slice[CORE],
+			structure
+		]));
+	}
+	/** The start position of the replaced range. */
+	get from() {
+		return this[CORE].from;
+	}
+	/** The end position of the replaced range. */
+	get to() {
+		return this[CORE].to;
+	}
+	/** The slice to insert. */
+	get slice() {
+		return wrap(this[CORE].slice);
+	}
+	/** @internal */
+	get structure() {
+		return this[CORE].structure;
+	}
+	/** @internal */
+	static fromJSON(schema, json) {
+		return wrap(guard(() => Step$1.fromJSONUnsafe(schema[CORE], {
+			...json,
+			stepType: "replace"
+		})));
+	}
+};
+/**
+* Replace a part of the document with a slice of content, but preserve
+* a range of the replaced content by moving it into the slice.
+*
+* @since 0.1.0
+* @category models
+*/
+var ReplaceAroundStep = class ReplaceAroundStep extends CoreStep {
+	/** Create a replace-around step with the given range and gap. */
+	constructor(from, to, gapFrom, gapTo, slice, insert, structure = false) {
+		super();
+		link(this, coreStep(this, new.target, ReplaceAroundStep, ReplaceAroundStep$1, [
+			from,
+			to,
+			gapFrom,
+			gapTo,
+			slice[CORE],
+			insert,
+			structure
+		]));
+	}
+	/** The start position of the replaced range. */
+	get from() {
+		return this[CORE].from;
+	}
+	/** The end position of the replaced range. */
+	get to() {
+		return this[CORE].to;
+	}
+	/** The start of preserved range. */
+	get gapFrom() {
+		return this[CORE].gapFrom;
+	}
+	/** The end of preserved range. */
+	get gapTo() {
+		return this[CORE].gapTo;
+	}
+	/** The slice to insert. */
+	get slice() {
+		return wrap(this[CORE].slice);
+	}
+	/** The position in the slice where the preserved range should be inserted. */
+	get insert() {
+		return this[CORE].insert;
+	}
+	/** @internal */
+	get structure() {
+		return this[CORE].structure;
+	}
+	/** @internal */
+	static fromJSON(schema, json) {
+		return wrap(guard(() => Step$1.fromJSONUnsafe(schema[CORE], {
+			...json,
+			stepType: "replaceAround"
+		})));
+	}
+};
+/**
+* Add a mark to all inline content between two positions.
+*
+* @since 0.1.0
+* @category models
+*/
+var AddMarkStep = class AddMarkStep extends CoreStep {
+	/** Create a mark step. */
+	constructor(from, to, mark) {
+		super();
+		link(this, coreStep(this, new.target, AddMarkStep, AddMarkStep$1, [
+			from,
+			to,
+			mark[CORE]
+		]));
+	}
+	/** The start of the marked range. */
+	get from() {
+		return this[CORE].from;
+	}
+	/** The end of the marked range. */
+	get to() {
+		return this[CORE].to;
+	}
+	/** The mark to add. */
+	get mark() {
+		return wrap(this[CORE].mark);
+	}
+	/** @internal */
+	static fromJSON(schema, json) {
+		return wrap(guard(() => Step$1.fromJSONUnsafe(schema[CORE], {
+			...json,
+			stepType: "addMark"
+		})));
+	}
+};
+/**
+* Remove a mark from all inline content between two positions.
+*
+* @since 0.1.0
+* @category models
+*/
+var RemoveMarkStep = class RemoveMarkStep extends CoreStep {
+	/** Create a mark-removing step. */
+	constructor(from, to, mark) {
+		super();
+		link(this, coreStep(this, new.target, RemoveMarkStep, RemoveMarkStep$1, [
+			from,
+			to,
+			mark[CORE]
+		]));
+	}
+	/** The start of the unmarked range. */
+	get from() {
+		return this[CORE].from;
+	}
+	/** The end of the unmarked range. */
+	get to() {
+		return this[CORE].to;
+	}
+	/** The mark to remove. */
+	get mark() {
+		return wrap(this[CORE].mark);
+	}
+	/** @internal */
+	static fromJSON(schema, json) {
+		return wrap(guard(() => Step$1.fromJSONUnsafe(schema[CORE], {
+			...json,
+			stepType: "removeMark"
+		})));
+	}
+};
+/**
+* Add a mark to a specific node.
+*
+* @since 0.1.0
+* @category models
+*/
+var AddNodeMarkStep = class AddNodeMarkStep extends CoreStep {
+	/** Create a node mark step. */
+	constructor(pos, mark) {
+		super();
+		link(this, coreStep(this, new.target, AddNodeMarkStep, AddNodeMarkStep$1, [pos, mark[CORE]]));
+	}
+	/** The position of the target node. */
+	get pos() {
+		return this[CORE].pos;
+	}
+	/** The mark to add. */
+	get mark() {
+		return wrap(this[CORE].mark);
+	}
+	/** @internal */
+	static fromJSON(schema, json) {
+		return wrap(guard(() => Step$1.fromJSONUnsafe(schema[CORE], {
+			...json,
+			stepType: "addNodeMark"
+		})));
+	}
+};
+/**
+* Remove a mark from a specific node.
+*
+* @since 0.1.0
+* @category models
+*/
+var RemoveNodeMarkStep = class RemoveNodeMarkStep extends CoreStep {
+	/** Create a mark-removing step. */
+	constructor(pos, mark) {
+		super();
+		link(this, coreStep(this, new.target, RemoveNodeMarkStep, RemoveNodeMarkStep$1, [pos, mark[CORE]]));
+	}
+	/** The position of the target node. */
+	get pos() {
+		return this[CORE].pos;
+	}
+	/** The mark to remove. */
+	get mark() {
+		return wrap(this[CORE].mark);
+	}
+	/** @internal */
+	static fromJSON(schema, json) {
+		return wrap(guard(() => Step$1.fromJSONUnsafe(schema[CORE], {
+			...json,
+			stepType: "removeNodeMark"
+		})));
+	}
+};
+var MarkSetStep = class extends CoreStep {
+	/** The grouped steps. */
+	get steps() {
+		return this[CORE].steps.map((s) => wrap(s));
+	}
+};
+/**
+* Update an attribute in a specific node.
+*
+* @since 0.1.0
+* @category models
+*/
+var AttrStep = class AttrStep extends CoreStep {
+	/** Construct an attribute step. */
+	constructor(pos, attr, value) {
+		super();
+		link(this, coreStep(this, new.target, AttrStep, AttrStep$1, [
+			pos,
+			attr,
+			value
+		]));
+	}
+	/** The position of the target node. */
+	get pos() {
+		return this[CORE].pos;
+	}
+	/** The attribute to set. */
+	get attr() {
+		return this[CORE].attr;
+	}
+	/** The attribute's new value. */
+	get value() {
+		return this[CORE].value;
+	}
+	/** @internal */
+	static fromJSON(schema, json) {
+		return wrap(guard(() => Step$1.fromJSONUnsafe(schema[CORE], {
+			...json,
+			stepType: "attr"
+		})));
+	}
+};
+/**
+* Update an attribute in the doc node.
+*
+* @since 0.1.0
+* @category models
+*/
+var DocAttrStep = class DocAttrStep extends CoreStep {
+	/** Construct an attribute step. */
+	constructor(attr, value) {
+		super();
+		link(this, coreStep(this, new.target, DocAttrStep, DocAttrStep$1, [attr, value]));
+	}
+	/** The attribute to set. */
+	get attr() {
+		return this[CORE].attr;
+	}
+	/** The attribute's new value. */
+	get value() {
+		return this[CORE].value;
+	}
+	/** @internal */
+	static fromJSON(schema, json) {
+		return wrap(guard(() => Step$1.fromJSONUnsafe(schema[CORE], {
+			...json,
+			stepType: "docAttr"
+		})));
+	}
+};
+registerWrapper(ReplaceStep$1, (core) => adopt(ReplaceStep.prototype, core));
+registerWrapper(ReplaceAroundStep$1, (core) => adopt(ReplaceAroundStep.prototype, core));
+registerWrapper(AddMarkStep$1, (core) => adopt(AddMarkStep.prototype, core));
+registerWrapper(RemoveMarkStep$1, (core) => adopt(RemoveMarkStep.prototype, core));
+registerWrapper(AddNodeMarkStep$1, (core) => adopt(AddNodeMarkStep.prototype, core));
+registerWrapper(RemoveNodeMarkStep$1, (core) => adopt(RemoveNodeMarkStep.prototype, core));
+registerWrapper(AttrStep$1, (core) => adopt(AttrStep.prototype, core));
+registerWrapper(DocAttrStep$1, (core) => adopt(DocAttrStep.prototype, core));
+registerWrapper(MarkSetStep$1, (core) => adopt(MarkSetStep.prototype, core));
+registerWrapper(StepResult$1, fromCoreResult);
+const wrappersToCore = (wrappers) => wrappers && wrappers.map((w) => w && {
+	type: w.type[CORE],
+	attrs: w.attrs ?? null
+});
+/**
+* Try to find a target depth to which the content in the given range
+* can be lifted.
+*
+* @since 0.1.0
+* @category structure
+*/
+const liftTarget = (range) => Option.getOrNull(liftTarget$1(range[CORE]));
+/**
+* Try to find a valid way to wrap the content in the given range in a
+* node of the given type.
+*
+* @since 0.1.0
+* @category structure
+*/
+const findWrapping = (range, nodeType, attrs = null, innerRange = range) => {
+	const found = Option.getOrNull(findWrapping$1(range[CORE], nodeType[CORE], attrs, innerRange[CORE]));
+	return found && found.map((w) => ({
+		type: wrap(w.type),
+		attrs: w.attrs ?? null
+	}));
+};
+/**
+* Check whether splitting at the given position is allowed.
+*
+* @since 0.1.0
+* @category structure
+*/
+const canSplit = (doc, pos, depth = 1, typesAfter) => guard(() => canSplit$1(doc[CORE], pos, depth, wrappersToCore(typesAfter)));
+/**
+* Test whether the blocks before and after a given position can be
+* joined.
+*
+* @since 0.1.0
+* @category structure
+*/
+const canJoin = (doc, pos) => guard(() => canJoin$1(doc[CORE], pos));
+/**
+* Find an ancestor of the given position that can be joined to the
+* block before (or after if `dir` is positive).
+*
+* @since 0.1.0
+* @category structure
+*/
+const joinPoint = (doc, pos, dir = -1) => guard(() => Option.getOrNull(joinPoint$1(doc[CORE], pos, dir)));
+/**
+* Try to find a point where a node of the given type can be inserted
+* near `pos`, by searching up the node hierarchy when `pos` itself
+* isn't a valid place but is at the start or end of a node.
+*
+* @since 0.1.0
+* @category structure
+*/
+const insertPoint = (doc, pos, nodeType) => guard(() => Option.getOrNull(insertPoint$1(doc[CORE], pos, nodeType[CORE])));
+/**
+* Finds a position at or around the given position where the given
+* slice can be inserted.
+*
+* @since 0.1.0
+* @category structure
+*/
+const dropPoint = (doc, pos, slice) => guard(() => Option.getOrNull(dropPoint$1(doc[CORE], pos, slice[CORE])));
+/**
+* 'Fit' a slice into a given position in the document, producing a
+* step that inserts it. Will return null if there's no meaningful way
+* to insert the slice here, or inserting it would be a no-op.
+*
+* @since 0.1.0
+* @category structure
+*/
+const replaceStep = (doc, from, to = from, slice = Slice.empty) => guard(() => nullable(replaceStep$1(doc[CORE], from, to, slice[CORE])));
+const contentInput = (content) => Array.isArray(content) ? content.map(unwrap) : unwrap(content);
+/**
+* Abstraction to build up and track an array of steps representing a
+* document transformation.
+*
+* @since 0.1.0
+* @category models
+*/
+var Transform = class {
+	/** Create a transform that starts with the given document. */
+	constructor(doc) {
+		link(this, new Transform$1(doc[CORE]));
+	}
+	/** The steps in this transform. */
+	get steps() {
+		return this[CORE].steps.map(wrap);
+	}
+	/** The documents before each of the steps. */
+	get docs() {
+		return this[CORE].docs.map(wrap);
+	}
+	/** A mapping with the maps for each of the steps in this transform. */
+	get mapping() {
+		return wrap(this[CORE].mapping);
+	}
+	/** The current document (the result of applying the steps in the transform). */
+	get doc() {
+		return wrap(this[CORE].doc);
+	}
+	/** The starting document. */
+	get before() {
+		return wrap(this[CORE].before);
+	}
+	/** Apply a new step in this transform, saving the result. Throws an error when the step fails. */
+	step(step) {
+		guard(() => this[CORE].stepUnsafe(step[CORE]));
+		return this;
+	}
+	/** Try to apply a step in this transformation, ignoring it if it fails. Returns the step result. */
+	maybeStep(step) {
+		return fromCoreResult(guard(() => this[CORE].maybeStep(step[CORE])));
+	}
+	/** True when the document has been changed (when there are any steps). */
+	get docChanged() {
+		return this[CORE].docChanged;
+	}
+	/** Return a single range, in post-transform document positions, that covers all content changed by this transform. */
+	changedRange() {
+		return Option.getOrNull(this[CORE].changedRange());
+	}
+	/** @internal */
+	addStep(step, doc) {
+		this[CORE].addStep(step[CORE], doc[CORE]);
+	}
+	/** Replace the part of the document between `from` and `to` with the given `slice`. */
+	replace(from, to = from, slice = Slice.empty) {
+		guard(() => this[CORE].replaceUnsafe(from, to, slice[CORE]));
+		return this;
+	}
+	/** Replace the given range with the given content, which may be a fragment, node, or array of nodes. */
+	replaceWith(from, to, content) {
+		guard(() => this[CORE].replaceWithUnsafe(from, to, contentInput(content)));
+		return this;
+	}
+	/** Delete the content between the given positions. */
+	delete(from, to) {
+		guard(() => this[CORE].deleteUnsafe(from, to));
+		return this;
+	}
+	/** Insert the given content at the given position. */
+	insert(pos, content) {
+		guard(() => this[CORE].insertUnsafe(pos, contentInput(content)));
+		return this;
+	}
+	/** Replace a range of the document with a given slice, using `from`, `to`, and the slice's `openStart` property as hints, rather than fixed start and end points. */
+	replaceRange(from, to, slice) {
+		guard(() => this[CORE].replaceRangeUnsafe(from, to, slice[CORE]));
+		return this;
+	}
+	/** Replace the given range with a node, but use `from` and `to` as hints, rather than precise positions. */
+	replaceRangeWith(from, to, node) {
+		guard(() => this[CORE].replaceRangeWithUnsafe(from, to, node[CORE]));
+		return this;
+	}
+	/** Delete the given range, expanding it to cover fully covered parent nodes until a valid replace is found. */
+	deleteRange(from, to) {
+		guard(() => this[CORE].deleteRangeUnsafe(from, to));
+		return this;
+	}
+	/** Split the content in the given range off from its parent, if there is sibling content before or after it, and move it up the tree to the depth specified by `target`. */
+	lift(range, target) {
+		guard(() => this[CORE].liftUnsafe(range[CORE], target));
+		return this;
+	}
+	/** Join the blocks around the given position. */
+	join(pos, depth = 1) {
+		guard(() => this[CORE].joinUnsafe(pos, depth));
+		return this;
+	}
+	/** Wrap the given range in the given set of wrappers. */
+	wrap(range, wrappers) {
+		guard(() => this[CORE].wrapUnsafe(range[CORE], wrappersToCore(wrappers)));
+		return this;
+	}
+	/** Set the type of all textblocks (partly) between `from` and `to` to the given node type with the given attributes. */
+	setBlockType(from, to = from, type, attrs = null) {
+		const coreAttrs = typeof attrs === "function" ? (node) => attrs(wrap(node)) : attrs;
+		guard(() => this[CORE].setBlockTypeUnsafe(from, to, type[CORE], coreAttrs));
+		return this;
+	}
+	/** Change the type, attributes, and/or marks of the node at `pos`. */
+	setNodeMarkup(pos, type, attrs = null, marks) {
+		guard(() => this[CORE].setNodeMarkupUnsafe(pos, type && type[CORE], attrs, marks && unwrapArray(marks)));
+		return this;
+	}
+	/** Set a single attribute on a given node to a new value. */
+	setNodeAttribute(pos, attr, value) {
+		guard(() => this[CORE].setNodeAttributeUnsafe(pos, attr, value));
+		return this;
+	}
+	/** Set a single attribute on the document to a new value. */
+	setDocAttribute(attr, value) {
+		guard(() => this[CORE].setDocAttributeUnsafe(attr, value));
+		return this;
+	}
+	/** Add a mark to the node at position `pos`. */
+	addNodeMark(pos, mark) {
+		guard(() => this[CORE].addNodeMarkUnsafe(pos, mark[CORE]));
+		return this;
+	}
+	/** Remove a mark (or all marks of the given type) from the node at position `pos`. */
+	removeNodeMark(pos, mark) {
+		guard(() => this[CORE].removeNodeMarkUnsafe(pos, mark[CORE]));
+		return this;
+	}
+	/** Split the node at the given position, and optionally, if `depth` is greater than one, any number of nodes above that. */
+	split(pos, depth = 1, typesAfter) {
+		guard(() => this[CORE].splitUnsafe(pos, depth, wrappersToCore(typesAfter)));
+		return this;
+	}
+	/** Add the given mark to the inline content between `from` and `to`. */
+	addMark(from, to, mark) {
+		guard(() => this[CORE].addMark(from, to, mark[CORE]));
+		return this;
+	}
+	/** Remove marks from inline nodes between `from` and `to`. */
+	removeMark(from, to, mark) {
+		guard(() => this[CORE].removeMark(from, to, mark && mark[CORE]));
+		return this;
+	}
+	/** Removes all marks and nodes from the content of the node at `pos` that don't match the given new parent node type. */
+	clearIncompatible(pos, parentType, match) {
+		guard(() => this[CORE].clearIncompatibleUnsafe(pos, parentType[CORE], match && match[CORE]));
+		return this;
+	}
+};
+registerWrapper(Transform$1, (core) => adopt(Transform.prototype, core));
+function toCore(value) {
+	return unwrap(value);
+}
+function fromCore(value) {
+	return wrap(value);
+}
+export { AddMarkStep, AddNodeMarkStep, AttrStep, DocAttrStep, MapResult, Mapping, RemoveMarkStep, RemoveNodeMarkStep, ReplaceAroundStep, ReplaceStep, Step, StepMap, StepResult, Transform, TransformError, canJoin, canSplit, dropPoint, findWrapping, fromCore, insertPoint, joinPoint, liftTarget, replaceStep, toCore };