@quillmark/svelte 0.21.0 → 0.23.0

package/dist/core/codec/tasks.js

@@ -0,0 +1,140 @@
+// A task item is a `list_item` whose `checked` is a boolean (CODEC §"Task items"). Its
+// `toDOM` draws a checkbox ahead of the item's blocks, disabled, which is the drawing a
+// held leaf, a copy and `renderContent` take; a leaf that edits mounts the item through
+// `taskItemView`, whose checkbox toggles. A task item is minted by source mode and by a
+// paste alone: no shorthand, command or key makes one.
+import { DOMSerializer } from 'prosemirror-model';
+import { Plugin } from 'prosemirror-state';
+import { splitListItem } from 'prosemirror-schema-list';
+const SVG = 'http://www.w3.org/2000/svg';
+/** The id the checkbox names its item's blocks by, fresh per drawing. */
+let drawn = 0;
+/** The `checked` an `<li>` states: `data-qm-checked`, which `toDOM` writes, else none. */
+export function taskChecked(el) {
+    const stated = el.getAttribute('data-qm-checked');
+    return stated === null ? null : stated === 'true';
+}
+/** Where an `<li>`'s blocks are: a task item's body, past its checkbox; the item itself
+ *  otherwise. */
+export function taskBody(el) {
+    const li = el;
+    const body = li.hasAttribute('data-qm-checked')
+        ? li.querySelector(':scope > [data-qm-task-body]')
+        : null;
+    return body ?? li;
+}
+/** A task item's `<li>`: the checkbox, unreachable by the caret, then the body holding
+ *  the item's blocks, which names it. The mark is the check glyph a matrix tick draws. */
+export function taskDOM(checked) {
+    const body = `qm-task-${++drawn}`;
+    return [
+        'li',
+        { 'data-qm-checked': String(checked) },
+        [
+            'span',
+            { class: 'qm-task', contenteditable: 'false' },
+            [
+                'input',
+                {
+                    type: 'checkbox',
+                    class: 'qm-task-box',
+                    'aria-labelledby': body,
+                    checked: checked ? '' : null,
+                    disabled: ''
+                }
+            ],
+            [
+                `${SVG} svg`,
+                {
+                    class: 'qm-task-mark',
+                    viewBox: '0 0 24 24',
+                    fill: 'none',
+                    stroke: 'currentColor',
+                    'stroke-width': '2',
+                    'stroke-linecap': 'round',
+                    'stroke-linejoin': 'round',
+                    'aria-hidden': 'true'
+                },
+                [`${SVG} path`, { d: 'M20 6 9 17l-5-5' }]
+            ]
+        ],
+        ['div', { id: body, 'data-qm-task-body': '' }, 0]
+    ];
+}
+const isTask = (node) => node.attrs.checked !== null;
+/**
+ * Every `list_item` in a leaf that edits, drawn by its own `toDOM`. A task item's checkbox
+ * is enabled, and a change to it is one `checked` transaction, so one `Mod-z` takes it
+ * back; where the leaf declines the edit the box returns to the item's value. The box
+ * keeps the press from the caret: a mousedown leaves the selection and the focus where
+ * they were, and ProseMirror reads no event aimed at it.
+ */
+function taskItemView(node, view, getPos) {
+    const { dom, contentDOM } = DOMSerializer.renderSpec(document, node.type.spec.toDOM(node));
+    const box = isTask(node)
+        ? dom.querySelector(':scope > .qm-task > input')
+        : null;
+    if (box) {
+        box.disabled = false;
+        box.addEventListener('mousedown', (e) => e.preventDefault());
+        box.addEventListener('change', () => {
+            const pos = getPos();
+            if (pos === undefined || !view.editable) {
+                box.checked = node.attrs.checked;
+                return;
+            }
+            view.dispatch(view.state.tr.setNodeAttribute(pos, 'checked', box.checked));
+        });
+    }
+    return {
+        dom,
+        contentDOM,
+        update(next) {
+            if (next.type !== node.type || isTask(next) !== isTask(node))
+                return false;
+            node = next;
+            if (box) {
+                box.checked = next.attrs.checked;
+                dom.setAttribute('data-qm-checked', String(next.attrs.checked));
+            }
+            return true;
+        },
+        stopEvent: (e) => box !== null && e.target === box,
+        ignoreMutation: (m) => m.type !== 'selection' && !contentDOM.contains(m.target)
+    };
+}
+/** The node view a block leaf mounts its list items through. */
+export function taskPlugin() {
+    return new Plugin({ props: { nodeViews: { list_item: taskItemView } } });
+}
+/**
+ * `splitListItem`, leaving the item that takes none of a task item's text an open task:
+ * the one below, or the one above where Enter is pressed at the head of the item's text.
+ * An empty item the split lifts out of a nested list keeps its own `checked`, as a
+ * Shift-Tab lift keeps it.
+ */
+export function splitTaskItem(itemType) {
+    const split = splitListItem(itemType);
+    return (state, dispatch, view) => {
+        const { $from, empty } = state.selection;
+        const item = $from.depth >= 2 ? $from.node(-1) : null;
+        if (!dispatch || item?.type !== itemType || !isTask(item))
+            return split(state, dispatch, view);
+        const lifted = $from.parent.content.size === 0 && item.childCount === 1;
+        const atHead = empty && $from.parentOffset === 0 && $from.index(-1) === 0;
+        return split(state, (tr) => {
+            const $at = tr.selection.$from;
+            const below = $at.before($at.depth - 1);
+            if (lifted)
+                tr.setNodeAttribute(below, 'checked', item.attrs.checked);
+            else if (atHead) {
+                const above = tr.doc.resolve(below).nodeBefore;
+                if (above)
+                    tr.setNodeAttribute(below - above.nodeSize, 'checked', false);
+            }
+            else
+                tr.setNodeAttribute(below, 'checked', false);
+            dispatch(tr);
+        });
+    };
+}

