@embedpdf/viewer-chrome 3.0.0-next.13 → 3.0.0-next.15

package/dist/commands-BmgxhJ8B.js

@@ -0,0 +1,953 @@
+import { DocumentsToken } from "@embedpdf/react/runtime";
+import { StageToken, ZoomMode } from "@embedpdf/react/stage";
+import { InteractionToken } from "@embedpdf/react/interaction";
+import { SelectionToken, copySelection } from "@embedpdf/react/selection";
+import { AnnotationToken } from "@embedpdf/react/annotation";
+import { StampToken } from "@embedpdf/react/stamp";
+import { MeasurementToken } from "@embedpdf/react/measurement";
+import { RedactionToken } from "@embedpdf/react/redaction";
+import { ActionsToken } from "@embedpdf/react/actions";
+import { FormToken } from "@embedpdf/react/form";
+import { SignatureToken } from "@embedpdf/react/signature";
+import { LinkToken } from "@embedpdf/react/link";
+import { I18nToken } from "@embedpdf/react/i18n";
+import { CommandsToken } from "@embedpdf/react/commands";
+import { HistoryToken } from "@embedpdf/react/history";
+import { ShellToken } from "@embedpdf/react/shell";
+import { barsInMode, modeCommandOf, modesOf, panelCommandOf } from "@embedpdf/core-ui";
+import { pickFile } from "@embedpdf/web";
+//#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 modesOf(data).map((mode) => {
+		const titled = 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(modeCommandOf(spec.mode))).map((spec) => {
+		const id = modeCommandOf(spec.mode);
+		return {
+			id,
+			label: spec.title ?? (spec.titleKey === void 0 ? spec.mode : void 0),
+			labelKey: spec.titleKey,
+			run: (commandContext) => {
+				commandContext.tryGet(ShellToken)?.toggle(id, { exclusive: MODE_TAG });
+				commandContext.tryGet(InteractionToken)?.activateTool("pointer");
+			},
+			active: (commandContext) => commandContext.tryGet(ShellToken)?.isOpen(id) ?? false
+		};
+	});
+}
+//#endregion
+//#region src/config/open-files.ts
+const OPEN_COMMAND_ID = "document:open";
+const PDF_TYPE = "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 || /\.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 || 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 = () => pickFile({ accept: `.pdf,${PDF_TYPE}` }).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(DocumentsToken)?.canOpenFiles() ?? false,
+	run: async (commandContext) => {
+		const documents = commandContext.tryGet(DocumentsToken);
+		if (!documents) return;
+		openFiles(documents, givenFilesOf(commandContext.args) ?? await pickedFiles());
+	}
+};
+//#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 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(InteractionToken)?.getActiveToolId());
+/** Where selection-made stamps go: the user's own library, persisted. */
+const CUSTOM_LIBRARY_ID = "embedpdf-custom";
+const stage = (commandContext) => commandContext.tryGet(StageToken);
+const interaction = (commandContext) => commandContext.tryGet(InteractionToken);
+const anno = (commandContext) => commandContext.tryGet(AnnotationToken);
+const textSelection = (commandContext) => commandContext.tryGet(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(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(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(CommandsToken)?.execute(panelCommandOf(id), { documentId: commandContext.documentId ?? void 0 }),
+	active: (commandContext) => commandContext.tryGet(ShellToken)?.isOpen(id) ?? false,
+	visible: (commandContext) => (commandContext.tryGet(CommandsToken)?.hasCommand(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(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(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() === 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() === ZoomMode.FitWidth,
+		enabled: (commandContext) => stage(commandContext) != null
+	},
+	{
+		id: "zoom:automatic",
+		labelKey: "commands.zoom.automatic",
+		run: (commandContext) => stage(commandContext)?.fitAutomatic(),
+		active: (commandContext) => stage(commandContext)?.getZoomMode() === 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(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"
+	},
+	openFileCommand,
+	{
+		id: "document:download",
+		labelKey: "commands.download",
+		icon: "download",
+		shortcut: "Mod+S",
+		categories: ["documents.download"],
+		allowed: (commandContext) => commandContext.tryGet(DocumentsToken)?.canDownload() ?? true,
+		notAllowedKey: "commands.notAllowed.doc-download",
+		run: (commandContext) => {
+			const id = commandContext.documentId ?? void 0;
+			const documents = commandContext.tryGet(DocumentsToken);
+			if (!documents) return;
+			documents.download(id).then((bytes) => {
+				const blob = new Blob([bytes], { type: "application/pdf" });
+				const url = URL.createObjectURL(blob);
+				const anchor = document.createElement("a");
+				anchor.href = url;
+				anchor.download = "document.pdf";
+				anchor.click();
+				URL.revokeObjectURL(url);
+			}).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(DocumentsToken)?.canPrint() ?? true,
+		notAllowedKey: "commands.notAllowed.doc-print",
+		run: (commandContext) => {
+			const actions = commandContext.documentId != null ? commandContext.tryGet(ActionsToken) : null;
+			if (actions) actions.runDocumentVerb("print", () => window.print());
+			else window.print();
+		}
+	},
+	{
+		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(ShellToken);
+			const open = shell ? openModeSurfaceOf(shell) : null;
+			if (open) shell?.close(open);
+			interaction(commandContext)?.activateTool("pointer");
+		},
+		active: (commandContext) => {
+			const shell = commandContext.tryGet(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(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(StampToken) != null && commandContext.tryGet(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(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(RedactionToken)?.canMark() ?? true,
+			notAllowedKey: "commands.notAllowed.annotations-create"
+		}
+	}),
+	{
+		id: "redaction:apply",
+		labelKey: "commands.redact.applyAll",
+		icon: "redact",
+		categories: ["redaction"],
+		allowed: (commandContext) => commandContext.tryGet(RedactionToken)?.canApply() ?? true,
+		modal: REDACT_CONFIRM_DIALOG,
+		enabled: (commandContext) => {
+			const redaction = commandContext.tryGet(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(MeasurementToken)?.canCalibrate() ?? true,
+		notAllowedKey: "commands.notAllowed.doc-annotate-modify",
+		enabled: (commandContext) => commandContext.tryGet(MeasurementToken) != null,
+		active: (commandContext) => interaction(commandContext)?.getActiveToolId() === "calibrate",
+		run: (commandContext) => commandContext.tryGet(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(StampToken)?.canCreateFromAnnotations(commandContext.documentId ?? void 0) ?? true,
+		notAllowedKey: "commands.notAllowed.doc-download",
+		run: (commandContext) => {
+			const annotation = anno(commandContext);
+			const stamp = commandContext.tryGet(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(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(ShellToken);
+				if (!shell) return;
+				if (!shell.isOpen("stamps")) await commandContext.tryGet(CommandsToken)?.execute(panelCommandOf("stamps"), { documentId });
+				shell.updateSurfaceProps("stamps", { libraryId });
+			}).catch((error) => console.warn("[embedpdf] stamp from selection failed", error));
+		},
+		visible: (commandContext) => commandContext.tryGet(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();
+			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(ShellToken)?.toggle("link-editor"),
+		active: (commandContext) => commandContext.tryGet(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(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(ShellToken) != null
+	},
+	{
+		id: "history:undo",
+		labelKey: "commands.undo",
+		icon: "arrowBackUp",
+		shortcut: "Mod+z",
+		run: (commandContext) => commandContext.tryGet(HistoryToken)?.undo(),
+		enabled: (commandContext) => commandContext.tryGet(HistoryToken)?.canUndo() ?? false
+	},
+	{
+		id: "history:redo",
+		labelKey: "commands.redo",
+		icon: "arrowForwardUp",
+		shortcut: ["Shift+Mod+z", "Mod+y"],
+		run: (commandContext) => commandContext.tryGet(HistoryToken)?.redo(),
+		enabled: (commandContext) => commandContext.tryGet(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(ShellToken)?.toggle(id, { exclusive: "mode" });
+			interaction(commandContext)?.activateTool("pointer");
+		},
+		active: (commandContext) => commandContext.tryGet(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
+export { openModeSurfaceOf as _, REDACT_CONFIRM_DIALOG as a, defaultCommands as c, toolCommandsFor as d, OPEN_COMMAND_ID as f, modeSpecsOf as g, modeCommandsFor as h, MODE_SURFACES as i, isDesigningForm as l, mayCarryPdf as m, FORM_DESIGN_TOOL as n, SHORTCUTS_DIALOG as o, isPdfFile as p, GO_TO_PAGE_DIALOG as r, TOOL_ICONS as s, FORM_DESIGN_PANEL as t, isFormDesignTool as u, sameModeSpecs as v };
+
+//# sourceMappingURL=commands-BmgxhJ8B.js.map