@thomasfosterau/effect-richtext 0.0.0 → 0.1.0

package/dist/inputrules.js

@@ -0,0 +1,321 @@
+import { Plugin } from "./state/plugin.js";
+import { TextSelection } from "./state/selection.js";
+import { canJoin, findWrappingOrNull } from "./transform/structure.js";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+// src/inputrules.ts
+/**
+* Input rules: regular expressions describing a piece of text that,
+* when typed, causes something to happen. Ported from
+* `prosemirror-inputrules`.
+*
+* ```ts skip-type-checking
+* const plugin = inputRules({
+*   rules: [...smartQuotes, emDash, wrappingInputRule(/^\s*>\s$/, schema.nodes.blockquote)]
+* })
+* ```
+*
+* Rule handlers may return a transaction (or `null`), like in
+* ProseMirror, but also an `Option<Transaction>` or an
+* `Effect<Option<Transaction>, E, R>`. The errors and requirements of
+* effectful rules end up in the plugin's type.
+*
+* @since 0.1.0
+*/
+/**
+* @since 0.1.0
+* @category symbols
+*/
+const InputRuleTypeId = Symbol.for("effect-richtext/inputrules/InputRule");
+/**
+* Input rules are regular expressions describing a piece of text that,
+* when typed, causes something to happen. This might be changing two
+* dashes into an emdash, wrapping a paragraph starting with `"> "` into
+* a blockquote, or something entirely different.
+*
+* @since 0.1.0
+* @category models
+*/
+var InputRule = class {
+	/**
+	* Create an input rule. The rule applies when the user typed something
+	* and the text directly in front of the cursor matches `match`, which
+	* should end with `$`.
+	*
+	* The `handler` can be a string, in which case the matched text, or
+	* the first matched group in the regexp, is replaced by that string.
+	*
+	* Or it can be a function, which will be called with the match array
+	* produced by `RegExp.exec`, as well as the start and end of the
+	* matched range, and which can return a transaction that describes the
+	* rule's effect, or `null` to indicate the input was not handled. It
+	* may also return an `Option` of a transaction, or an Effect producing
+	* one.
+	*/
+	constructor(match, handler, options = {}) {
+		this.match = match;
+		this.handler = Predicate.isString(handler) ? stringHandler(handler) : handler;
+		this.undoable = options.undoable !== false;
+		this.inCode = options.inCode || false;
+		this.inCodeMark = options.inCodeMark !== false;
+	}
+};
+function stringHandler(string) {
+	return (state, match, start, end) => {
+		let insert = string;
+		if (match[1]) {
+			const offset = match[0].lastIndexOf(match[1]);
+			insert += match[0].slice(offset + match[1].length);
+			start += offset;
+			const cutOff = start - end;
+			if (cutOff > 0) {
+				insert = match[0].slice(offset - cutOff, offset) + insert;
+				start = end;
+			}
+		}
+		return state.tr.insertTextUnsafe(insert, start, end);
+	};
+}
+const MAX_MATCH = 500;
+/**
+* Create an input rules plugin. When enabled, it will cause text input
+* that matches any of the given rules to trigger the rule's action.
+*
+* Rules are tried in order. Rules whose handler returns an Effect run
+* with the view's context: when such an effect completes synchronously,
+* it behaves exactly like a plain rule. When it is asynchronous, the
+* input is considered handled; when it eventually finds no transaction
+* (or fails), the typed text is inserted, and when it produces a
+* transaction, it is dispatched—both only if the editor state didn't
+* change in the meantime.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const inputRules = ({ rules }) => {
+	const plugin = new Plugin({
+		state: {
+			init: () => Option.none(),
+			apply(tr, prev) {
+				const stored = tr.getMeta(plugin);
+				if (Option.isSome(stored)) return stored;
+				return tr.selectionSet || tr.docChanged ? Option.none() : prev;
+			}
+		},
+		props: {
+			handleTextInput(view, from, to, text, deflt) {
+				return run(view, from, to, text, rules, plugin, deflt);
+			},
+			handleDOMEvents: { compositionend: (view) => {
+				setTimeout(() => {
+					if (view.isDestroyed) return;
+					const sel = view.state.selection;
+					const $cursor = sel instanceof TextSelection ? sel.$cursorOrNull : null;
+					if ($cursor) view.runHandler(run(view, $cursor.pos, $cursor.pos, "", rules, plugin, void 0));
+				});
+				return false;
+			} }
+		},
+		isInputRules: true
+	});
+	return plugin;
+};
+const hasCodeMark = (marks) => marks.some((m) => m.type.spec.code);
+function run(view, from, to, text, rules, plugin, deflt) {
+	if (view.composing) return false;
+	const state = view.state, $from = state.doc.resolveUnsafe(from);
+	return tryRules({
+		view,
+		state,
+		$from,
+		from,
+		to,
+		text,
+		textBefore: $from.parent.textBetween(Math.max(0, $from.parentOffset - MAX_MATCH), $from.parentOffset, null, "") + text,
+		rules,
+		plugin,
+		deflt,
+		sync: true
+	}, 0);
+}
+function tryRules(cx, start) {
+	const { $from, rules, state, text, textBefore } = cx;
+	for (let i = start; i < rules.length; i++) {
+		const rule = rules[i];
+		if (!rule.inCodeMark && hasCodeMark($from.marks())) continue;
+		if ($from.parent.type.spec.code) {
+			if (!rule.inCode) continue;
+		} else if (rule.inCode === "only") continue;
+		const match = rule.match.exec(textBefore);
+		if (!match || match[0].length < text.length) continue;
+		const startPos = cx.from - (match[0].length - text.length);
+		if (!rule.inCodeMark) {
+			let hasMark = false;
+			state.doc.nodesBetween(startPos, $from.pos, (node) => {
+				if (node.isInline && hasCodeMark(node.marks)) hasMark = true;
+			});
+			if (hasMark) continue;
+		}
+		const result = rule.handler(state, match, startPos, cx.to);
+		if (Effect.isEffect(result)) return runEffectRule(cx, rule, result, i + 1);
+		const tr = Option.isOption(result) ? Option.getOrNull(result) : result;
+		if (!tr) continue;
+		return applyRule(cx, rule, tr);
+	}
+	return false;
+}
+function applyRule(cx, rule, tr) {
+	if (rule.undoable) tr.setMeta(cx.plugin, {
+		transform: tr,
+		from: cx.from,
+		to: cx.to,
+		text: cx.text
+	});
+	return Effect.as(cx.view.dispatch(tr), true);
+}
+function fallback(cx) {
+	if (cx.sync || !cx.deflt || cx.view.isDestroyed || cx.view.state !== cx.state) return Effect.succeed(false);
+	return Effect.as(cx.view.dispatch(cx.deflt()), true);
+}
+function runEffectRule(cx, rule, effect, next) {
+	if (cx.sync) queueMicrotask(() => cx.sync = false);
+	return effect.pipe(Effect.flatMap((result) => {
+		if (Option.isSome(result)) {
+			if (cx.view.isDestroyed || cx.view.state !== cx.state) return Effect.succeed(true);
+			return applyRule(cx, rule, result.value);
+		}
+		const rest = tryRules(cx, next);
+		if (Effect.isEffect(rest)) return rest;
+		return fallback(cx);
+	}), Effect.tapCause(() => fallback(cx)));
+}
+/**
+* This is a command that will undo an input rule, if applying such a
+* rule was the last thing that the user did.
+*
+* @since 0.1.0
+* @category commands
+*/
+const undoInputRule = (state, dispatch) => Effect.suspend(() => {
+	const plugins = state.plugins;
+	for (let i = 0; i < plugins.length; i++) {
+		const plugin = plugins[i];
+		if (!plugin.spec.isInputRules) continue;
+		const undoable = Option.getOrNull(Option.flatten(plugin.getState(state)));
+		if (!undoable) continue;
+		if (!dispatch) return Effect.succeed(true);
+		const tr = state.tr, toUndo = undoable.transform;
+		for (let j = toUndo.steps.length - 1; j >= 0; j--) tr.stepUnsafe(toUndo.steps[j].invert(toUndo.docs[j]));
+		if (undoable.text) {
+			const marks = tr.doc.resolveUnsafe(undoable.from).marks();
+			tr.replaceWithUnsafe(undoable.from, undoable.to, state.schema.textUnsafe(undoable.text, marks));
+		} else tr.deleteUnsafe(undoable.from, undoable.to);
+		return Effect.as(dispatch(tr), true);
+	}
+	return Effect.succeed(false);
+});
+const resolveAttrs = (getAttrs, match) => Predicate.isFunction(getAttrs) ? getAttrs(match) : getAttrs;
+/**
+* Build an input rule for automatically wrapping a textblock when a
+* given string is typed. The `regexp` argument is directly passed
+* through to the `InputRule` constructor. You'll probably want the
+* regexp to start with `^`, so that the pattern can only occur at the
+* start of a textblock.
+*
+* `nodeType` is the type of node to wrap in. If it needs attributes,
+* you can either pass them directly, or pass a function that will
+* compute them from the regular expression match.
+*
+* By default, if there's a node with the same type above the newly
+* wrapped node, the rule will try to join those two nodes. You can pass
+* a join predicate, which takes a regular expression match and the node
+* before the wrapped node, and can return a boolean to indicate whether
+* a join should happen.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const wrappingInputRule = (regexp, nodeType, getAttrs = null, joinPredicate) => new InputRule(regexp, (state, match, start, end) => {
+	const attrs = resolveAttrs(getAttrs, match);
+	const tr = state.tr.deleteUnsafe(start, end);
+	const range = tr.doc.resolveUnsafe(start).blockRangeOrNull();
+	const wrapping = range && findWrappingOrNull(range, nodeType, attrs);
+	if (!wrapping) return null;
+	tr.wrapUnsafe(range, wrapping);
+	const before = tr.doc.resolveUnsafe(start - 1).nodeBeforeOrNull;
+	if (before && before.type === nodeType && canJoin(tr.doc, start - 1) && (!joinPredicate || joinPredicate(match, before))) tr.joinUnsafe(start - 1);
+	return tr;
+});
+/**
+* Build an input rule that changes the type of a textblock when the
+* matched text is typed into it. You'll usually want to start your
+* regexp with `^` so that it is only matched at the start of a
+* textblock. The optional `getAttrs` parameter can be used to compute
+* the new node's attributes, and works the same as in the
+* `wrappingInputRule` function.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const textblockTypeInputRule = (regexp, nodeType, getAttrs = null) => new InputRule(regexp, (state, match, start, end) => {
+	const $start = state.doc.resolveUnsafe(start);
+	const attrs = resolveAttrs(getAttrs, match);
+	if (!$start.node(-1).canReplaceWith($start.index(-1), $start.indexAfter(-1), nodeType)) return null;
+	return state.tr.deleteUnsafe(start, end).setBlockTypeUnsafe(start, start, nodeType, attrs);
+});
+/**
+* Converts double dashes to an emdash.
+*
+* @since 0.1.0
+* @category rules
+*/
+const emDash = new InputRule(/--$/, "—", { inCodeMark: false });
+/**
+* Converts three dots to an ellipsis character.
+*
+* @since 0.1.0
+* @category rules
+*/
+const ellipsis = new InputRule(/\.\.\.$/, "…", { inCodeMark: false });
+/**
+* “Smart” opening double quotes.
+*
+* @since 0.1.0
+* @category rules
+*/
+const openDoubleQuote = new InputRule(/(?:^|[\s{[(<'"‘“])(")$/, "“", { inCodeMark: false });
+/**
+* “Smart” closing double quotes.
+*
+* @since 0.1.0
+* @category rules
+*/
+const closeDoubleQuote = new InputRule(/"$/, "”", { inCodeMark: false });
+/**
+* “Smart” opening single quotes.
+*
+* @since 0.1.0
+* @category rules
+*/
+const openSingleQuote = new InputRule(/(?:^|[\s{[(<'"‘“])(')$/, "‘", { inCodeMark: false });
+/**
+* “Smart” closing single quotes.
+*
+* @since 0.1.0
+* @category rules
+*/
+const closeSingleQuote = new InputRule(/'$/, "’", { inCodeMark: false });
+/**
+* Smart-quote related input rules.
+*
+* @since 0.1.0
+* @category rules
+*/
+const smartQuotes = [
+	openDoubleQuote,
+	closeDoubleQuote,
+	openSingleQuote,
+	closeSingleQuote
+];
+export { InputRule, InputRuleTypeId, closeDoubleQuote, closeSingleQuote, ellipsis, emDash, inputRules, openDoubleQuote, openSingleQuote, smartQuotes, textblockTypeInputRule, undoInputRule, wrappingInputRule };

package/dist/internal/attempt.js

@@ -0,0 +1,15 @@
+import * as Effect from "effect/Effect";
+import * as Result from "effect/Result";
+// src/internal/attempt.ts
+/**
+* Lift a synchronous computation that signals expected failure by
+* throwing a tagged error (as recognised by `isExpected`) into an
+* Effect. Other exceptions become defects.
+*
+* @internal
+*/
+const attempt = (f, isExpected) => Effect.suspend(() => Result.match(Result.try(f), {
+	onSuccess: Effect.succeed,
+	onFailure: (e) => isExpected(e) ? Effect.fail(e) : Effect.die(e)
+}));
+export { attempt };

package/dist/internal/json.js

@@ -0,0 +1,29 @@
+import * as Option from "effect/Option";
+import * as Schema from "effect/Schema";
+// src/internal/json.ts
+const UnknownFromJsonString = /* @__PURE__ */ Schema.fromJsonString(Schema.Unknown);
+const JsonFromJsonString = /* @__PURE__ */ Schema.fromJsonString(Schema.Json);
+const encodeJsonString = /* @__PURE__ */ Schema.encodeOption(UnknownFromJsonString);
+const decodeJsonString = /* @__PURE__ */ Schema.decodeOption(JsonFromJsonString);
+/**
+* Serialize a value as a JSON string (calling `toJSON` where defined, as
+* `JSON.stringify` does), or `None` when it has no JSON form (`undefined`,
+* a function, a cycle, a `BigInt`).
+*
+* @internal
+*/
+const stringifyJson = (value) => encodeJsonString(value);
+/**
+* Parse a JSON string, or `None` when it is not valid JSON.
+*
+* @internal
+*/
+const parseJson = (text) => decodeJsonString(text);
+/**
+* Render a value for an error or debug message: its JSON form, or
+* `String(value)` when it has none.
+*
+* @internal
+*/
+const showJson = (value) => Option.getOrElse(stringifyJson(value), () => String(value));
+export { parseJson, showJson, stringifyJson };

package/dist/keymap/keymap.d.ts

@@ -0,0 +1,130 @@
+import { AnySchema } from "../model/schema.js";
+import "../model.js";
+import "../state.js";
+import { Command } from "../state/transaction.js";
+import { Plugin } from "../state/plugin.js";
+import { EditorView } from "../view/view.js";
+import * as Effect from "effect/Effect";
+import * as Schema from "effect/Schema";
+declare const KeymapError_base: Schema.Class<KeymapError, Schema.TaggedStruct<"KeymapError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * An invalid keymap: a key name with an unrecognized modifier, or two
+ * bindings for the same key.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export declare class KeymapError extends KeymapError_base {}
+/**
+ * A set of key bindings, mapping key names to commands.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface Bindings {
+  readonly [key: string]: Command<any, any, any>;
+}
+/**
+ * The union of the error types of the commands in a set of bindings.
+ *
+ * @since 0.1.0
+ * @category type-level
+ */
+export type BindingsError<B extends Bindings> = { [K in keyof B]: B[K] extends ((...args: any) => Effect.Effect<any, infer E, any>) ? E : never; }[keyof B];
+/**
+ * The union of the requirements of the commands in a set of bindings.
+ *
+ * @since 0.1.0
+ * @category type-level
+ */
+export type BindingsRequirements<B extends Bindings> = { [K in keyof B]: B[K] extends ((...args: any) => Effect.Effect<any, any, infer R>) ? R : never; }[keyof B];
+/**
+ * The editor view a keydown handler receives. Its `dispatch` is passed
+ * to bound commands, and the view itself as their third argument.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type KeymapView<Sc extends AnySchema = AnySchema> = EditorView<Sc, any, any>;
+/**
+ * A keydown handler, as created by `keydownHandler`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export type KeydownHandler<E = never, R = never> = (view: KeymapView<any>, event: KeyboardEvent) => Effect.Effect<boolean, E, R>;
+/**
+ * Normalize a key name (such as `"Mod-Shift-a"`) into the canonical
+ * form used for lookups (`"Shift-Ctrl-a"` on non-Mac platforms).
+ * Throws a `KeymapError` for unrecognized modifiers.
+ *
+ * @since 0.1.0
+ * @category utils
+ */
+export declare function normalizeKeyName(name: string): string;
+/**
+ * Normalize the key names of a set of bindings. Throws a `KeymapError`
+ * for invalid or duplicate key names.
+ *
+ * @internal
+ */
+export declare function normalizeBindings<A>(map: {
+  readonly [key: string]: A;
+}): Record<string, A>;
+/**
+ * Find the bindings matching a keydown event, in the order in which
+ * they should be tried.
+ *
+ * @internal
+ */
+export declare function matchBindings<A>(map: Record<string, A>, event: KeyboardEvent): Array<A>;
+/**
+ * Create a keymap plugin for the given set of bindings.
+ *
+ * Bindings should map key names to commands, which will be called with
+ * `(state, dispatch, view)` arguments, and should succeed with `true`
+ * when they've handled the key. Note that the view argument isn't part
+ * of the command protocol, but can be used as an escape hatch if a
+ * binding needs to directly interact with the UI.
+ *
+ * Key names may be strings like `"Shift-Ctrl-Enter"`—a key identifier
+ * prefixed with zero or more modifiers. Key identifiers are based on
+ * the strings that can appear in `KeyEvent.key`. Use lowercase letters
+ * to refer to letter keys (or uppercase letters if you want shift to be
+ * held). You may use `"Space"` as an alias for the `" "` name.
+ *
+ * Modifiers can be given in any order. `Shift-` (or `s-`), `Alt-` (or
+ * `a-`), `Ctrl-` (or `c-` or `Control-`) and `Cmd-` (or `m-` or
+ * `Meta-`) are recognized. For characters that are created by holding
+ * shift, the `Shift-` prefix is implied, and should not be added
+ * explicitly.
+ *
+ * You can use `Mod-` as a shorthand for `Cmd-` on Mac and `Ctrl-` on
+ * other platforms.
+ *
+ * You can add multiple keymap plugins to an editor. The order in which
+ * they appear determines their precedence (the ones early in the array
+ * get to dispatch first).
+ *
+ * The plugin's error and requirement types are the unions of those of
+ * the bound commands. Throws a `KeymapError` when a key name is invalid
+ * or bound twice.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare const keymap: <const B extends Bindings>(bindings: B) => Plugin<undefined, AnySchema, BindingsError<B>, BindingsRequirements<B>>;
+/**
+ * Given a set of bindings (using the same format as `keymap`), return a
+ * keydown handler that handles them. The handler succeeds with `true`
+ * when one of the matching commands handled the key.
+ *
+ * Throws a `KeymapError` when a key name is invalid or bound twice.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare const keydownHandler: <const B extends Bindings>(bindings: B) => KeydownHandler<BindingsError<B>, BindingsRequirements<B>>;
+export {};

package/dist/keymap/keymap.js

@@ -0,0 +1,159 @@
+import { Plugin } from "../state/plugin.js";
+import * as Arr from "effect/Array";
+import * as Effect from "effect/Effect";
+import * as Predicate from "effect/Predicate";
+import * as Schema from "effect/Schema";
+import { base, keyName } from "w3c-keyname";
+// src/keymap/keymap.ts
+/**
+* Keymaps: plugins that bind key names to commands, ported from
+* `prosemirror-keymap`.
+*
+* Ported from prosemirror-keymap (MIT, Marijn Haverbeke and others).
+*
+* @since 0.1.0
+*/
+const mac = !Predicate.isUndefined(globalThis.navigator) && /Mac|iP(hone|[oa]d)/.test(navigator.platform);
+const windows = !Predicate.isUndefined(globalThis.navigator) && /Win/.test(navigator.platform);
+/**
+* An invalid keymap: a key name with an unrecognized modifier, or two
+* bindings for the same key.
+*
+* @since 0.1.0
+* @category errors
+*/
+var KeymapError = class extends Schema.TaggedError()("KeymapError", { message: Schema.String }) {};
+/**
+* Normalize a key name (such as `"Mod-Shift-a"`) into the canonical
+* form used for lookups (`"Shift-Ctrl-a"` on non-Mac platforms).
+* Throws a `KeymapError` for unrecognized modifiers.
+*
+* @since 0.1.0
+* @category utils
+*/
+function normalizeKeyName(name) {
+	const parts = name.split(/-(?!$)/);
+	let result = parts[parts.length - 1];
+	if (result === "Space") result = " ";
+	let alt = false, ctrl = false, shift = false, meta = false;
+	for (let i = 0; i < parts.length - 1; i++) {
+		const mod = parts[i];
+		if (/^(cmd|meta|m)$/i.test(mod)) meta = true;
+		else if (/^a(lt)?$/i.test(mod)) alt = true;
+		else if (/^(c|ctrl|control)$/i.test(mod)) ctrl = true;
+		else if (/^s(hift)?$/i.test(mod)) shift = true;
+		else if (/^mod$/i.test(mod)) {
+			if (mac) meta = true;
+			else ctrl = true;
+		} else throw new KeymapError({ message: "Unrecognized modifier name: " + mod });
+	}
+	if (alt) result = "Alt-" + result;
+	if (ctrl) result = "Ctrl-" + result;
+	if (meta) result = "Meta-" + result;
+	if (shift) result = "Shift-" + result;
+	return result;
+}
+/**
+* Normalize the key names of a set of bindings. Throws a `KeymapError`
+* for invalid or duplicate key names.
+*
+* @internal
+*/
+function normalizeBindings(map) {
+	const copy = Object.create(null);
+	for (const prop in map) {
+		const norm = normalizeKeyName(prop);
+		if (Object.prototype.hasOwnProperty.call(copy, norm)) throw new KeymapError({ message: "Multiple bindings for key " + norm + " in a single keymap" });
+		copy[norm] = map[prop];
+	}
+	return copy;
+}
+function modifiers(name, event, shift = true) {
+	if (event.altKey) name = "Alt-" + name;
+	if (event.ctrlKey) name = "Ctrl-" + name;
+	if (event.metaKey) name = "Meta-" + name;
+	if (shift && event.shiftKey) name = "Shift-" + name;
+	return name;
+}
+/**
+* Find the bindings matching a keydown event, in the order in which
+* they should be tried.
+*
+* @internal
+*/
+function matchBindings(map, event) {
+	const name = keyName(event);
+	const candidates = [];
+	const direct = map[modifiers(name, event)];
+	if (direct) candidates.push(direct);
+	if (name.length === 1 && name !== " ") {
+		if (event.shiftKey) {
+			const noShift = map[modifiers(name, event, false)];
+			if (noShift) candidates.push(noShift);
+		}
+		let baseName;
+		if ((event.altKey || event.metaKey || event.ctrlKey) && !(windows && event.ctrlKey && event.altKey) && (baseName = base[event.keyCode]) && baseName !== name) {
+			const fromCode = map[modifiers(baseName, event)];
+			if (fromCode) candidates.push(fromCode);
+		}
+	}
+	return candidates;
+}
+const succeedFalse = Effect.succeed(false);
+const succeedTrue = Effect.succeed(true);
+/**
+* Create a keymap plugin for the given set of bindings.
+*
+* Bindings should map key names to commands, which will be called with
+* `(state, dispatch, view)` arguments, and should succeed with `true`
+* when they've handled the key. Note that the view argument isn't part
+* of the command protocol, but can be used as an escape hatch if a
+* binding needs to directly interact with the UI.
+*
+* Key names may be strings like `"Shift-Ctrl-Enter"`—a key identifier
+* prefixed with zero or more modifiers. Key identifiers are based on
+* the strings that can appear in `KeyEvent.key`. Use lowercase letters
+* to refer to letter keys (or uppercase letters if you want shift to be
+* held). You may use `"Space"` as an alias for the `" "` name.
+*
+* Modifiers can be given in any order. `Shift-` (or `s-`), `Alt-` (or
+* `a-`), `Ctrl-` (or `c-` or `Control-`) and `Cmd-` (or `m-` or
+* `Meta-`) are recognized. For characters that are created by holding
+* shift, the `Shift-` prefix is implied, and should not be added
+* explicitly.
+*
+* You can use `Mod-` as a shorthand for `Cmd-` on Mac and `Ctrl-` on
+* other platforms.
+*
+* You can add multiple keymap plugins to an editor. The order in which
+* they appear determines their precedence (the ones early in the array
+* get to dispatch first).
+*
+* The plugin's error and requirement types are the unions of those of
+* the bound commands. Throws a `KeymapError` when a key name is invalid
+* or bound twice.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const keymap = (bindings) => new Plugin({ props: { handleKeyDown: keydownHandler(bindings) } });
+/**
+* Given a set of bindings (using the same format as `keymap`), return a
+* keydown handler that handles them. The handler succeeds with `true`
+* when one of the matching commands handled the key.
+*
+* Throws a `KeymapError` when a key name is invalid or bound twice.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const keydownHandler = (bindings) => {
+	const map = normalizeBindings(bindings);
+	return (view, event) => {
+		const candidates = matchBindings(map, event);
+		if (Arr.isArrayEmpty(candidates)) return succeedFalse;
+		const loop = (i) => i === candidates.length ? succeedFalse : Effect.flatMap(Effect.suspend(() => candidates[i](view.state, view.dispatch, view)), (handled) => handled ? succeedTrue : loop(i + 1));
+		return loop(0);
+	};
+};
+export { KeymapError, keydownHandler, keymap, matchBindings, normalizeBindings, normalizeKeyName };

package/dist/keymap.d.ts

@@ -0,0 +1,2 @@
+import { Bindings, BindingsError, BindingsRequirements, KeydownHandler, KeymapError, KeymapView, keydownHandler, keymap, matchBindings, normalizeBindings, normalizeKeyName } from "./keymap/keymap.js";
+export { Bindings, BindingsError, BindingsRequirements, KeydownHandler, KeymapError, KeymapView, keydownHandler, keymap, matchBindings, normalizeBindings, normalizeKeyName };

package/dist/keymap.js

@@ -0,0 +1 @@
+export { KeymapError, keydownHandler, keymap, matchBindings, normalizeBindings, normalizeKeyName } from "./keymap/keymap.js";

package/dist/markdown/errors.d.ts

@@ -0,0 +1,23 @@
+import * as Schema from "effect/Schema";
+declare const MarkdownError_base: Schema.Class<MarkdownError, Schema.TaggedStruct<"MarkdownError", {
+  readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * A Markdown error: the tokenizer produced a token type the parser has
+ * no handler for, a parser was configured with an invalid parsing
+ * spec, or (in strict mode) the serializer met a node or mark type it
+ * has no serializer for.
+ *
+ * Parsing reports unsupported tokens in the Effect error channel; the
+ * other cases are programming errors and are thrown.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export declare class MarkdownError extends MarkdownError_base {}
+/**
+ * @since 0.1.0
+ * @category guards
+ */
+export declare const isMarkdownError: (u: unknown) => u is MarkdownError;
+export {};