@quillmark/svelte 0.10.1 → 0.11.0

package/dist/visual/VisualEditorInner.svelte

@@ -32,7 +32,14 @@
 	import { errorMessage, reportError } from '../core/errors.js';
 	import { bloomInside } from '../core/bloom.js';
 	import { createLifespan } from '../core/teardown.js';
-	import type { Addr, CardAddr, Diagnostic, Resolved, ResolvedField } from '@quillmark/wasm';
+	import type {
+		Addr,
+		CardAddr,
+		Diagnostic,
+		PayloadItem,
+		Resolved,
+		ResolvedField
+	} from '@quillmark/wasm';
 	import type { VisualEditorProps } from './props.js';
 	import { mergeStrings, setWording } from './strings.js';
 	import type { CardId, ChangeSource } from './signals.js';
@@ -45,6 +52,8 @@
 		groupSections,
 		groupLabel,
 		cardTitle,
+		titleFields,
+		fieldValues,
 		bodyEnabled,
 		humanize,
 		provenanceMap,
@@ -144,6 +153,7 @@
 	 */
 	function bump(source: ChangeSource, cardId?: CardId, at?: Addr | number): void {
 		revision++;
+		liveTitles = {};
 		const path =
 			at == null ? undefined : typeof at === 'number' ? cardPath(at, liveKinds()) : pathFor(at);
 		onChange?.({ source, cardId, path });
@@ -154,8 +164,11 @@
 		return cardIds.indexOf(id);
 	}
 	/** The inverse, for the two signals that arrive as an address and nothing else (a
-	 * focus, a prose commit), off the same array the mutation boundary reads. */
-	function cardIdOf(addr: Addr): CardId {
+	 * focus, a prose commit), off the same array the mutation boundary reads.
+	 * `undefined` for an address outside the live card array, as {@link pathFor}: the
+	 * key is a host's only handle on a card, so a stale one is dropped rather than
+	 * reported. */
+	function cardIdOf(addr: Addr): CardId | undefined {
 		return addr.card == null ? 'main' : cardIds[addr.card];
 	}
 
@@ -214,7 +227,9 @@
 		lastCaretField = undefined;
 		lastCaretPos = undefined;
 		const field = pathFor(plain);
-		if (field != null) onActiveLeafChange?.({ field, cardId: activeCardId });
+		// Both halves or neither: a stale addr names no path and no live card.
+		if (field != null && activeCardId != null)
+			onActiveLeafChange?.({ field, cardId: activeCardId });
 	}
 	/** No card kinds are read for a main address; the shared empty stands in so the
 	 *  common case allocates nothing. */
@@ -261,7 +276,35 @@
 	 *  bump `revision` (see {@link bump}). */
 	function proseChanged(addr: Addr): void {
 		const plain = normalize(addr);
-		onChange?.({ source: 'prose', cardId: cardIdOf(plain), path: pathFor(plain) });
+		const cardId = cardIdOf(plain);
+		if (cardId == null) return;
+		refreshTitle(plain, cardId);
+		onChange?.({ source: 'prose', cardId, path: pathFor(plain) });
+	}
+
+	/** A card's header after a prose commit to a field its `{field}` title names: the
+	 *  one piece of the model that lane changes, held beside the model and dropped on
+	 *  the next bump, which rebuilds it from the document. The kind is the derived
+	 *  tree's ({@link liveKinds}), so the document is read only for a title that
+	 *  names the field. */
+	let liveTitles = $state<Record<CardId, string>>({});
+	function refreshTitle(addr: Addr, cardId: CardId): void {
+		const { card: at, field } = addr;
+		if (field == null) return;
+		const shown = at == null ? model.main : model.cards[at];
+		if (!shown) return;
+		const cardSchema = at == null ? quill.schema.main : quill.schema.card_kinds?.[shown.kind];
+		if (!titleFields(cardSchema?.ui?.title).includes(field)) return;
+		const live = at == null ? doc.main : doc.cards[at];
+		if (!live) return;
+		liveTitles = {
+			...liveTitles,
+			[cardId]: cardTitle(cardSchema, shown.kind, fieldValues(live.payloadItems), undefined)
+		};
+	}
+	function titled(c: CardModel): CardModel {
+		const t = liveTitles[c.id];
+		return t == null ? c : { ...c, titlePlaceholder: t };
 	}
 
 	// ── Commit routing ──────────────────────────────────────────────────────────
