@grida/svg-editor 1.0.0-alpha.16 → 1.0.0-alpha.18

package/dist/{editor-DKQOIKuU.mjs → editor-BkCbYCz2.mjs}

@@ -1,7 +1,8 @@
-import { _ as XLINK_NS, a as paint, b as is_text_input_focused, g as SvgDocument, h as transform, i as TOOL_CURSOR, m as group, n as insertions, p as translate_pipeline, r as DEFAULT_STYLE, s as resize_pipeline, u as rotate_pipeline, v as XMLNS_NS, y as array_shallow_equal } from "./model-L3t9ixT_.mjs";
+import { S as is_text_input_focused, _ as SVG_NS, a as paint, b as XMLNS_NS, g as subtree, h as transform, i as TOOL_CURSOR, m as group, n as insertions, p as translate_pipeline, r as DEFAULT_STYLE, s as resize_pipeline, u as rotate_pipeline, v as SvgDocument, x as array_shallow_equal, y as WELL_KNOWN_NS_PREFIXES } from "./model-DU0GOMwM.mjs";
 import { HistoryImpl } from "@grida/history";
 import { KeyCode, M, chunkKey, eventToChunk, getKeyboardOS, kb, keybindingsToKeyCodes } from "@grida/keybinding";
 import cmath from "@grida/cmath";
