@embedpdf/viewer-chrome 3.0.0-next.14 → 3.0.0-next.16

package/dist/commands-DL1gjZt7.cjs

@@ -0,0 +1,1473 @@
+let _embedpdf_react_runtime = require("@embedpdf/react/runtime");
+let _embedpdf_react_stage = require("@embedpdf/react/stage");
+let _embedpdf_react_page_edit = require("@embedpdf/react/page-edit");
+let _embedpdf_react_outline = require("@embedpdf/react/outline");
+let _embedpdf_react_attachment = require("@embedpdf/react/attachment");
+let _embedpdf_react_interaction = require("@embedpdf/react/interaction");
+let _embedpdf_react_selection = require("@embedpdf/react/selection");
+let _embedpdf_react_annotation = require("@embedpdf/react/annotation");
+let _embedpdf_react_stamp = require("@embedpdf/react/stamp");
+let _embedpdf_react_measurement = require("@embedpdf/react/measurement");
+let _embedpdf_react_redaction = require("@embedpdf/react/redaction");
+let _embedpdf_react_form = require("@embedpdf/react/form");
+let _embedpdf_react_signature = require("@embedpdf/react/signature");
+let _embedpdf_react_link = require("@embedpdf/react/link");
+let _embedpdf_react_i18n = require("@embedpdf/react/i18n");
+let _embedpdf_react_commands = require("@embedpdf/react/commands");
+let _embedpdf_react_history = require("@embedpdf/react/history");
+let _embedpdf_react_shell = require("@embedpdf/react/shell");
+let _embedpdf_core_ui = require("@embedpdf/core-ui");
+let _embedpdf_web = require("@embedpdf/web");
+//#region src/config/attachments.ts
+/**
+* The attachment commands, for the attachments panel (its header, each file's menu) and the
+* strip over a selected file attachment annotation. The panel's commands act on the selected
+* file (`attachment.getSelected()`); the panel selects a file before it opens that file's menu.
+* Adding and deleting need `doc.attachments.modify` (a page's file: the annotation plugin's
+* `canDelete()`) and the `attachments.adding` feature. Saving takes a file out of the document,
+* so it goes with `documents.download` and needs `doc.download`: `readOnly` keeps it.
+*/
+/** The attachments panel's id in the layout. */
+const ATTACHMENTS_PANEL = "attachments";
+/** The menu of a file in the attachments panel: the commands below, for that file. */
+const ATTACHMENT_ITEM_MENU = "attachment-item";
+const attachmentOf = (commandContext) => commandContext.tryGet(_embedpdf_react_attachment.AttachmentToken);
+/** The first selected file. */
+const selectedOf$2 = (commandContext) => attachmentOf(commandContext)?.getSelected()[0] ?? null;
+/** Save a file as the browser saves a download, under its cleaned name. */
+async function saveAttachedFile(attachment, file) {
+	const { bytes, name, mimeType } = await attachment.download(file);
+	(0, _embedpdf_web.saveFile)(bytes, name, mimeType ?? void 0);
+}
+/** The one file attachment annotation selected on the pages, or null. */
+const selectedAnnotationFile = (commandContext) => {
+	const selection = commandContext.tryGet(_embedpdf_react_annotation.AnnotationToken)?.selection.list() ?? [];
+	const [only] = selection;
+	if (selection.length !== 1 || only?.subtype !== "file-attachment") return null;
+	const key = (0, _embedpdf_react_annotation.annotationKey)(only.ref);
+	return (attachmentOf(commandContext)?.list() ?? []).find((file) => file.home.kind === "page" && (0, _embedpdf_react_annotation.annotationKey)(file.home.ref) === key) ?? null;
+};
+/** Saving: the right to take files out, and the feature on. */
+const SAVES = {
+	categories: ["documents.download"],
+	allowed: (commandContext) => attachmentOf(commandContext)?.canDownload() ?? true,
+	notAllowedKey: "commands.notAllowed.doc-download"
+};
+/** Adding and deleting: the right to, and the feature on. */
+const EDITS$1 = {
+	categories: ["attachments.adding"],
+	allowed: (commandContext) => attachmentOf(commandContext)?.canAdd() ?? true,
+	notAllowedKey: "commands.notAllowed.doc-attachments-modify"
+};
+const attachmentCommands = [
+	{
+		id: "attachment:add",
+		labelKey: "commands.attachment.add",
+		icon: "plus",
+		...EDITS$1,
+		run: async (commandContext) => {
+			const attachment = attachmentOf(commandContext);
+			if (!attachment) return;
+			const files = commandContext.args?.files ?? [await (0, _embedpdf_web.pickFile)()].filter((file) => file !== null);
+			if (files.length === 0) return;
+			commandContext.tryGet(_embedpdf_react_shell.ShellToken)?.open(ATTACHMENTS_PANEL);
+			await attachment.add(files.map((data) => ({ data })));
+		}
+	},
+	{
+		id: "attachment:save",
+		labelKey: "commands.attachment.save",
+		icon: "download",
+		...SAVES,
+		enabled: (commandContext) => selectedOf$2(commandContext) !== null,
+		run: async (commandContext) => {
+			const attachment = attachmentOf(commandContext);
+			const file = selectedOf$2(commandContext);
+			if (attachment && file) await saveAttachedFile(attachment, file);
+		}
+	},
+	{
+		id: "attachment:go-to",
+		labelKey: "commands.attachment.goTo",
+		visible: (commandContext) => selectedOf$2(commandContext)?.home.kind === "page",
+		run: (commandContext) => {
+			const file = selectedOf$2(commandContext);
+			if (file) attachmentOf(commandContext)?.reveal(file);
+		}
+	},
+	{
+		id: "attachment:delete",
+		labelKey: "commands.attachment.delete",
+		icon: "trash",
+		...EDITS$1,
+		allowed: (commandContext) => {
+			const attachment = attachmentOf(commandContext);
+			const file = selectedOf$2(commandContext);
+			if (!attachment) return true;
+			return file ? attachment.canRemove(file) : attachment.canAdd();
+		},
+		enabled: (commandContext) => selectedOf$2(commandContext) !== null,
+		run: async (commandContext) => {
+			const attachment = attachmentOf(commandContext);
+			const file = selectedOf$2(commandContext);
+			if (attachment && file) await attachment.remove(file);
+		}
+	},
+	{
+		id: "menu:attachment-item",
+		labelKey: "commands.attachment.more",
+		icon: "dots",
+		menu: ATTACHMENT_ITEM_MENU,
+		categories: ["attachments"]
+	},
+	{
+		id: "annotation:save-file",
+		labelKey: "commands.annotate.saveFile",
+		icon: "download",
+		...SAVES,
+		visible: (commandContext) => selectedAnnotationFile(commandContext) !== null,
+		run: async (commandContext) => {
+			const attachment = attachmentOf(commandContext);
+			const file = selectedAnnotationFile(commandContext);
+			if (attachment && file) await saveAttachedFile(attachment, file);
+		}
+	}
+];
+//#endregion
+//#region src/config/modes.ts
+/** The exclusivity tag every mode surface opens with. */
+const MODE_TAG = "mode";
+/** The open mode's surface (`mode:<mode>`), or `null` while viewing. */
+function openModeSurfaceOf(shell) {
+	return shell.listOpenSurfaces().find((surface) => surface.exclusive === "mode")?.id ?? null;
+}
+/** The layout's modes, in bar order, each titled by its first bar with a title. */
+function modeSpecsOf(data) {
+	return (0, _embedpdf_core_ui.modesOf)(data).map((mode) => {
+		const titled = (0, _embedpdf_core_ui.barsInMode)(data, mode).map((barId) => data.bars[barId]).find((bar) => bar.title !== void 0 || bar.titleKey !== void 0);
+		return {
+			mode,
+			title: titled?.title,
+			titleKey: titled?.titleKey
+		};
+	});
+}
+/** Whether two lists of modes are the same, title for title. */
+const sameModeSpecs = (left, right) => left.length === right.length && left.every((spec, i) => spec.mode === right[i].mode && spec.title === right[i].title && spec.titleKey === right[i].titleKey);
+/**
+* A command for each mode that has none yet (`isTaken` says which ids do): it opens the mode,
+* or closes it when it is open, and shows the default pointer. Without a title, its tab reads
+* the mode's own name.
+*/
+function modeCommandsFor(specs, isTaken) {
+	return specs.filter((spec) => !isTaken((0, _embedpdf_core_ui.modeCommandOf)(spec.mode))).map((spec) => {
+		const id = (0, _embedpdf_core_ui.modeCommandOf)(spec.mode);
+		return {
+			id,
+			label: spec.title ?? (spec.titleKey === void 0 ? spec.mode : void 0),
+			labelKey: spec.titleKey,
+			run: (commandContext) => {
+				commandContext.tryGet(_embedpdf_react_shell.ShellToken)?.toggle(id, { exclusive: MODE_TAG });
+				commandContext.tryGet(_embedpdf_react_interaction.InteractionToken)?.activateTool("pointer");
+			},
+			active: (commandContext) => commandContext.tryGet(_embedpdf_react_shell.ShellToken)?.isOpen(id) ?? false
+		};
+	});
+}
+//#endregion
+//#region src/config/open-files.ts
+const OPEN_COMMAND_ID = "document:open";
+const PDF_TYPE$1 = "application/pdf";
+/** Whether a file is a PDF, by its type or, where the system gives it none, its name. */
+const isPdfFile = (file) => file.type === PDF_TYPE$1 || /\.pdf$/i.test(file.name);
+/**
+* Whether a drag may bring a PDF: it carries files, and one of them is a PDF or of a type the
+* browser doesn't know. Text, links and anything dragged inside the page carry no files; where
+* the browser doesn't list the files while dragging, they may be PDFs.
+*/
+function mayCarryPdf(transfer) {
+	if (!transfer || !Array.from(transfer.types).includes("Files")) return false;
+	const files = Array.from(transfer.items ?? []).filter((item) => item.kind === "file");
+	return files.length === 0 || files.some((item) => item.type === PDF_TYPE$1 || item.type === "");
+}
+const givenFilesOf = (args) => {
+	const files = args?.files;
+	return Array.isArray(files) ? files : null;
+};
+/** The file the user picks in the file dialog, as a list: empty when they close it. */
+const pickedFiles = () => (0, _embedpdf_web.pickFile)({ accept: `.pdf,${PDF_TYPE$1}` }).then((file) => file ? [file] : []);
+/**
+* Open each file as a new tab, the first one shown. Its tab is there at once, named like a `src`
+* file's (its name without `.pdf`), while the file is read; one that can't be opened says why
+* in its tab.
+*/
+function openFiles(documents, files) {
+	documents.openAll(files.map((file) => ({
+		name: file.name.replace(/\.pdf$/i, "") || file.name,
+		source: async () => ({
+			kind: "bytes",
+			bytes: new Uint8Array(await file.arrayBuffer())
+		})
+	})));
+}
+const openFileCommand = {
+	id: OPEN_COMMAND_ID,
+	labelKey: "commands.open",
+	icon: "fileImport",
+	shortcut: "Mod+O",
+	categories: ["documents.open"],
+	visible: (commandContext) => commandContext.tryGet(_embedpdf_react_runtime.DocumentsToken)?.canOpenFiles() ?? false,
+	run: async (commandContext) => {
+		const documents = commandContext.tryGet(_embedpdf_react_runtime.DocumentsToken);
+		if (!documents) return;
+		openFiles(documents, givenFilesOf(commandContext.args) ?? await pickedFiles());
+	}
+};
+//#endregion
+//#region src/config/outline.ts
+/** The outline panel's id in the layout. */
+const OUTLINE_PANEL = "outline";
+/**
+* A request to rename an item in its row: the selected one, once it isn't the item `after`
+* names (an add selects the item it makes). The panel takes the request and closes it.
+*/
+const OUTLINE_RENAME = "outline-rename";
+/** The dialog that edits one item's title, look, target and open state (`props.item`). */
+const OUTLINE_PROPERTIES_DIALOG = "outline-properties";
+/** The menu of a row of the outline: the commands below, for that row. */
+const OUTLINE_ITEM_MENU = "outline-item";
+const outlineOf = (commandContext) => commandContext.tryGet(_embedpdf_react_outline.OutlineToken);
+/** The first selected item, as the outline holds it. */
+const selectedOf$1 = (commandContext) => {
+	const outline = outlineOf(commandContext);
+	const [ref] = outline?.getSelected() ?? [];
+	return ref ? outline?.get(ref) ?? null : null;
+};
+const hasSelection$1 = (commandContext) => selectedOf$1(commandContext) !== null;
+/** What a command that changes the outline needs: the right to, and the feature on. */
+const EDITS = {
+	categories: ["outline.editing"],
+	allowed: (commandContext) => outlineOf(commandContext)?.canEdit() ?? true,
+	notAllowedKey: "commands.notAllowed.doc-outline-modify"
+};
+/**
+* Add an item and rename it in its row, as Acrobat's New Bookmark does: it goes to where the
+* view is, after the selected item, or at the end of the outline when none is selected.
+*/
+async function addItem(commandContext, input) {
+	const outline = outlineOf(commandContext);
+	if (!outline) return;
+	const shell = commandContext.tryGet(_embedpdf_react_shell.ShellToken);
+	const selected = selectedOf$1(commandContext);
+	shell?.open(OUTLINE_PANEL);
+	shell?.open(OUTLINE_RENAME, { props: { after: selected?.ref.objectNumber ?? null } });
+	try {
+		await outline.create(input(selected), { select: true });
+	} catch (error) {
+		shell?.close(OUTLINE_RENAME);
+		throw error;
+	}
+}
+const outlineCommands = [
+	{
+		id: "outline:add",
+		labelKey: "commands.outline.add",
+		icon: "plus",
+		shortcut: "Mod+B",
+		...EDITS,
+		run: (commandContext) => addItem(commandContext, (selected) => selected ? {
+			parent: selected.parent,
+			position: { after: selected.ref }
+		} : {})
+	},
+	{
+		id: "outline:add-child",
+		labelKey: "commands.outline.addChild",
+		...EDITS,
+		enabled: hasSelection$1,
+		run: (commandContext) => addItem(commandContext, (selected) => selected ? { parent: selected.ref } : {})
+	},
+	{
+		id: "outline:rename",
+		labelKey: "commands.outline.rename",
+		...EDITS,
+		enabled: hasSelection$1,
+		run: (commandContext) => {
+			const selected = selectedOf$1(commandContext);
+			if (!selected) return;
+			commandContext.tryGet(_embedpdf_react_shell.ShellToken)?.open(OUTLINE_RENAME, { props: { item: selected.ref.objectNumber } });
+		}
+	},
+	{
+		id: "outline:set-destination",
+		labelKey: "commands.outline.setDestination",
+		...EDITS,
+		enabled: (commandContext) => hasSelection$1(commandContext) && outlineOf(commandContext)?.getCurrentViewTarget() != null,
+		run: async (commandContext) => {
+			const outline = outlineOf(commandContext);
+			const selected = selectedOf$1(commandContext);
+			const target = outline?.getCurrentViewTarget() ?? null;
+			if (outline && selected && target) await outline.update(selected.ref, { target });
+		}
+	},
+	{
+		id: "outline:properties",
+		labelKey: "commands.outline.properties",
+		...EDITS,
+		enabled: hasSelection$1,
+		run: (commandContext) => {
+			const selected = selectedOf$1(commandContext);
+			if (!selected) return;
+			commandContext.tryGet(_embedpdf_react_shell.ShellToken)?.open(OUTLINE_PROPERTIES_DIALOG, {
+				exclusive: "modal",
+				props: { item: selected.ref.objectNumber }
+			});
+		}
+	},
+	{
+		id: "outline:delete",
+		labelKey: "commands.outline.delete",
+		icon: "trash",
+		...EDITS,
+		enabled: hasSelection$1,
+		run: async (commandContext) => {
+			const outline = outlineOf(commandContext);
+			const selected = outline?.getSelected() ?? [];
+			if (outline && selected.length > 0) await outline.delete(selected);
+		}
+	},
+	{
+		id: "menu:outline-item",
+		labelKey: "commands.outline.more",
+		icon: "dots",
+		menu: OUTLINE_ITEM_MENU,
+		...EDITS
+	},
+	{
+		id: "outline:expand-all",
+		labelKey: "commands.outline.expandAll",
+		icon: "chevronsDown",
+		categories: ["outline"],
+		run: (commandContext) => outlineOf(commandContext)?.expandAll()
+	},
+	{
+		id: "outline:collapse-all",
+		labelKey: "commands.outline.collapseAll",
+		icon: "chevronsUp",
+		categories: ["outline"],
+		run: (commandContext) => outlineOf(commandContext)?.collapseAll()
+	}
+];
+//#endregion
+//#region src/config/page-commands.ts
+/** The menu of a page: the commands below, for that page and the others selected with it. */
+const PAGE_MENU = "page";
+const PDF_TYPE = "application/pdf";
+const pageEditOf = (commandContext) => commandContext.tryGet(_embedpdf_react_page_edit.PageEditToken);
+const selectedOf = (commandContext) => pageEditOf(commandContext)?.getSelected() ?? [];
+const hasSelection = (commandContext) => selectedOf(commandContext).length > 0;
+/** The document's pages, in display order. */
+const pagesOf = (commandContext) => commandContext.tryGet(_embedpdf_react_runtime.DocumentsToken)?.listPages(commandContext.documentId ?? void 0) ?? [];
+const argsOf = (commandContext) => commandContext.args ?? {};
+/** What a command that changes the pages needs: the right to, and the feature on. */
+const PAGE_EDITS = {
+	categories: ["pages"],
+	allowed: (commandContext) => pageEditOf(commandContext)?.canEdit() ?? true,
+	notAllowedKey: "commands.notAllowed.doc-pages-assemble"
+};
+/**
+* Where new pages go: where the caller says, else after the selected page that comes last, else
+* at the end.
+*/
+function insertPositionOf(commandContext) {
+	const given = argsOf(commandContext).position;
+	if (given) return given;
+	const selected = new Set(selectedOf(commandContext).map((ref) => ref.objectNumber));
+	const last = pagesOf(commandContext).filter((page) => selected.has(page.ref.objectNumber)).pop();
+	return last ? { after: last.ref } : "end";
+}
+/** The PDFs the caller passed, else the one the user picks: empty when they close the dialog. */
+async function filesToInsert(commandContext) {
+	const given = argsOf(commandContext).files;
+	if (given) return given.filter(isPdfFile);
+	const picked = await (0, _embedpdf_web.pickFile)({ accept: `.pdf,${PDF_TYPE}` });
+	return picked ? [picked] : [];
+}
+/** The name of a copy of some of the document's pages: the document's own name, then `-pages`. */
+function extractNameOf(commandContext) {
+	const id = commandContext.documentId ?? void 0;
+	return `${commandContext.tryGet(_embedpdf_react_runtime.DocumentsToken)?.get(id)?.name?.replace(/\.pdf$/i, "") || "document"}-pages.pdf`;
+}
+const rotate = (id, labelKey, icon, delta) => ({
+	id,
+	labelKey,
+	icon,
+	...PAGE_EDITS,
+	enabled: hasSelection,
+	run: async (commandContext) => {
+		const selected = selectedOf(commandContext);
+		if (selected.length > 0) await pageEditOf(commandContext)?.rotateBy(selected, delta);
+	}
+});
+const pageCommands = [
+	rotate("page:rotate-clockwise", "commands.pages.rotateClockwise", "pageRotateClockwise", 90),
+	rotate("page:rotate-counterclockwise", "commands.pages.rotateCounterclockwise", "pageRotateCounterClockwise", -90),
+	{
+		id: "page:delete",
+		labelKey: "commands.pages.delete",
+		icon: "trash",
+		...PAGE_EDITS,
+		enabled: (commandContext) => {
+			const count = selectedOf(commandContext).length;
+			return count > 0 && count < pagesOf(commandContext).length;
+		},
+		run: async (commandContext) => {
+			const selected = selectedOf(commandContext);
+			if (selected.length > 0) await pageEditOf(commandContext)?.delete(selected);
+		}
+	},
+	{
+		id: "page:duplicate",
+		labelKey: "commands.pages.duplicate",
+		icon: "copy",
+		categories: PAGE_EDITS.categories,
+		allowed: (commandContext) => {
+			const pageEdit = pageEditOf(commandContext);
+			return pageEdit ? pageEdit.canEdit() && pageEdit.canExtract() : true;
+		},
+		enabled: hasSelection,
+		run: async (commandContext) => {
+			const pageEdit = pageEditOf(commandContext);
+			const selected = selectedOf(commandContext);
+			if (!pageEdit || selected.length === 0) return;
+			const { pages } = await pageEdit.duplicate(selected);
+			pageEdit.select(pages);
+		}
+	},
+	{
+		id: "page:insert-blank",
+		labelKey: "commands.pages.insertBlank",
+		icon: "filePlus",
+		...PAGE_EDITS,
+		run: async (commandContext) => {
+			const pageEdit = pageEditOf(commandContext);
+			if (!pageEdit) return;
+			const { pages } = await pageEdit.insertBlank({ position: insertPositionOf(commandContext) });
+			pageEdit.select(pages);
+		}
+	},
+	{
+		id: "page:insert-file",
+		labelKey: "commands.pages.insertFile",
+		icon: "fileImport",
+		...PAGE_EDITS,
+		run: async (commandContext) => {
+			const pageEdit = pageEditOf(commandContext);
+			if (!pageEdit) return;
+			let position = insertPositionOf(commandContext);
+			const files = await filesToInsert(commandContext);
+			const inserted = [];
+			for (const file of files) {
+				const { pages } = await pageEdit.insertFromBytes(new Uint8Array(await file.arrayBuffer()), { position });
+				inserted.push(...pages);
+				const last = pages[pages.length - 1];
+				if (last) position = { after: last };
+			}
+			if (inserted.length > 0) pageEdit.select(inserted);
+		}
+	},
+	{
+		id: "page:extract",
+		labelKey: "commands.pages.extract",
+		icon: "fileExport",
+		categories: ["documents.download"],
+		allowed: (commandContext) => pageEditOf(commandContext)?.canExtract() ?? true,
+		notAllowedKey: "commands.notAllowed.doc-download",
+		enabled: hasSelection,
+		run: async (commandContext) => {
+			const selected = selectedOf(commandContext);
+			const pageEdit = pageEditOf(commandContext);
+			if (!pageEdit || selected.length === 0) return;
+			(0, _embedpdf_web.saveFile)(await pageEdit.extract(selected), extractNameOf(commandContext), PDF_TYPE);
+		}
+	},
+	{
+		id: "page:select-all",
+		labelKey: "commands.pages.selectAll",
+		categories: PAGE_EDITS.categories,
+		enabled: (commandContext) => selectedOf(commandContext).length < pagesOf(commandContext).length,
+		run: (commandContext) => pageEditOf(commandContext)?.select(pagesOf(commandContext).map((page) => page.ref))
+	},
+	{
+		id: "menu:page",
+		labelKey: "commands.pages.more",
+		icon: "dots",
+		menu: PAGE_MENU,
+		...PAGE_EDITS
+	}
+];
+//#endregion
+//#region src/config/commands.ts
+/**
+* The command vocabulary — the semantic layer. Every command is a pure value:
+* label key, icon, shortcut, derivations, and a `run` (or a declarative
+* surface target). Commands reach plugins through a typed
+* `commandContext.tryGet(Token)`, never by string id and cast.
+*
+* Each command names its most specific feature in `categories` (the tree in
+* `../features.ts`), so `disable` and `readOnly` turn it off, and whether the
+* session may run it in `allowed`, from the owning plugin's `can*` check
+* (docs/conventions/permissions.md), so a user who may not doesn't see it.
+* `enabled` is only for what can't run right now.
+*
+* Wiring:
+*   zoom/pan/pointer/spread/scroll/rotate  → real Stage / Interaction / PageEdit
+*   modes                                  → shell exclusive surfaces ('mode')
+*   panels                                 → the layout's `panel:<id>` (panels.ts)
+*   menus / modals                         → declarative shell targets
+*   annotate + shape tools                 → real interaction tools
+*   form tools                             → real form plugin palette (draw-to-place)
+*   insert tools                           → real stamp and signature panels +
+*                                            image/attachment click-then-pick
+*   history undo/redo                      → real History
+*/
+/** The dialog the Go to Page command opens without a page to go to (ui/go-to-page.tsx). */
+const GO_TO_PAGE_DIALOG = "go-to-page";
+/** The keyboard shortcuts sheet, which `?` opens (ui/shortcuts-sheet.tsx). */
+const SHORTCUTS_DIALOG = "shortcuts";
+/** The confirmation before marked areas are removed for good (ui/redact-confirm.tsx). */
+const REDACT_CONFIRM_DIALOG = "redact-confirm";
+/** The Print dialog: which pages, and whether annotations print (ui/print-dialog.tsx). */
+const PRINT_DIALOG = "print";
+/** The form designer's sidebar (ui/form-design-panel.tsx), which `form:design` opens. */
+const FORM_DESIGN_PANEL = "form-design";
+/** Form design's resting tool, the form plugin's: widgets select, move and resize there. */
+const FORM_DESIGN_TOOL = "form-edit";
+/** The form plugin's field tools, each placing a field (the Form bar's `tool:*` buttons). */
+const FORM_FIELD_TOOLS = [
+	"form-text",
+	"form-checkbox",
+	"form-radio",
+	"form-combobox",
+	"form-listbox",
+	"form-button",
+	"form-signature"
+];
+/**
+* Whether a tool designs a form: design's resting tool, or a field tool. Neither fills, so the
+* form lends its widgets to be selected, moved and resized.
+*/
+const isFormDesignTool = (tool) => tool === "form-edit" || tool != null && FORM_FIELD_TOOLS.includes(tool);
+/** Whether a form is being designed: the active tool designs it. */
+const isDesigningForm = (commandContext) => isFormDesignTool(commandContext.tryGet(_embedpdf_react_interaction.InteractionToken)?.getActiveToolId());
+/** Where selection-made stamps go: the user's own library, persisted. */
+const CUSTOM_LIBRARY_ID = "embedpdf-custom";
+const stage = (commandContext) => commandContext.tryGet(_embedpdf_react_stage.StageToken);
+const interaction = (commandContext) => commandContext.tryGet(_embedpdf_react_interaction.InteractionToken);
+const anno = (commandContext) => commandContext.tryGet(_embedpdf_react_annotation.AnnotationToken);
+const textSelection = (commandContext) => commandContext.tryGet(_embedpdf_react_selection.SelectionToken);
+/** Drawing an annotation of any kind: `annotation.canCreate()`. */
+const CREATES_ANNOTATIONS = {
+	allowed: (commandContext) => anno(commandContext)?.canCreate() ?? true,
+	notAllowedKey: "commands.notAllowed.annotations-create"
+};
+/** Placing and changing form fields: `form.canDesign()`. */
+const DESIGNS_FORMS = {
+	allowed: (commandContext) => commandContext.tryGet(_embedpdf_react_form.FormToken)?.canDesign() ?? true,
+	notAllowedKey: "commands.notAllowed.doc-forms-modify"
+};
+/** Placing a stamp or a signature mark: `stamp.canPlace()`. */
+const PLACES_STAMPS = {
+	allowed: (commandContext) => commandContext.tryGet(_embedpdf_react_stamp.StampToken)?.canPlace(commandContext.documentId ?? void 0) ?? true,
+	notAllowedKey: "commands.notAllowed.annotations-create"
+};
+const sameTextRange = (left, right) => left === right || !!left && !!right && left.start.page.objectNumber === right.start.page.objectNumber && left.start.index === right.start.index && left.end.page.objectNumber === right.end.page.objectNumber && left.end.index === right.end.index;
+/**
+* What a command needs to open and close the layout's panel `id`: it runs the panel's own
+* `panel:<id>` command (config/panels.ts), so it opens only what that one may, shows only while
+* the layout has the panel and `visible` says so, and is active while the panel is open.
+*/
+const togglesPanel = (id, visible) => ({
+	run: (commandContext) => commandContext.tryGet(_embedpdf_react_commands.CommandsToken)?.execute((0, _embedpdf_core_ui.panelCommandOf)(id), { documentId: commandContext.documentId ?? void 0 }),
+	active: (commandContext) => commandContext.tryGet(_embedpdf_react_shell.ShellToken)?.isOpen(id) ?? false,
+	visible: (commandContext) => (commandContext.tryGet(_embedpdf_react_commands.CommandsToken)?.hasCommand((0, _embedpdf_core_ui.panelCommandOf)(id)) ?? false) && (visible?.(commandContext) ?? true)
+});
+/** A measuring tool can run on the current page: it has a scale (`measurement.canMeasure`). */
+const canMeasureNow = (commandContext) => {
+	const page = stage(commandContext)?.getCurrentPage();
+	return page != null && (commandContext.tryGet(_embedpdf_react_measurement.MeasurementToken)?.canMeasure(page) ?? false);
+};
+const hasAnnotationSelection = (commandContext) => (anno(commandContext)?.selection.list().length ?? 0) > 0;
+/** Whether people may change every selected annotation by hand (no turned-off feature froze it). */
+const selectionEditable = (commandContext) => {
+	const annotation = anno(commandContext);
+	return (annotation?.selection.list() ?? []).every(({ ref }) => annotation.isEditable(ref));
+};
+/** Strip items gate per subtype (comment hidden on links/widgets) through
+*  one derivation over the selected DTOs, not per-command lookups. */
+const selectionSubtypes = (commandContext) => new Set((anno(commandContext)?.selection.list() ?? []).map((annotation) => annotation.subtype));
+/**
+* The selection's `link` value: a target, `null` (linkable but none set), or
+* `undefined` when the selection cannot carry a link at all (widgets, mixed
+* link states) — the schema decides, never a subtype blocklist.
+*/
+/** The selection's link target, as the annotation holds it (destinations in the file's coordinates). */
+const selectionLink = (commandContext) => {
+	const props = anno(commandContext)?.selection.getProperties();
+	if (!props || !props.properties.some((property) => property.key === "link") || props.mixed.includes("link")) return void 0;
+	return props.values.link ?? null;
+};
+/**
+* toolId → the same icon + accent definition its toolbar button uses, recorded
+* as a side effect of the `tool()` command definitions below — one source of
+* truth, so the tool cursor (ui/tool-cursor.tsx) and the button can never
+* drift apart.
+*/
+const TOOL_ICONS = {};
+TOOL_ICONS["stamp"] = { icon: "rubberStamp" };
+const toolAccent = (commandContext, toolId, accent) => {
+	if (!accent) return null;
+	const anno = commandContext.tryGet(_embedpdf_react_annotation.AnnotationToken);
+	if (!anno) return null;
+	const defaults = anno.tools.getDefaults(toolId);
+	const colorOf = (key) => defaults[key] ?? void 0;
+	return {
+		primary: colorOf(accent.primary),
+		secondary: accent.secondary ? colorOf(accent.secondary) : void 0
+	};
+};
+/** toolId → the feature its command belongs to, for the tools of yours that extend it. */
+const TOOL_FEATURES = {};
+/** A tool command without its label: activates a real interaction tool; active = it's the tool.
+*  The icon previews the tool's current defaults — keyed by the same toolId
+*  as run/active, so the accent can't drift to another tool's colors. */
+const toolCommand = (id, toolId, icon, { feature, check, accent }) => {
+	if (icon) TOOL_ICONS[toolId] = {
+		icon,
+		...accent ? { accent } : {}
+	};
+	TOOL_FEATURES[toolId] = feature;
+	return {
+		id,
+		...icon ? { icon } : {},
+		categories: [feature],
+		...check,
+		run: (commandContext) => interaction(commandContext)?.activateTool(toolId),
+		active: (commandContext) => interaction(commandContext)?.getActiveToolId() === toolId,
+		enabled: (commandContext) => interaction(commandContext) != null,
+		iconAccent: (commandContext) => toolAccent(commandContext, toolId, accent)
+	};
+};
+const tool = (id, toolId, labelKey, icon, options) => ({
+	...toolCommand(id, toolId, icon, options),
+	labelKey
+});
+/**
+* Selected text made into a highlight, an underline or a strikeout, with the colors of the
+* tool that makes the same: shown only while there's a selection.
+*/
+const markupSelection = (id, toolId, labelKey, icon, feature) => ({
+	id,
+	labelKey,
+	icon,
+	categories: [feature],
+	...CREATES_ANNOTATIONS,
+	visible: (commandContext) => textSelection(commandContext)?.hasSelection() ?? false,
+	run: (commandContext) => anno(commandContext)?.createFromSelection(toolId),
+	iconAccent: (commandContext) => toolAccent(commandContext, toolId, { primary: "color" })
+});
+/** The page number `page:go-to` was given (`args: { page }`, counted from 1), or `null`. */
+const pageArgOf = (args) => {
+	const page = args?.page;
+	return typeof page === "number" && Number.isFinite(page) ? Math.round(page) : null;
+};
+/** A fixed zoom level (fraction), e.g. 1 = 100%. */
+const zoomLevel = (id, level, label) => ({
+	id,
+	labelKey: label,
+	run: (commandContext) => stage(commandContext)?.zoomTo({ level }),
+	enabled: (commandContext) => stage(commandContext) != null
+});
+const spread = (id, mode, labelKey, icon) => ({
+	id,
+	labelKey,
+	icon,
+	run: (commandContext) => stage(commandContext)?.updateSettings({ spread: mode }),
+	active: (commandContext) => stage(commandContext)?.getSettings().spread === mode,
+	enabled: (commandContext) => stage(commandContext) != null
+});
+const defaultCommands = [
+	{
+		id: "zoom:in",
+		labelKey: "commands.zoom.in",
+		icon: "zoomIn",
+		shortcut: ["Mod+=", "Mod+NumpadAdd"],
+		run: (commandContext) => stage(commandContext)?.zoomIn(),
+		enabled: (commandContext) => stage(commandContext) != null
+	},
+	{
+		id: "zoom:out",
+		labelKey: "commands.zoom.out",
+		icon: "zoomOut",
+		shortcut: ["Mod+-", "Mod+NumpadSubtract"],
+		run: (commandContext) => stage(commandContext)?.zoomOut(),
+		enabled: (commandContext) => stage(commandContext) != null
+	},
+	{
+		id: "zoom:fit-page",
+		labelKey: "commands.zoom.fitPage",
+		icon: "fitToPage",
+		shortcut: "Mod+0",
+		run: (commandContext) => stage(commandContext)?.fitPage(),
+		active: (commandContext) => stage(commandContext)?.getZoomMode() === _embedpdf_react_stage.ZoomMode.FitPage,
+		enabled: (commandContext) => stage(commandContext) != null
+	},
+	{
+		id: "zoom:fit-width",
+		labelKey: "commands.zoom.fitWidth",
+		icon: "fitToWidth",
+		shortcut: "Mod+1",
+		run: (commandContext) => stage(commandContext)?.fitWidth(),
+		active: (commandContext) => stage(commandContext)?.getZoomMode() === _embedpdf_react_stage.ZoomMode.FitWidth,
+		enabled: (commandContext) => stage(commandContext) != null
+	},
+	{
+		id: "zoom:automatic",
+		labelKey: "commands.zoom.automatic",
+		run: (commandContext) => stage(commandContext)?.fitAutomatic(),
+		active: (commandContext) => stage(commandContext)?.getZoomMode() === _embedpdf_react_stage.ZoomMode.Automatic,
+		enabled: (commandContext) => stage(commandContext) != null
+	},
+	zoomLevel("zoom:50", .5, "commands.zoom.p50"),
+	zoomLevel("zoom:100", 1, "commands.zoom.p100"),
+	zoomLevel("zoom:150", 1.5, "commands.zoom.p150"),
+	zoomLevel("zoom:200", 2, "commands.zoom.p200"),
+	zoomLevel("zoom:400", 4, "commands.zoom.p400"),
+	{
+		id: "menu:zoom",
+		labelKey: "commands.zoom.menu",
+		icon: "zoomIn",
+		menu: "zoom"
+	},
+	{
+		id: "page:next",
+		labelKey: "commands.page.next",
+		icon: "chevronRight",
+		shortcut: "ArrowRight",
+		run: (commandContext) => stage(commandContext)?.nextPage(),
+		enabled: (commandContext) => stage(commandContext)?.canGoNext() ?? false
+	},
+	{
+		id: "page:previous",
+		labelKey: "commands.page.previous",
+		icon: "chevronLeft",
+		shortcut: "ArrowLeft",
+		run: (commandContext) => stage(commandContext)?.previousPage(),
+		enabled: (commandContext) => stage(commandContext)?.canGoPrevious() ?? false
+	},
+	{
+		id: "page:first",
+		labelKey: "commands.page.first",
+		shortcut: "Home",
+		run: (commandContext) => stage(commandContext)?.goToFirstPage(),
+		enabled: (commandContext) => stage(commandContext)?.canGoPrevious() ?? false
+	},
+	{
+		id: "page:last",
+		labelKey: "commands.page.last",
+		shortcut: "End",
+		run: (commandContext) => stage(commandContext)?.goToLastPage(),
+		enabled: (commandContext) => stage(commandContext)?.canGoNext() ?? false
+	},
+	{
+		id: "page:go-to",
+		labelKey: "commands.page.goTo",
+		run: (commandContext) => {
+			const view = stage(commandContext);
+			if (!view) return;
+			const page = pageArgOf(commandContext.args);
+			if (page === null) {
+				commandContext.tryGet(_embedpdf_react_shell.ShellToken)?.open(GO_TO_PAGE_DIALOG, { exclusive: "modal" });
+				return;
+			}
+			view.goToPage(Math.min(Math.max(page, 1), view.getPageCount()) - 1);
+		},
+		enabled: (commandContext) => (stage(commandContext)?.getPageCount() ?? 0) > 0
+	},
+	{
+		id: "tool:pan",
+		labelKey: "commands.pan",
+		icon: "hand",
+		run: (commandContext) => interaction(commandContext)?.activateTool("pan"),
+		active: (commandContext) => interaction(commandContext)?.getActiveToolId() === "pan",
+		enabled: (commandContext) => interaction(commandContext) != null
+	},
+	{
+		id: "tool:pointer",
+		labelKey: "commands.pointer",
+		icon: "pointer",
+		run: (commandContext) => interaction(commandContext)?.activateTool("pointer"),
+		active: (commandContext) => interaction(commandContext)?.getActiveToolId() === "pointer",
+		enabled: (commandContext) => interaction(commandContext) != null
+	},
+	{
+		id: "menu:document",
+		labelKey: "commands.menu",
+		icon: "menu",
+		menu: "document"
+	},
+	{
+		id: "menu:view",
+		labelKey: "commands.viewControls",
+		icon: "viewSettings",
+		menu: "view"
+	},
+	...outlineCommands,
+	...attachmentCommands,
+	...pageCommands,
+	openFileCommand,
+	{
+		id: "document:download",
+		labelKey: "commands.download",
+		icon: "download",
+		shortcut: "Mod+S",
+		categories: ["documents.download"],
+		allowed: (commandContext) => commandContext.tryGet(_embedpdf_react_runtime.DocumentsToken)?.canDownload() ?? true,
+		notAllowedKey: "commands.notAllowed.doc-download",
+		run: (commandContext) => {
+			const id = commandContext.documentId ?? void 0;
+			const documents = commandContext.tryGet(_embedpdf_react_runtime.DocumentsToken);
+			if (!documents) return;
+			documents.download(id).then((bytes) => (0, _embedpdf_web.saveFile)(bytes, "document.pdf", "application/pdf")).catch((error) => console.warn("[snippet-react] download failed", error));
+		},
+		enabled: (commandContext) => commandContext.documentId != null
+	},
+	{
+		id: "document:print",
+		labelKey: "commands.print",
+		icon: "print",
+		shortcut: "Mod+P",
+		categories: ["documents.print"],
+		allowed: (commandContext) => commandContext.tryGet(_embedpdf_react_runtime.DocumentsToken)?.canPrint() ?? true,
+		notAllowedKey: "commands.notAllowed.doc-print",
+		modal: PRINT_DIALOG,
+		enabled: (commandContext) => commandContext.documentId != null
+	},
+	{
+		id: "view:fullscreen",
+		labelKey: "commands.fullscreen",
+		icon: "externalLink",
+		run: () => {
+			if (document.fullscreenElement) document.exitFullscreen();
+			else document.documentElement.requestFullscreen().catch(() => {});
+		},
+		active: () => Boolean(document.fullscreenElement)
+	},
+	spread("view:single-page", "none", "commands.spread.none", "singlePage"),
+	spread("view:two-pages", "odd", "commands.spread.odd", "doublePage"),
+	spread("view:cover-page", "even", "commands.spread.even", "book2"),
+	{
+		id: "view:scroll-vertical",
+		labelKey: "commands.scroll.vertical",
+		icon: "vertical",
+		run: (commandContext) => stage(commandContext)?.updateSettings({ layout: "vertical" }),
+		active: (commandContext) => stage(commandContext)?.getSettings().layout === "vertical",
+		enabled: (commandContext) => stage(commandContext) != null
+	},
+	{
+		id: "view:scroll-horizontal",
+		labelKey: "commands.scroll.horizontal",
+		icon: "horizontal",
+		run: (commandContext) => stage(commandContext)?.updateSettings({ layout: "horizontal" }),
+		active: (commandContext) => stage(commandContext)?.getSettings().layout === "horizontal",
+		enabled: (commandContext) => stage(commandContext) != null
+	},
+	{
+		id: "view:rotate-clockwise",
+		labelKey: "commands.rotate.clockwise",
+		icon: "rotateClockwise",
+		run: (commandContext) => stage(commandContext)?.rotateViewBy(90),
+		enabled: (commandContext) => stage(commandContext) != null
+	},
+	{
+		id: "view:rotate-counterclockwise",
+		labelKey: "commands.rotate.counterclockwise",
+		icon: "rotateCounterClockwise",
+		run: (commandContext) => stage(commandContext)?.rotateViewBy(-90),
+		enabled: (commandContext) => stage(commandContext) != null
+	},
+	{
+		id: "mode:view",
+		labelKey: "commands.mode.view",
+		run: (commandContext) => {
+			const shell = commandContext.tryGet(_embedpdf_react_shell.ShellToken);
+			const open = shell ? openModeSurfaceOf(shell) : null;
+			if (open) shell?.close(open);
+			interaction(commandContext)?.activateTool("pointer");
+		},
+		active: (commandContext) => {
+			const shell = commandContext.tryGet(_embedpdf_react_shell.ShellToken);
+			return shell ? openModeSurfaceOf(shell) === null : true;
+		}
+	},
+	modeCommand("mode:annotate", "commands.mode.annotate", { feature: "annotations" }),
+	modeCommand("mode:shapes", "commands.mode.shapes", { feature: "shapes" }),
+	modeCommand("mode:insert", "commands.mode.insert"),
+	modeCommand("mode:form", "commands.mode.form", { feature: "forms.building" }),
+	modeCommand("mode:redact", "commands.mode.redact", { feature: "redaction" }),
+	modeCommand("mode:measure", "commands.mode.measure", { feature: "measurement" }),
+	tool("tool:highlight", "highlight", "commands.annotate.highlight", "highlight", {
+		feature: "annotations.highlight",
+		check: CREATES_ANNOTATIONS,
+		accent: { primary: "color" }
+	}),
+	tool("tool:strikeout", "strikeout", "commands.annotate.strikeout", "strikethrough", {
+		feature: "annotations.markup",
+		check: CREATES_ANNOTATIONS,
+		accent: { primary: "color" }
+	}),
+	tool("tool:underline", "underline", "commands.annotate.underline", "underline", {
+		feature: "annotations.markup",
+		check: CREATES_ANNOTATIONS,
+		accent: { primary: "color" }
+	}),
+	tool("tool:squiggly", "squiggly", "commands.annotate.squiggly", "squiggly", {
+		feature: "annotations.markup",
+		check: CREATES_ANNOTATIONS,
+		accent: { primary: "color" }
+	}),
+	tool("tool:ink", "ink", "commands.annotate.ink", "pencilMarker", {
+		feature: "annotations.drawing",
+		check: CREATES_ANNOTATIONS,
+		accent: { primary: "color" }
+	}),
+	tool("tool:ink-highlight", "ink-highlight", "commands.annotate.inkHighlight", "inkHighlighter", {
+		feature: "annotations.drawing",
+		check: CREATES_ANNOTATIONS,
+		accent: { primary: "color" }
+	}),
+	tool("tool:free-text", "free-text", "commands.annotate.text", "freeText", {
+		feature: "annotations.text",
+		check: CREATES_ANNOTATIONS,
+		accent: { primary: "fontColor" }
+	}),
+	tool("tool:insert-text", "insert-text", "commands.annotate.insertText", "insertText", {
+		feature: "annotations.text",
+		check: CREATES_ANNOTATIONS,
+		accent: { primary: "color" }
+	}),
+	tool("tool:replace-text", "replace-text", "commands.annotate.replaceText", "replaceText", {
+		feature: "annotations.text",
+		check: CREATES_ANNOTATIONS,
+		accent: { primary: "color" }
+	}),
+	tool("tool:callout", "free-text-callout", "commands.annotate.callout", "callout", {
+		feature: "annotations.text",
+		check: CREATES_ANNOTATIONS,
+		accent: {
+			primary: "color",
+			secondary: "interiorColor"
+		}
+	}),
+	tool("tool:note", "note", "commands.annotate.note", "message", {
+		feature: "annotations.notes",
+		check: CREATES_ANNOTATIONS
+	}),
+	tool("tool:link", "link", "commands.annotate.link", "link", {
+		feature: "annotations.links",
+		check: CREATES_ANNOTATIONS
+	}),
+	tool("tool:square", "square", "commands.shapes.rectangle", "square", {
+		feature: "shapes",
+		check: CREATES_ANNOTATIONS,
+		accent: {
+			primary: "color",
+			secondary: "interiorColor"
+		}
+	}),
+	tool("tool:circle", "circle", "commands.shapes.circle", "circle", {
+		feature: "shapes",
+		check: CREATES_ANNOTATIONS,
+		accent: {
+			primary: "color",
+			secondary: "interiorColor"
+		}
+	}),
+	tool("tool:line", "line", "commands.shapes.line", "line", {
+		feature: "shapes",
+		check: CREATES_ANNOTATIONS,
+		accent: { primary: "color" }
+	}),
+	tool("tool:arrow", "arrow", "commands.shapes.arrow", "lineArrow", {
+		feature: "shapes",
+		check: CREATES_ANNOTATIONS,
+		accent: { primary: "color" }
+	}),
+	tool("tool:polygon", "polygon", "commands.shapes.polygon", "polygon", {
+		feature: "shapes",
+		check: CREATES_ANNOTATIONS,
+		accent: {
+			primary: "color",
+			secondary: "interiorColor"
+		}
+	}),
+	tool("tool:polyline", "polyline", "commands.shapes.polyline", "zigzag", {
+		feature: "shapes",
+		check: CREATES_ANNOTATIONS,
+		accent: { primary: "color" }
+	}),
+	{
+		id: "tool:stamp",
+		labelKey: "commands.insert.stamp",
+		icon: "rubberStamp",
+		categories: ["stamps"],
+		...PLACES_STAMPS,
+		...togglesPanel("stamps", (commandContext) => commandContext.tryGet(_embedpdf_react_stamp.StampToken) != null)
+	},
+	tool("tool:attachment", "attachment", "commands.insert.attachment", "paperclip", {
+		feature: "attachments.adding",
+		check: CREATES_ANNOTATIONS
+	}),
+	{
+		id: "tool:signature",
+		labelKey: "commands.insert.signature",
+		icon: "signature",
+		categories: ["signatures.signing"],
+		...PLACES_STAMPS,
+		...togglesPanel("signatures", (commandContext) => commandContext.tryGet(_embedpdf_react_stamp.StampToken) != null && commandContext.tryGet(_embedpdf_react_signature.SignatureToken) != null)
+	},
+	tool("tool:image", "image", "commands.insert.image", "photo", {
+		feature: "stamps",
+		check: CREATES_ANNOTATIONS
+	}),
+	{
+		id: "form:design",
+		labelKey: "commands.form.design",
+		icon: "formDesign",
+		categories: ["forms.building"],
+		...DESIGNS_FORMS,
+		run: (commandContext) => {
+			const tools = interaction(commandContext);
+			const shell = commandContext.tryGet(_embedpdf_react_shell.ShellToken);
+			if (!tools) return;
+			if (isDesigningForm(commandContext)) {
+				tools.activateTool("pointer");
+				shell?.close(FORM_DESIGN_PANEL);
+				return;
+			}
+			if (shell && !shell.isOpen("mode:form")) shell.open("mode:form", { exclusive: "mode" });
+			tools.activateTool(FORM_DESIGN_TOOL);
+			shell?.open(FORM_DESIGN_PANEL);
+		},
+		active: isDesigningForm,
+		enabled: (commandContext) => interaction(commandContext) != null
+	},
+	tool("tool:text-field", "form-text", "commands.form.textfield", "formTextfield", {
+		feature: "forms.building",
+		check: DESIGNS_FORMS
+	}),
+	tool("tool:checkbox", "form-checkbox", "commands.form.checkbox", "formCheckbox", {
+		feature: "forms.building",
+		check: DESIGNS_FORMS
+	}),
+	tool("tool:radio", "form-radio", "commands.form.radio", "formRadio", {
+		feature: "forms.building",
+		check: DESIGNS_FORMS
+	}),
+	tool("tool:combo-box", "form-combobox", "commands.form.select", "formSelect", {
+		feature: "forms.building",
+		check: DESIGNS_FORMS
+	}),
+	tool("tool:list-box", "form-listbox", "commands.form.listbox", "formListbox", {
+		feature: "forms.building",
+		check: DESIGNS_FORMS
+	}),
+	tool("tool:button", "form-button", "commands.form.button", "formButton", {
+		feature: "forms.building",
+		check: DESIGNS_FORMS
+	}),
+	tool("tool:signature-field", "form-signature", "commands.form.signature", "signature", {
+		feature: "forms.building",
+		check: DESIGNS_FORMS
+	}),
+	tool("tool:redact", "redact", "commands.redact.mark", "redactArea", {
+		feature: "redaction",
+		check: {
+			allowed: (commandContext) => commandContext.tryGet(_embedpdf_react_redaction.RedactionToken)?.canMark() ?? true,
+			notAllowedKey: "commands.notAllowed.annotations-create"
+		}
+	}),
+	{
+		id: "redaction:apply",
+		labelKey: "commands.redact.applyAll",
+		icon: "redact",
+		categories: ["redaction"],
+		allowed: (commandContext) => commandContext.tryGet(_embedpdf_react_redaction.RedactionToken)?.canApply() ?? true,
+		modal: REDACT_CONFIRM_DIALOG,
+		enabled: (commandContext) => {
+			const redaction = commandContext.tryGet(_embedpdf_react_redaction.RedactionToken);
+			return !!redaction && redaction.getPendingCount() > 0 && !redaction.isApplying();
+		}
+	},
+	{
+		...tool("tool:distance", "distance", "measurement.distance", "distance", {
+			feature: "measurement",
+			check: CREATES_ANNOTATIONS,
+			accent: { primary: "color" }
+		}),
+		enabled: canMeasureNow
+	},
+	{
+		...tool("tool:perimeter", "perimeter", "measurement.perimeter", "perimeter", {
+			feature: "measurement",
+			check: CREATES_ANNOTATIONS,
+			accent: { primary: "color" }
+		}),
+		enabled: canMeasureNow
+	},
+	{
+		...tool("tool:area", "area", "measurement.area", "area", {
+			feature: "measurement",
+			check: CREATES_ANNOTATIONS,
+			accent: { primary: "color" }
+		}),
+		enabled: canMeasureNow
+	},
+	{
+		id: "measurement:calibrate",
+		labelKey: "measurement.calibrate",
+		icon: "calibrate",
+		categories: ["measurement"],
+		allowed: (commandContext) => commandContext.tryGet(_embedpdf_react_measurement.MeasurementToken)?.canCalibrate() ?? true,
+		notAllowedKey: "commands.notAllowed.doc-annotate-modify",
+		enabled: (commandContext) => commandContext.tryGet(_embedpdf_react_measurement.MeasurementToken) != null,
+		active: (commandContext) => interaction(commandContext)?.getActiveToolId() === "calibrate",
+		run: (commandContext) => commandContext.tryGet(_embedpdf_react_measurement.MeasurementToken)?.startCalibration()
+	},
+	{
+		id: "annotation:cancel-creation",
+		labelKey: "commands.annotate.cancelCreation",
+		shortcut: "Escape",
+		enabled: (commandContext) => anno(commandContext)?.draft.get() != null,
+		run: (commandContext) => anno(commandContext)?.draft.cancel()
+	},
+	{
+		id: "annotation:delete",
+		labelKey: "commands.annotate.delete",
+		icon: "trash",
+		shortcut: ["Delete", "Backspace"],
+		categories: ["annotations"],
+		run: (commandContext) => void anno(commandContext)?.selection.delete(),
+		visible: hasAnnotationSelection,
+		enabled: (commandContext) => {
+			const annotation = anno(commandContext);
+			const selected = annotation?.selection.list() ?? [];
+			return selected.length > 0 && selected.every(({ ref }) => annotation.canDelete(ref) && annotation.isEditable(ref));
+		}
+	},
+	{
+		id: "annotation:comment",
+		labelKey: "commands.comment",
+		icon: "comment",
+		categories: ["comments"],
+		...togglesPanel("comments", (commandContext) => hasAnnotationSelection(commandContext) && !selectionSubtypes(commandContext).has("widget"))
+	},
+	{
+		id: "annotation:style",
+		labelKey: "commands.style",
+		icon: "palette",
+		categories: ["annotations"],
+		...togglesPanel("style", (commandContext) => (anno(commandContext)?.selection.getProperties().properties.length ?? 0) > 0)
+	},
+	{
+		id: "annotation:stamp-from-selection",
+		labelKey: "commands.annotate.stampFromSelection",
+		icon: "rubberStampPlus",
+		categories: ["stamps"],
+		allowed: (commandContext) => commandContext.tryGet(_embedpdf_react_stamp.StampToken)?.canCreateFromAnnotations(commandContext.documentId ?? void 0) ?? true,
+		notAllowedKey: "commands.notAllowed.doc-download",
+		run: (commandContext) => {
+			const annotation = anno(commandContext);
+			const stamp = commandContext.tryGet(_embedpdf_react_stamp.StampToken);
+			const documentId = commandContext.documentId;
+			if (!annotation || !stamp || documentId == null) return;
+			const dtos = annotation.selection.list();
+			const page = dtos[0]?.ref.page;
+			if (page === void 0) return;
+			const i18n = commandContext.tryGet(_embedpdf_react_i18n.I18nToken);
+			const label = i18n?.t("demo.stampsCustomLabel") ?? "Custom stamp";
+			const libraryName = i18n?.t("demo.stampsCustomLibrary") ?? "My stamps";
+			const libraryId = CUSTOM_LIBRARY_ID;
+			(stamp.getLibrary(libraryId) ? Promise.resolve(libraryId) : stamp.createLibrary(libraryName, {
+				id: libraryId,
+				categories: ["custom"]
+			}).then(({ library }) => library.id)).then((id) => stamp.createAssetFromAnnotations(page, dtos.map((annotation) => annotation.ref), {
+				libraryId: id,
+				label: `${label} ${stamp.listAssets({ libraryId: id }).length + 1}`
+			}, { documentId })).then(async () => {
+				const shell = commandContext.tryGet(_embedpdf_react_shell.ShellToken);
+				if (!shell) return;
+				if (!shell.isOpen("stamps")) await commandContext.tryGet(_embedpdf_react_commands.CommandsToken)?.execute((0, _embedpdf_core_ui.panelCommandOf)("stamps"), { documentId });
+				shell.updateSurfaceProps("stamps", { libraryId });
+			}).catch((error) => console.warn("[embedpdf] stamp from selection failed", error));
+		},
+		visible: (commandContext) => commandContext.tryGet(_embedpdf_react_stamp.StampToken) != null && hasAnnotationSelection(commandContext) && !selectionSubtypes(commandContext).has("widget") && !selectionSubtypes(commandContext).has("redact") && new Set((anno(commandContext)?.selection.list() ?? []).map((annotation) => annotation.ref.page.objectNumber)).size === 1
+	},
+	{
+		id: "annotation:group",
+		labelKey: "commands.annotate.group",
+		icon: "group",
+		categories: ["annotations"],
+		run: (commandContext) => void anno(commandContext)?.selection.group(),
+		visible: (commandContext) => (anno(commandContext)?.selection.canGroup() ?? false) && selectionEditable(commandContext)
+	},
+	{
+		id: "annotation:ungroup",
+		labelKey: "commands.annotate.ungroup",
+		icon: "ungroup",
+		categories: ["annotations"],
+		run: (commandContext) => void anno(commandContext)?.selection.ungroup(),
+		visible: (commandContext) => (anno(commandContext)?.selection.canUngroup() ?? false) && selectionEditable(commandContext)
+	},
+	{
+		id: "selection:copy",
+		labelKey: "commands.selection.copy",
+		icon: "copy",
+		categories: ["text.copy"],
+		allowed: (commandContext) => textSelection(commandContext)?.canCopy() ?? true,
+		notAllowedKey: "commands.notAllowed.doc-text-copy",
+		visible: (commandContext) => textSelection(commandContext)?.hasSelection() ?? false,
+		run: (commandContext) => {
+			const selection = textSelection(commandContext);
+			if (!selection) return;
+			const copiedRange = selection.getRange();
+			(0, _embedpdf_react_selection.copySelection)(selection).then((text) => {
+				if (text !== "" && sameTextRange(selection.getRange(), copiedRange)) selection.clear();
+			}, () => {});
+		}
+	},
+	markupSelection("selection:highlight", "highlight", "commands.annotate.highlight", "highlight", "annotations.highlight"),
+	markupSelection("selection:underline", "underline", "commands.annotate.underline", "underline", "annotations.markup"),
+	markupSelection("selection:strikeout", "strikeout", "commands.annotate.strikeout", "strikethrough", "annotations.markup"),
+	{
+		id: "annotation:link",
+		labelKey: "commands.annotate.link",
+		icon: "link",
+		categories: ["annotations.links"],
+		run: (commandContext) => commandContext.tryGet(_embedpdf_react_shell.ShellToken)?.toggle("link-editor"),
+		active: (commandContext) => commandContext.tryGet(_embedpdf_react_shell.ShellToken)?.isOpen("link-editor") ?? false,
+		visible: (commandContext) => selectionLink(commandContext) === null
+	},
+	{
+		id: "annotation:goto-link",
+		labelKey: "commands.annotate.gotoLink",
+		icon: "externalLink",
+		run: (commandContext) => {
+			const target = selectionLink(commandContext);
+			if (target) commandContext.tryGet(_embedpdf_react_link.LinkToken)?.activate(target);
+		},
+		visible: (commandContext) => selectionLink(commandContext) != null
+	},
+	{
+		id: "annotation:remove-link",
+		labelKey: "commands.annotate.removeLink",
+		icon: "linkOff",
+		categories: ["annotations.links"],
+		run: (commandContext) => anno(commandContext)?.selection.updateLink(null),
+		visible: (commandContext) => selectionLink(commandContext) != null
+	},
+	{
+		id: "help:shortcuts",
+		labelKey: "commands.shortcuts",
+		shortcut: "?",
+		modal: SHORTCUTS_DIALOG,
+		enabled: (commandContext) => commandContext.tryGet(_embedpdf_react_shell.ShellToken) != null
+	},
+	{
+		id: "history:undo",
+		labelKey: "commands.undo",
+		icon: "arrowBackUp",
+		shortcut: "Mod+z",
+		run: (commandContext) => commandContext.tryGet(_embedpdf_react_history.HistoryToken)?.undo(),
+		enabled: (commandContext) => commandContext.tryGet(_embedpdf_react_history.HistoryToken)?.canUndo() ?? false
+	},
+	{
+		id: "history:redo",
+		labelKey: "commands.redo",
+		icon: "arrowForwardUp",
+		shortcut: ["Shift+Mod+z", "Mod+y"],
+		run: (commandContext) => commandContext.tryGet(_embedpdf_react_history.HistoryToken)?.redo(),
+		enabled: (commandContext) => commandContext.tryGet(_embedpdf_react_history.HistoryToken)?.canRedo() ?? false
+	}
+];
+const MODE_SURFACES = [
+	"mode:annotate",
+	"mode:shapes",
+	"mode:insert",
+	"mode:form",
+	"mode:redact",
+	"mode:measure"
+];
+function modeCommand(id, labelKey, { feature } = {}) {
+	return {
+		id,
+		labelKey,
+		...feature ? { categories: [feature] } : {},
+		run: (commandContext) => {
+			commandContext.tryGet(_embedpdf_react_shell.ShellToken)?.toggle(id, { exclusive: "mode" });
+			interaction(commandContext)?.activateTool("pointer");
+		},
+		active: (commandContext) => commandContext.tryGet(_embedpdf_react_shell.ShellToken)?.isOpen(id) ?? false
+	};
+}
+/**
+* A `tool:<id>` command for each tool of yours (`plugins.annotation.tools`) that no command has
+* (`isTaken` says which ids do): labelled by its `meta.label`, else its id; drawn with its
+* `meta.icon`, else the icon of the tool it extends; in that tool's feature, else `annotations`.
+*/
+function toolCommandsFor(tools, isTaken) {
+	return tools.flatMap((input) => {
+		const id = `tool:${input.id}`;
+		if (isTaken(id)) return [];
+		const base = input.extends;
+		const meta = input.meta ?? {};
+		const icon = typeof meta.icon === "string" ? meta.icon : base && TOOL_ICONS[base]?.icon;
+		return [{
+			...toolCommand(id, input.id, icon || void 0, {
+				feature: base && TOOL_FEATURES[base] || "annotations",
+				check: CREATES_ANNOTATIONS,
+				...base && TOOL_ICONS[base]?.accent ? { accent: TOOL_ICONS[base].accent } : {}
+			}),
+			label: typeof meta.label === "string" ? meta.label : input.id
+		}];
+	});
+}
+//#endregion
+Object.defineProperty(exports, "FORM_DESIGN_PANEL", {
+	enumerable: true,
+	get: function() {
+		return FORM_DESIGN_PANEL;
+	}
+});
+Object.defineProperty(exports, "FORM_DESIGN_TOOL", {
+	enumerable: true,
+	get: function() {
+		return FORM_DESIGN_TOOL;
+	}
+});
+Object.defineProperty(exports, "GO_TO_PAGE_DIALOG", {
+	enumerable: true,
+	get: function() {
+		return GO_TO_PAGE_DIALOG;
+	}
+});
+Object.defineProperty(exports, "MODE_SURFACES", {
+	enumerable: true,
+	get: function() {
+		return MODE_SURFACES;
+	}
+});
+Object.defineProperty(exports, "OPEN_COMMAND_ID", {
+	enumerable: true,
+	get: function() {
+		return OPEN_COMMAND_ID;
+	}
+});
+Object.defineProperty(exports, "OUTLINE_PROPERTIES_DIALOG", {
+	enumerable: true,
+	get: function() {
+		return OUTLINE_PROPERTIES_DIALOG;
+	}
+});
+Object.defineProperty(exports, "OUTLINE_RENAME", {
+	enumerable: true,
+	get: function() {
+		return OUTLINE_RENAME;
+	}
+});
+Object.defineProperty(exports, "PRINT_DIALOG", {
+	enumerable: true,
+	get: function() {
+		return PRINT_DIALOG;
+	}
+});
+Object.defineProperty(exports, "REDACT_CONFIRM_DIALOG", {
+	enumerable: true,
+	get: function() {
+		return REDACT_CONFIRM_DIALOG;
+	}
+});
+Object.defineProperty(exports, "SHORTCUTS_DIALOG", {
+	enumerable: true,
+	get: function() {
+		return SHORTCUTS_DIALOG;
+	}
+});
+Object.defineProperty(exports, "TOOL_ICONS", {
+	enumerable: true,
+	get: function() {
+		return TOOL_ICONS;
+	}
+});
+Object.defineProperty(exports, "defaultCommands", {
+	enumerable: true,
+	get: function() {
+		return defaultCommands;
+	}
+});
+Object.defineProperty(exports, "isDesigningForm", {
+	enumerable: true,
+	get: function() {
+		return isDesigningForm;
+	}
+});
+Object.defineProperty(exports, "isFormDesignTool", {
+	enumerable: true,
+	get: function() {
+		return isFormDesignTool;
+	}
+});
+Object.defineProperty(exports, "isPdfFile", {
+	enumerable: true,
+	get: function() {
+		return isPdfFile;
+	}
+});
+Object.defineProperty(exports, "mayCarryPdf", {
+	enumerable: true,
+	get: function() {
+		return mayCarryPdf;
+	}
+});
+Object.defineProperty(exports, "modeCommandsFor", {
+	enumerable: true,
+	get: function() {
+		return modeCommandsFor;
+	}
+});
+Object.defineProperty(exports, "modeSpecsOf", {
+	enumerable: true,
+	get: function() {
+		return modeSpecsOf;
+	}
+});
+Object.defineProperty(exports, "openModeSurfaceOf", {
+	enumerable: true,
+	get: function() {
+		return openModeSurfaceOf;
+	}
+});
+Object.defineProperty(exports, "sameModeSpecs", {
+	enumerable: true,
+	get: function() {
+		return sameModeSpecs;
+	}
+});
+Object.defineProperty(exports, "toolCommandsFor", {
+	enumerable: true,
+	get: function() {
+		return toolCommandsFor;
+	}
+});
+
+//# sourceMappingURL=commands-DL1gjZt7.cjs.map