@artifact-kit/deckkit-pro 0.1.0

package/dist/image.js

@@ -0,0 +1,102 @@
+import { mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+import sharp from "sharp";
+async function getImageInfo(input) {
+  const metadata = await sharp(input).metadata();
+  return {
+    width: metadata.width,
+    height: metadata.height,
+    format: metadata.format,
+    channels: metadata.channels,
+    space: metadata.space,
+    hasAlpha: metadata.hasAlpha,
+    density: metadata.density,
+    size: metadata.size
+  };
+}
+async function cropImage(input, options) {
+  return sharp(input).extract({
+    left: options.x,
+    top: options.y,
+    width: options.width,
+    height: options.height
+  }).png().toBuffer();
+}
+async function resizeImage(input, options) {
+  const image = sharp(input).resize({
+    width: options.width,
+    height: options.height,
+    fit: options.fit ?? "contain",
+    background: options.background
+  });
+  return image.png().toBuffer();
+}
+async function sampleColor(input, x, y) {
+  const { data, info } = await sharp(input).ensureAlpha().extract({ left: x, top: y, width: 1, height: 1 }).raw().toBuffer({ resolveWithObject: true });
+  return {
+    x,
+    y,
+    r: data[0] ?? 0,
+    g: data[1] ?? 0,
+    b: data[2] ?? 0,
+    alpha: info.channels >= 4 ? data[3] : void 0
+  };
+}
+async function compareImages(reference, generated, options = {}) {
+  const [refBuffer, genBuffer] = await Promise.all([
+    sharp(reference).png().toBuffer(),
+    sharp(generated).png().toBuffer()
+  ]);
+  const [refInfo, genInfo] = await Promise.all([getImageInfo(refBuffer), getImageInfo(genBuffer)]);
+  const gap = options.gap ?? 12;
+  const width = (refInfo.width ?? 0) + (genInfo.width ?? 0) + gap;
+  const height = Math.max(refInfo.height ?? 0, genInfo.height ?? 0);
+  return sharp({
+    create: {
+      width,
+      height,
+      channels: 4,
+      background: options.background ?? { r: 255, g: 255, b: 255, alpha: 1 }
+    }
+  }).composite([
+    { input: refBuffer, left: 0, top: 0 },
+    { input: genBuffer, left: (refInfo.width ?? 0) + gap, top: 0 }
+  ]).png().toBuffer();
+}
+async function overlayImages(reference, generated, options = {}) {
+  const refInfo = await getImageInfo(reference);
+  const refWidth = refInfo.width ?? 1;
+  const refHeight = refInfo.height ?? 1;
+  const generatedBuffer = await withOpacity(
+    await sharp(generated).resize({ width: refWidth, height: refHeight, fit: "contain" }).ensureAlpha().png().toBuffer(),
+    options.opacity ?? 0.5
+  );
+  return sharp(reference).resize({ width: refWidth, height: refHeight, fit: "contain", background: options.background }).composite([{ input: generatedBuffer, left: 0, top: 0 }]).png().toBuffer();
+}
+async function withOpacity(input, opacity) {
+  const clampedOpacity = Math.max(0, Math.min(1, opacity));
+  const { data, info } = await sharp(input).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+  for (let index = 3; index < data.length; index += info.channels) {
+    data[index] = Math.round((data[index] ?? 0) * clampedOpacity);
+  }
+  return sharp(data, {
+    raw: {
+      width: info.width,
+      height: info.height,
+      channels: info.channels
+    }
+  }).png().toBuffer();
+}
+async function writeImage(buffer, output) {
+  await mkdir(dirname(output), { recursive: true });
+  await sharp(buffer).toFile(output);
+}
+export {
+  compareImages,
+  cropImage,
+  getImageInfo,
+  overlayImages,
+  resizeImage,
+  sampleColor,
+  writeImage
+};

package/dist/index.cjs

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const gradientFill = require("./gradient-fill.cjs");
+const svgToCustomGeometry = require("./svg-to-custom-geometry.cjs");
+const svgToPng = require("./svg-to-png.cjs");
+const image = require("./image.cjs");
+function deckkitPro() {
+  return {
+    name: "@artifact-kit/deckkit-pro",
+    setup(context) {
+      gradientFill.setupGradientFill(context);
+      svgToCustomGeometry.setupSvgCustomGeometry(context);
+    }
+  };
+}
+exports.renderGradientFill = gradientFill.renderGradientFill;
+exports.setupGradientFill = gradientFill.setupGradientFill;
+exports.handleSvgCustomGeometry = svgToCustomGeometry.handleSvgCustomGeometry;
+exports.setupSvgCustomGeometry = svgToCustomGeometry.setupSvgCustomGeometry;
+exports.svgToCustomGeometry = svgToCustomGeometry.svgToCustomGeometry;
+exports.renderSvgToPng = svgToPng.renderSvgToPng;
+exports.writeSvgToPng = svgToPng.writeSvgToPng;
+exports.compareImages = image.compareImages;
+exports.cropImage = image.cropImage;
+exports.getImageInfo = image.getImageInfo;
+exports.overlayImages = image.overlayImages;
+exports.resizeImage = image.resizeImage;
+exports.sampleColor = image.sampleColor;
+exports.writeImage = image.writeImage;
+exports.deckkitPro = deckkitPro;
+exports.default = deckkitPro;

package/dist/index.js

@@ -0,0 +1,33 @@
+import { setupGradientFill } from "./gradient-fill.js";
+import { renderGradientFill } from "./gradient-fill.js";
+import { setupSvgCustomGeometry } from "./svg-to-custom-geometry.js";
+import { handleSvgCustomGeometry, svgToCustomGeometry } from "./svg-to-custom-geometry.js";
+import { renderSvgToPng, writeSvgToPng } from "./svg-to-png.js";
+import { compareImages, cropImage, getImageInfo, overlayImages, resizeImage, sampleColor, writeImage } from "./image.js";
+function deckkitPro() {
+  return {
+    name: "@artifact-kit/deckkit-pro",
+    setup(context) {
+      setupGradientFill(context);
+      setupSvgCustomGeometry(context);
+    }
+  };
+}
+export {
+  compareImages,
+  cropImage,
+  deckkitPro,
+  deckkitPro as default,
+  getImageInfo,
+  handleSvgCustomGeometry,
+  overlayImages,
+  renderGradientFill,
+  renderSvgToPng,
+  resizeImage,
+  sampleColor,
+  setupGradientFill,
+  setupSvgCustomGeometry,
+  svgToCustomGeometry,
+  writeImage,
+  writeSvgToPng
+};

package/dist/svg-to-custom-geometry.cjs

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const paper = require("paper-jsdom");
+function setupSvgCustomGeometry(context) {
+  context.addShapeHandler(handleSvgCustomGeometry);
+}
+function handleSvgCustomGeometry({ target, shape, options }) {
+  const svg = options.svg;
+  if (String(shape) !== "custGeom" || typeof svg !== "string") return void 0;
+  const { svg: _svg, svgPrecision, ...baseOptions } = options;
+  const result = svgToCustomGeometry(svg, {
+    x: typeof options.x === "number" ? options.x : void 0,
+    y: typeof options.y === "number" ? options.y : void 0,
+    w: typeof options.w === "number" ? options.w : void 0,
+    h: typeof options.h === "number" ? options.h : void 0,
+    precision: svgPrecision
+  });
+  result.paths.forEach((path, index) => {
+    target.addShape("custGeom", {
+      ...baseOptions,
+      x: options.x,
+      y: options.y,
+      w: result.width,
+      h: result.height,
+      objectName: options.objectName ? `${options.objectName} ${index + 1}` : void 0,
+      points: path.points,
+      fill: path.fill,
+      line: path.line
+    });
+  });
+  return true;
+}
+function svgToCustomGeometry(svg, options = {}) {
+  const viewBox = readViewBox(svg) ?? readSvgSize(svg) ?? [0, 0, 1, 1];
+  const [, , viewBoxWidth, viewBoxHeight] = viewBox;
+  const width = options.w ?? viewBoxWidth / 100;
+  const height = options.h ?? viewBoxHeight / 100;
+  const precision = options.precision ?? 5;
+  paper.setup(new paper.Size(viewBoxWidth || 1, viewBoxHeight || 1));
+  try {
+    const rootItem = paper.project.importSVG(svg, {
+      expandShapes: true,
+      insert: true
+    });
+    const items = rootItem.getItems({
+      match: (item) => item instanceof paper.Path || item instanceof paper.CompoundPath
+    });
+    const paths = collectUniquePathItems(items).map((pathItem) => paperPathToCustomGeometry(pathItem, viewBox, width, height, precision));
+    return {
+      width,
+      height,
+      viewBox,
+      paths
+    };
+  } finally {
+    paper.project.clear();
+  }
+}
+function collectUniquePathItems(items) {
+  const seen = /* @__PURE__ */ new Set();
+  const paths = [];
+  for (const item of items) {
+    const pathItems = paperItemToPaths(item);
+    for (const pathItem of pathItems) {
+      if (seen.has(pathItem)) continue;
+      seen.add(pathItem);
+      paths.push(pathItem);
+    }
+  }
+  return paths;
+}
+function paperItemToPaths(item) {
+  if (item instanceof paper.Path) return [item];
+  if (item instanceof paper.CompoundPath) return item.children.filter((child) => child instanceof paper.Path);
+  return [];
+}
+function paperPathToCustomGeometry(pathItem, viewBox, width, height, precision) {
+  const stroke = inheritedStroke(pathItem);
+  return {
+    points: pathToCustomGeometryPoints(pathItem, viewBox, width, height, precision),
+    fill: colorToFill(inheritedValue(pathItem, "fillColor")),
+    line: colorToLine(stroke.color, stroke.width, viewBox, width, height)
+  };
+}
+function inheritedStroke(item) {
+  let cursor = item;
+  while (cursor) {
+    if (cursor.strokeColor) {
+      return {
+        color: cursor.strokeColor,
+        width: cursor.strokeWidth
+      };
+    }
+    cursor = cursor.parent;
+  }
+  return { color: void 0, width: void 0 };
+}
+function inheritedValue(item, key) {
+  let cursor = item;
+  while (cursor) {
+    const value = cursor[key];
+    if (value !== void 0 && value !== null) return value;
+    cursor = cursor.parent;
+  }
+  return void 0;
+}
+function pathToCustomGeometryPoints(pathItem, viewBox, width, height, precision) {
+  const segments = pathItem.segments;
+  if (!segments || segments.length === 0) return [];
+  const points = [movePoint(segments[0].point, viewBox, width, height, precision)];
+  for (let index = 1; index < segments.length; index += 1) {
+    points.push(segmentPoint(segments[index - 1], segments[index], viewBox, width, height, precision));
+  }
+  if (pathItem.closed) {
+    points.push(segmentPoint(segments[segments.length - 1], segments[0], viewBox, width, height, precision));
+    points.push({ close: true });
+  }
+  return points;
+}
+function movePoint(point, viewBox, width, height, precision) {
+  return {
+    ...scalePoint(point, viewBox, width, height, precision),
+    moveTo: true
+  };
+}
+function segmentPoint(from, to, viewBox, width, height, precision) {
+  const end = scalePoint(to.point, viewBox, width, height, precision);
+  const fromHandle = from.handleOut;
+  const toHandle = to.handleIn;
+  if (!fromHandle.isZero() || !toHandle.isZero()) {
+    const c1 = scalePoint(from.point.add(fromHandle), viewBox, width, height, precision);
+    const c2 = scalePoint(to.point.add(toHandle), viewBox, width, height, precision);
+    return {
+      ...end,
+      curve: {
+        type: "cubic",
+        x1: c1.x,
+        y1: c1.y,
+        x2: c2.x,
+        y2: c2.y
+      }
+    };
+  }
+  return end;
+}
+function scalePoint(point, viewBox, width, height, precision) {
+  const [minX, minY, viewBoxWidth, viewBoxHeight] = viewBox;
+  return {
+    x: round((point.x - minX) / viewBoxWidth * width, precision),
+    y: round((point.y - minY) / viewBoxHeight * height, precision)
+  };
+}
+function colorToFill(color) {
+  const hex = paperColorToHex(color);
+  return hex ? { color: hex } : void 0;
+}
+function colorToLine(color, strokeWidth, viewBox, width, height) {
+  const hex = paperColorToHex(color);
+  if (!hex) return { type: "none" };
+  const [, , viewBoxWidth, viewBoxHeight] = viewBox;
+  const scale = (width / viewBoxWidth + height / viewBoxHeight) / 2;
+  return {
+    color: hex,
+    width: strokeWidth ? Math.max(0.1, strokeWidth * scale * 72) : 1
+  };
+}
+function paperColorToHex(color) {
+  const css = color?.toCSS?.(true);
+  if (typeof css !== "string" || !css.startsWith("#")) return void 0;
+  return css.slice(1).toUpperCase();
+}
+function readViewBox(svg) {
+  const match = svg.match(/\bviewBox=["']([^"']+)["']/);
+  if (!match) return void 0;
+  const values = match[1].trim().split(/[\s,]+/).map(Number);
+  return values.length === 4 && values.every(Number.isFinite) ? values : void 0;
+}
+function readSvgSize(svg) {
+  const width = readNumericSvgAttr(svg, "width");
+  const height = readNumericSvgAttr(svg, "height");
+  return width && height ? [0, 0, width, height] : void 0;
+}
+function readNumericSvgAttr(svg, attr) {
+  const match = svg.match(new RegExp(`\\b${attr}=["']([0-9.]+)`));
+  if (!match) return void 0;
+  const value = Number(match[1]);
+  return Number.isFinite(value) ? value : void 0;
+}
+function round(value, precision) {
+  const scale = 10 ** precision;
+  return Math.round(value * scale) / scale;
+}
+exports.handleSvgCustomGeometry = handleSvgCustomGeometry;
+exports.setupSvgCustomGeometry = setupSvgCustomGeometry;
+exports.svgToCustomGeometry = svgToCustomGeometry;

package/dist/svg-to-custom-geometry.js

@@ -0,0 +1,195 @@
+import paper from "paper-jsdom";
+function setupSvgCustomGeometry(context) {
+  context.addShapeHandler(handleSvgCustomGeometry);
+}
+function handleSvgCustomGeometry({ target, shape, options }) {
+  const svg = options.svg;
+  if (String(shape) !== "custGeom" || typeof svg !== "string") return void 0;
+  const { svg: _svg, svgPrecision, ...baseOptions } = options;
+  const result = svgToCustomGeometry(svg, {
+    x: typeof options.x === "number" ? options.x : void 0,
+    y: typeof options.y === "number" ? options.y : void 0,
+    w: typeof options.w === "number" ? options.w : void 0,
+    h: typeof options.h === "number" ? options.h : void 0,
+    precision: svgPrecision
+  });
+  result.paths.forEach((path, index) => {
+    target.addShape("custGeom", {
+      ...baseOptions,
+      x: options.x,
+      y: options.y,
+      w: result.width,
+      h: result.height,
+      objectName: options.objectName ? `${options.objectName} ${index + 1}` : void 0,
+      points: path.points,
+      fill: path.fill,
+      line: path.line
+    });
+  });
+  return true;
+}
+function svgToCustomGeometry(svg, options = {}) {
+  const viewBox = readViewBox(svg) ?? readSvgSize(svg) ?? [0, 0, 1, 1];
+  const [, , viewBoxWidth, viewBoxHeight] = viewBox;
+  const width = options.w ?? viewBoxWidth / 100;
+  const height = options.h ?? viewBoxHeight / 100;
+  const precision = options.precision ?? 5;
+  paper.setup(new paper.Size(viewBoxWidth || 1, viewBoxHeight || 1));
+  try {
+    const rootItem = paper.project.importSVG(svg, {
+      expandShapes: true,
+      insert: true
+    });
+    const items = rootItem.getItems({
+      match: (item) => item instanceof paper.Path || item instanceof paper.CompoundPath
+    });
+    const paths = collectUniquePathItems(items).map((pathItem) => paperPathToCustomGeometry(pathItem, viewBox, width, height, precision));
+    return {
+      width,
+      height,
+      viewBox,
+      paths
+    };
+  } finally {
+    paper.project.clear();
+  }
+}
+function collectUniquePathItems(items) {
+  const seen = /* @__PURE__ */ new Set();
+  const paths = [];
+  for (const item of items) {
+    const pathItems = paperItemToPaths(item);
+    for (const pathItem of pathItems) {
+      if (seen.has(pathItem)) continue;
+      seen.add(pathItem);
+      paths.push(pathItem);
+    }
+  }
+  return paths;
+}
+function paperItemToPaths(item) {
+  if (item instanceof paper.Path) return [item];
+  if (item instanceof paper.CompoundPath) return item.children.filter((child) => child instanceof paper.Path);
+  return [];
+}
+function paperPathToCustomGeometry(pathItem, viewBox, width, height, precision) {
+  const stroke = inheritedStroke(pathItem);
+  return {
+    points: pathToCustomGeometryPoints(pathItem, viewBox, width, height, precision),
+    fill: colorToFill(inheritedValue(pathItem, "fillColor")),
+    line: colorToLine(stroke.color, stroke.width, viewBox, width, height)
+  };
+}
+function inheritedStroke(item) {
+  let cursor = item;
+  while (cursor) {
+    if (cursor.strokeColor) {
+      return {
+        color: cursor.strokeColor,
+        width: cursor.strokeWidth
+      };
+    }
+    cursor = cursor.parent;
+  }
+  return { color: void 0, width: void 0 };
+}
+function inheritedValue(item, key) {
+  let cursor = item;
+  while (cursor) {
+    const value = cursor[key];
+    if (value !== void 0 && value !== null) return value;
+    cursor = cursor.parent;
+  }
+  return void 0;
+}
+function pathToCustomGeometryPoints(pathItem, viewBox, width, height, precision) {
+  const segments = pathItem.segments;
+  if (!segments || segments.length === 0) return [];
+  const points = [movePoint(segments[0].point, viewBox, width, height, precision)];
+  for (let index = 1; index < segments.length; index += 1) {
+    points.push(segmentPoint(segments[index - 1], segments[index], viewBox, width, height, precision));
+  }
+  if (pathItem.closed) {
+    points.push(segmentPoint(segments[segments.length - 1], segments[0], viewBox, width, height, precision));
+    points.push({ close: true });
+  }
+  return points;
+}
+function movePoint(point, viewBox, width, height, precision) {
+  return {
+    ...scalePoint(point, viewBox, width, height, precision),
+    moveTo: true
+  };
+}
+function segmentPoint(from, to, viewBox, width, height, precision) {
+  const end = scalePoint(to.point, viewBox, width, height, precision);
+  const fromHandle = from.handleOut;
+  const toHandle = to.handleIn;
+  if (!fromHandle.isZero() || !toHandle.isZero()) {
+    const c1 = scalePoint(from.point.add(fromHandle), viewBox, width, height, precision);
+    const c2 = scalePoint(to.point.add(toHandle), viewBox, width, height, precision);
+    return {
+      ...end,
+      curve: {
+        type: "cubic",
+        x1: c1.x,
+        y1: c1.y,
+        x2: c2.x,
+        y2: c2.y
+      }
+    };
+  }
+  return end;
+}
+function scalePoint(point, viewBox, width, height, precision) {
+  const [minX, minY, viewBoxWidth, viewBoxHeight] = viewBox;
+  return {
+    x: round((point.x - minX) / viewBoxWidth * width, precision),
+    y: round((point.y - minY) / viewBoxHeight * height, precision)
+  };
+}
+function colorToFill(color) {
+  const hex = paperColorToHex(color);
+  return hex ? { color: hex } : void 0;
+}
+function colorToLine(color, strokeWidth, viewBox, width, height) {
+  const hex = paperColorToHex(color);
+  if (!hex) return { type: "none" };
+  const [, , viewBoxWidth, viewBoxHeight] = viewBox;
+  const scale = (width / viewBoxWidth + height / viewBoxHeight) / 2;
+  return {
+    color: hex,
+    width: strokeWidth ? Math.max(0.1, strokeWidth * scale * 72) : 1
+  };
+}
+function paperColorToHex(color) {
+  const css = color?.toCSS?.(true);
+  if (typeof css !== "string" || !css.startsWith("#")) return void 0;
+  return css.slice(1).toUpperCase();
+}
+function readViewBox(svg) {
+  const match = svg.match(/\bviewBox=["']([^"']+)["']/);
+  if (!match) return void 0;
+  const values = match[1].trim().split(/[\s,]+/).map(Number);
+  return values.length === 4 && values.every(Number.isFinite) ? values : void 0;
+}
+function readSvgSize(svg) {
+  const width = readNumericSvgAttr(svg, "width");
+  const height = readNumericSvgAttr(svg, "height");
+  return width && height ? [0, 0, width, height] : void 0;
+}
+function readNumericSvgAttr(svg, attr) {
+  const match = svg.match(new RegExp(`\\b${attr}=["']([0-9.]+)`));
+  if (!match) return void 0;
+  const value = Number(match[1]);
+  return Number.isFinite(value) ? value : void 0;
+}
+function round(value, precision) {
+  const scale = 10 ** precision;
+  return Math.round(value * scale) / scale;
+}
+export {
+  handleSvgCustomGeometry,
+  setupSvgCustomGeometry,
+  svgToCustomGeometry
+};

package/dist/svg-to-png-cli.cjs

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+"use strict";
+const node_fs = require("node:fs");
+const promises = require("node:fs/promises");
+const node_path = require("node:path");
+const svgToPng = require("./svg-to-png.cjs");
+const FIT_VALUES = /* @__PURE__ */ new Set(["cover", "contain", "fill", "inside", "outside"]);
+async function main(args) {
+  const parsed = parseArgs(args);
+  if (!parsed.input) {
+    printUsage();
+    process.exitCode = 1;
+    return;
+  }
+  const svg = await readSvgInput(parsed.input);
+  await svgToPng.writeSvgToPng(svg, parsed.output, parsed.options);
+  console.log(parsed.output);
+}
+function parseArgs(args) {
+  const result = {
+    output: "output.png",
+    options: {}
+  };
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    switch (arg) {
+      case "-o":
+      case "--output":
+        result.output = readValue(args, ++index, arg);
+        break;
+      case "--width":
+        result.options.width = readNumber(args, ++index, arg);
+        break;
+      case "--height":
+        result.options.height = readNumber(args, ++index, arg);
+        break;
+      case "--density":
+        result.options.density = readNumber(args, ++index, arg);
+        break;
+      case "--fit": {
+        const fit = readValue(args, ++index, arg);
+        if (!FIT_VALUES.has(fit)) {
+          throw new Error(`Invalid --fit value "${fit}". Expected one of: ${Array.from(FIT_VALUES).join(", ")}`);
+        }
+        result.options.fit = fit;
+        break;
+      }
+      case "--background":
+        result.options.background = readValue(args, ++index, arg);
+        break;
+      case "--compression-level":
+        result.options.compressionLevel = readNumber(args, ++index, arg);
+        break;
+      case "-h":
+      case "--help":
+        printUsage();
+        process.exit(0);
+      default:
+        if (arg.startsWith("-")) {
+          throw new Error(`Unknown option: ${arg}`);
+        }
+        if (result.input !== void 0) {
+          throw new Error(`Unexpected extra argument: ${arg}`);
+        }
+        result.input = arg;
+    }
+  }
+  return result;
+}
+async function readSvgInput(input) {
+  if (node_fs.existsSync(input)) {
+    return promises.readFile(input, "utf8");
+  }
+  return input;
+}
+function readValue(args, index, option) {
+  const value = args[index];
+  if (!value) {
+    throw new Error(`Missing value for ${option}`);
+  }
+  return value;
+}
+function readNumber(args, index, option) {
+  const value = Number(readValue(args, index, option));
+  if (!Number.isFinite(value)) {
+    throw new Error(`Invalid numeric value for ${option}`);
+  }
+  return value;
+}
+function printUsage() {
+  const command = node_path.basename(process.argv[1] ?? "svg-to-png-cli.js", node_path.extname(process.argv[1] ?? ""));
+  console.log(`Usage:
+  node ${command}.js "<svg ...>" -o output.png
+  node ${command}.js input.svg -o output.png
+
+Options:
+  -o, --output <path>              Output PNG path. Defaults to output.png.
+  --width <px>                     Resize output width.
+  --height <px>                    Resize output height.
+  --fit <mode>                     cover, contain, fill, inside, or outside. Defaults to contain.
+  --density <dpi>                  SVG render density.
+  --background <color>             Flatten transparent background, e.g. "#ffffff".
+  --compression-level <0-9>        PNG compression level.`);
+}
+main(process.argv.slice(2)).catch((error) => {
+  console.error(error instanceof Error ? error.message : error);
+  process.exitCode = 1;
+});