+import { encode_attr_value } from "@grida/svg/parser";
 //#region src/commands/registry.ts
 var CommandRegistry = class {
 	constructor() {
@@ -82,6 +83,11 @@ function registerDefaultCommands(reg, editor) {
 		if (editor.state.selection.length === 0) return false;
 		return editor.commands.group();
 	});
+	reg.register("selection.duplicate", () => {
+		if (editor.state.mode !== "select") return false;
+		if (editor.state.selection.length === 0) return false;
+		return editor.commands.duplicate().length > 0;
+	});
 	reg.register("selection.ungroup", () => {
 		if (editor.state.mode !== "select") return false;
 		if (editor.state.selection.length !== 1) return false;
@@ -131,6 +137,31 @@ function registerDefaultCommands(reg, editor) {
 		if (editor.state.mode !== "select") return false;
 		return editor.commands.align(args);
 	});
+	reg.register("clipboard.copy", () => {
+		if (editor.state.mode !== "select") return false;
+		if (editor.state.selection.length === 0) return false;
+		return editor.commands.copy() !== null;
+	});
+	reg.register("clipboard.cut", () => {
+		if (editor.state.mode !== "select") return false;
+		if (editor.state.selection.length === 0) return false;
+		return editor.commands.cut() !== null;
+	});
+	reg.register("clipboard.paste", (args) => {
+		if (editor.state.mode !== "select") return false;
+		const text = args?.text;
+		if (typeof text === "string") return editor.commands.paste(text).length > 0;
+		const provider = editor.providers.clipboard;
+		if (provider) {
+			provider.read().then((text) => {
+				if (text) editor.commands.paste(text);
+			}).catch((err) => {
+				console.warn("[svg-editor] clipboard provider read failed:", err);
+			});
+			return true;
+		}
+		return editor.commands.paste().length > 0;
+	});
 	reg.register("content.enter", () => editor.enter_content_edit());
 	reg.register("hierarchy.enter", () => {
 		if (editor.state.selection.length !== 1) return false;
@@ -356,6 +387,10 @@ const DEFAULT_BINDINGS = [
 		keybinding: kb(KeyCode.KeyG, M.CtrlCmd | M.Shift),
 		command: "selection.ungroup"
 	},
+	{
+		keybinding: kb(KeyCode.KeyD, M.CtrlCmd),
+		command: "selection.duplicate"
+	},
 	{
 		keybinding: kb(KeyCode.KeyA, M.CtrlCmd),
 		command: "selection.all"
@@ -836,6 +871,176 @@ function create_defs(doc) {
 	return { gradients: new GradientsRegistry(doc) };
 }
 //#endregion
+//#region src/core/clipboard.ts
+/**
+* Clipboard payload extraction — selection → standalone SVG document.
+*
+* Implements the copy side of the clipboard FRD
+* ([docs/wg/feat-svg-editor/clipboard.md](../../../../docs/wg/feat-svg-editor/clipboard.md)):
+* the payload is a standalone, namespace-well-formed SVG document — not a
+* private envelope. Assembly is a pure function of (document, selection):
+* no geometry, no environment, no randomness (FRD R6 — the same selection
+* yields the same bytes headless or surface-attached).
+*
+* What the payload carries, and what it deliberately does not
+* (FRD §Extraction — five context kinds):
+*
+*   1. Referenced resources — CARRIED. The outbound `url(#…)` / `href`
+*      closure is walked from the closed carrier list below and emitted
+*      verbatim in one `<defs>` block.
+*   2. Namespace declarations — CARRIED. Prefixes a subtree borrows from
+*      ancestor scope are declared on the payload shell (an undeclared
+*      prefix is a well-formedness error, so this includes the deliberate
+*      well-known-table repair for e.g. `xlink`).
+*   3. Ancestor transforms — NOT carried (verbatim policy).
+*   4. Inherited presentation / cascade — NOT carried (verbatim policy).
+*   5. Viewport — NOT carried (no `viewBox`, no sizing on the shell).
+*
+* This module is the **payload extraction** operation only. The sibling
+* operation the FRD names — in-document subtree CLONE (duplicate /
+* clone-drag), which must NOT carry the closure — lives in `./subtree`.
+* The two share exactly selection normalization (`subtree.normalize_roots`)
+* and verbatim subtree serialization (`doc.serialize_node`).
+*/
+let clipboard;
+(function(_clipboard) {
+	/**
+	* Presentation carriers that may hold `url(#…)` references, read both as
+	* a presentation attribute and as an inline `style=""` declaration.
+	*
+	* CLOSED LIST — extending it is a spec change to the FRD's §Extraction 1
+	* carrier list, not a bug fix. Deliberately NOT walked in v1 (documented
+	* degradations): `<style>` element rules (CSS parsing is the deferred
+	* cascade capability), SMIL timing/value references, `cursor`, SVG 2
+	* text-layout properties.
+	*/
+	const URL_REF_PROPS = [
+		"fill",
+		"stroke",
+		"filter",
+		"clip-path",
+		"mask",
+		"marker-start",
+		"marker-mid",
+		"marker-end",
+		"marker"
+	];
+	/** Set view of {@link URL_REF_PROPS} for membership tests over parsed
+	*  style declarations. */
+	const URL_REF_PROP_SET = new Set(URL_REF_PROPS);
+	/**
+	* Elements whose `href` / `xlink:href` is a same-document resource
+	* reference the closure follows. CLOSED LIST — `<a href>` is navigation,
+	* `<image href>` is content, SMIL `href` is an animation target; none of
+	* them are walked.
+	*/
+	const HREF_TAGS = new Set([
+		"use",
+		"textPath",
+		"mpath",
+		"feImage",
+		"pattern",
+		"linearGradient",
+		"radialGradient",
+		"filter"
+	]);
+	/**
+	* `url(#id)` extractor. Global — a single value can carry several
+	* references (`filter: url(#a) blur(2px) url(#b)` is a legal filter
+	* function list). Same quoting tolerance as the defs registry's
+	* ref-counting pattern.
+	*/
+	const URL_REF_RE = /url\(\s*["']?#([^"')\s]+)["']?\s*\)/g;
+	function extract_payload(doc, selection) {
+		const order = subtree.by_document_order(doc);
+		const roots = subtree.normalize_roots(doc, selection, order);
+		if (roots.length === 0) return null;
+		const closure = collect_reference_closure(doc, roots);
+		const shell_ns = /* @__PURE__ */ new Map();
+		for (const member of [...closure, ...roots].sort(order)) for (const prefix of doc.undeclared_ns_prefixes(member)) {
+			if (shell_ns.has(prefix)) continue;
+			const uri = resolve_prefix(doc, member, prefix);
+			if (uri !== null) shell_ns.set(prefix, uri);
+		}
+		let shell = `<svg xmlns="${SVG_NS}"`;
+		for (const [prefix, uri] of shell_ns) shell += ` xmlns:${prefix}="${encode_attr_value(uri, "\"")}"`;
+		shell += ">";
+		const defs_block = closure.length > 0 ? `<defs>${closure.map((id) => doc.serialize_node(id)).join("")}</defs>` : "";
+		const content = roots.map((id) => doc.serialize_node(id)).join("");
+		return `${shell}${defs_block}${content}</svg>`;
+	}
+	_clipboard.extract_payload = extract_payload;
+	function collect_reference_closure(doc, roots) {
+		const id_map = /* @__PURE__ */ new Map();
+		for (const el of doc.all_elements()) {
+			const id_attr = doc.get_attr(el, "id");
+			if (id_attr !== null && !id_map.has(id_attr)) id_map.set(id_attr, el);
+		}
+		const in_forest = (target) => roots.some((r) => doc.contains(r, target));
+		const collected = /* @__PURE__ */ new Set();
+		const pending = [...roots];
+		while (pending.length > 0) {
+			const subtree = pending.pop();
+			for (const el of elements_of_subtree(doc, subtree)) for (const ref of refs_of(doc, el)) {
+				const target = id_map.get(ref);
+				if (target === void 0) continue;
+				if (in_forest(target)) continue;
+				if (collected.has(target)) continue;
+				collected.add(target);
+				pending.push(target);
+			}
+		}
+		return doc.prune_nested_nodes([...collected]).sort(subtree.by_document_order(doc));
+	}
+	_clipboard.collect_reference_closure = collect_reference_closure;
+	/** Preorder element walk of `root`'s subtree, root included. */
+	function elements_of_subtree(doc, root) {
+		const out = [];
+		const walk = (id) => {
+			if (!doc.is_element(id)) return;
+			out.push(id);
+			for (const c of doc.children_of(id)) walk(c);
+		};
+		walk(root);
+		return out;
+	}
+	/** Same-document reference ids carried by one element, per the closed
+	*  carrier list. */
+	function refs_of(doc, id) {
+		const out = [];
+		for (const prop of URL_REF_PROPS) {
+			const value = doc.get_attr(id, prop);
+			if (!value) continue;
+			for (const m of value.matchAll(URL_REF_RE)) out.push(m[1]);
+		}
+		for (const { property, value } of doc.get_all_styles(id)) {
+			if (!URL_REF_PROP_SET.has(property)) continue;
+			for (const m of value.matchAll(URL_REF_RE)) out.push(m[1]);
+		}
+		if (HREF_TAGS.has(doc.tag_of(id))) {
+			const href = doc.get_attr(id, "href");
+			if (href !== null && href.startsWith("#") && href.length > 1) out.push(href.slice(1));
+		}
+		return out;
+	}
+	/**
+	* Resolve a prefix a member's subtree borrows from ancestor scope:
+	* nearest ancestor `xmlns:<prefix>` declaration wins (correct XML
+	* scoping), falling back to the well-known table — the deliberate
+	* repair that keeps the payload namespace-well-formed even when the
+	* source never declared the prefix (FRD §Extraction 2).
+	*/
+	function resolve_prefix(doc, member, prefix) {
+		let cur = doc.parent_of(member);
+		while (cur !== null) {
+			const uri = doc.get_attr(cur, prefix, XMLNS_NS);
+			if (uri !== null) return uri;
+			cur = doc.parent_of(cur);
+		}
+		return WELL_KNOWN_NS_PREFIXES.get(prefix) ?? null;
+	}
+})(clipboard || (clipboard = {}));
+//#endregion
 //#region src/core/align.ts
 /**
 * Compute per-member translation deltas to align `members` against `target`.
@@ -1051,10 +1256,11 @@ function _create_svg_editor_internal(opts) {
 	let mode = "select";
 	let tool = TOOL_CURSOR;
 	let version = 0;
-	/** Document-edit counter — only bumps on actual mutations, not selection. */
-	let doc_version = 0;
-	/** doc_version at the last load()/serialize(); compared to derive `dirty`. */
-	let baseline_doc_version = 0;
+	/** `doc.revision` at the last load()/reset(); compared to derive `dirty`.
+	*  The doc's own total mutation counter is the single edit-version
+	*  source — `content_version`, `dirty`, and the typed-read memo caches
+	*  all derive from it (no editor-side shadow counter to drift). */
+	let baseline_revision = doc.revision;
 	/**
 	* Bumps once per `editor.load(svg)` call. The constructor's initial parse
 	* does NOT count — it's the "factory" state. Hosts subscribe via
@@ -1067,6 +1273,23 @@ function _create_svg_editor_internal(opts) {
 		...opts.style
 	};
 	const providers = opts.providers ?? {};
+	/**
+	* In-memory clipboard buffer — the transport floor (FRD R1: the buffer
+	* write cannot fail; external channels are best-effort on top). NOT part
+	* of `EditorState` and NOT history-managed: it survives `load()` /
+	* `reset()` / undo, like the OS clipboard it mirrors.
+	*/
+	let clipboard_buffer = null;
+	/**
+	* The last committed duplication — read by the NEXT `duplicate()` to
+	* repeat the user's translate delta (gridaco/grida#825; spec
+	* §Repeating offset). Session state like `clipboard_buffer`: not in
+	* `EditorState`, not history-managed (undo/redo replay never re-arms
+	* it — only a user-initiated ⌘D or cloned-drag commit does). Staleness
+	* is caught at use by `subtree.repeat_delta`; the only eager clears are
+	* `load()` / `reset()`, where every NodeId dies wholesale.
+	*/
+	let active_duplication = null;
 	const listeners = /* @__PURE__ */ new Set();
 	let attached_surface = null;
 	/**
@@ -1082,11 +1305,11 @@ function _create_svg_editor_internal(opts) {
 			scope,
 			mode,
 			tool,
-			dirty: doc_version !== baseline_doc_version,
+			dirty: doc.revision !== baseline_revision,
 			can_undo: history.stack.canUndo,
 			can_redo: history.stack.canRedo,
 			version,
-			content_version: doc_version,
+			content_version: doc.revision,
 			structure_version: doc.structure_version,
 			geometry_version: doc.geometry_version,
 			load_version
@@ -1120,7 +1343,6 @@ function _create_svg_editor_internal(opts) {
 		}
 	}
 	doc.on_change(() => {
-		doc_version++;
 		fire_geometry_listeners_if_advanced();
 	});
 	function subscribe(fn) {
@@ -1245,14 +1467,14 @@ function _create_svg_editor_internal(opts) {
 	function node_property_cached(id, name) {
 		const key = `${id}${name}`;
 		const cached = property_cache.get(key);
-		if (cached && cached.doc_version === doc_version) return cached.value;
+		if (cached && cached.revision === doc.revision) return cached.value;
 		const next = properties.read(doc, id, name);
 		if (cached && properties.value_equals(cached.value, next)) {
-			cached.doc_version = doc_version;
+			cached.revision = doc.revision;
 			return cached.value;
 		}
 		property_cache.set(key, {
-			doc_version,
+			revision: doc.revision,
 			value: next
 		});
 		return next;
@@ -1260,7 +1482,7 @@ function _create_svg_editor_internal(opts) {
 	function node_properties(id, names) {
 		const key = `${id}${names.join("
")}`;
 		const cached = properties_cache.get(key);
-		if (cached && cached.doc_version === doc_version) return cached.value;
+		if (cached && cached.revision === doc.revision) return cached.value;
 		const next = {};
 		let changed = !cached;
 		for (const name of names) {
@@ -1269,12 +1491,12 @@ function _create_svg_editor_internal(opts) {
 			if (cached && cached.value[name] !== v) changed = true;
 		}
 		if (cached && !changed) {
-			cached.doc_version = doc_version;
+			cached.revision = doc.revision;
 			return cached.value;
 		}
 		const frozen = Object.freeze(next);
 		properties_cache.set(key, {
-			doc_version,
+			revision: doc.revision,
 			value: frozen
 		});
 		return frozen;
@@ -1282,7 +1504,7 @@ function _create_svg_editor_internal(opts) {
 	function node_paint(id, channel) {
 		const key = `${id}${channel}`;
 		const cached = paint_cache.get(key);
-		if (cached && cached.doc_version === doc_version) return cached.value;
+		if (cached && cached.revision === doc.revision) return cached.value;
 		const { declared, provenance } = properties.resolve_declared(doc, id, channel);
 		const next = {
 			declared,
@@ -1290,11 +1512,11 @@ function _create_svg_editor_internal(opts) {
 			provenance
 		};
 		if (cached && paint.value_equals(cached.value, next)) {
-			cached.doc_version = doc_version;
+			cached.revision = doc.revision;
 			return cached.value;
 		}
 		paint_cache.set(key, {
-			doc_version,
+			revision: doc.revision,
 			value: next
 		});
 		return next;
@@ -1383,6 +1605,13 @@ function _create_svg_editor_internal(opts) {
 		});
 		return { gradient_id };
 	}
+	/** World→local delta projection shared by every one-shot translate
+	*  writer (translate / nudge via `prepare_rpc`, align). Re-expresses a
+	*  world-space delta in the frame the target's position attributes are
+	*  written in — nested-viewport / transformed-ancestor correctness.
+	*  Identity for flat docs and DOM-less hosts (no provider, or a
+	*  provider without a layout engine). */
+	const project_world_delta = (id, d) => geometry_provider?.world_delta_to_local?.(id, d) ?? d;
 	/** Shared one-shot translate runner. `stages` selects semantics — see
 	*  `core/translate-pipeline/README.md`'s "Stage lists per entry point". */
 	function do_translate_oneshot(delta, stages, label) {
@@ -1402,7 +1631,7 @@ function _create_svg_editor_internal(opts) {
 			},
 			emit,
 			stages,
-			project: (id, d) => geometry_provider?.world_delta_to_local?.(id, d) ?? d
+			project: project_world_delta
 		});
 		apply();
 		history.atomic(label, (tx) => {
@@ -1451,7 +1680,6 @@ function _create_svg_editor_internal(opts) {
 			members.push({
 				id,
 				rz: resize_pipeline.intent.capture_baseline(doc, id, bbox),
-				transform_pre: doc.get_attr(id, "transform"),
 				bbox
 			});
 		}
@@ -1486,10 +1714,7 @@ function _create_svg_editor_internal(opts) {
 			emit();
 		};
 		const revert = () => {
-			for (const { m, origin } of ops) {
-				resize_pipeline.intent.apply(doc, m.id, m.rz, 1, 1, origin);
-				doc.set_attr(m.id, "transform", m.transform_pre);
-			}
+			for (const { m } of ops) resize_pipeline.intent.restore(doc, m.id, m.rz);
 			emit();
 		};
 		apply();
@@ -1766,7 +1991,10 @@ function _create_svg_editor_internal(opts) {
 	* center of a reference rect. Same mechanics as `resize_to`: per-member
 	* translate baselines (so `<g>`, transformed, and natively-attributed
 	* nodes all write the cleanest in-place representation), one atomic
-	* history step.
+	* history step. Deltas are computed in world space and re-expressed in
+	* each member's local frame before writing (`world_delta_to_local`),
+	* so members under scaled/rotated ancestors land exactly and a repeat
+	* invocation is a no-op.
 	*
 	* Reference rect is selection-size dependent:
 	*   - multi-selection: union of member bboxes
@@ -1802,8 +2030,10 @@ function _create_svg_editor_internal(opts) {
 			if (!parent_bbox) return false;
 			target = parent_bbox;
 		} else target = cmath.rect.union(members.map((m) => m.bbox));
-		const deltas = compute_align_deltas(members, target, direction);
-		if (deltas.size === 0) return false;
+		const world_deltas = compute_align_deltas(members, target, direction);
+		if (world_deltas.size === 0) return false;
+		const deltas = /* @__PURE__ */ new Map();
+		for (const [id, d] of world_deltas) deltas.set(id, project_world_delta(id, d));
 		const apply = () => {
 			for (const m of members) {
 				const d = deltas.get(m.id);
@@ -1905,13 +2135,19 @@ function _create_svg_editor_internal(opts) {
 		});
 	}
 	function remove() {
+		remove_selection("remove");
+	}
+	/**
+	* Shared deletion body for `remove` and `cut` — identical
+	* capture/revert semantics, differing only in the history label
+	* (`verb`), so undo attribution names the gesture that caused the
+	* deletion.
+	*/
+	function remove_selection(verb) {
 		if (selection.length === 0) return;
 		const filtered = doc.prune_nested_nodes(selection).filter((id) => doc.parent_of(id) !== null);
 		if (filtered.length === 0) return;
-		const doc_order = doc.all_elements();
-		const index_of = /* @__PURE__ */ new Map();
-		for (let i = 0; i < doc_order.length; i++) index_of.set(doc_order[i], i);
-		const captures = [...filtered].sort((a, b) => (index_of.get(a) ?? 0) - (index_of.get(b) ?? 0)).map((id) => ({
+		const captures = [...filtered].sort(subtree.by_document_order(doc)).map((id) => ({
 			id,
 			parent: doc.parent_of(id),
 			next_sibling: doc.next_element_sibling_of(id)
@@ -1929,7 +2165,7 @@ function _create_svg_editor_internal(opts) {
 			set_selection(old_selection);
 		};
 		apply();
-		history.atomic(captures.length === 1 ? "remove" : `remove ${captures.length}`, (tx) => {
+		history.atomic(captures.length === 1 ? verb : `${verb} ${captures.length}`, (tx) => {
 			tx.push({
 				providerId: PROVIDER_ID,
 				apply,
@@ -2063,12 +2299,20 @@ function _create_svg_editor_internal(opts) {
 	* hoisted declarations + selection in ONE history step.
 	*/
 	function insert_fragment(svg, opts) {
+		return insert_fragment_impl(svg, opts, "insert fragment");
+	}
+	/**
+	* Label-bearing body shared by `insert_fragment` and `paste` — same
+	* atomic insertion, differing only in history attribution (undo for a
+	* paste gesture should read "paste", not "insert fragment").
+	*/
+	function insert_fragment_impl(svg, opts, label) {
 		const parent = opts?.parent ?? doc.root;
 		if (!doc.is_element(parent) || !doc.contains(doc.root, parent)) throw new Error(`insert_fragment: parent ${JSON.stringify(parent)} is not an element in the current document`);
 		const select_after = opts?.select !== false;
 		const { roots, xmlns } = doc.create_fragment(svg);
 		if (roots.length === 0) return [];
-		const known_uri = new Map([["xlink", XLINK_NS]]);
+		const known_uri = new Map(WELL_KNOWN_NS_PREFIXES);
 		for (const d of xmlns) known_uri.set(d.prefix, d.uri);
 		const hoist = [];
 		const considered = /* @__PURE__ */ new Set();
@@ -2096,7 +2340,7 @@ function _create_svg_editor_internal(opts) {
 			if (select_after) set_selection(previous_selection);
 		};
 		apply();
-		history.atomic("insert fragment", (tx) => {
+		history.atomic(label, (tx) => {
 			tx.push({
 				providerId: PROVIDER_ID,
 				apply,
@@ -2105,6 +2349,95 @@ function _create_svg_editor_internal(opts) {
 		});
 		return roots;
 	}
+	function copy_impl(deliver_external) {
+		const payload = clipboard.extract_payload(doc, selection);
+		if (payload === null) return null;
+		clipboard_buffer = payload;
+		if (deliver_external && providers.clipboard) providers.clipboard.write(payload).catch((err) => {
+			console.warn("[svg-editor] clipboard provider write failed:", err);
+		});
+		return payload;
+	}
+	function copy() {
+		return copy_impl(true);
+	}
+	function cut_impl(deliver_external) {
+		const payload = copy_impl(deliver_external);
+		if (payload === null) return null;
+		remove_selection("cut");
+		return payload;
+	}
+	function cut() {
+		return cut_impl(true);
+	}
+	function paste(text) {
+		if (text !== void 0 && typeof text !== "string") throw new TypeError(`paste(text) requires a string when provided, got ${text === null ? "null" : typeof text}`);
+		const source = text ?? clipboard_buffer;
+		if (source === null) return [];
+		try {
+			return insert_fragment_impl(source, void 0, "paste");
+		} catch (err) {
+			if (err instanceof TypeError) throw err;
+			return [];
+		}
+	}
+	/**
+	* Duplicate over `subtree.clone_plan` — see the `Commands` doc. Same
+	* atomic shape as `insert_fragment_impl`: closures own the
+	* insert/remove pair so redo re-inserts the same NodeIds.
+	*
+	* Repeating offset (gridaco/grida#825, spec §Repeating offset): when
+	* the targets are exactly the previous duplication's clones and
+	* geometry witnesses a rigid translate between that record's origins
+	* and clones, the fresh clones land displaced by the same delta. The
+	* offset rides the translate pipeline INSIDE the same atomic step —
+	* one undo removes copy + offset together. Clone baselines are
+	* key-swapped from the origins (a clone is a verbatim copy at rest —
+	* the orchestrator's `enter_clone` trick), so nothing reads the
+	* detached clones. Any failed precondition degrades to plain
+	* duplicate-in-place; never an error.
+	*/
+	function duplicate() {
+		const plan = subtree.clone_plan(doc, selection);
+		if (plan.length === 0) return [];
+		const clones = plan.map((p) => p.clone);
+		const origins = plan.map((p) => p.origin);
+		const previous_selection = selection;
+		const delta = subtree.repeat_delta(active_duplication, origins, (id) => geometry_provider ? geometry_provider.bounds_of(id) : null);
+		let offset_plan = null;
+		if (delta) {
+			const baselines = /* @__PURE__ */ new Map();
+			for (const p of plan) baselines.set(p.clone, translate_pipeline.intent.capture_baseline(doc, p.origin));
+			offset_plan = {
+				ids: clones,
+				baselines,
+				delta
+			};
+		}
+		const apply = () => {
+			subtree.insert_plan(doc, plan);
+			if (offset_plan) translate_pipeline.apply(doc, offset_plan, project_world_delta);
+			set_selection(clones);
+		};
+		const revert = () => {
+			if (offset_plan) translate_pipeline.revert(doc, offset_plan);
+			subtree.remove_plan(doc, plan);
+			set_selection(previous_selection);
+		};
+		apply();
+		history.atomic("duplicate", (tx) => {
+			tx.push({
+				providerId: PROVIDER_ID,
+				apply,
+				revert
+			});
+		});
+		active_duplication = {
+			origins,
+			clones
+		};
+		return clones;
+	}
 	/**
 	* Preview-bracketed insertion. Used by the pointer-driven drag gesture
 	* in the DOM surface. Per-frame attr writes call `update(attrs)`; one
@@ -2292,7 +2625,8 @@ function _create_svg_editor_internal(opts) {
 		mode = "select";
 		tool = TOOL_CURSOR;
 		history.clear();
-		baseline_doc_version = doc_version;
+		active_duplication = null;
+		baseline_revision = doc.revision;
 		load_version++;
 		emit();
 	}
@@ -2331,6 +2665,10 @@ function _create_svg_editor_internal(opts) {
 		align,
 		reorder,
 		remove,
+		copy,
+		cut,
+		paste,
+		duplicate,
 		group: group$1,
 		ungroup,
 		insert,
@@ -2358,7 +2696,8 @@ function _create_svg_editor_internal(opts) {
 		scope = null;
 		mode = "select";
 		tool = TOOL_CURSOR;
-		baseline_doc_version = doc_version;
+		active_duplication = null;
+		baseline_revision = doc.revision;
 		emit();
 	}
 	function attach(surface) {
@@ -2541,7 +2880,14 @@ function _create_svg_editor_internal(opts) {
 		providers,
 		_internal: {
 			doc,
-			history: { preview: (label) => history.preview(label) },
+			history: {
+				preview: (label) => history.preview(label),
+				undo_label: () => history.stack.undoLabel
+			},
+			clipboard: {
+				copy: () => copy_impl(false),
+				cut: () => cut_impl(false)
+			},
 			insert_text_preview,
 			emit,
 			subscribe_translate_commit(cb) {
@@ -2551,6 +2897,9 @@ function _create_svg_editor_internal(opts) {
 				};
 			},
 			notify_translate_commit,
+			seed_duplication(record) {
+				active_duplication = record;
+			},
 			set_content_edit_driver(fn) {
 				content_edit_driver = fn;
 			},