@overtone-art/canvas-editor-core 0.2.6 → 0.2.8

package/dist/node.js

@@ -0,0 +1,814 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/displacement.ts
+function finiteScale(value, fallback, label) {
+  const resolved = value ?? fallback;
+  if (!Number.isFinite(resolved)) throw new Error(`${label} must be finite`);
+  return resolved;
+}
+function sample(source, width, height, x, y, channel) {
+  const clampedX = Math.max(0, Math.min(width - 1, x));
+  const clampedY = Math.max(0, Math.min(height - 1, y));
+  const x0 = Math.floor(clampedX);
+  const y0 = Math.floor(clampedY);
+  const x1 = Math.min(width - 1, x0 + 1);
+  const y1 = Math.min(height - 1, y0 + 1);
+  const tx = clampedX - x0;
+  const ty = clampedY - y0;
+  const top = source[(y0 * width + x0) * 4 + channel] * (1 - tx) + source[(y0 * width + x1) * 4 + channel] * tx;
+  const bottom = source[(y1 * width + x0) * 4 + channel] * (1 - tx) + source[(y1 * width + x1) * 4 + channel] * tx;
+  return top * (1 - ty) + bottom * ty;
+}
+function displaceRgba(source, map, width, height, options) {
+  if (!Number.isInteger(width) || !Number.isInteger(height) || width <= 0 || height <= 0) {
+    throw new Error("Displacement dimensions must be positive integers");
+  }
+  const expectedLength = width * height * 4;
+  if (source.length !== expectedLength || map.length !== expectedLength) {
+    throw new Error("Displacement source and map must match the requested dimensions");
+  }
+  const scaleX = finiteScale(options.scaleX, 10, "Displacement scaleX");
+  const scaleY = finiteScale(options.scaleY, 10, "Displacement scaleY");
+  const channelX = CHANNEL_INDEX[options.channelX ?? "red"];
+  const channelY = CHANNEL_INDEX[options.channelY ?? "green"];
+  const output = new Uint8ClampedArray(expectedLength);
+  for (let y = 0; y < height; y += 1) {
+    for (let x = 0; x < width; x += 1) {
+      const offset = (y * width + x) * 4;
+      const sourceX = x + (map[offset + channelX] - 128) / 127 * scaleX;
+      const sourceY = y + (map[offset + channelY] - 128) / 127 * scaleY;
+      for (let channel = 0; channel < 4; channel += 1) {
+        output[offset + channel] = Math.round(
+          sample(source, width, height, sourceX, sourceY, channel)
+        );
+      }
+    }
+  }
+  return output;
+}
+var CHANNEL_INDEX;
+var init_displacement = __esm({
+  "src/displacement.ts"() {
+    "use strict";
+    CHANNEL_INDEX = {
+      red: 0,
+      green: 1,
+      blue: 2,
+      alpha: 3
+    };
+  }
+});
+
+// src/export.ts
+function computePrintAreaClip(area, scaleX, scaleY, targetWidth, targetHeight) {
+  const left = Math.max(0, Math.min(targetWidth, area.left * scaleX));
+  const top = Math.max(0, Math.min(targetHeight, area.top * scaleY));
+  const right = Math.max(left, Math.min(targetWidth, (area.left + area.width) * scaleX));
+  const bottom = Math.max(top, Math.min(targetHeight, (area.top + area.height) * scaleY));
+  return { left, top, width: right - left, height: bottom - top };
+}
+function computeCoverPlacement(sourceWidth, sourceHeight, targetWidth, targetHeight) {
+  if (sourceWidth <= 0 || sourceHeight <= 0 || targetWidth <= 0 || targetHeight <= 0) {
+    throw new Error("Cover dimensions must be positive");
+  }
+  const scale = Math.max(targetWidth / sourceWidth, targetHeight / sourceHeight);
+  const width = sourceWidth * scale;
+  const height = sourceHeight * scale;
+  return {
+    left: (targetWidth - width) / 2,
+    top: (targetHeight - height) / 2,
+    width,
+    height
+  };
+}
+var import_fabric;
+var init_export = __esm({
+  "src/export.ts"() {
+    "use strict";
+    import_fabric = require("fabric");
+    init_displacement();
+  }
+});
+
+// src/print.ts
+function svgAttributes(source) {
+  return Object.fromEntries(
+    [...source.matchAll(/([\w:-]+)=(?:"([^"]*)"|'([^']*)')/g)].map((match) => [
+      match[1],
+      match[2] ?? match[3] ?? ""
+    ])
+  );
+}
+function decodeXmlText(source) {
+  return source.replace(/<[^>]+>/g, "").replace(
+    /&#x([\da-f]+);/gi,
+    (_, value) => String.fromCodePoint(Number.parseInt(value, 16))
+  ).replace(/&#(\d+);/g, (_, value) => String.fromCodePoint(Number(value))).replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+}
+function escapeXmlAttribute(value) {
+  return value.replace(/[<>&"']/g, (character) => `&#${character.charCodeAt(0)};`);
+}
+function fontSource(files, family, bold, italic) {
+  const suffix = bold && italic ? "-BoldItalic" : bold ? "-Bold" : italic ? "-Italic" : "";
+  const own = (key) => Object.hasOwn(files, key) ? files[key] : void 0;
+  return own(`${family}${suffix}`) ?? own(family);
+}
+async function outlineSvgText(svg, files, outlined) {
+  const fontkit = await import("fontkit");
+  let output = "";
+  let cursor = 0;
+  for (const textMatch of svg.matchAll(/<text\b([^>]*)>([\s\S]*?)<\/text>/gi)) {
+    const index = textMatch.index ?? 0;
+    output += svg.slice(cursor, index);
+    cursor = index + textMatch[0].length;
+    const textAttributes = svgAttributes(textMatch[1]);
+    const spans = [...textMatch[2].matchAll(/<tspan\b([^>]*)>([\s\S]*?)<\/tspan>/gi)];
+    const lines = spans.length ? spans.map((span) => ({ attributes: svgAttributes(span[1]), text: decodeXmlText(span[2]) })) : [{ attributes: textAttributes, text: decodeXmlText(textMatch[2]) }];
+    const resolved = lines.map((line) => {
+      const attributes = { ...textAttributes, ...line.attributes };
+      const family = attributes["font-family"] ?? "sans-serif";
+      const bold = /bold|[6-9]00/i.test(attributes["font-weight"] ?? "");
+      const italic = /italic|oblique/i.test(attributes["font-style"] ?? "");
+      return { ...line, attributes, family, source: fontSource(files, family, bold, italic) };
+    });
+    if (resolved.some((line) => !line.source)) {
+      output += textMatch[0];
+      continue;
+    }
+    const paths = [];
+    for (const line of resolved) {
+      const source = line.source;
+      const opened = typeof source === "string" ? fontkit.openSync(source) : fontkit.create(Buffer.from(source.buffer, source.byteOffset, source.byteLength));
+      if (!("layout" in opened)) {
+        throw new Error(`Font collection requires a named face: ${line.family}`);
+      }
+      const size = Number.parseFloat(line.attributes["font-size"] ?? "16");
+      const scale = size / opened.unitsPerEm;
+      const style = line.attributes.style ?? "";
+      const run = opened.layout(line.text);
+      let penX = Number.parseFloat(line.attributes.x ?? "0");
+      const baseline = Number.parseFloat(line.attributes.y ?? "0");
+      run.glyphs.forEach((glyph, glyphIndex) => {
+        const position = run.positions[glyphIndex];
+        const x = penX + position.xOffset * scale;
+        const y = baseline - position.yOffset * scale;
+        paths.push(
+          `<path d="${glyph.path.toSVG()}" transform="translate(${x} ${y}) scale(${scale} ${-scale})" style="${escapeXmlAttribute(style)}"/>`
+        );
+        penX += position.xAdvance * scale;
+      });
+      outlined.add(line.family);
+    }
+    output += `<g data-outlined-font="${escapeXmlAttribute([...new Set(resolved.map((line) => line.family))].join(","))}">${paths.join("")}</g>`;
+  }
+  return output + svg.slice(cursor);
+}
+function rgbToCmyk([redByte, greenByte, blueByte]) {
+  const red = redByte / 255;
+  const green = greenByte / 255;
+  const blue = blueByte / 255;
+  const black = 1 - Math.max(red, green, blue);
+  if (black >= 1) return [0, 0, 0, 100];
+  return [
+    (1 - red - black) / (1 - black) * 100,
+    (1 - green - black) / (1 - black) * 100,
+    (1 - blue - black) / (1 - black) * 100,
+    black * 100
+  ];
+}
+async function imageSourceBytes(source, allow) {
+  if (source.startsWith("data:")) {
+    const response2 = await fetch(source);
+    if (!response2.ok) throw new Error("Failed to decode an embedded SVG image");
+    return new Uint8Array(await response2.arrayBuffer());
+  }
+  const permitted = allow ? allow(source) : (() => {
+    try {
+      return ["http:", "https:"].includes(new URL(source).protocol);
+    } catch {
+      return false;
+    }
+  })();
+  if (!permitted) throw new Error(`Blocked disallowed vector image URL: ${source}`);
+  const response = await fetch(source);
+  if (!response.ok) throw new Error(`Failed to load vector image: ${source}`);
+  return new Uint8Array(await response.arrayBuffer());
+}
+async function convertSvgImagesToCmyk(svg, sharp, profile, allow) {
+  const sources = /* @__PURE__ */ new Set();
+  for (const image of svg.matchAll(/<image\b[^>]*(?:xlink:href|href)="([^"]+)"[^>]*>/gi)) {
+    if (image[1]) sources.add(image[1]);
+  }
+  let converted = svg;
+  for (const source of sources) {
+    const bytes = await imageSourceBytes(source, allow);
+    const jpeg = await sharp(bytes).flatten({ background: "#ffffff" }).toColourspace("cmyk").withIccProfile(profile).jpeg({ quality: 100, chromaSubsampling: "4:4:4" }).toBuffer();
+    const dataUrl = `data:image/jpeg;base64,${jpeg.toString("base64")}`;
+    converted = converted.split(source).join(dataUrl);
+  }
+  return converted;
+}
+async function renderVectorOverlay(state, options, width, height, sharp, warnings, outlinedFonts, unoutlinedFonts) {
+  const [{ default: PDFKit }, { default: SVGtoPDF }, { renderEditorState: renderEditorState2 }] = await Promise.all([
+    import("pdfkit"),
+    import("svg-to-pdfkit"),
+    Promise.resolve().then(() => (init_node(), node_exports))
+  ]);
+  const rendered = await renderEditorState2(
+    { ...state, background: "#ffffff" },
+    {
+      format: "svg",
+      allowImageUrl: options.allowImageUrl
+    }
+  );
+  if (typeof rendered.data !== "string") throw new Error("Vector rendering returned raster data");
+  const fontFiles = options.fontFiles ?? {};
+  const outlinedSvg = options.outlineFonts === false ? rendered.data : await outlineSvgText(rendered.data, fontFiles, outlinedFonts);
+  const svg = await convertSvgImagesToCmyk(
+    outlinedSvg,
+    sharp,
+    options.iccProfile ?? "cmyk",
+    options.allowImageUrl
+  );
+  const remainingText = [...svg.matchAll(/<text\b([^>]*)>/gi)].map(
+    (match) => svgAttributes(match[1])
+  );
+  for (const attributes of remainingText) {
+    const family = attributes["font-family"] ?? "sans-serif";
+    unoutlinedFonts.add(family);
+    const bold = /bold|[6-9]00/i.test(attributes["font-weight"] ?? "");
+    const italic = /italic|oblique/i.test(attributes["font-style"] ?? "");
+    if (!fontSource(fontFiles, family, bold, italic)) {
+      warnings.push(
+        `Font "${family}" used a PDF standard fallback; supply fontFiles for exact embedding`
+      );
+    }
+  }
+  const document = new PDFKit({ autoFirstPage: false, compress: false, pdfVersion: "1.7" });
+  for (const [name, path] of Object.entries(fontFiles)) {
+    document.registerFont(name, typeof path === "string" ? path : Buffer.from(path));
+  }
+  document.addPage({ size: [width, height], margin: 0 });
+  SVGtoPDF(document, svg, 0, 0, {
+    width,
+    height,
+    preserveAspectRatio: "none",
+    colorCallback: (color) => {
+      const [rgb, opacity] = color;
+      return [rgbToCmyk(rgb), opacity];
+    },
+    warningCallback: (warning) => warnings.push(`Vector render: ${warning}`)
+  });
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    document.on("data", (chunk) => chunks.push(chunk));
+    document.on("error", reject);
+    document.on("end", () => resolve(new Uint8Array(Buffer.concat(chunks))));
+    document.end();
+  });
+}
+function positive(value, label) {
+  if (!Number.isFinite(value) || value <= 0) throw new Error(`${label} must be positive`);
+  return value;
+}
+function boundedDpi(value, label) {
+  const dpi = positive(value, label);
+  if (dpi > MAX_DPI) throw new Error(`${label} must not exceed ${MAX_DPI}`);
+  if (dpi < 1) throw new Error(`${label} must be at least 1`);
+  return dpi;
+}
+function nonNegative(value, label) {
+  if (!Number.isFinite(value) || value < 0) throw new Error(`${label} cannot be negative`);
+  return value;
+}
+function preflightSafeArea(state, safePixels) {
+  if (safePixels <= 0) return [];
+  const right = state.canvas.width - safePixels;
+  const bottom = state.canvas.height - safePixels;
+  const warnings = [];
+  for (const layer of state.layers) {
+    if (!layer.visible) continue;
+    const object = layer.fabricObject;
+    const left = Number(object.left ?? 0);
+    const top = Number(object.top ?? 0);
+    const width = Number(object.width ?? 0) * Math.abs(Number(object.scaleX ?? 1));
+    const height = Number(object.height ?? 0) * Math.abs(Number(object.scaleY ?? 1));
+    if (left < safePixels || top < safePixels || left + width > right || top + height > bottom) {
+      warnings.push(`Layer "${layer.name}" extends outside the configured safe area`);
+    }
+  }
+  return warnings;
+}
+async function renderPrintPdf(state, options = {}) {
+  const dpi = boundedDpi(options.dpi ?? state.canvas.dpi ?? 300, "Print DPI");
+  const documentDpi = boundedDpi(state.canvas.dpi ?? 72, "Document DPI");
+  const maxPixels = positive(options.maxPixels ?? DEFAULT_MAX_PIXELS, "Max pixels");
+  const bleedInches = nonNegative(options.bleed ?? 0.125, "Bleed");
+  const marksMarginInches = nonNegative(options.marksMargin ?? 0.25, "Marks margin");
+  const safeAreaInches = nonNegative(options.safeArea ?? 0, "Safe area");
+  const rendering = options.rendering ?? "vector";
+  const bleedPixels = Math.round(bleedInches * dpi);
+  const trimWidthPoints = state.canvas.width / documentDpi * 72;
+  const trimHeightPoints = state.canvas.height / documentDpi * 72;
+  const bleedPoints = bleedInches * 72;
+  const marksMarginPoints = marksMarginInches * 72;
+  const scale = dpi / documentDpi;
+  const outputPixels = Math.round(state.canvas.width * scale + bleedPixels * 2) * Math.round(state.canvas.height * scale + bleedPixels * 2);
+  if (!Number.isFinite(outputPixels) || outputPixels > maxPixels) {
+    throw new Error(
+      `Print raster of ${outputPixels} pixels exceeds the ${maxPixels} pixel budget; lower the DPI or raise maxPixels`
+    );
+  }
+  const [{ default: sharp }, pdfLib] = await Promise.all([import("sharp"), import("pdf-lib")]);
+  const { renderEditorState: renderEditorState2 } = await Promise.resolve().then(() => (init_node(), node_exports));
+  const rendered = await renderEditorState2(state, {
+    format: "png",
+    multiplier: scale,
+    allowImageUrl: options.allowImageUrl
+  });
+  if (typeof rendered.data === "string") throw new Error("Print rasterization returned SVG data");
+  let pipeline = sharp(rendered.data).flatten({ background: "#ffffff" });
+  if (bleedPixels > 0) {
+    pipeline = pipeline.extend({
+      top: bleedPixels,
+      right: bleedPixels,
+      bottom: bleedPixels,
+      left: bleedPixels,
+      extendWith: "copy"
+    });
+  }
+  const { data: cmykJpeg, info } = await pipeline.toColourspace("cmyk").withIccProfile(options.iccProfile ?? "cmyk").withDensity(dpi).jpeg({ quality: 100, chromaSubsampling: "4:4:4" }).toBuffer({ resolveWithObject: true });
+  const metadata = await sharp(cmykJpeg).metadata();
+  if (info.channels !== 4 || metadata.space !== "cmyk" || !metadata.icc) {
+    throw new Error("CMYK conversion did not produce a four-channel image with an ICC profile");
+  }
+  const { PDFDocument, PDFDict, PDFName, PDFString, cmyk } = pdfLib;
+  const document = await PDFDocument.create();
+  const title = options.title ?? "Overtone Canvas Editor print export";
+  document.setTitle(title);
+  document.setCreator("@overtone-art/canvas-editor-core");
+  document.setProducer("@overtone-art/canvas-editor-core");
+  const pageWidth = trimWidthPoints + bleedPoints * 2 + marksMarginPoints * 2;
+  const pageHeight = trimHeightPoints + bleedPoints * 2 + marksMarginPoints * 2;
+  const page = document.addPage([pageWidth, pageHeight]);
+  const image = await document.embedJpg(cmykJpeg);
+  page.drawImage(image, {
+    x: marksMarginPoints,
+    y: marksMarginPoints,
+    width: trimWidthPoints + bleedPoints * 2,
+    height: trimHeightPoints + bleedPoints * 2
+  });
+  const trimLeft = marksMarginPoints + bleedPoints;
+  const trimBottom = marksMarginPoints + bleedPoints;
+  const trimRight = trimLeft + trimWidthPoints;
+  const trimTop = trimBottom + trimHeightPoints;
+  const warnings = preflightSafeArea(state, safeAreaInches * documentDpi);
+  const outlinedFonts = /* @__PURE__ */ new Set();
+  const unoutlinedFonts = /* @__PURE__ */ new Set();
+  if (rendering === "vector") {
+    const vectorPdf = await renderVectorOverlay(
+      state,
+      options,
+      trimWidthPoints,
+      trimHeightPoints,
+      sharp,
+      warnings,
+      outlinedFonts,
+      unoutlinedFonts
+    );
+    const [vectorPage] = await document.embedPdf(vectorPdf);
+    page.drawPage(vectorPage, {
+      x: trimLeft,
+      y: trimBottom,
+      width: trimWidthPoints,
+      height: trimHeightPoints
+    });
+  }
+  const bleedLeft = marksMarginPoints;
+  const bleedBottom = marksMarginPoints;
+  const bleedRight = pageWidth - marksMarginPoints;
+  const bleedTop = pageHeight - marksMarginPoints;
+  const context = document.context;
+  page.node.set(PDFName.of("TrimBox"), context.obj([trimLeft, trimBottom, trimRight, trimTop]));
+  page.node.set(
+    PDFName.of("BleedBox"),
+    context.obj([bleedLeft, bleedBottom, bleedRight, bleedTop])
+  );
+  page.node.set(PDFName.of("ArtBox"), context.obj([trimLeft, trimBottom, trimRight, trimTop]));
+  const markColour = cmyk(0, 0, 0, 1);
+  if (options.trimMarks !== false) {
+    const offset = Math.max(3, bleedPoints / 2);
+    const length = Math.max(9, marksMarginPoints - 3);
+    for (const x of [trimLeft, trimRight]) {
+      page.drawLine({
+        start: { x, y: trimBottom - offset },
+        end: { x, y: trimBottom - offset - length },
+        thickness: 0.5,
+        color: markColour
+      });
+      page.drawLine({
+        start: { x, y: trimTop + offset },
+        end: { x, y: trimTop + offset + length },
+        thickness: 0.5,
+        color: markColour
+      });
+    }
+    for (const y of [trimBottom, trimTop]) {
+      page.drawLine({
+        start: { x: trimLeft - offset, y },
+        end: { x: trimLeft - offset - length, y },
+        thickness: 0.5,
+        color: markColour
+      });
+      page.drawLine({
+        start: { x: trimRight + offset, y },
+        end: { x: trimRight + offset + length, y },
+        thickness: 0.5,
+        color: markColour
+      });
+    }
+  }
+  if (options.registrationMarks !== false) {
+    for (const [x, y] of [
+      [pageWidth / 2, marksMarginPoints / 2],
+      [pageWidth / 2, pageHeight - marksMarginPoints / 2],
+      [marksMarginPoints / 2, pageHeight / 2],
+      [pageWidth - marksMarginPoints / 2, pageHeight / 2]
+    ]) {
+      page.drawCircle({ x, y, size: 4, borderWidth: 0.5, borderColor: markColour });
+      page.drawLine({
+        start: { x: x - 6, y },
+        end: { x: x + 6, y },
+        thickness: 0.5,
+        color: markColour
+      });
+      page.drawLine({
+        start: { x, y: y - 6 },
+        end: { x, y: y + 6 },
+        thickness: 0.5,
+        color: markColour
+      });
+    }
+  }
+  const profileStream = context.flateStream(metadata.icc, {
+    N: 4,
+    Alternate: PDFName.of("DeviceCMYK")
+  });
+  const profileRef = context.register(profileStream);
+  const outputIntent = context.obj({
+    Type: PDFName.of("OutputIntent"),
+    S: PDFName.of("GTS_PDFX"),
+    OutputConditionIdentifier: PDFString.of(options.outputConditionIdentifier ?? "CMYK"),
+    RegistryName: PDFString.of("https://www.color.org"),
+    Info: PDFString.of(options.outputConditionIdentifier ?? "CMYK print condition"),
+    DestOutputProfile: profileRef
+  });
+  document.catalog.set(PDFName.of("OutputIntents"), context.obj([context.register(outputIntent)]));
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const xmp = `<?xpacket begin="\uFEFF" id="W5M0MpCehiHzreSzNTczkc9d"?>
+<x:xmpmeta xmlns:x="adobe:ns:meta/"><rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
+<rdf:Description rdf:about="" xmlns:pdfxid="http://www.npes.org/pdfx/ns/id/" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:xmp="http://ns.adobe.com/xap/1.0/" pdfxid:GTS_PDFXVersion="PDF/X-4" xmp:CreateDate="${now}"><dc:title><rdf:Alt><rdf:li xml:lang="x-default">${title.replace(/[<>&]/g, "")}</rdf:li></rdf:Alt></dc:title></rdf:Description>
+</rdf:RDF></x:xmpmeta><?xpacket end="w"?>`;
+  const metadataStream = context.flateStream(new TextEncoder().encode(xmp), {
+    Type: PDFName.of("Metadata"),
+    Subtype: PDFName.of("XML")
+  });
+  document.catalog.set(PDFName.of("Metadata"), context.register(metadataStream));
+  const infoRef = context.trailerInfo.Info;
+  if (infoRef) {
+    const infoDict = context.lookup(infoRef, PDFDict);
+    infoDict.set(PDFName.of("GTS_PDFXVersion"), PDFString.of("PDF/X-4"));
+    infoDict.set(PDFName.of("Trapped"), PDFName.of("False"));
+  }
+  return {
+    format: "pdf",
+    mimeType: "application/pdf",
+    data: await document.save({ useObjectStreams: false }),
+    standard: "PDF/X-4",
+    colourSpace: "CMYK",
+    rendering,
+    outlinedFonts: [...outlinedFonts].sort(),
+    unoutlinedFonts: [...unoutlinedFonts].sort(),
+    dpi,
+    trimWidthPoints,
+    trimHeightPoints,
+    bleedPoints,
+    warnings
+  };
+}
+var MAX_DPI, DEFAULT_MAX_PIXELS;
+var init_print = __esm({
+  "src/print.ts"() {
+    "use strict";
+    MAX_DPI = 2400;
+    DEFAULT_MAX_PIXELS = 25e7;
+  }
+});
+
+// src/node.ts
+var node_exports = {};
+__export(node_exports, {
+  renderEditorState: () => renderEditorState,
+  renderEditorStateBatch: () => renderEditorStateBatch,
+  renderMockupState: () => renderMockupState,
+  renderMockupStateBatch: () => renderMockupStateBatch,
+  renderPrintPdf: () => renderPrintPdf
+});
+module.exports = __toCommonJS(node_exports);
+function defaultAllowImageUrl(url) {
+  const scheme = /^([a-z][a-z\d+.-]*):/i.exec(url.trim());
+  return scheme !== null && ALLOWED_PROTOCOLS.has(`${scheme[1].toLowerCase()}:`);
+}
+function assertImageUrlsAllowed(value, allow) {
+  if (Array.isArray(value)) {
+    for (const item of value) assertImageUrlsAllowed(item, allow);
+    return;
+  }
+  if (!value || typeof value !== "object") return;
+  for (const [key, entry] of Object.entries(value)) {
+    if (typeof entry === "string") {
+      if (URL_KEYS.has(key) && !allow(entry)) {
+        throw new Error(`Blocked disallowed image URL: ${entry.slice(0, 120)}`);
+      }
+    } else {
+      assertImageUrlsAllowed(entry, allow);
+    }
+  }
+}
+function validateState(state) {
+  if (!state?.canvas || !Array.isArray(state.layers) || !Number.isFinite(state.canvas.width) || !Number.isFinite(state.canvas.height) || state.canvas.width <= 0 || state.canvas.height <= 0) {
+    throw new Error("Invalid editor state");
+  }
+  const major = Number.parseInt(state.version?.split(".")[0] ?? "1", 10);
+  if (!Number.isFinite(major) || major > 2) {
+    throw new Error(`Unsupported editor state version: ${state.version}`);
+  }
+}
+function dataUrlBytes(dataUrl) {
+  const encoded = dataUrl.slice(dataUrl.indexOf(",") + 1);
+  const binary = atob(encoded);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index);
+  return bytes;
+}
+function validateOptions(options) {
+  const format = options.format ?? "png";
+  const multiplier = options.multiplier ?? 1;
+  const quality = options.quality ?? 1;
+  const allowImageUrl = options.allowImageUrl ?? defaultAllowImageUrl;
+  if (!Number.isFinite(multiplier) || multiplier <= 0) {
+    throw new Error("Render multiplier must be positive");
+  }
+  if (!Number.isFinite(quality) || quality < 0 || quality > 1) {
+    throw new Error("Render quality must be between 0 and 1");
+  }
+  return { format, multiplier, quality, allowImageUrl };
+}
+async function createStateCanvas(state, transparent = false) {
+  const canvas = new import_node.StaticCanvas(void 0, {
+    width: state.canvas.width,
+    height: state.canvas.height,
+    backgroundColor: transparent ? "" : state.background ?? "",
+    preserveObjectStacking: true
+  });
+  try {
+    if (!transparent && state.backgroundImage) {
+      canvas.backgroundImage = (await import_node.util.enlivenObjects([state.backgroundImage]))[0];
+    }
+    const objects = await import_node.util.enlivenObjects(
+      state.layers.map((layer) => layer.fabricObject)
+    );
+    objects.forEach((object, index) => {
+      const layer = state.layers[index];
+      object.set({ visible: layer.visible, opacity: layer.opacity });
+      canvas.add(object);
+    });
+    canvas.renderAll();
+    return canvas;
+  } catch (error) {
+    canvas.dispose();
+    throw error;
+  }
+}
+function encodeCanvas(canvas, options) {
+  const { format, multiplier, quality } = options;
+  const width = Math.round(canvas.getWidth() * multiplier);
+  const height = Math.round(canvas.getHeight() * multiplier);
+  if (format === "svg") {
+    return { format, mimeType: "image/svg+xml", data: canvas.toSVG(), width, height };
+  }
+  const dataUrl = canvas.toDataURL({ format, multiplier, quality });
+  return {
+    format,
+    mimeType: format === "jpeg" ? "image/jpeg" : `image/${format}`,
+    data: dataUrlBytes(dataUrl),
+    width,
+    height
+  };
+}
+function compositeOperation(mode) {
+  return !mode || mode === "normal" ? "source-over" : mode;
+}
+function clampOpacity(value = 1) {
+  return Math.max(0, Math.min(1, value));
+}
+async function coverImage(url, width, height) {
+  let image;
+  try {
+    image = await import_node.FabricImage.fromURL(url);
+  } catch (error) {
+    throw new Error(`Failed to load mockup image: ${url}`, { cause: error });
+  }
+  const sourceWidth = image.width;
+  const sourceHeight = image.height;
+  const placement = computeCoverPlacement(sourceWidth, sourceHeight, width, height);
+  image.set({
+    originX: "left",
+    originY: "top",
+    left: placement.left,
+    top: placement.top,
+    scaleX: placement.width / sourceWidth,
+    scaleY: placement.height / sourceHeight,
+    selectable: false,
+    evented: false
+  });
+  return image;
+}
+async function displacedDesignUrl(designCanvas, displacement, width, height) {
+  const mapCanvas = new import_node.StaticCanvas(void 0, { width, height });
+  const warpedCanvas = new import_node.StaticCanvas(void 0, { width, height });
+  try {
+    mapCanvas.add(await coverImage(displacement.image, width, height));
+    mapCanvas.renderAll();
+    const pixels = displaceRgba(
+      designCanvas.getContext().getImageData(0, 0, width, height).data,
+      mapCanvas.getContext().getImageData(0, 0, width, height).data,
+      width,
+      height,
+      displacement
+    );
+    const imageData = warpedCanvas.getContext().createImageData(width, height);
+    imageData.data.set(pixels);
+    warpedCanvas.getContext().putImageData(imageData, 0, 0);
+    return warpedCanvas.toDataURL({ format: "png", multiplier: 1 });
+  } catch (error) {
+    throw new Error("Failed to apply mockup displacement map", { cause: error });
+  } finally {
+    mapCanvas.dispose();
+    warpedCanvas.dispose();
+  }
+}
+async function renderEditorState(state, options = {}) {
+  validateState(state);
+  const resolved = validateOptions(options);
+  assertImageUrlsAllowed(state, resolved.allowImageUrl);
+  const canvas = await createStateCanvas(state);
+  try {
+    return encodeCanvas(canvas, resolved);
+  } finally {
+    canvas.dispose();
+  }
+}
+async function renderMockupState(state, options = {}) {
+  validateState(state);
+  const resolved = validateOptions(options);
+  assertImageUrlsAllowed(state, resolved.allowImageUrl);
+  if (resolved.format === "svg") {
+    throw new Error("Mockup rendering supports PNG, JPEG, and WebP output");
+  }
+  const mockup = state.mockup;
+  if (!mockup?.image) throw new Error("No mockup is configured");
+  const designCanvas = await createStateCanvas(state, true);
+  const output = new import_node.StaticCanvas(void 0, {
+    width: state.canvas.width,
+    height: state.canvas.height,
+    preserveObjectStacking: true
+  });
+  try {
+    output.add(await coverImage(mockup.image, state.canvas.width, state.canvas.height));
+    const designUrl = mockup.displacement ? await displacedDesignUrl(
+      designCanvas,
+      mockup.displacement,
+      state.canvas.width,
+      state.canvas.height
+    ) : designCanvas.toDataURL({ format: "png", multiplier: 1 });
+    const design = await import_node.FabricImage.fromURL(designUrl);
+    design.set({
+      originX: "left",
+      originY: "top",
+      left: 0,
+      top: 0,
+      opacity: clampOpacity(mockup.designOpacity),
+      globalCompositeOperation: compositeOperation(mockup.designBlendMode),
+      selectable: false,
+      evented: false
+    });
+    if (mockup.printArea && mockup.clipToPrintArea !== false) {
+      const clip = computePrintAreaClip(
+        mockup.printArea,
+        1,
+        1,
+        state.canvas.width,
+        state.canvas.height
+      );
+      design.clipPath = new import_node.Rect({
+        originX: "left",
+        originY: "top",
+        left: clip.left,
+        top: clip.top,
+        width: clip.width,
+        height: clip.height,
+        absolutePositioned: true
+      });
+    }
+    output.add(design);
+    if (mockup.overlay) {
+      const overlay = await coverImage(
+        mockup.overlay.image,
+        state.canvas.width,
+        state.canvas.height
+      );
+      overlay.set({
+        opacity: clampOpacity(mockup.overlay.opacity),
+        globalCompositeOperation: compositeOperation(mockup.overlay.blendMode ?? "multiply")
+      });
+      output.add(overlay);
+    }
+    output.renderAll();
+    return encodeCanvas(output, resolved);
+  } finally {
+    designCanvas.dispose();
+    output.dispose();
+  }
+}
+async function renderBatch(states, options, renderer) {
+  const concurrency = Math.max(1, Math.floor(options.concurrency ?? 2));
+  const results = new Array(states.length);
+  let nextIndex = 0;
+  await Promise.all(
+    Array.from({ length: Math.min(concurrency, states.length) }, async () => {
+      while (nextIndex < states.length) {
+        const index = nextIndex++;
+        results[index] = await renderer(states[index], options);
+      }
+    })
+  );
+  return results;
+}
+async function renderEditorStateBatch(states, options = {}) {
+  return renderBatch(states, options, renderEditorState);
+}
+async function renderMockupStateBatch(states, options = {}) {
+  return renderBatch(states, options, renderMockupState);
+}
+var import_node, ALLOWED_PROTOCOLS, URL_KEYS;
+var init_node = __esm({
+  "src/node.ts"() {
+    import_node = require("fabric/node");
+    init_export();
+    init_displacement();
+    init_print();
+    ALLOWED_PROTOCOLS = /* @__PURE__ */ new Set(["http:", "https:", "data:"]);
+    URL_KEYS = /* @__PURE__ */ new Set(["src", "image"]);
+  }
+});
+init_node();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  renderEditorState,
+  renderEditorStateBatch,
+  renderMockupState,
+  renderMockupStateBatch,
+  renderPrintPdf
+});
+//# sourceMappingURL=node.js.map