package/dist/core/errors.d.ts

@@ -11,8 +11,8 @@ export type EditorErrorCode =
  *  the whole projection instead, so the store is correct and this field's
  *  identity anchors were paid. */
  | 'commit-fallback'
-/** The overwrite fallback also failed, or the typed writer refused a `plaintext`
- *  leaf's text: the optimistic PM state stands and the store is stale for this
+/** The overwrite fallback also failed, or the typed writer refused a `text` leaf's
+ *  text: the optimistic PM state stands and the store is stale for this
  *  field. The one code here that leaves damage. */
  | 'commit-lost'
 /** A card operation (add, move, remove, retype) that threw. The document is

package/dist/visual/ArrayField.svelte

@@ -2,7 +2,7 @@
  An `array` field → an add/remove repeater. Elements commit by value: every
  edit / add / remove / move rebuilds the whole array and hands it to the parent's typed
  `writer.set(field, wholeArray)` (arrays are not op-addressed). Element control
- by `items.type`: `richtext` / `plaintext` → a prose element
+ by `items.type`: `richtext` / `text` → a prose element
  ({@link ProseValue}), `object` → a summary row that opens onto a subform, or a
  table's row where the array asks for one and the cells are short, everything else →
  a text input. The add chip sits in the label header row (space-between with the field
@@ -71,9 +71,10 @@
 		controlKind,
 		declaredContent,
 		humanize,
-		obliged,
+		literalText,
 		rowSummary,
 		schemaAt,
+		textCap,
 		type ArrayLayout
 	} from './structure.js';
 	import { splitDeep, unrouted, type DeepDiagnostic } from './diagnostics.js';
@@ -105,8 +106,6 @@
 		max?: number;
 		/** Accessible-name prefix for the element controls (`label` + 1-based index). */
 		label?: string;
