fabricjs-document-engine 1.0.2 → 1.1.0

package/dist/assets/asset-pipeline.cjs

@@ -5,6 +5,12 @@ const require_font_check = require("./font-check.cjs");
 const require_content_limits = require("../security/content-limits.cjs");
 const require_image_check = require("./image-check.cjs");
 //#region src/assets/asset-pipeline.ts
+function imageCheckOptions(options) {
+	return {
+		timeoutMs: options.imageTimeout,
+		concurrency: options.maxConcurrentImages
+	};
+}
 function cloneDocument(document) {
 	return JSON.parse(JSON.stringify(document));
 }
@@ -54,17 +60,23 @@ function fontWarnings(fonts) {
 		objectIds: font.objectIds
 	}));
 }
-async function inspectAssets(document, options, signal) {
+async function inspectAssets(document, options, signal, onImageProgress) {
 	const manifest = require_asset_manifest.buildAssetManifest(document.objects);
 	const uniqueImages = [...groupByUrl(require_asset_references.findImageReferences(document.objects).filter((reference) => !require_asset_manifest.isEmbeddedUrl(reference.url)))].map(([url, references]) => ({
 		url,
 		crossOrigin: references[0].crossOrigin
 	}));
-	const [missingUrls, unavailableFonts] = await Promise.all([options.checkImages === false ? Promise.resolve([]) : require_image_check.findMissingImages(uniqueImages, signal), require_font_check.findUnavailableFonts(manifest.fonts, options.loadFont)]);
-	const missing = new Set(missingUrls);
+	const [failures, unavailableFonts] = await Promise.all([options.checkImages === false ? Promise.resolve([]) : require_image_check.findMissingImages(uniqueImages, signal, {
+		...imageCheckOptions(options),
+		onProgress: onImageProgress
+	}), require_font_check.findUnavailableFonts(manifest.fonts, options.loadFont)]);
+	const failuresByUrl = new Map(failures.map((failure) => [failure.url, failure]));
 	return {
 		manifest,
-		missingImages: manifest.images.filter((image) => missing.has(image.url)),
+		missingImages: manifest.images.filter((image) => failuresByUrl.has(image.url)).map((image) => ({
+			...image,
+			failure: failuresByUrl.get(image.url)
+		})),
 		unavailableFonts,
 		warnings: [...crossOriginWarnings(document), ...fontWarnings(unavailableFonts)]
 	};
@@ -80,10 +92,10 @@ async function replaceMissingImages(document, missingImages, options, signal) {
 		const replacement = await replace(image);
 		if (typeof replacement === "string" && replacement.length > 0) replacements.set(image.url, replacement);
 	}
-	const brokenReplacements = new Set(await require_image_check.findMissingImages([...replacements.values()].map((url) => ({
+	const brokenReplacements = new Set((await require_image_check.findMissingImages([...replacements.values()].map((url) => ({
 		url,
 		crossOrigin: null
-	})), signal));
+	})), signal, imageCheckOptions(options))).map((failure) => failure.url));
 	const stillMissing = [];
 	const warnings = [];
 	const groups = groupByUrl(require_asset_references.findImageReferences(document.objects));
@@ -106,20 +118,20 @@ async function replaceMissingImages(document, missingImages, options, signal) {
 		warnings
 	};
 }
-async function prepareAssetsForLoad(input, options, signal, isAllowedUrl) {
+async function prepareAssetsForLoad(input, options, signal, isAllowedUrl, onImageProgress) {
 	const document = cloneDocument(input);
 	const { resolveUrl } = options;
 	if (resolveUrl) await rewriteUrls(document, async (url) => resolveUrl(url));
 	require_content_limits.refuseUnsafeImageUrls(document.objects, isAllowedUrl);
-	const report = await inspectAssets(document, options, signal);
+	const report = await inspectAssets(document, options, signal, onImageProgress);
 	if (options.requireFonts && report.unavailableFonts.length > 0) {
 		const families = report.unavailableFonts.map((font) => font.family).join(", ");
 		throw new require_errors.DocumentEngineError("MISSING_FONTS", `These fonts are not available: ${families}`, { missingFonts: report.unavailableFonts });
 	}
 	const { stillMissing, warnings } = await replaceMissingImages(document, report.missingImages, options, signal);
 	if (stillMissing.length > 0) {
-		const urls = stillMissing.map((image) => image.url).join(", ");
-		throw new require_errors.DocumentEngineError("MISSING_ASSETS", `These images could not be loaded: ${urls}`, { missingAssets: stillMissing });
+		const reasons = stillMissing.map((image) => image.failure ? `${image.url} (${image.failure.reason})` : image.url).join(", ");
+		throw new require_errors.DocumentEngineError("MISSING_ASSETS", `These images could not be loaded: ${reasons}`, { missingAssets: stillMissing });
 	}
 	return {
 		document,

package/dist/assets/asset-pipeline.d.cts

@@ -1,7 +1,7 @@
 import { AssetManifest, FontAsset, ImageAsset } from "./asset-manifest.cjs";
 import { FontLoader } from "./font-check.cjs";
 //#region src/assets/asset-pipeline.d.ts
-export type AssetWarningCode = "IMAGE_CROSS_ORIGIN" | "FONT_UNAVAILABLE" | "ASSET_NOT_PORTABLE" | "IMAGE_REPLACED";
+export type AssetWarningCode = "IMAGE_CROSS_ORIGIN" | "FONT_UNAVAILABLE" | "ASSET_NOT_PORTABLE" | "IMAGE_REPLACED" | "IMAGE_NOT_EMBEDDED" | "FONT_NOT_EMBEDDED" | "TEXT_ON_PATH_APPROXIMATED";
 export interface AssetWarning {
   code: AssetWarningCode;
   message: string;
@@ -21,6 +21,10 @@ export interface AssetOptions {
   loadFont?: FontLoader;
   checkImages?: boolean;
   requireFonts?: boolean;
+  /** Milliseconds to wait for each image before it counts as missing. Default 30000. `0` waits forever. */
+  imageTimeout?: number;
+  /** How many images load at the same time while checking. Default 6. */
+  maxConcurrentImages?: number;
 }
 export interface AssetReport {
   manifest: AssetManifest;

package/dist/assets/asset-pipeline.d.ts

@@ -1,7 +1,7 @@
 import { AssetManifest, FontAsset, ImageAsset } from "./asset-manifest.js";
 import { FontLoader } from "./font-check.js";
 //#region src/assets/asset-pipeline.d.ts
-export type AssetWarningCode = "IMAGE_CROSS_ORIGIN" | "FONT_UNAVAILABLE" | "ASSET_NOT_PORTABLE" | "IMAGE_REPLACED";
+export type AssetWarningCode = "IMAGE_CROSS_ORIGIN" | "FONT_UNAVAILABLE" | "ASSET_NOT_PORTABLE" | "IMAGE_REPLACED" | "IMAGE_NOT_EMBEDDED" | "FONT_NOT_EMBEDDED" | "TEXT_ON_PATH_APPROXIMATED";
 export interface AssetWarning {
   code: AssetWarningCode;
   message: string;
@@ -21,6 +21,10 @@ export interface AssetOptions {
   loadFont?: FontLoader;
   checkImages?: boolean;
   requireFonts?: boolean;
+  /** Milliseconds to wait for each image before it counts as missing. Default 30000. `0` waits forever. */
+  imageTimeout?: number;
+  /** How many images load at the same time while checking. Default 6. */
+  maxConcurrentImages?: number;
 }
 export interface AssetReport {
   manifest: AssetManifest;

package/dist/assets/asset-pipeline.js

@@ -5,6 +5,12 @@ import { findUnavailableFonts } from "./font-check.js";
 import { refuseUnsafeImageUrls } from "../security/content-limits.js";
 import { findMissingImages, isCrossOriginUrl, isPortableUrl } from "./image-check.js";
 //#region src/assets/asset-pipeline.ts
+function imageCheckOptions(options) {
+	return {
+		timeoutMs: options.imageTimeout,
+		concurrency: options.maxConcurrentImages
+	};
+}
 function cloneDocument(document) {
 	return JSON.parse(JSON.stringify(document));
 }
@@ -54,17 +60,23 @@ function fontWarnings(fonts) {
 		objectIds: font.objectIds
 	}));
 }
-async function inspectAssets(document, options, signal) {
+async function inspectAssets(document, options, signal, onImageProgress) {
 	const manifest = buildAssetManifest(document.objects);
 	const uniqueImages = [...groupByUrl(findImageReferences(document.objects).filter((reference) => !isEmbeddedUrl(reference.url)))].map(([url, references]) => ({
 		url,
 		crossOrigin: references[0].crossOrigin
 	}));
-	const [missingUrls, unavailableFonts] = await Promise.all([options.checkImages === false ? Promise.resolve([]) : findMissingImages(uniqueImages, signal), findUnavailableFonts(manifest.fonts, options.loadFont)]);
-	const missing = new Set(missingUrls);
+	const [failures, unavailableFonts] = await Promise.all([options.checkImages === false ? Promise.resolve([]) : findMissingImages(uniqueImages, signal, {
+		...imageCheckOptions(options),
+		onProgress: onImageProgress
+	}), findUnavailableFonts(manifest.fonts, options.loadFont)]);
+	const failuresByUrl = new Map(failures.map((failure) => [failure.url, failure]));
 	return {
 		manifest,
-		missingImages: manifest.images.filter((image) => missing.has(image.url)),
+		missingImages: manifest.images.filter((image) => failuresByUrl.has(image.url)).map((image) => ({
+			...image,
+			failure: failuresByUrl.get(image.url)
+		})),
 		unavailableFonts,
 		warnings: [...crossOriginWarnings(document), ...fontWarnings(unavailableFonts)]
 	};
@@ -80,10 +92,10 @@ async function replaceMissingImages(document, missingImages, options, signal) {
 		const replacement = await replace(image);
 		if (typeof replacement === "string" && replacement.length > 0) replacements.set(image.url, replacement);
 	}
-	const brokenReplacements = new Set(await findMissingImages([...replacements.values()].map((url) => ({
+	const brokenReplacements = new Set((await findMissingImages([...replacements.values()].map((url) => ({
 		url,
 		crossOrigin: null
-	})), signal));
+	})), signal, imageCheckOptions(options))).map((failure) => failure.url));
 	const stillMissing = [];
 	const warnings = [];
 	const groups = groupByUrl(findImageReferences(document.objects));
@@ -106,20 +118,20 @@ async function replaceMissingImages(document, missingImages, options, signal) {
 		warnings
 	};
 }
-async function prepareAssetsForLoad(input, options, signal, isAllowedUrl) {
+async function prepareAssetsForLoad(input, options, signal, isAllowedUrl, onImageProgress) {
 	const document = cloneDocument(input);
 	const { resolveUrl } = options;
 	if (resolveUrl) await rewriteUrls(document, async (url) => resolveUrl(url));
 	refuseUnsafeImageUrls(document.objects, isAllowedUrl);
-	const report = await inspectAssets(document, options, signal);
+	const report = await inspectAssets(document, options, signal, onImageProgress);
 	if (options.requireFonts && report.unavailableFonts.length > 0) {
 		const families = report.unavailableFonts.map((font) => font.family).join(", ");
 		throw new DocumentEngineError("MISSING_FONTS", `These fonts are not available: ${families}`, { missingFonts: report.unavailableFonts });
 	}
 	const { stillMissing, warnings } = await replaceMissingImages(document, report.missingImages, options, signal);
 	if (stillMissing.length > 0) {
-		const urls = stillMissing.map((image) => image.url).join(", ");
-		throw new DocumentEngineError("MISSING_ASSETS", `These images could not be loaded: ${urls}`, { missingAssets: stillMissing });
+		const reasons = stillMissing.map((image) => image.failure ? `${image.url} (${image.failure.reason})` : image.url).join(", ");
+		throw new DocumentEngineError("MISSING_ASSETS", `These images could not be loaded: ${reasons}`, { missingAssets: stillMissing });
 	}
 	return {
 		document,

package/dist/assets/font-check.cjs

@@ -29,9 +29,17 @@ function cssFamily(family) {
 function fontDescriptor(font, size = 32) {
 	return `${font.style} ${font.weight} ${size}px ${cssFamily(firstFamily(font.family))}`;
 }
+let measuringContext;
+/** One small canvas for every check, rather than a new one each time. */
 function createMeasuringContext() {
 	if (typeof document === "undefined") return null;
-	return document.createElement("canvas").getContext("2d");
+	if (measuringContext === void 0) {
+		const canvas = document.createElement("canvas");
+		canvas.width = 1;
+		canvas.height = 1;
+		measuringContext = canvas.getContext("2d");
+	}
+	return measuringContext;
 }
 function isFontRenderable(font, context = createMeasuringContext()) {
 	const family = firstFamily(font.family);

package/dist/assets/font-check.js

@@ -29,9 +29,17 @@ function cssFamily(family) {
 function fontDescriptor(font, size = 32) {
 	return `${font.style} ${font.weight} ${size}px ${cssFamily(firstFamily(font.family))}`;
 }
+let measuringContext;
+/** One small canvas for every check, rather than a new one each time. */
 function createMeasuringContext() {
 	if (typeof document === "undefined") return null;
-	return document.createElement("canvas").getContext("2d");
+	if (measuringContext === void 0) {
+		const canvas = document.createElement("canvas");
+		canvas.width = 1;
+		canvas.height = 1;
+		measuringContext = canvas.getContext("2d");
+	}
+	return measuringContext;
 }
 function isFontRenderable(font, context = createMeasuringContext()) {
 	const family = firstFamily(font.family);

package/dist/assets/image-check.cjs

@@ -1,5 +1,7 @@
+const require_concurrency = require("../util/concurrency.cjs");
 let fabric = require("fabric");
 //#region src/assets/image-check.ts
+const DEFAULT_IMAGE_TIMEOUT_MS = 3e4;
 function isCrossOriginUrl(url) {
 	const location = globalThis.location;
 	if (!location || url.startsWith("data:") || url.startsWith("blob:")) return false;
@@ -22,14 +24,94 @@ function isSameUrl(first, second) {
 		return false;
 	}
 }
-async function findMissingImages(images, signal) {
-	const results = await Promise.allSettled(images.map((image) => fabric.util.loadImage(image.url, {
-		signal,
-		crossOrigin: image.crossOrigin ?? null
-	})));
-	return images.filter((_, index) => results[index].status === "rejected").map((image) => image.url);
+function shortUrl(url) {
+	return url.length > 80 ? `${url.slice(0, 77)}...` : url;
+}
+function failure(url, reason, message, extra = {}) {
+	return {
+		url,
+		reason,
+		message: `The image ${shortUrl(url)} ${message}`,
+		...extra
+	};
+}
+async function fetchHeaders(url, init) {
+	const response = await fetch(url, {
+		cache: "no-store",
+		...init
+	});
+	response.body?.cancel().catch(() => void 0);
+	return response;
+}
+/** Works out why an image failed to load, after it already failed. */
+async function explainFailure(image, signal) {
+	const { url } = image;
+	if (url.startsWith("data:")) return failure(url, "DECODE", "is embedded data the browser cannot decode as a picture");
+	if (typeof fetch !== "function") return failure(url, "NETWORK", "could not be loaded");
+	const credentials = image.crossOrigin === "use-credentials" ? "include" : "same-origin";
+	try {
+		const response = await fetchHeaders(url, {
+			mode: "cors",
+			credentials,
+			signal
+		});
+		if (response.ok) return failure(url, "DECODE", "downloaded, but the browser could not decode it as a picture", { status: response.status });
+		if (response.status === 404 || response.status === 410) return failure(url, "NOT_FOUND", `was not found (HTTP ${response.status})`, { status: response.status });
+		return failure(url, "HTTP_ERROR", `could not be downloaded (HTTP ${response.status})`, { status: response.status });
+	} catch {
+		if (signal.aborted) return failure(url, "ABORTED", "stopped loading because the work was cancelled");
+	}
+	if (isCrossOriginUrl(url)) try {
+		await fetchHeaders(url, {
+			mode: "no-cors",
+			signal
+		});
+		if (image.crossOrigin) return failure(url, "CORS", "comes from another site that does not send CORS headers (Access-Control-Allow-Origin) for this page");
+		return failure(url, "NETWORK", "comes from another site that answered, but the browser hides the reason it failed. Check the URL and the server.");
+	} catch {
+		if (signal.aborted) return failure(url, "ABORTED", "stopped loading because the work was cancelled");
+	}
+	return failure(url, "NETWORK", "could not be reached. Check the URL and the network connection.");
+}
+async function checkImage(image, signal, timeoutMs) {
+	const attempt = new AbortController();
+	let timedOut = false;
+	const stop = () => attempt.abort();
+	signal.addEventListener("abort", stop, { once: true });
+	const timer = timeoutMs > 0 && Number.isFinite(timeoutMs) ? setTimeout(() => {
+		timedOut = true;
+		attempt.abort();
+	}, timeoutMs) : void 0;
+	try {
+		if (signal.aborted) attempt.abort();
+		await fabric.util.loadImage(image.url, {
+			signal: attempt.signal,
+			crossOrigin: image.crossOrigin ?? null
+		});
+		return;
+	} catch {
+		if (timedOut) return failure(image.url, "TIMEOUT", `did not finish loading within ${timeoutMs} ms`, { timeoutMs });
+		if (signal.aborted) return failure(image.url, "ABORTED", "stopped loading because the work was cancelled");
+		return explainFailure(image, signal);
+	} finally {
+		if (timer !== void 0) clearTimeout(timer);
+		signal.removeEventListener("abort", stop);
+	}
+}
+/** Loads every image, a few at a time, and returns the ones that failed. */
+async function findMissingImages(images, signal, options = {}) {
+	const timeoutMs = options.timeoutMs ?? 3e4;
+	let done = 0;
+	options.onProgress?.(0, images.length);
+	return (await require_concurrency.mapWithConcurrency(images, options.concurrency ?? 6, async (image) => {
+		const result = await checkImage(image, signal, timeoutMs);
+		done += 1;
+		options.onProgress?.(done, images.length);
+		return result;
+	})).filter((result) => result !== void 0);
 }
 //#endregion
+exports.DEFAULT_IMAGE_TIMEOUT_MS = DEFAULT_IMAGE_TIMEOUT_MS;
 exports.findMissingImages = findMissingImages;
 exports.isCrossOriginUrl = isCrossOriginUrl;
 exports.isPortableUrl = isPortableUrl;

package/dist/assets/image-check.d.cts

@@ -0,0 +1,17 @@
+//#region src/assets/image-check.d.ts
+/**
+ * Why an image could not be loaded. Browsers hide some details on purpose:
+ * a server on another site that sends no CORS headers looks the same as a
+ * network failure unless the image asked for CORS.
+ */
+export type ImageFailureReason = "NOT_FOUND" | "HTTP_ERROR" | "CORS" | "NETWORK" | "TIMEOUT" | "DECODE" | "ABORTED";
+export interface ImageLoadFailure {
+  url: string;
+  reason: ImageFailureReason;
+  message: string;
+  /** The HTTP status, when the browser lets the page read it. */
+  status?: number;
+  /** The time limit that ran out, for `TIMEOUT`. */
+  timeoutMs?: number;
+}
+//#endregion

package/dist/assets/image-check.d.ts

@@ -0,0 +1,17 @@
+//#region src/assets/image-check.d.ts
+/**
+ * Why an image could not be loaded. Browsers hide some details on purpose:
+ * a server on another site that sends no CORS headers looks the same as a
+ * network failure unless the image asked for CORS.
+ */
+export type ImageFailureReason = "NOT_FOUND" | "HTTP_ERROR" | "CORS" | "NETWORK" | "TIMEOUT" | "DECODE" | "ABORTED";
+export interface ImageLoadFailure {
+  url: string;
+  reason: ImageFailureReason;
+  message: string;
+  /** The HTTP status, when the browser lets the page read it. */
+  status?: number;
+  /** The time limit that ran out, for `TIMEOUT`. */
+  timeoutMs?: number;
+}
+//#endregion

package/dist/assets/image-check.js

@@ -1,5 +1,7 @@
+import { mapWithConcurrency } from "../util/concurrency.js";
 import { util } from "fabric";
 //#region src/assets/image-check.ts
+const DEFAULT_IMAGE_TIMEOUT_MS = 3e4;
 function isCrossOriginUrl(url) {
 	const location = globalThis.location;
 	if (!location || url.startsWith("data:") || url.startsWith("blob:")) return false;
@@ -22,12 +24,91 @@ function isSameUrl(first, second) {
 		return false;
 	}
 }
-async function findMissingImages(images, signal) {
-	const results = await Promise.allSettled(images.map((image) => util.loadImage(image.url, {
-		signal,
-		crossOrigin: image.crossOrigin ?? null
-	})));
-	return images.filter((_, index) => results[index].status === "rejected").map((image) => image.url);
+function shortUrl(url) {
+	return url.length > 80 ? `${url.slice(0, 77)}...` : url;
+}
+function failure(url, reason, message, extra = {}) {
+	return {
+		url,
+		reason,
+		message: `The image ${shortUrl(url)} ${message}`,
+		...extra
+	};
+}
+async function fetchHeaders(url, init) {
+	const response = await fetch(url, {
+		cache: "no-store",
+		...init
+	});
+	response.body?.cancel().catch(() => void 0);
+	return response;
+}
+/** Works out why an image failed to load, after it already failed. */
+async function explainFailure(image, signal) {
+	const { url } = image;
+	if (url.startsWith("data:")) return failure(url, "DECODE", "is embedded data the browser cannot decode as a picture");
+	if (typeof fetch !== "function") return failure(url, "NETWORK", "could not be loaded");
+	const credentials = image.crossOrigin === "use-credentials" ? "include" : "same-origin";
+	try {
+		const response = await fetchHeaders(url, {
+			mode: "cors",
+			credentials,
+			signal
+		});
+		if (response.ok) return failure(url, "DECODE", "downloaded, but the browser could not decode it as a picture", { status: response.status });
+		if (response.status === 404 || response.status === 410) return failure(url, "NOT_FOUND", `was not found (HTTP ${response.status})`, { status: response.status });
+		return failure(url, "HTTP_ERROR", `could not be downloaded (HTTP ${response.status})`, { status: response.status });
+	} catch {
+		if (signal.aborted) return failure(url, "ABORTED", "stopped loading because the work was cancelled");
+	}
+	if (isCrossOriginUrl(url)) try {
+		await fetchHeaders(url, {
+			mode: "no-cors",
+			signal
+		});
+		if (image.crossOrigin) return failure(url, "CORS", "comes from another site that does not send CORS headers (Access-Control-Allow-Origin) for this page");
+		return failure(url, "NETWORK", "comes from another site that answered, but the browser hides the reason it failed. Check the URL and the server.");
+	} catch {
+		if (signal.aborted) return failure(url, "ABORTED", "stopped loading because the work was cancelled");
+	}
+	return failure(url, "NETWORK", "could not be reached. Check the URL and the network connection.");
+}
+async function checkImage(image, signal, timeoutMs) {
+	const attempt = new AbortController();
+	let timedOut = false;
+	const stop = () => attempt.abort();
+	signal.addEventListener("abort", stop, { once: true });
+	const timer = timeoutMs > 0 && Number.isFinite(timeoutMs) ? setTimeout(() => {
+		timedOut = true;
+		attempt.abort();
+	}, timeoutMs) : void 0;
+	try {
+		if (signal.aborted) attempt.abort();
+		await util.loadImage(image.url, {
+			signal: attempt.signal,
+			crossOrigin: image.crossOrigin ?? null
+		});
+		return;
+	} catch {
+		if (timedOut) return failure(image.url, "TIMEOUT", `did not finish loading within ${timeoutMs} ms`, { timeoutMs });
+		if (signal.aborted) return failure(image.url, "ABORTED", "stopped loading because the work was cancelled");
+		return explainFailure(image, signal);
+	} finally {
+		if (timer !== void 0) clearTimeout(timer);
+		signal.removeEventListener("abort", stop);
+	}
+}
+/** Loads every image, a few at a time, and returns the ones that failed. */
+async function findMissingImages(images, signal, options = {}) {
+	const timeoutMs = options.timeoutMs ?? 3e4;
+	let done = 0;
+	options.onProgress?.(0, images.length);
+	return (await mapWithConcurrency(images, options.concurrency ?? 6, async (image) => {
+		const result = await checkImage(image, signal, timeoutMs);
+		done += 1;
+		options.onProgress?.(done, images.length);
+		return result;
+	})).filter((result) => result !== void 0);
 }
 //#endregion
-export { findMissingImages, isCrossOriginUrl, isPortableUrl, isSameUrl };
+export { DEFAULT_IMAGE_TIMEOUT_MS, findMissingImages, isCrossOriginUrl, isPortableUrl, isSameUrl };

package/dist/commands/clipboard.cjs

@@ -0,0 +1,136 @@
+const require_errors = require("../engine/errors.cjs");
+const require_content_limits = require("../security/content-limits.cjs");
+const require_object_ids = require("../fabric/object-ids.cjs");
+const require_walk_objects = require("../fabric/walk-objects.cjs");
+const require_fabric_adapter = require("../fabric/fabric-adapter.cjs");
+let fabric = require("fabric");
+//#region src/commands/clipboard.ts
+const CLIPBOARD_FORMAT = "fabricjs-document-engine/objects";
+function clone(value) {
+	return JSON.parse(JSON.stringify(value));
+}
+/** Removes every id, so the engine gives each pasted object, child and clip path a new one. */
+function withoutIds(object) {
+	const copy = { ...object };
+	delete copy.id;
+	if (Array.isArray(copy.objects)) copy.objects = copy.objects.map(withoutIds);
+	if (copy.clipPath && typeof copy.clipPath === "object") copy.clipPath = withoutIds(copy.clipPath);
+	return copy;
+}
+function moved(object, distance) {
+	const left = typeof object.left === "number" ? object.left : 0;
+	const top = typeof object.top === "number" ? object.top : 0;
+	return {
+		...object,
+		left: left + distance,
+		top: top + distance
+	};
+}
+function refuseInvalidContent(message) {
+	throw new require_errors.DocumentEngineError("INVALID_DOCUMENT", `The clipboard content is not valid: ${message}`);
+}
+function checkContent(content, limits) {
+	if (typeof content !== "object" || content === null) refuseInvalidContent("it is not an object");
+	const candidate = content;
+	if (candidate.format !== "fabricjs-document-engine/objects") refuseInvalidContent(`its format is not "${CLIPBOARD_FORMAT}"`);
+	if (candidate.version !== 1) refuseInvalidContent("its version is not 1");
+	if (!Array.isArray(candidate.objects)) refuseInvalidContent("it has no objects list");
+	const secured = require_content_limits.secureDocument({ objects: candidate.objects }, limits);
+	const objects = secured.objects.filter((object) => typeof object === "object" && object !== null && typeof object.type === "string");
+	if (objects.length !== secured.objects.length) refuseInvalidContent("every object needs a type");
+	require_content_limits.refuseUnsafeImageUrls(objects, limits?.isAllowedUrl);
+	return {
+		format: CLIPBOARD_FORMAT,
+		version: 1,
+		objects
+	};
+}
+function topLevelInOrder(engine, objects) {
+	const stack = engine.canvas.getObjects();
+	const wanted = new Set(objects);
+	return stack.filter((object) => wanted.has(object));
+}
+function selectionOf(engine) {
+	return engine.canvas.getActiveObjects?.() ?? [];
+}
+function refuseUnknownTypes(objects) {
+	const unknownTypes = [...require_walk_objects.collectSerializedTypes(objects)].filter((type) => !fabric.classRegistry.has(type));
+	if (unknownTypes.length === 0) return;
+	throw new require_errors.DocumentEngineError("UNKNOWN_OBJECT_TYPE", `The clipboard holds object types that are not registered: ${unknownTypes.join(", ")}`, { unknownTypes });
+}
+function select(engine, objects) {
+	const canvas = engine.canvas;
+	if (typeof canvas.setActiveObject !== "function" || objects.length === 0) return;
+	canvas.discardActiveObject?.();
+	canvas.setActiveObject(objects.length === 1 ? objects[0] : new fabric.ActiveSelection(objects, { canvas: engine.canvas }));
+}
+/**
+* A clipboard for one engine. Copies keep custom properties and the exact
+* position of objects in groups and selections; pastes get fresh ids for
+* every object and child and count as one undo step.
+*/
+function createClipboard(engine, options = {}) {
+	const defaultOffset = options.offset ?? 10;
+	let content;
+	let pastes = 0;
+	function copyObjects(objects) {
+		const chosen = topLevelInOrder(engine, objects);
+		if (chosen.length === 0) return 0;
+		const document = engine.toDocument();
+		const serialized = chosen.map((object) => require_object_ids.readObjectId(object)).map((id) => document.objects.find((object) => object.id === id)).filter((object) => object !== void 0);
+		content = {
+			format: CLIPBOARD_FORMAT,
+			version: 1,
+			objects: clone(serialized)
+		};
+		return serialized.length;
+	}
+	return {
+		copy(objects) {
+			const count = copyObjects(objects ?? selectionOf(engine));
+			if (count > 0) pastes = 0;
+			return count;
+		},
+		cut(objects) {
+			const chosen = topLevelInOrder(engine, objects ?? selectionOf(engine));
+			const count = copyObjects(chosen);
+			if (count === 0) return 0;
+			pastes = -1;
+			engine.transaction(count === 1 ? "Cut" : `Cut ${count} objects`, () => {
+				engine.canvas.discardActiveObject?.();
+				engine.canvas.remove(...chosen);
+			});
+			engine.canvas.requestRenderAll();
+			return count;
+		},
+		async paste(pasteOptions = {}) {
+			if (!content) return [];
+			const target = pasteOptions.target ?? engine;
+			const offset = pasteOptions.offset ?? defaultOffset;
+			pastes += 1;
+			const distance = offset * pastes;
+			const serialized = content.objects.map((object) => moved(withoutIds(object), distance));
+			refuseUnknownTypes(serialized);
+			const created = await require_fabric_adapter.createObjects(clone(serialized));
+			target.transaction(created.length === 1 ? "Paste" : `Paste ${created.length} objects`, () => {
+				target.canvas.add(...created);
+			});
+			if (pasteOptions.select ?? true) select(target, created);
+			target.canvas.requestRenderAll();
+			return created;
+		},
+		hasContent: () => content !== void 0,
+		read: () => content ? clone(content) : void 0,
+		write(next) {
+			content = checkContent(next, options.limits);
+			pastes = 0;
+		},
+		clear() {
+			content = void 0;
+			pastes = 0;
+		}
+	};
+}
+//#endregion
+exports.CLIPBOARD_FORMAT = CLIPBOARD_FORMAT;
+exports.createClipboard = createClipboard;