@@ -423,10 +466,11 @@
 		// Ids are never reused, so an entry keyed to the gone card is unreachable rather
 		// than mis-attributed to whichever card takes this position: it needs dropping
 		// because nothing else will ever clear it.
-		if ([...commitErrors.keys()].some((k) => k.startsWith(`${id}:`)))
-			editCommitErrors((m) => {
-				for (const k of [...m.keys()]) if (k.startsWith(`${id}:`)) m.delete(k);
-			});
+		const prefix = `${id}:`;
+		const stale = [...commitErrors.keys()].filter((k) => k.startsWith(prefix));
+		// Guarded: `editCommitErrors` clones the map, and a removal matching nothing has
+		// nothing to re-derive.
+		if (stale.length) editCommitErrors((m) => stale.forEach((k) => m.delete(k)));
 		// No addr: the removed card has none left and every survivor's shifted. The
 		// stack changed, not a leaf, and the id is the only handle the removal leaves.
 		bump('structure', id);
@@ -435,7 +479,12 @@
 		const i = cardIndexOf(id);
 		if (i < 0) return;
 		try {
-			doc.setCardKind(i, kind);
+			// Insert the retyped card ahead of the original and drop the original after.
+			// `insertCard` validates the whole card before it mutates and `removeCard`
+			// cannot throw, so a refusal leaves the document as it was; the reverse order
+			// would leave it a card short.
+			doc.insertCard({ ...doc.card(i), kind }, i);
+			doc.removeCard(i + 1);
 			bump('structure', id, i);
 		} catch (e) {
 			reportError(onError, {
@@ -536,15 +585,13 @@
 		isMain: boolean,
 		kind: string,
 		card: {
-			payloadItems: { type: string; key?: string; value?: unknown }[];
+			payloadItems: readonly PayloadItem[];
 			ext?: Record<string, unknown>;
 		},
 		cardSchema: Parameters<typeof fieldModels>[0] | undefined,
 		rows: ResolvedCardRows
 	): CardModel {
-		const values: Record<string, unknown> = {};
-		for (const p of card.payloadItems)
-			if (p.type === 'field' && p.key != null) values[p.key] = p.value;
+		const values = fieldValues(card.payloadItems);
 		const fields = cardSchema ? fieldModels(cardSchema) : [];
 		const sections = cardSchema
 			? groupSections(fields, groupOrder(cardSchema), (g) => groupLabel(cardSchema, g))
@@ -588,12 +635,12 @@
 		// chrome, so a resolve failure degrades to no ghosts, never a blank form.
 		let resolved: Resolved | undefined;
 		try {
-			resolved = quill.resolve(doc);
+			resolved = quill.reader(doc).resolve();
 		} catch (e) {
 			reportError(onError, {
 				code: 'resolve-failed',
 				severity: 'error',
-				message: `quill.resolve threw; ghosted defaults fall back to none: ${errorMessage(e)}`,
+				message: `reader.resolve threw; ghosted defaults fall back to none: ${errorMessage(e)}`,
 				cause: e
 			});
 		}
@@ -807,7 +854,7 @@
 	<div class="qm-primary">
 		<Card
 			bind:this={mainCard}
-			card={model.main}
+			card={titled(model.main)}
 			{doc}
 			{quill}
 			isFirst={true}
@@ -839,7 +886,7 @@
 		<div class="qm-card-slot" bind:this={slotEls[i]} animate:reorder={isReordering}>
 			<Card
 				bind:this={cardRefs[i]}
-				card={c}
+				card={titled(c)}
 				{doc}
 				{quill}
 				isFirst={i === 0}

package/dist/visual/controls.css

@@ -12,9 +12,9 @@
  Every selector here is `:where()`-wrapped, so a recipe computes at specificity zero.
  That is the point twice over: a consumer's stylesheet beats the chrome without
  `!important`, and a component's own scoped block overrides its shared base —
- `.qm-card-delete` recolours a `.qm-chip` under the pointer, `.qm-json` adds the monospace face over
- `.qm-input` — with no specificity fight. Unlayered with it, so a host's own layered
- reset never reaches these rules whatever order the sheets load in (`core/theme.css`). */
+ `.qm-card-delete` recolours a `.qm-chip` under the pointer — with no specificity
+ fight. Unlayered with it, so a host's own layered reset never reaches these rules
+ whatever order the sheets load in (`core/theme.css`). */
 
 /* The themed focus ring in place of the raw UA outline, as a
  rule rather than a pair of rungs each control assembles. `--_qm-ring`
@@ -63,11 +63,10 @@
 }
 
 /* A typed value's box (every scalar control and every prose leaf): the text and
- numeric inputs, the array's JSON textarea, the enum trigger, the date field, and
- the inline richtext leaves. One rule, because a
- leaf that agrees with the input beside it "by construction" has to draw the same
- declarations, not a copy of them: five hand-kept copies agree until one is
- edited, and nothing raises it (no literal is minted, so `check:style` stays
+ numeric inputs, the enum trigger, the date field, and the inline richtext leaves.
+ One rule, because a leaf that agrees with the input beside it "by construction" has
+ to draw the same declarations, not a copy of them: five hand-kept copies agree
+ until one is edited, and nothing raises it (no literal is minted, so `check:style` stays
  green while a control renders subtly the wrong height).
 
  Leading sits on the wide list rather than on the box's own, because a box's
@@ -91,7 +90,7 @@
 	color: var(--_qm-ink);
 	caret-color: currentColor;
 }
-/* The box is A fill and not an edge (ARCHITECTURE §Styling), and the fill is the
+/* The box is a fill and not an edge (ARCHITECTURE §Styling), and the fill is the
  well rung: a field is a hole cut into the card rather than a plane of its own,
  and with no edge to carry it the step is the whole of what says so. */
 :where(.qm-control-box),

package/dist/visual/ext.d.ts

@@ -4,23 +4,22 @@ import type { Document, CardAddr } from '@quillmark/wasm';
  * main). A key whose patch value is `undefined` is dropped; every other key in the
  * namespace is carried through untouched.
  *
- * **The namespace is the write unit.** `storeExtNamespace` replaces the namespace
- * it targets (preserving sibling namespaces, but not sibling keys) so a writer
- * that stores only its own key silently destroys the others, and
- * `removeExtNamespace` destroys all of them. `tips` and `title` are siblings here,
- * so a namespace-replacing dismissal would wipe every renamed card's title. Routing
- * every writer through this function is what makes that unexpressible rather than
- * merely documented: key N+1 inherits the merge instead of re-deriving it.
+ * **The whole map is the write unit.** `storeExt` replaces `$ext` entire, so a writer
+ * that stores only its own key silently destroys every sibling namespace, and a
+ * namespace-replacing write destroys the sibling keys inside it. `tips` and `title`
+ * are siblings here, so either would wipe every renamed card's title. Routing every
+ * writer through this function is what makes that unexpressible rather than merely
+ * documented: key N+1 inherits the merge instead of re-deriving it.
  *
  * The drop is an explicit `delete`, not a stored `undefined`: whether a JS
  * `undefined` survives the wasm-bindgen crossing is not a property worth depending
  * on.
  *
- * **A namespace emptied of keys is removed, not stored empty.** That is
- * `removeExtNamespace`'s one correct use: it takes the whole namespace, and there is
- * nothing left in this one to lose. `$ext` goes with it when `editor` was the last
- * namespace, so a document nothing has renamed or hinted carries no editor slot
- * rather than an empty one. A patch dropping keys the namespace does not have writes
- * nothing, so dismissing tips on a document that carries none is not a mutation.
+ * **A namespace emptied of keys is removed, not stored empty**, and `$ext` goes with
+ * it when `editor` was the last namespace — `removeExt` being the one call that drops
+ * the map, where `storeExt({})` records an explicit empty one. So a document nothing
+ * has renamed or hinted carries no editor slot rather than an empty one. A patch
+ * dropping keys the namespace does not have writes nothing, so dismissing tips on a
+ * document that carries none is not a mutation.
  */
 export declare function patchEditorExt(doc: Document, addr: CardAddr, patch: Record<string, unknown>): void;

package/dist/visual/ext.js

@@ -3,29 +3,27 @@
  * main). A key whose patch value is `undefined` is dropped; every other key in the
  * namespace is carried through untouched.
  *
- * **The namespace is the write unit.** `storeExtNamespace` replaces the namespace
- * it targets (preserving sibling namespaces, but not sibling keys) so a writer
- * that stores only its own key silently destroys the others, and
- * `removeExtNamespace` destroys all of them. `tips` and `title` are siblings here,
- * so a namespace-replacing dismissal would wipe every renamed card's title. Routing
- * every writer through this function is what makes that unexpressible rather than
- * merely documented: key N+1 inherits the merge instead of re-deriving it.
+ * **The whole map is the write unit.** `storeExt` replaces `$ext` entire, so a writer
+ * that stores only its own key silently destroys every sibling namespace, and a
+ * namespace-replacing write destroys the sibling keys inside it. `tips` and `title`
+ * are siblings here, so either would wipe every renamed card's title. Routing every
+ * writer through this function is what makes that unexpressible rather than merely
+ * documented: key N+1 inherits the merge instead of re-deriving it.
  *
  * The drop is an explicit `delete`, not a stored `undefined`: whether a JS
  * `undefined` survives the wasm-bindgen crossing is not a property worth depending
  * on.
  *
- * **A namespace emptied of keys is removed, not stored empty.** That is
- * `removeExtNamespace`'s one correct use: it takes the whole namespace, and there is
- * nothing left in this one to lose. `$ext` goes with it when `editor` was the last
- * namespace, so a document nothing has renamed or hinted carries no editor slot
- * rather than an empty one. A patch dropping keys the namespace does not have writes
- * nothing, so dismissing tips on a document that carries none is not a mutation.
+ * **A namespace emptied of keys is removed, not stored empty**, and `$ext` goes with
+ * it when `editor` was the last namespace — `removeExt` being the one call that drops
+ * the map, where `storeExt({})` records an explicit empty one. So a document nothing
+ * has renamed or hinted carries no editor slot rather than an empty one. A patch
+ * dropping keys the namespace does not have writes nothing, so dismissing tips on a
+ * document that carries none is not a mutation.
  */
 export function patchEditorExt(doc, addr, patch) {
-    // `getExtNamespace` reads just this namespace rather than serializing the whole
-    // card to fish out one `$ext` slot.
-    const current = doc.getExtNamespace(addr, 'editor');
+    const ext = doc.getExt(addr) ?? {};
+    const current = ext.editor;
     const next = { ...(current ?? {}) };
     for (const [key, value] of Object.entries(patch)) {
         if (value === undefined)
@@ -34,7 +32,12 @@ export function patchEditorExt(doc, addr, patch) {
             next[key] = value;
     }
     if (Object.keys(next).length > 0)
-        doc.storeExtNamespace(addr, 'editor', next);
-    else if (current)
-        doc.removeExtNamespace(addr, 'editor');
+        doc.storeExt(addr, { ...ext, editor: next });
+    else if (current) {
+        const { editor: _editor, ...rest } = ext;
+        if (Object.keys(rest).length > 0)
+            doc.storeExt(addr, rest);
+        else
+            doc.removeExt(addr);
+    }
 }

package/dist/visual/index.js

@@ -25,7 +25,6 @@ export { createField } from '../core/codec/index.js';
 // it. The empty body's per-card hook is the `bodyPlaceholder` key inside it.
 export { DEFAULT_VISUAL_STRINGS } from './strings.js';
 // The `$ext.editor` write unit. A consumer seeding editor-side chrome
-// state (a card title, the tips channel) goes through this rather than
-// `storeExtNamespace`, which replaces the namespace and takes the sibling keys with
-// it.
+// state (a card title, the tips channel) goes through this rather than `storeExt`,
+// which replaces the whole map and takes every sibling with it.
 export { patchEditorExt } from './ext.js';

package/dist/visual/links.d.ts

@@ -9,6 +9,10 @@ import type { Command, EditorState } from 'prosemirror-state';
  * A rooted value is left alone, being the spelling that asks for the embedding
  * page, and so is anything already carrying a scheme the link mark renders.
  *
+ * `localhost:5173` names a host too, and `SCHEME` reads its host as the scheme: a
+ * colon followed by a port is a host with a port, so it takes the host prefix rather
+ * than the refusal a scheme nothing renders gets.
+ *
  * `''` for a blank value and for a scheme the mark renders inert, both being nothing
  * to apply: `setLink` declines an empty href, so the refusal lands at the prompt's
  * own exit rather than storing a link that draws as plain text.

package/dist/visual/links.js

@@ -1,4 +1,4 @@
-import { rendersHref } from '../core/codec/index.js';
+import { rendersHref, storableUrl } from '../core/codec/index.js';
 /** A scheme: a letter, then letters, digits, `+`, `-` or `.`, then `:` (RFC 3986). */
 const SCHEME = /^[a-z][a-z0-9+.-]*:/i;
 /** Rooted at the page rather than at a host: an absolute path, a query, a fragment,
@@ -6,6 +6,9 @@ const SCHEME = /^[a-z][a-z0-9+.-]*:/i;
 const ROOTED = /^[/#?]/;
 /** A bare mail address: one `@`, no scheme and no path. */
 const ADDRESS = /^[^\s/@]+@[^\s/@]+$/;
+/** A host carrying a port, which spells a scheme to `SCHEME` and is not one: what
+ *  follows the colon is digits, and no scheme the mark renders takes a port. */
+const HOST_PORT = /^[a-z0-9.-]+:\d+([/?#]|$)/i;
 /**
  * The href a typed value stands for. A value with no scheme names a host, and
  * stored verbatim it is a relative href resolving against whatever page the editor
@@ -16,15 +19,23 @@ const ADDRESS = /^[^\s/@]+@[^\s/@]+$/;
  * A rooted value is left alone, being the spelling that asks for the embedding
  * page, and so is anything already carrying a scheme the link mark renders.
  *
+ * `localhost:5173` names a host too, and `SCHEME` reads its host as the scheme: a
+ * colon followed by a port is a host with a port, so it takes the host prefix rather
+ * than the refusal a scheme nothing renders gets.
+ *
  * `''` for a blank value and for a scheme the mark renders inert, both being nothing
  * to apply: `setLink` declines an empty href, so the refusal lands at the prompt's
  * own exit rather than storing a link that draws as plain text.
  */
 export function normalizeHref(raw) {
-    const value = raw.trim();
-    if (!value || !rendersHref(value))
+    const value = storableUrl(raw.trim());
+    if (!value)
+        return '';
+    if (!rendersHref(value) && !HOST_PORT.test(value))
         return '';
-    if (SCHEME.test(value) || ROOTED.test(value))
+    if (SCHEME.test(value) && rendersHref(value))
+        return value;
+    if (ROOTED.test(value))
         return value;
     return ADDRESS.test(value) ? `mailto:${value}` : `https://${value}`;
 }

package/dist/visual/strings.d.ts

@@ -16,7 +16,7 @@ export interface VisualStrings extends TableChromeStrings, SlashStrings {
     cardTitle: string;
     /** The trailing strip's visible words, which are also every strip's accessible
      * name; the plus rides the wording. One string over
-     * one kind and many: the trigger seeds A card, and which kind is the menu's word
+     * one kind and many: the trigger seeds a card, and which kind is the menu's word
      * to say or the schema's to have already settled. */
     addCard: string;
     arrayAdd: string;
@@ -64,6 +64,9 @@ export interface VisualStrings extends TableChromeStrings, SlashStrings {
     retypeLabel: string;
     retypePlaceholder: string;
     noCardKinds: string;
+    /** The body leaf's accessible name: no label names it, the body being the one
+     *  surface in a card that is paper ({@link Card}). */
+    bodyLabel: string;
     /**
      * The flat built-in invitation: the package's own words, kept to the one thing
      * true of every body so it claims nothing about the card it sits in.
@@ -91,9 +94,9 @@ export interface VisualStrings extends TableChromeStrings, SlashStrings {
  * - **`edit::field_coercion_failed`**: re-words from the app's own control state, the
  *   refused value being in neither document (unchanged on throw) nor schema.
  * - **`parse::yaml_error_with_location`, `invalid_structure`**: does not re-word. No
- *   `path`, and `args` carries the location (`blockIndex`, `line`) and nothing else,
- *   engine prose riding under no key: the parser's own text, its column and its caret
- *   snippet exist only inside `message`.
+ *   `path`; `args` names the block (`blockIndex`) and `location` places the failure in
+ *   the document's own coordinates, engine prose riding under no key: the parser's own
+ *   text, its column and its caret snippet exist only inside `message`.
  * - **`LiveSession.warnings`**: does not re-word. Backend text, an external feed.
  *
  * The last two are the boundary's shape, not a gap in it, so the fallback arm is

package/dist/visual/strings.js

@@ -55,6 +55,7 @@ export const DEFAULT_VISUAL_STRINGS = {
     retypeLabel: 'Change to',
     retypePlaceholder: 'Choose a type…',
     noCardKinds: 'This document declares no card types — delete this card to remove it.',
+    bodyLabel: 'Body',
     bodyGhost: 'Write…',
     bodyPlaceholder: () => undefined
 };

package/dist/visual/structure.d.ts

@@ -1,4 +1,4 @@
-import type { QuillCardSchema, QuillFieldSchema, ResolvedField, Resolved } from '@quillmark/wasm';
+import type { PayloadItem, QuillCardSchema, QuillFieldSchema, ResolvedField, Resolved } from '@quillmark/wasm';
 /** The control a field type maps to (VISUAL_EDITOR §"Structure mirrors the schema"). */
 export type ControlKind = 'prose' | 'text' | 'enum' | 'variant' | 'number' | 'boolean' | 'date' | 'array' | 'object';
 /** One field, projected: its schema, the control it renders as, and its layout hints. */
@@ -233,8 +233,16 @@ export interface PlacedField {
  * Pure, and stays pure: no width, no measurement, nothing to re-derive on resize.
  */
 export declare function placeFields(fields: FieldModel[]): PlacedField[];
+/** A card's field values by key, off its payload items. */
+export declare function fieldValues(items: readonly PayloadItem[]): Record<string, unknown>;
 /** Interpolate a `{field}` card-title template against live field values. */
 export declare function interpolateTitle(template: string, values: Record<string, unknown>): string;
+/** A field value as title text. A parsed field rests as the authored string and a
+ *  committed one as `Content`, whose `text` is the same words; a scalar reads as
+ *  itself and any other container as nothing. */
+export declare function titleText(v: unknown): string;
+/** The field names a `{field}` title reads. */
+export declare function titleFields(template: string | undefined): string[];
 /**
  * Resolve a card instance's header title: the per-instance `$ext.editor.title`
  * override wins; else the schema `ui.title` (literal or `{field}` template

package/dist/visual/structure.js

@@ -268,12 +268,34 @@ export function placeFields(fields) {
     flush();
     return out;
 }
+/** A card's field values by key, off its payload items. */
+export function fieldValues(items) {
+    const values = {};
+    for (const p of items)
+        if (p.type === 'field')
+            values[p.key] = p.value;
+    return values;
+}
 /** Interpolate a `{field}` card-title template against live field values. */
 export function interpolateTitle(template, values) {
-    return template.replace(/\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_m, name) => {
-        const v = values[name];
-        return v == null ? '' : String(v);
-    });
+    return template.replace(/\{([A-Za-z_][A-Za-z0-9_]*)\}/g, (_m, name) => titleText(values[name]));
+}
+/** A field value as title text. A parsed field rests as the authored string and a
+ *  committed one as `Content`, whose `text` is the same words; a scalar reads as
+ *  itself and any other container as nothing. */
+export function titleText(v) {
+    if (v == null)
+        return '';
+    if (typeof v !== 'object')
+        return String(v);
+    const text = v.text;
+    return typeof text === 'string' ? text : '';
+}
+/** The field names a `{field}` title reads. */
+export function titleFields(template) {
+    if (!template)
+        return [];
+    return [...template.matchAll(/\{([A-Za-z_][A-Za-z0-9_]*)\}/g)].map((m) => m[1]);
 }
 /**
  * Resolve a card instance's header title: the per-instance `$ext.editor.title`

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@quillmark/svelte",
-	"version": "0.10.1",
+	"version": "0.11.0",
 	"description": "Editor, live-preview and source surfaces over a Quillmark WASM session.",
 	"repository": {
 		"type": "git",
@@ -66,7 +66,7 @@
 		"check": "svelte-check --tsconfig ./tsconfig.json"
 	},
 	"peerDependencies": {
-		"@quillmark/wasm": ">=0.110.0-0",
+		"@quillmark/wasm": ">=0.113.0-0",
 		"svelte": "^5.0.0"
 	},
 	"dependencies": {