-		/** No-default field → a persistent required `*` on the label. */
-		required?: boolean;
 		/** Schema `description`: the label's help affordance. */
 		description?: string;
 		/** The label's own DOM id. An array is a group (N inputs, no single `for`
@@ -140,7 +139,6 @@
 		layout = 'list',
 		max,
 		label,
-		required,
 		description,
 		labelId,
 		descriptionId,
@@ -519,9 +517,10 @@
 	 *  any cell an open row holds: Alt+↑/↓, the table island's own binding. The nearest
 	 *  row answers, or none does: a press inside a nested row is that row's whether it
 	 *  holds a reorder or not, so a key in a table's cell or a list of strings' input
-	 *  moves nothing, and never the record around it. */
+	 *  moves nothing, and never the record around it. A held drag owns the row until its
+	 *  release. */
 	function onRowKey(e: KeyboardEvent, k: number): void {
-		if (!e.altKey || e.shiftKey || e.ctrlKey || e.metaKey || e.isComposing) return;
+		if (!e.altKey || e.shiftKey || e.ctrlKey || e.metaKey || e.isComposing || drag) return;
 		// A cell that took the key — a select opening, a date segment stepping, a prose
 		// leaf joining — owns it.
 		if (e.defaultPrevented) return;
@@ -536,42 +535,53 @@
 
 	// ── The drag handle ──────────────────────────────────────────────────────────
 	// Press-and-drag the handle moves its row; a press that does not travel past the dead
-	// zone does nothing. The rows are measured once the drag engages, nothing reflowing
-	// until the release (the lift is a tone and the drop rule is out of flow), and the
-	// release is the one splice `move` makes.
+	// zone does nothing. The drop is the row under the pointer, read off the rows where
+	// they stand, so a scroll by any hand re-picks it. Held in an edge band of its
+	// scrollport, the drag scrolls it toward the rows out of view, once the pointer has
+	// been outside the band: a press on a row already in the band does not scroll. Nothing
+	// reflows until the release (the lift is a tone and the drop rule is out of flow), and
+	// the release is the one splice `move` makes. A handle that loses the pointer, or
+	// leaves the DOM, ends the drag with no move.
 	const DEAD_ZONE = 3;
-	type RowDrag = {
-		k: number;
-		origin: number;
-		engaged: boolean;
-		drop: number;
-		heads: { start: number; end: number }[];
-	};
+	/** The band at a scrollport's top and bottom edges that scrolls it under a held drag,
+	 *  and the most one frame scrolls, reached at the edge itself. */
+	const EDGE = 48;
+	const STEP = 16;
+	type RowDrag = { k: number; origin: number; y: number; engaged: boolean; drop: number };
 	let drag = $state<RowDrag | undefined>();
+	let follow: { grip: Element; port: Element; armed: boolean; frame: number } | undefined;
 	function onHandleDown(e: PointerEvent, k: number): void {
 		if (e.button !== 0) return;
 		e.preventDefault();
-		(e.currentTarget as HTMLElement).setPointerCapture?.(e.pointerId);
-		drag = { k, origin: e.clientY, engaged: false, drop: k, heads: [] };
+		release();
+		const grip = e.currentTarget as HTMLElement;
+		grip.setPointerCapture?.(e.pointerId);
+		drag = { k, origin: e.clientY, y: e.clientY, engaged: false, drop: k };
+		follow = { grip, port: scrollport(grip), armed: false, frame: 0 };
 	}
 	function onHandleMove(e: PointerEvent): void {
 		if (!drag) return;
+		drag.y = e.clientY;
 		if (!drag.engaged) {
 			if (Math.abs(e.clientY - drag.origin) < DEAD_ZONE) return;
 			drag.engaged = true;
-			drag.heads = ids.map((id) => {
-				const box = rowEls[id]?.getBoundingClientRect();
-				return { start: box?.top ?? 0, end: box?.bottom ?? 0 };
-			});
+			addEventListener('scroll', repick, { capture: true, passive: true });
+			if (follow) follow.frame = requestAnimationFrame(edgeScroll);
 		}
-		drag.drop = dropIndex(drag, e.clientY);
+		repick();
+	}
+	function repick(): void {
+		if (drag?.engaged) drag.drop = dropIndex(drag.k, drag.y);
 	}
+	const rowBox = (i: number): DOMRect | undefined => rowEls[ids[i]]?.getBoundingClientRect();
 	/** The row the pointer is over, or the nearest one past either end. */
-	function dropIndex(d: RowDrag, y: number): number {
-		let best = d.k;
+	function dropIndex(k: number, y: number): number {
+		let best = k;
 		let nearest = Infinity;
-		d.heads.forEach((head, i) => {
-			const gap = y < head.start ? head.start - y : y > head.end ? y - head.end : 0;
+		ids.forEach((_, i) => {
+			const box = rowBox(i);
+			if (!box) return;
+			const gap = y < box.top ? box.top - y : y > box.bottom ? y - box.bottom : 0;
 			if (gap < nearest) {
 				nearest = gap;
 				best = i;
@@ -579,9 +589,45 @@
 		});
 		return best;
 	}
+	const page = (): Element => document.scrollingElement ?? document.documentElement;
+	/** The nearest ancestor that scrolls vertically, else the page. */
+	function scrollport(from: Element): Element {
+		for (let el = from.parentElement; el; el = el.parentElement) {
+			const { overflowY } = getComputedStyle(el);
+			if (/auto|scroll/.test(overflowY) && el.scrollHeight > el.clientHeight) return el;
+		}
+		return page();
+	}
+	function edgeScroll(): void {
+		if (!follow || !drag?.engaged) return;
+		if (!follow.grip.isConnected) {
+			drag = undefined;
+			release();
+			return;
+		}
+		const { port } = follow;
+		const box = port === page() ? undefined : port.getBoundingClientRect();
+		const top = Math.max(box?.top ?? 0, 0);
+		const bottom = Math.min(box?.bottom ?? innerHeight, innerHeight);
+		const into = Math.min(drag.y - top - EDGE, 0) + Math.max(drag.y - bottom + EDGE, 0);
+		if (!into) follow.armed = true;
+		// Only toward rows still out of view: past the list's end there is nothing to reach.
+		const beyond =
+			into < 0 ? (rowBox(0)?.top ?? top) < top : (rowBox(ids.length - 1)?.bottom ?? 0) > bottom;
+		if (into && follow.armed && beyond)
+			port.scrollBy({ top: STEP * Math.max(-1, Math.min(1, into / EDGE)), behavior: 'instant' });
+		follow.frame = requestAnimationFrame(edgeScroll);
+	}
+	function release(): void {
+		if (follow) cancelAnimationFrame(follow.frame);
+		follow = undefined;
+		removeEventListener('scroll', repick, { capture: true });
+	}
+	onDestroy(release);
 	function onHandleUp(e: PointerEvent): void {
 		const done = drag;
 		drag = undefined;
+		release();
 		if (!done?.engaged || e.type !== 'pointerup') return;
 		move(done.k, done.drop);
 	}
@@ -600,14 +646,7 @@
 >
 	<div class="qm-array-header">
 		{#if label != null}
-			<FieldLabel
-				{label}
-				id={labelId}
-				{descriptionId}
-				onActivate={focus}
-				{required}
-				{description}
-			/>
+			<FieldLabel {label} id={labelId} {descriptionId} onActivate={focus} {description} />
 		{:else}
 			<span></span>
 		{/if}
@@ -632,15 +671,15 @@
 	     each block's one child: a branch inside the block would stand between them. -->
 	{#if table}
 		<div
-			class={['qm-array-rows qm-array-table', { empty: ids.length === 0 }]}
+			class={['qm-array-rows qm-array-table qm-wash', { empty: ids.length === 0 }]}
 			data-default={defaulted ? '' : undefined}
 			bind:this={rowsEl}
 		>
 			<div class="qm-array-table-scroller" style:--table-cols={columns.length}>
 				<!-- The header names the columns, so a cell carries no label of its own: its
 				     accessible name is the row's and the column's composed (`ObjectField`). The
-				     obligation mark and the guidance affordance ride the header, being the
-				     column's rather than any one cell's. -->
+				     guidance affordance rides the header, being the column's rather than any
+				     one cell's. -->
 				<div class="qm-array-table-head">
 					{#each columns as [key, sub] (key)}
 						<div
@@ -652,7 +691,6 @@
 							<FieldLabel
 								label={columnTitle(key, sub)}
 								descriptionId={idBase != null ? propertyDomIds(idBase, key).description : undefined}
-								required={obliged(sub)}
 								description={sub.description}
 							/>
 						</div>
@@ -660,7 +698,11 @@
 					<span class="qm-array-table-head-end"></span>
 				</div>
 				{#each ids as id, k (id)}
-					<div class="qm-array-row qm-array-table-row" bind:this={rowEls[id]}>
+					<div
+						class="qm-array-row qm-array-table-row qm-wash"
+						data-qm-index={k}
+						bind:this={rowEls[id]}
+					>
 						<ObjectField
 							bare
 							bind:this={cellEls[id]}
@@ -680,7 +722,7 @@
 		</div>
 	{:else if control === 'object'}
 		<div
-			class={['qm-array-rows', { empty: ids.length === 0 }]}
+			class={['qm-array-rows qm-wash', { empty: ids.length === 0 }]}
 			data-default={defaulted ? '' : undefined}
 			bind:this={rowsEl}
 		>
@@ -690,10 +732,11 @@
 				     interaction of the row's own: the row is no tab stop. -->
 				<div
 					class={[
-						'qm-array-row qm-element',
+						'qm-array-row qm-element qm-wash',
 						{ open: open.has(id), lifted: drag?.engaged && drag.k === k }
 					]}
 					data-drop={dropSide(k)}
+					data-qm-index={k}
 					bind:this={rowEls[id]}
 					animate:reorder={arm.armed}
 					onkeydown={(e) => onRowKey(e, k)}
@@ -708,6 +751,7 @@
 							type="button"
 							class="qm-control-box qm-focus-ring qm-element-summary"
 							aria-expanded={open.has(id)}
+							aria-keyshortcuts="Alt+ArrowUp Alt+ArrowDown"
 							onclick={() => toggleRow(id)}
 						>
 							<!-- Leading, and it rotates: trailing is the figure for pushing a new
@@ -745,18 +789,19 @@
 		</div>
 	{:else}
 		<div
-			class={['qm-array-rows', { empty: ids.length === 0 }]}
+			class={['qm-array-rows qm-wash', { empty: ids.length === 0 }]}
 			data-default={defaulted ? '' : undefined}
 			bind:this={rowsEl}
 		>
 			{#each ids as id, k (id)}
-				<div class="qm-array-row" bind:this={rowEls[id]}>
+				<div class="qm-array-row qm-wash" data-qm-index={k} bind:this={rowEls[id]}>
 					{#if control === 'prose'}
 						<ProseValue
 							bind:this={els[id]}
 							content={() => readAt([k])}
 							value={arr[k]}
-							plaintext={items != null && baseType(items) === 'plaintext'}
+							plaintext={items != null && literalText(items)}
+							cap={textCap(items)}
 							label={rowName(k)}
 							onChange={(rt) => commitElement(k, rt)}
 							onKey={(e) => onElementKey(e, k)}
@@ -794,20 +839,20 @@
 {/snippet}
 
 <!-- An `object` row's drag handle, a table grip's twin hung off the row's start edge.
-     It holds no focus, as a grip does not: its keyboard twin is Alt+↑/↓ from anywhere in
-     the row. -->
+     Pointer-only and out of the accessibility tree: a press on it does nothing, so a
+     button there would be one a screen reader activates to no effect. Its twin is
+     Alt+↑/↓ from anywhere in the row, which the summary announces. -->
 {#snippet handle(k: number)}
-	<button
-		type="button"
+	<span
 		class="qm-row-handle"
-		tabindex="-1"
+		aria-hidden="true"
 		title={t.strings.arrayDrag}
-		aria-label={rowAction(t.strings.arrayDrag, k)}
 		onpointerdown={(e) => onHandleDown(e, k)}
 		onpointermove={onHandleMove}
 		onpointerup={onHandleUp}
 		onpointercancel={onHandleUp}
-		><span class="qm-row-handle-bar"><Icon name="grip-vertical" /></span></button
+		onlostpointercapture={onHandleUp}
+		><span class="qm-row-handle-bar"><Icon name="grip-vertical" /></span></span
 	>
 {/snippet}
 
@@ -841,14 +886,13 @@
 	}
 	/* The elements, in a box of their own: the arrival wash blooms here rather than over
 	 the wrapper `Field` hands this component (`washBox`), which is the label's box too.
-	 Positioned for the wash's inset child, and rounded to the rung a row's own box
-	 draws, the way `.qm-field-control` is for every other control.
+	 Rounded to the rung a row's own box draws, the way `.qm-field-control` is for every
+	 other control.
 
 	 `display: none` when there are no elements, so the header does not stand a gap above
 	 an empty box; a wash over it then paints nothing, which is what an array with
 	 nothing in it has to show. */
 	.qm-array-rows {
-		position: relative;
 		display: flex;
 		flex-direction: column;
 		gap: var(--_qm-space);
@@ -873,7 +917,6 @@
 	 against. `minmax(0, …)` because a long unbroken value grows an `auto` track, and the
 	 edge with it. */
 	.qm-array-row {
-		position: relative;
 		display: grid;
 		grid-template-columns: minmax(0, 1fr);
 		row-gap: var(--_qm-space);
@@ -953,9 +996,6 @@
 		display: flex;
 		align-items: center;
 		justify-content: center;
-		padding: 0;
-		border: none;
-		background: none;
 		color: var(--_qm-ink-label);
 		cursor: grab;
 		touch-action: none;
@@ -988,7 +1028,7 @@
 	.qm-element.lifted > .qm-element-head > .qm-element-summary {
 		opacity: var(--_qm-opacity-muted);
 	}
-	.qm-element[data-drop]::after {
+	.qm-element[data-drop]::before {
 		content: '';
 		position: absolute;
 		inset-inline: 0;
@@ -997,10 +1037,10 @@
 		border-radius: var(--_qm-radius-pill);
 		pointer-events: none;
 	}
-	.qm-element[data-drop='before']::after {
+	.qm-element[data-drop='before']::before {
 		top: calc(-0.5 * (var(--_qm-space) + var(--_qm-ring-width)));
 	}
-	.qm-element[data-drop='after']::after {
+	.qm-element[data-drop='after']::before {
 		bottom: calc(-0.5 * (var(--_qm-space) + var(--_qm-ring-width)));
 	}
 	/* ── An object element ──────────────────────────────────────────────────────

package/dist/visual/ArrayField.svelte.d.ts

@@ -15,8 +15,6 @@ interface Props {
     max?: number;
     /** Accessible-name prefix for the element controls (`label` + 1-based index). */
     label?: string;
-    /** No-default field → a persistent required `*` on the label. */
-    required?: boolean;
     /** Schema `description`: the label's help affordance. */
     description?: string;
     /** The label's own DOM id. An array is a group (N inputs, no single `for`

package/dist/visual/Card.svelte

@@ -10,7 +10,7 @@
 	// component renders standalone too.
 	const t = wording();
 	import Icon from './icons/Icon.svelte';
-	import type { Document, Quill, Addr, Diagnostic } from '@quillmark/wasm';
+	import type { Document, Quill, Addr, Diagnostic, PathStep } from '@quillmark/wasm';
 	import type { EditorErrorHandler } from '../core/errors.js';
 	import type { LeafRegistry } from './leaves.js';
 	import type { CardModel, FieldModel } from './structure.js';
@@ -48,7 +48,7 @@
 		kinds: string[];
 		ops: CardOps;
 		enumDisallowed?: 'hide' | 'disable';
-		onFocus?: (addr: Addr) => void;
+		onFocus?: (addr: Addr, steps?: readonly PathStep[]) => void;
 		onCaretMove?: (addr: Addr, pos: number) => void;
 		onChange?: (addr: Addr) => void;
 		onError?: EditorErrorHandler;
@@ -279,7 +279,7 @@
 									<div class="qm-group-head">
 										<button
 											type="button"
-											class="qm-group-header"
+											class="qm-group-header qm-focus-ring"
 											id={headIds?.label}
 											bind:this={headers[group]}
 											aria-expanded={isOpen}
@@ -538,6 +538,12 @@
 	.qm-card-title:focus {
 		color: var(--_qm-ink);
 	}
+	/* The automatic title, at the label ink every placeholder takes rather than the UA's
+	 grey, and steady under focus, where a typed title steps to the ink. */
+	.qm-card-title::placeholder {
+		color: var(--_qm-ink-label);
+		opacity: 1;
+	}
 	.qm-card-body {
 		display: flex;
 		flex-direction: column;

package/dist/visual/Card.svelte.d.ts

@@ -1,4 +1,4 @@
-import type { Document, Quill, Addr, Diagnostic } from '@quillmark/wasm';
+import type { Document, Quill, Addr, Diagnostic, PathStep } from '@quillmark/wasm';
 import type { EditorErrorHandler } from '../core/errors.js';
 import type { LeafRegistry } from './leaves.js';
 import type { CardModel } from './structure.js';
@@ -27,7 +27,7 @@ interface Props {
     kinds: string[];
     ops: CardOps;
     enumDisallowed?: 'hide' | 'disable';
-    onFocus?: (addr: Addr) => void;
+    onFocus?: (addr: Addr, steps?: readonly PathStep[]) => void;
     onCaretMove?: (addr: Addr, pos: number) => void;
     onChange?: (addr: Addr) => void;
     onError?: EditorErrorHandler;