obsidian-integration-testing 10.1.0 → 10.2.0

package/dist/lib/cjs/fit-screenshot.cjs

@@ -0,0 +1,124 @@
+"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 __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);
+var fit_screenshot_exports = {};
+__export(fit_screenshot_exports, {
+  computeFitToCanvas: () => computeFitToCanvas,
+  fitScreenshotToCanvas: () => fitScreenshotToCanvas
+});
+module.exports = __toCommonJS(fit_screenshot_exports);
+const DEFAULT_BLUR_SIGMA = 24;
+const MARGIN_SIDES = 2;
+function computeFitToCanvas(params) {
+  const {
+    canvasHeightInPixels,
+    canvasWidthInPixels,
+    sourceHeightInPixels,
+    sourceWidthInPixels
+  } = params;
+  const namedDimensions = [
+    ["canvasHeightInPixels", canvasHeightInPixels],
+    ["canvasWidthInPixels", canvasWidthInPixels],
+    ["sourceHeightInPixels", sourceHeightInPixels],
+    ["sourceWidthInPixels", sourceWidthInPixels]
+  ];
+  for (const [name, value] of namedDimensions) {
+    if (!Number.isFinite(value) || value <= 0) {
+      throw new Error(`computeFitToCanvas: ${name} must be a positive number, got ${String(value)}.`);
+    }
+  }
+  const scaledHeightInPixels = canvasHeightInPixels;
+  const exactScaledWidth = sourceWidthInPixels * (canvasHeightInPixels / sourceHeightInPixels);
+  const scaledWidthInPixels = roundToMatchingParity(exactScaledWidth, canvasWidthInPixels);
+  if (scaledWidthInPixels > canvasWidthInPixels) {
+    throw new Error(
+      `computeFitToCanvas: the source is wider than the canvas once scaled to its height (${String(scaledWidthInPixels)} > ${String(canvasWidthInPixels)}); this fits by height and cannot letterbox.`
+    );
+  }
+  const marginInPixels = (canvasWidthInPixels - scaledWidthInPixels) / MARGIN_SIDES;
+  return {
+    marginInPixels,
+    offsetXInPixels: marginInPixels,
+    offsetYInPixels: 0,
+    scaledHeightInPixels,
+    scaledWidthInPixels
+  };
+}
+async function fitScreenshotToCanvas(bytes, options) {
+  const {
+    blurSigma = DEFAULT_BLUR_SIGMA,
+    canvasHeightInPixels,
+    canvasWidthInPixels
+  } = options;
+  const sharp = await importSharp();
+  const metadata = await sharp(bytes).metadata();
+  const sourceWidthInPixels = metadata.width;
+  const sourceHeightInPixels = metadata.height;
+  if (sourceWidthInPixels === void 0 || sourceHeightInPixels === void 0) {
+    throw new Error("fitScreenshotToCanvas: could not read the source image dimensions.");
+  }
+  const geometry = computeFitToCanvas({
+    canvasHeightInPixels,
+    canvasWidthInPixels,
+    sourceHeightInPixels,
+    sourceWidthInPixels
+  });
+  const background = await sharp(bytes).resize(canvasWidthInPixels, canvasHeightInPixels, { fit: "cover" }).blur(blurSigma).toBuffer();
+  const foreground = await sharp(bytes).resize(geometry.scaledWidthInPixels, geometry.scaledHeightInPixels, { fit: "fill" }).toBuffer();
+  const composed = await sharp(background).composite([{
+    input: foreground,
+    left: geometry.offsetXInPixels,
+    top: geometry.offsetYInPixels
+  }]).png().toBuffer();
+  return new Uint8Array(composed);
+}
+async function importSharp() {
+  try {
+    const sharpModule = await import("sharp");
+    const factory = sharpModule.default;
+    return factory;
+  } catch (error) {
+    throw new Error(
+      'fitScreenshotToCanvas needs the optional peer dependency "sharp". Install it in the consuming project (npm i -D sharp).',
+      { cause: error }
+    );
+  }
+}
+function roundToMatchingParity(value, target) {
+  const rounded = Math.round(value);
+  if ((target - rounded) % MARGIN_SIDES === 0) {
+    return rounded;
+  }
+  return value >= rounded ? rounded + 1 : rounded - 1;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  computeFitToCanvas,
+  fitScreenshotToCanvas
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/fit-screenshot.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Fits a screenshot onto a canvas of a different aspect ratio without cropping\n * it or distorting it, filling the leftover margins with a blurred, enlarged\n * copy of the same image (the \"pillarbox\" treatment used by store listings).\n *\n * The motivating case is a mobile store screenshot. The Android emulator's\n * framebuffer is whatever the AVD's screen is \u2014 a Pixel 10 Pro XL is 1344x2992,\n * roughly 9:20 \u2014 while the community store asks for 900x1600 (9:16). Cropping\n * to 9:16 throws away a fifth of the frame, and stretching distorts the UI, so\n * the image is scaled to fit the HEIGHT and the two side margins are filled.\n *\n * The geometry is a pure function so it can be unit-tested; the pixel work needs\n * `sharp`, which is an OPTIONAL peer dependency \u2014 declared rather than bundled\n * because only screenshot capture needs it, and it ships platform-specific\n * native binaries that every other consumer would pay for.\n */\n\n/**\n * Parameters for {@link computeFitToCanvas}.\n */\nexport interface ComputeFitToCanvasParams {\n  /**\n   * Height of the target canvas, in pixels.\n   */\n  readonly canvasHeightInPixels: number;\n\n  /**\n   * Width of the target canvas, in pixels.\n   */\n  readonly canvasWidthInPixels: number;\n\n  /**\n   * Height of the source image, in pixels.\n   */\n  readonly sourceHeightInPixels: number;\n\n  /**\n   * Width of the source image, in pixels.\n   */\n  readonly sourceWidthInPixels: number;\n}\n\n/**\n * Options for {@link fitScreenshotToCanvas}.\n */\nexport interface FitScreenshotToCanvasOptions {\n  /**\n   * Gaussian blur strength applied to the margin fill.\n   *\n   * @default `24`\n   */\n  readonly blurSigma?: number;\n\n  /**\n   * Height of the target canvas, in pixels.\n   */\n  readonly canvasHeightInPixels: number;\n\n  /**\n   * Width of the target canvas, in pixels.\n   */\n  readonly canvasWidthInPixels: number;\n}\n\n/**\n * Where the scaled source image sits on the canvas.\n */\nexport interface FitToCanvasGeometry {\n  /**\n   * Width of each side margin, in pixels. Both sides are equal by construction.\n   */\n  readonly marginInPixels: number;\n\n  /**\n   * Left offset of the scaled image on the canvas, in pixels.\n   */\n  readonly offsetXInPixels: number;\n\n  /**\n   * Top offset of the scaled image on the canvas, in pixels.\n   */\n  readonly offsetYInPixels: number;\n\n  /**\n   * Height the source is scaled to, in pixels.\n   */\n  readonly scaledHeightInPixels: number;\n\n  /**\n   * Width the source is scaled to, in pixels.\n   */\n  readonly scaledWidthInPixels: number;\n}\n\n/**\n * A layer passed to `sharp`'s `composite`.\n */\ninterface SharpCompositeLayer {\n  readonly input: Buffer;\n  readonly left: number;\n  readonly top: number;\n}\n\n/**\n * The `sharp` entry point this module uses, described structurally so the module\n * type-checks against the optional peer rather than depending on its types.\n */\ntype SharpFactory = (input: Uint8Array) => SharpInstance;\n\n/**\n * One `sharp` pipeline.\n */\ninterface SharpInstance {\n  blur(this: void, sigma: number): SharpInstance;\n  composite(this: void, layers: SharpCompositeLayer[]): SharpInstance;\n  metadata(this: void): Promise<SharpMetadata>;\n  png(this: void): SharpInstance;\n  resize(this: void, width: number, height: number, options?: SharpResizeOptions): SharpInstance;\n  toBuffer(this: void): Promise<Buffer>;\n}\n\n/**\n * The subset of `sharp`'s metadata this module reads.\n */\ninterface SharpMetadata {\n  readonly height?: number | undefined;\n  readonly width?: number | undefined;\n}\n\n/**\n * The subset of `sharp`'s resize options this module sets.\n */\ninterface SharpResizeOptions {\n  readonly fit: 'cover' | 'fill';\n}\n\n/**\n * Default Gaussian blur strength for the margin fill: soft enough that no\n * detail reads as content, gentle enough to keep the frame's colors.\n */\nconst DEFAULT_BLUR_SIGMA = 24;\n\n/**\n * The number of side margins the leftover width is split between.\n */\nconst MARGIN_SIDES = 2;\n\n/**\n * Computes how a source image is scaled and placed to fill a canvas's height,\n * with equal margins on the left and right.\n *\n * The scaled width is rounded to the nearest integer that leaves an EVEN\n * remainder, so the two margins are exactly equal \u2014 an asymmetric pillarbox is\n * visible at a glance and looks like a mistake. Where both neighbors qualify,\n * the one closer to the true scaled width wins, so the aspect error stays below\n * one part in a thousand.\n *\n * Worked example, the mobile store case: a 1344x2992 frame onto a 900x1600\n * canvas scales by `1600/2992` to 718.72 wide. 719 would leave a 181px\n * remainder, which cannot split evenly, so 718 is chosen (margin 91) over 720\n * (margin 90) because 718 is nearer 718.72.\n *\n * @param params - The source and canvas dimensions.\n * @returns The scaled size, the offsets, and the side margin.\n * @throws Error if any dimension is not a positive number.\n */\nexport function computeFitToCanvas(params: ComputeFitToCanvasParams): FitToCanvasGeometry {\n  const {\n    canvasHeightInPixels,\n    canvasWidthInPixels,\n    sourceHeightInPixels,\n    sourceWidthInPixels\n  } = params;\n\n  const namedDimensions: [string, number][] = [\n    ['canvasHeightInPixels', canvasHeightInPixels],\n    ['canvasWidthInPixels', canvasWidthInPixels],\n    ['sourceHeightInPixels', sourceHeightInPixels],\n    ['sourceWidthInPixels', sourceWidthInPixels]\n  ];\n\n  for (const [name, value] of namedDimensions) {\n    if (!Number.isFinite(value) || value <= 0) {\n      throw new Error(`computeFitToCanvas: ${name} must be a positive number, got ${String(value)}.`);\n    }\n  }\n\n  const scaledHeightInPixels = canvasHeightInPixels;\n  const exactScaledWidth = sourceWidthInPixels * (canvasHeightInPixels / sourceHeightInPixels);\n  const scaledWidthInPixels = roundToMatchingParity(exactScaledWidth, canvasWidthInPixels);\n\n  if (scaledWidthInPixels > canvasWidthInPixels) {\n    throw new Error(\n      'computeFitToCanvas: the source is wider than the canvas once scaled to its height '\n        + `(${String(scaledWidthInPixels)} > ${String(canvasWidthInPixels)}); this fits by height and cannot letterbox.`\n    );\n  }\n\n  const marginInPixels = (canvasWidthInPixels - scaledWidthInPixels) / MARGIN_SIDES;\n\n  return {\n    marginInPixels,\n    offsetXInPixels: marginInPixels,\n    offsetYInPixels: 0,\n    scaledHeightInPixels,\n    scaledWidthInPixels\n  };\n}\n\n/**\n * Scales a screenshot to fill a canvas's height and fills the side margins with\n * a blurred, enlarged copy of the same image.\n *\n * Nothing is cropped and nothing is stretched: the visible screenshot keeps its\n * aspect ratio to within a rounding pixel, and the margins are made of the\n * image itself rather than a flat color, so the result reads as one frame.\n *\n * @param bytes - The source PNG.\n * @param options - The target canvas size and blur strength.\n * @returns A {@link Promise} that resolves to the composed PNG, exactly the canvas size.\n * @throws Error if `sharp` is not installed, or the source dimensions cannot be read.\n */\nexport async function fitScreenshotToCanvas(bytes: Uint8Array, options: FitScreenshotToCanvasOptions): Promise<Uint8Array> {\n  const {\n    blurSigma = DEFAULT_BLUR_SIGMA,\n    canvasHeightInPixels,\n    canvasWidthInPixels\n  } = options;\n\n  const sharp = await importSharp();\n  const metadata = await sharp(bytes).metadata();\n  const sourceWidthInPixels = metadata.width;\n  const sourceHeightInPixels = metadata.height;\n\n  /* v8 ignore next 3 -- Defensive: `sharp` rejects a non-image before it can report metadata without dimensions, so this branch is unreachable from a test. */\n  if (sourceWidthInPixels === undefined || sourceHeightInPixels === undefined) {\n    throw new Error('fitScreenshotToCanvas: could not read the source image dimensions.');\n  }\n\n  const geometry = computeFitToCanvas({\n    canvasHeightInPixels,\n    canvasWidthInPixels,\n    sourceHeightInPixels,\n    sourceWidthInPixels\n  });\n\n  // The background is the same frame blown up to COVER the canvas and blurred,\n  // So the margins carry the screenshot's own colors instead of a flat bar.\n  const background = await sharp(bytes)\n    .resize(canvasWidthInPixels, canvasHeightInPixels, { fit: 'cover' })\n    .blur(blurSigma)\n    .toBuffer();\n\n  const foreground = await sharp(bytes)\n    .resize(geometry.scaledWidthInPixels, geometry.scaledHeightInPixels, { fit: 'fill' })\n    .toBuffer();\n\n  const composed = await sharp(background)\n    .composite([{\n      input: foreground,\n      left: geometry.offsetXInPixels,\n      top: geometry.offsetYInPixels\n    }])\n    .png()\n    .toBuffer();\n\n  return new Uint8Array(composed);\n}\n\n/**\n * Loads `sharp` on demand, so importing this module does not require it.\n *\n * @returns A {@link Promise} that resolves to the `sharp` factory.\n * @throws Error naming the missing optional peer dependency.\n */\nasync function importSharp(): Promise<SharpFactory> {\n  try {\n    // eslint-disable-next-line no-restricted-syntax -- `sharp` is an OPTIONAL peer, so it must be loaded lazily: a static import would drag its native binaries into every consumer of this package's index.\n    const sharpModule = await import('sharp');\n    const factory: unknown = sharpModule.default;\n    return factory as SharpFactory;\n  } catch (error: unknown) {\n    /* v8 ignore start -- Reached only when the optional peer is absent, which it never is in this package's own test run. */\n    throw new Error(\n      'fitScreenshotToCanvas needs the optional peer dependency \"sharp\". '\n        + 'Install it in the consuming project (npm i -D sharp).',\n      { cause: error }\n    );\n    /* v8 ignore stop */\n  }\n}\n\n/**\n * Rounds a width to the nearest integer sharing `target`'s parity, so\n * `target - result` is even and splits into two equal margins.\n *\n * @param value - The exact scaled width.\n * @param target - The canvas width whose parity must be matched.\n * @returns The nearest integer of the same parity as `target`.\n */\nfunction roundToMatchingParity(value: number, target: number): number {\n  const rounded = Math.round(value);\n  if ((target - rounded) % MARGIN_SIDES === 0) {\n    return rounded;\n  }\n\n  // `rounded` leaves an odd remainder, so step to whichever neighbor is closer\n  // To the true value; both have the parity `rounded` lacks.\n  return value >= rounded ? rounded + 1 : rounded - 1;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA8IA,MAAM,qBAAqB;AAK3B,MAAM,eAAe;AAqBd,SAAS,mBAAmB,QAAuD;AACxF,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,QAAM,kBAAsC;AAAA,IAC1C,CAAC,wBAAwB,oBAAoB;AAAA,IAC7C,CAAC,uBAAuB,mBAAmB;AAAA,IAC3C,CAAC,wBAAwB,oBAAoB;AAAA,IAC7C,CAAC,uBAAuB,mBAAmB;AAAA,EAC7C;AAEA,aAAW,CAAC,MAAM,KAAK,KAAK,iBAAiB;AAC3C,QAAI,CAAC,OAAO,SAAS,KAAK,KAAK,SAAS,GAAG;AACzC,YAAM,IAAI,MAAM,uBAAuB,IAAI,mCAAmC,OAAO,KAAK,CAAC,GAAG;AAAA,IAChG;AAAA,EACF;AAEA,QAAM,uBAAuB;AAC7B,QAAM,mBAAmB,uBAAuB,uBAAuB;AACvE,QAAM,sBAAsB,sBAAsB,kBAAkB,mBAAmB;AAEvF,MAAI,sBAAsB,qBAAqB;AAC7C,UAAM,IAAI;AAAA,MACR,sFACQ,OAAO,mBAAmB,CAAC,MAAM,OAAO,mBAAmB,CAAC;AAAA,IACtE;AAAA,EACF;AAEA,QAAM,kBAAkB,sBAAsB,uBAAuB;AAErE,SAAO;AAAA,IACL;AAAA,IACA,iBAAiB;AAAA,IACjB,iBAAiB;AAAA,IACjB;AAAA,IACA;AAAA,EACF;AACF;AAeA,eAAsB,sBAAsB,OAAmB,SAA4D;AACzH,QAAM;AAAA,IACJ,YAAY;AAAA,IACZ;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,QAAM,QAAQ,MAAM,YAAY;AAChC,QAAM,WAAW,MAAM,MAAM,KAAK,EAAE,SAAS;AAC7C,QAAM,sBAAsB,SAAS;AACrC,QAAM,uBAAuB,SAAS;AAGtC,MAAI,wBAAwB,UAAa,yBAAyB,QAAW;AAC3E,UAAM,IAAI,MAAM,oEAAoE;AAAA,EACtF;AAEA,QAAM,WAAW,mBAAmB;AAAA,IAClC;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC;AAID,QAAM,aAAa,MAAM,MAAM,KAAK,EACjC,OAAO,qBAAqB,sBAAsB,EAAE,KAAK,QAAQ,CAAC,EAClE,KAAK,SAAS,EACd,SAAS;AAEZ,QAAM,aAAa,MAAM,MAAM,KAAK,EACjC,OAAO,SAAS,qBAAqB,SAAS,sBAAsB,EAAE,KAAK,OAAO,CAAC,EACnF,SAAS;AAEZ,QAAM,WAAW,MAAM,MAAM,UAAU,EACpC,UAAU,CAAC;AAAA,IACV,OAAO;AAAA,IACP,MAAM,SAAS;AAAA,IACf,KAAK,SAAS;AAAA,EAChB,CAAC,CAAC,EACD,IAAI,EACJ,SAAS;AAEZ,SAAO,IAAI,WAAW,QAAQ;AAChC;AAQA,eAAe,cAAqC;AAClD,MAAI;AAEF,UAAM,cAAc,MAAM,OAAO,OAAO;AACxC,UAAM,UAAmB,YAAY;AACrC,WAAO;AAAA,EACT,SAAS,OAAgB;AAEvB,UAAM,IAAI;AAAA,MACR;AAAA,MAEA,EAAE,OAAO,MAAM;AAAA,IACjB;AAAA,EAEF;AACF;AAUA,SAAS,sBAAsB,OAAe,QAAwB;AACpE,QAAM,UAAU,KAAK,MAAM,KAAK;AAChC,OAAK,SAAS,WAAW,iBAAiB,GAAG;AAC3C,WAAO;AAAA,EACT;AAIA,SAAO,SAAS,UAAU,UAAU,IAAI,UAAU;AACpD;",
  "names": []
}


package/dist/lib/cjs/fit-screenshot.d.cts

@@ -0,0 +1,117 @@
+/**
+ * @file
+ *
+ * Fits a screenshot onto a canvas of a different aspect ratio without cropping
+ * it or distorting it, filling the leftover margins with a blurred, enlarged
+ * copy of the same image (the "pillarbox" treatment used by store listings).
+ *
+ * The motivating case is a mobile store screenshot. The Android emulator's
+ * framebuffer is whatever the AVD's screen is — a Pixel 10 Pro XL is 1344x2992,
+ * roughly 9:20 — while the community store asks for 900x1600 (9:16). Cropping
+ * to 9:16 throws away a fifth of the frame, and stretching distorts the UI, so
+ * the image is scaled to fit the HEIGHT and the two side margins are filled.
+ *
+ * The geometry is a pure function so it can be unit-tested; the pixel work needs
+ * `sharp`, which is an OPTIONAL peer dependency — declared rather than bundled
+ * because only screenshot capture needs it, and it ships platform-specific
+ * native binaries that every other consumer would pay for.
+ */
+/**
+ * Parameters for {@link computeFitToCanvas}.
+ */
+export interface ComputeFitToCanvasParams {
+    /**
+     * Height of the target canvas, in pixels.
+     */
+    readonly canvasHeightInPixels: number;
+    /**
+     * Width of the target canvas, in pixels.
+     */
+    readonly canvasWidthInPixels: number;
+    /**
+     * Height of the source image, in pixels.
+     */
+    readonly sourceHeightInPixels: number;
+    /**
+     * Width of the source image, in pixels.
+     */
+    readonly sourceWidthInPixels: number;
+}
+/**
+ * Options for {@link fitScreenshotToCanvas}.
+ */
+export interface FitScreenshotToCanvasOptions {
+    /**
+     * Gaussian blur strength applied to the margin fill.
+     *
+     * @default `24`
+     */
+    readonly blurSigma?: number;
+    /**
+     * Height of the target canvas, in pixels.
+     */
+    readonly canvasHeightInPixels: number;
+    /**
+     * Width of the target canvas, in pixels.
+     */
+    readonly canvasWidthInPixels: number;
+}
+/**
+ * Where the scaled source image sits on the canvas.
+ */
+export interface FitToCanvasGeometry {
+    /**
+     * Width of each side margin, in pixels. Both sides are equal by construction.
+     */
+    readonly marginInPixels: number;
+    /**
+     * Left offset of the scaled image on the canvas, in pixels.
+     */
+    readonly offsetXInPixels: number;
+    /**
+     * Top offset of the scaled image on the canvas, in pixels.
+     */
+    readonly offsetYInPixels: number;
+    /**
+     * Height the source is scaled to, in pixels.
+     */
+    readonly scaledHeightInPixels: number;
+    /**
+     * Width the source is scaled to, in pixels.
+     */
+    readonly scaledWidthInPixels: number;
+}
+/**
+ * Computes how a source image is scaled and placed to fill a canvas's height,
+ * with equal margins on the left and right.
+ *
+ * The scaled width is rounded to the nearest integer that leaves an EVEN
+ * remainder, so the two margins are exactly equal — an asymmetric pillarbox is
+ * visible at a glance and looks like a mistake. Where both neighbors qualify,
+ * the one closer to the true scaled width wins, so the aspect error stays below
+ * one part in a thousand.
+ *
+ * Worked example, the mobile store case: a 1344x2992 frame onto a 900x1600
+ * canvas scales by `1600/2992` to 718.72 wide. 719 would leave a 181px
+ * remainder, which cannot split evenly, so 718 is chosen (margin 91) over 720
+ * (margin 90) because 718 is nearer 718.72.
+ *
+ * @param params - The source and canvas dimensions.
+ * @returns The scaled size, the offsets, and the side margin.
+ * @throws Error if any dimension is not a positive number.
+ */
+export declare function computeFitToCanvas(params: ComputeFitToCanvasParams): FitToCanvasGeometry;
+/**
+ * Scales a screenshot to fill a canvas's height and fills the side margins with
+ * a blurred, enlarged copy of the same image.
+ *
+ * Nothing is cropped and nothing is stretched: the visible screenshot keeps its
+ * aspect ratio to within a rounding pixel, and the margins are made of the
+ * image itself rather than a flat color, so the result reads as one frame.
+ *
+ * @param bytes - The source PNG.
+ * @param options - The target canvas size and blur strength.
+ * @returns A {@link Promise} that resolves to the composed PNG, exactly the canvas size.
+ * @throws Error if `sharp` is not installed, or the source dimensions cannot be read.
+ */
+export declare function fitScreenshotToCanvas(bytes: Uint8Array, options: FitScreenshotToCanvasOptions): Promise<Uint8Array>;

package/dist/lib/cjs/index.cjs

@@ -31,10 +31,12 @@ __export(index_exports, {
   buildDemoVaultPopulate: () => import_demo_vault_populate.buildDemoVaultPopulate,
   buildDeviceMetricsOverride: () => import_capture_screenshot.buildDeviceMetricsOverride,
   captureObsidianScreenshot: () => import_capture_obsidian_screenshot.captureObsidianScreenshot,
+  computeFitToCanvas: () => import_fit_screenshot.computeFitToCanvas,
   connectToCdp: () => import_connect_to_cdp.connectToCdp,
   createTransportFromOptions: () => import_transport_factory.createTransportFromOptions,
   decodeBase64Png: () => import_capture_screenshot.decodeBase64Png,
   evalInObsidian: () => import_eval_in_obsidian.evalInObsidian,
+  fitScreenshotToCanvas: () => import_fit_screenshot.fitScreenshotToCanvas,
   getVersionMetadata: () => import_obsidian_metadata.getVersionMetadata,
   isPng: () => import_capture_screenshot.isPng,
   pollInObsidian: () => import_poll_in_obsidian.pollInObsidian,
@@ -61,6 +63,7 @@ var import_demo_vault_populate = require("./demo-vault-populate.cjs");
 var import_demo_vault_tree = require("./demo-vault-tree.cjs");
 var import_electron_compatibility = require("./electron-compatibility.cjs");
 var import_eval_in_obsidian = require("./eval-in-obsidian.cjs");
+var import_fit_screenshot = require("./fit-screenshot.cjs");
 var import_incompatible_installer_version_error = require("./incompatible-installer-version-error.cjs");
 var import_installer_compatibility = require("./installer-compatibility.cjs");
 var import_lib_registry = require("./lib-registry.cjs");
@@ -91,10 +94,12 @@ var import_version_matrix = require("./version-matrix.cjs");
   buildDemoVaultPopulate,
   buildDeviceMetricsOverride,
   captureObsidianScreenshot,
+  computeFitToCanvas,
   connectToCdp,
   createTransportFromOptions,
   decodeBase64Png,
   evalInObsidian,
+  fitScreenshotToCanvas,
   getVersionMetadata,
   isPng,
   pollInObsidian,
@@ -110,4 +115,4 @@ var import_version_matrix = require("./version-matrix.cjs");
   setVaultPathResolver,
   unregisterVault
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/index.d.cts

@@ -22,6 +22,8 @@ export type { ElectronCompatibility, ElectronCompatibilityTier, ResolveElectronC
 export { resolveElectronCompatibility } from './electron-compatibility.cjs';
 export type { EvalInObsidianParams, HoverElementParams, Lib, MoveMouseParams, PressKeyParams, TypeIntoEditorParams, UnhoverElementParams, WaitUntilParams } from './eval-in-obsidian.cjs';
 export { evalInObsidian } from './eval-in-obsidian.cjs';
+export type { ComputeFitToCanvasParams, FitScreenshotToCanvasOptions, FitToCanvasGeometry } from './fit-screenshot.cjs';
+export { computeFitToCanvas, fitScreenshotToCanvas } from './fit-screenshot.cjs';
 export type { IncompatibleInstallerVersionErrorConstructorParams } from './incompatible-installer-version-error.cjs';
 export { IncompatibleInstallerVersionError } from './incompatible-installer-version-error.cjs';
 export type { InstallerCompatibility, InstallerCompatibilityTier, ResolveInstallerCompatibilityParams } from './installer-compatibility.cjs';

package/dist/lib/cjs/library.cjs

@@ -21,7 +21,7 @@ __export(library_exports, {
   LIBRARY_VERSION: () => LIBRARY_VERSION
 });
 module.exports = __toCommonJS(library_exports);
-const LIBRARY_VERSION = false ? "dev" : "10.0.0";
+const LIBRARY_VERSION = false ? "dev" : "10.1.0";
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   LIBRARY_VERSION

package/dist/lib/esm/fit-screenshot.d.mts

@@ -0,0 +1,117 @@
+/**
+ * @file
+ *
+ * Fits a screenshot onto a canvas of a different aspect ratio without cropping
+ * it or distorting it, filling the leftover margins with a blurred, enlarged
+ * copy of the same image (the "pillarbox" treatment used by store listings).
+ *
+ * The motivating case is a mobile store screenshot. The Android emulator's
+ * framebuffer is whatever the AVD's screen is — a Pixel 10 Pro XL is 1344x2992,
+ * roughly 9:20 — while the community store asks for 900x1600 (9:16). Cropping
+ * to 9:16 throws away a fifth of the frame, and stretching distorts the UI, so
+ * the image is scaled to fit the HEIGHT and the two side margins are filled.
+ *
+ * The geometry is a pure function so it can be unit-tested; the pixel work needs
+ * `sharp`, which is an OPTIONAL peer dependency — declared rather than bundled
+ * because only screenshot capture needs it, and it ships platform-specific
+ * native binaries that every other consumer would pay for.
+ */
+/**
+ * Parameters for {@link computeFitToCanvas}.
+ */
+export interface ComputeFitToCanvasParams {
+    /**
+     * Height of the target canvas, in pixels.
+     */
+    readonly canvasHeightInPixels: number;
+    /**
+     * Width of the target canvas, in pixels.
+     */
+    readonly canvasWidthInPixels: number;
+    /**
+     * Height of the source image, in pixels.
+     */
+    readonly sourceHeightInPixels: number;
+    /**
+     * Width of the source image, in pixels.
+     */
+    readonly sourceWidthInPixels: number;
+}
+/**
+ * Options for {@link fitScreenshotToCanvas}.
+ */
+export interface FitScreenshotToCanvasOptions {
+    /**
+     * Gaussian blur strength applied to the margin fill.
+     *
+     * @default `24`
+     */
+    readonly blurSigma?: number;
+    /**
+     * Height of the target canvas, in pixels.
+     */
+    readonly canvasHeightInPixels: number;
+    /**
+     * Width of the target canvas, in pixels.
+     */
+    readonly canvasWidthInPixels: number;
+}
+/**
+ * Where the scaled source image sits on the canvas.
+ */
+export interface FitToCanvasGeometry {
+    /**
+     * Width of each side margin, in pixels. Both sides are equal by construction.
+     */
+    readonly marginInPixels: number;
+    /**
+     * Left offset of the scaled image on the canvas, in pixels.
+     */
+    readonly offsetXInPixels: number;
+    /**
+     * Top offset of the scaled image on the canvas, in pixels.
+     */
+    readonly offsetYInPixels: number;
+    /**
+     * Height the source is scaled to, in pixels.
+     */
+    readonly scaledHeightInPixels: number;
+    /**
+     * Width the source is scaled to, in pixels.
+     */
+    readonly scaledWidthInPixels: number;
+}
+/**
+ * Computes how a source image is scaled and placed to fill a canvas's height,
+ * with equal margins on the left and right.
+ *
+ * The scaled width is rounded to the nearest integer that leaves an EVEN
+ * remainder, so the two margins are exactly equal — an asymmetric pillarbox is
+ * visible at a glance and looks like a mistake. Where both neighbors qualify,
+ * the one closer to the true scaled width wins, so the aspect error stays below
+ * one part in a thousand.
+ *
+ * Worked example, the mobile store case: a 1344x2992 frame onto a 900x1600
+ * canvas scales by `1600/2992` to 718.72 wide. 719 would leave a 181px
+ * remainder, which cannot split evenly, so 718 is chosen (margin 91) over 720
+ * (margin 90) because 718 is nearer 718.72.
+ *
+ * @param params - The source and canvas dimensions.
+ * @returns The scaled size, the offsets, and the side margin.
+ * @throws Error if any dimension is not a positive number.
+ */
+export declare function computeFitToCanvas(params: ComputeFitToCanvasParams): FitToCanvasGeometry;
+/**
+ * Scales a screenshot to fill a canvas's height and fills the side margins with
+ * a blurred, enlarged copy of the same image.
+ *
+ * Nothing is cropped and nothing is stretched: the visible screenshot keeps its
+ * aspect ratio to within a rounding pixel, and the margins are made of the
+ * image itself rather than a flat color, so the result reads as one frame.
+ *
+ * @param bytes - The source PNG.
+ * @param options - The target canvas size and blur strength.
+ * @returns A {@link Promise} that resolves to the composed PNG, exactly the canvas size.
+ * @throws Error if `sharp` is not installed, or the source dimensions cannot be read.
+ */
+export declare function fitScreenshotToCanvas(bytes: Uint8Array, options: FitScreenshotToCanvasOptions): Promise<Uint8Array>;

package/dist/lib/esm/fit-screenshot.mjs

@@ -0,0 +1,89 @@
+const DEFAULT_BLUR_SIGMA = 24;
+const MARGIN_SIDES = 2;
+function computeFitToCanvas(params) {
+  const {
+    canvasHeightInPixels,
+    canvasWidthInPixels,
+    sourceHeightInPixels,
+    sourceWidthInPixels
+  } = params;
+  const namedDimensions = [
+    ["canvasHeightInPixels", canvasHeightInPixels],
+    ["canvasWidthInPixels", canvasWidthInPixels],
+    ["sourceHeightInPixels", sourceHeightInPixels],
+    ["sourceWidthInPixels", sourceWidthInPixels]
+  ];
+  for (const [name, value] of namedDimensions) {
+    if (!Number.isFinite(value) || value <= 0) {
+      throw new Error(`computeFitToCanvas: ${name} must be a positive number, got ${String(value)}.`);
+    }
+  }
+  const scaledHeightInPixels = canvasHeightInPixels;
+  const exactScaledWidth = sourceWidthInPixels * (canvasHeightInPixels / sourceHeightInPixels);
+  const scaledWidthInPixels = roundToMatchingParity(exactScaledWidth, canvasWidthInPixels);
+  if (scaledWidthInPixels > canvasWidthInPixels) {
+    throw new Error(
+      `computeFitToCanvas: the source is wider than the canvas once scaled to its height (${String(scaledWidthInPixels)} > ${String(canvasWidthInPixels)}); this fits by height and cannot letterbox.`
+    );
+  }
+  const marginInPixels = (canvasWidthInPixels - scaledWidthInPixels) / MARGIN_SIDES;
+  return {
+    marginInPixels,
+    offsetXInPixels: marginInPixels,
+    offsetYInPixels: 0,
+    scaledHeightInPixels,
+    scaledWidthInPixels
+  };
+}
+async function fitScreenshotToCanvas(bytes, options) {
+  const {
+    blurSigma = DEFAULT_BLUR_SIGMA,
+    canvasHeightInPixels,
+    canvasWidthInPixels
+  } = options;
+  const sharp = await importSharp();
+  const metadata = await sharp(bytes).metadata();
+  const sourceWidthInPixels = metadata.width;
+  const sourceHeightInPixels = metadata.height;
+  if (sourceWidthInPixels === void 0 || sourceHeightInPixels === void 0) {
+    throw new Error("fitScreenshotToCanvas: could not read the source image dimensions.");
+  }
+  const geometry = computeFitToCanvas({
+    canvasHeightInPixels,
+    canvasWidthInPixels,
+    sourceHeightInPixels,
+    sourceWidthInPixels
+  });
+  const background = await sharp(bytes).resize(canvasWidthInPixels, canvasHeightInPixels, { fit: "cover" }).blur(blurSigma).toBuffer();
+  const foreground = await sharp(bytes).resize(geometry.scaledWidthInPixels, geometry.scaledHeightInPixels, { fit: "fill" }).toBuffer();
+  const composed = await sharp(background).composite([{
+    input: foreground,
+    left: geometry.offsetXInPixels,
+    top: geometry.offsetYInPixels
+  }]).png().toBuffer();
+  return new Uint8Array(composed);
+}
+async function importSharp() {
+  try {
+    const sharpModule = await import("sharp");
+    const factory = sharpModule.default;
+    return factory;
+  } catch (error) {
+    throw new Error(
+      'fitScreenshotToCanvas needs the optional peer dependency "sharp". Install it in the consuming project (npm i -D sharp).',
+      { cause: error }
+    );
+  }
+}
+function roundToMatchingParity(value, target) {
+  const rounded = Math.round(value);
+  if ((target - rounded) % MARGIN_SIDES === 0) {
+    return rounded;
+  }
+  return value >= rounded ? rounded + 1 : rounded - 1;
+}
+export {
+  computeFitToCanvas,
+  fitScreenshotToCanvas
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/fit-screenshot.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Fits a screenshot onto a canvas of a different aspect ratio without cropping\n * it or distorting it, filling the leftover margins with a blurred, enlarged\n * copy of the same image (the \"pillarbox\" treatment used by store listings).\n *\n * The motivating case is a mobile store screenshot. The Android emulator's\n * framebuffer is whatever the AVD's screen is \u2014 a Pixel 10 Pro XL is 1344x2992,\n * roughly 9:20 \u2014 while the community store asks for 900x1600 (9:16). Cropping\n * to 9:16 throws away a fifth of the frame, and stretching distorts the UI, so\n * the image is scaled to fit the HEIGHT and the two side margins are filled.\n *\n * The geometry is a pure function so it can be unit-tested; the pixel work needs\n * `sharp`, which is an OPTIONAL peer dependency \u2014 declared rather than bundled\n * because only screenshot capture needs it, and it ships platform-specific\n * native binaries that every other consumer would pay for.\n */\n\n/**\n * Parameters for {@link computeFitToCanvas}.\n */\nexport interface ComputeFitToCanvasParams {\n  /**\n   * Height of the target canvas, in pixels.\n   */\n  readonly canvasHeightInPixels: number;\n\n  /**\n   * Width of the target canvas, in pixels.\n   */\n  readonly canvasWidthInPixels: number;\n\n  /**\n   * Height of the source image, in pixels.\n   */\n  readonly sourceHeightInPixels: number;\n\n  /**\n   * Width of the source image, in pixels.\n   */\n  readonly sourceWidthInPixels: number;\n}\n\n/**\n * Options for {@link fitScreenshotToCanvas}.\n */\nexport interface FitScreenshotToCanvasOptions {\n  /**\n   * Gaussian blur strength applied to the margin fill.\n   *\n   * @default `24`\n   */\n  readonly blurSigma?: number;\n\n  /**\n   * Height of the target canvas, in pixels.\n   */\n  readonly canvasHeightInPixels: number;\n\n  /**\n   * Width of the target canvas, in pixels.\n   */\n  readonly canvasWidthInPixels: number;\n}\n\n/**\n * Where the scaled source image sits on the canvas.\n */\nexport interface FitToCanvasGeometry {\n  /**\n   * Width of each side margin, in pixels. Both sides are equal by construction.\n   */\n  readonly marginInPixels: number;\n\n  /**\n   * Left offset of the scaled image on the canvas, in pixels.\n   */\n  readonly offsetXInPixels: number;\n\n  /**\n   * Top offset of the scaled image on the canvas, in pixels.\n   */\n  readonly offsetYInPixels: number;\n\n  /**\n   * Height the source is scaled to, in pixels.\n   */\n  readonly scaledHeightInPixels: number;\n\n  /**\n   * Width the source is scaled to, in pixels.\n   */\n  readonly scaledWidthInPixels: number;\n}\n\n/**\n * A layer passed to `sharp`'s `composite`.\n */\ninterface SharpCompositeLayer {\n  readonly input: Buffer;\n  readonly left: number;\n  readonly top: number;\n}\n\n/**\n * The `sharp` entry point this module uses, described structurally so the module\n * type-checks against the optional peer rather than depending on its types.\n */\ntype SharpFactory = (input: Uint8Array) => SharpInstance;\n\n/**\n * One `sharp` pipeline.\n */\ninterface SharpInstance {\n  blur(this: void, sigma: number): SharpInstance;\n  composite(this: void, layers: SharpCompositeLayer[]): SharpInstance;\n  metadata(this: void): Promise<SharpMetadata>;\n  png(this: void): SharpInstance;\n  resize(this: void, width: number, height: number, options?: SharpResizeOptions): SharpInstance;\n  toBuffer(this: void): Promise<Buffer>;\n}\n\n/**\n * The subset of `sharp`'s metadata this module reads.\n */\ninterface SharpMetadata {\n  readonly height?: number | undefined;\n  readonly width?: number | undefined;\n}\n\n/**\n * The subset of `sharp`'s resize options this module sets.\n */\ninterface SharpResizeOptions {\n  readonly fit: 'cover' | 'fill';\n}\n\n/**\n * Default Gaussian blur strength for the margin fill: soft enough that no\n * detail reads as content, gentle enough to keep the frame's colors.\n */\nconst DEFAULT_BLUR_SIGMA = 24;\n\n/**\n * The number of side margins the leftover width is split between.\n */\nconst MARGIN_SIDES = 2;\n\n/**\n * Computes how a source image is scaled and placed to fill a canvas's height,\n * with equal margins on the left and right.\n *\n * The scaled width is rounded to the nearest integer that leaves an EVEN\n * remainder, so the two margins are exactly equal \u2014 an asymmetric pillarbox is\n * visible at a glance and looks like a mistake. Where both neighbors qualify,\n * the one closer to the true scaled width wins, so the aspect error stays below\n * one part in a thousand.\n *\n * Worked example, the mobile store case: a 1344x2992 frame onto a 900x1600\n * canvas scales by `1600/2992` to 718.72 wide. 719 would leave a 181px\n * remainder, which cannot split evenly, so 718 is chosen (margin 91) over 720\n * (margin 90) because 718 is nearer 718.72.\n *\n * @param params - The source and canvas dimensions.\n * @returns The scaled size, the offsets, and the side margin.\n * @throws Error if any dimension is not a positive number.\n */\nexport function computeFitToCanvas(params: ComputeFitToCanvasParams): FitToCanvasGeometry {\n  const {\n    canvasHeightInPixels,\n    canvasWidthInPixels,\n    sourceHeightInPixels,\n    sourceWidthInPixels\n  } = params;\n\n  const namedDimensions: [string, number][] = [\n    ['canvasHeightInPixels', canvasHeightInPixels],\n    ['canvasWidthInPixels', canvasWidthInPixels],\n    ['sourceHeightInPixels', sourceHeightInPixels],\n    ['sourceWidthInPixels', sourceWidthInPixels]\n  ];\n\n  for (const [name, value] of namedDimensions) {\n    if (!Number.isFinite(value) || value <= 0) {\n      throw new Error(`computeFitToCanvas: ${name} must be a positive number, got ${String(value)}.`);\n    }\n  }\n\n  const scaledHeightInPixels = canvasHeightInPixels;\n  const exactScaledWidth = sourceWidthInPixels * (canvasHeightInPixels / sourceHeightInPixels);\n  const scaledWidthInPixels = roundToMatchingParity(exactScaledWidth, canvasWidthInPixels);\n\n  if (scaledWidthInPixels > canvasWidthInPixels) {\n    throw new Error(\n      'computeFitToCanvas: the source is wider than the canvas once scaled to its height '\n        + `(${String(scaledWidthInPixels)} > ${String(canvasWidthInPixels)}); this fits by height and cannot letterbox.`\n    );\n  }\n\n  const marginInPixels = (canvasWidthInPixels - scaledWidthInPixels) / MARGIN_SIDES;\n\n  return {\n    marginInPixels,\n    offsetXInPixels: marginInPixels,\n    offsetYInPixels: 0,\n    scaledHeightInPixels,\n    scaledWidthInPixels\n  };\n}\n\n/**\n * Scales a screenshot to fill a canvas's height and fills the side margins with\n * a blurred, enlarged copy of the same image.\n *\n * Nothing is cropped and nothing is stretched: the visible screenshot keeps its\n * aspect ratio to within a rounding pixel, and the margins are made of the\n * image itself rather than a flat color, so the result reads as one frame.\n *\n * @param bytes - The source PNG.\n * @param options - The target canvas size and blur strength.\n * @returns A {@link Promise} that resolves to the composed PNG, exactly the canvas size.\n * @throws Error if `sharp` is not installed, or the source dimensions cannot be read.\n */\nexport async function fitScreenshotToCanvas(bytes: Uint8Array, options: FitScreenshotToCanvasOptions): Promise<Uint8Array> {\n  const {\n    blurSigma = DEFAULT_BLUR_SIGMA,\n    canvasHeightInPixels,\n    canvasWidthInPixels\n  } = options;\n\n  const sharp = await importSharp();\n  const metadata = await sharp(bytes).metadata();\n  const sourceWidthInPixels = metadata.width;\n  const sourceHeightInPixels = metadata.height;\n\n  /* v8 ignore next 3 -- Defensive: `sharp` rejects a non-image before it can report metadata without dimensions, so this branch is unreachable from a test. */\n  if (sourceWidthInPixels === undefined || sourceHeightInPixels === undefined) {\n    throw new Error('fitScreenshotToCanvas: could not read the source image dimensions.');\n  }\n\n  const geometry = computeFitToCanvas({\n    canvasHeightInPixels,\n    canvasWidthInPixels,\n    sourceHeightInPixels,\n    sourceWidthInPixels\n  });\n\n  // The background is the same frame blown up to COVER the canvas and blurred,\n  // So the margins carry the screenshot's own colors instead of a flat bar.\n  const background = await sharp(bytes)\n    .resize(canvasWidthInPixels, canvasHeightInPixels, { fit: 'cover' })\n    .blur(blurSigma)\n    .toBuffer();\n\n  const foreground = await sharp(bytes)\n    .resize(geometry.scaledWidthInPixels, geometry.scaledHeightInPixels, { fit: 'fill' })\n    .toBuffer();\n\n  const composed = await sharp(background)\n    .composite([{\n      input: foreground,\n      left: geometry.offsetXInPixels,\n      top: geometry.offsetYInPixels\n    }])\n    .png()\n    .toBuffer();\n\n  return new Uint8Array(composed);\n}\n\n/**\n * Loads `sharp` on demand, so importing this module does not require it.\n *\n * @returns A {@link Promise} that resolves to the `sharp` factory.\n * @throws Error naming the missing optional peer dependency.\n */\nasync function importSharp(): Promise<SharpFactory> {\n  try {\n    // eslint-disable-next-line no-restricted-syntax -- `sharp` is an OPTIONAL peer, so it must be loaded lazily: a static import would drag its native binaries into every consumer of this package's index.\n    const sharpModule = await import('sharp');\n    const factory: unknown = sharpModule.default;\n    return factory as SharpFactory;\n  } catch (error: unknown) {\n    /* v8 ignore start -- Reached only when the optional peer is absent, which it never is in this package's own test run. */\n    throw new Error(\n      'fitScreenshotToCanvas needs the optional peer dependency \"sharp\". '\n        + 'Install it in the consuming project (npm i -D sharp).',\n      { cause: error }\n    );\n    /* v8 ignore stop */\n  }\n}\n\n/**\n * Rounds a width to the nearest integer sharing `target`'s parity, so\n * `target - result` is even and splits into two equal margins.\n *\n * @param value - The exact scaled width.\n * @param target - The canvas width whose parity must be matched.\n * @returns The nearest integer of the same parity as `target`.\n */\nfunction roundToMatchingParity(value: number, target: number): number {\n  const rounded = Math.round(value);\n  if ((target - rounded) % MARGIN_SIDES === 0) {\n    return rounded;\n  }\n\n  // `rounded` leaves an odd remainder, so step to whichever neighbor is closer\n  // To the true value; both have the parity `rounded` lacks.\n  return value >= rounded ? rounded + 1 : rounded - 1;\n}\n"],
  "mappings": "AA8IA,MAAM,qBAAqB;AAK3B,MAAM,eAAe;AAqBd,SAAS,mBAAmB,QAAuD;AACxF,QAAM;AAAA,IACJ;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,QAAM,kBAAsC;AAAA,IAC1C,CAAC,wBAAwB,oBAAoB;AAAA,IAC7C,CAAC,uBAAuB,mBAAmB;AAAA,IAC3C,CAAC,wBAAwB,oBAAoB;AAAA,IAC7C,CAAC,uBAAuB,mBAAmB;AAAA,EAC7C;AAEA,aAAW,CAAC,MAAM,KAAK,KAAK,iBAAiB;AAC3C,QAAI,CAAC,OAAO,SAAS,KAAK,KAAK,SAAS,GAAG;AACzC,YAAM,IAAI,MAAM,uBAAuB,IAAI,mCAAmC,OAAO,KAAK,CAAC,GAAG;AAAA,IAChG;AAAA,EACF;AAEA,QAAM,uBAAuB;AAC7B,QAAM,mBAAmB,uBAAuB,uBAAuB;AACvE,QAAM,sBAAsB,sBAAsB,kBAAkB,mBAAmB;AAEvF,MAAI,sBAAsB,qBAAqB;AAC7C,UAAM,IAAI;AAAA,MACR,sFACQ,OAAO,mBAAmB,CAAC,MAAM,OAAO,mBAAmB,CAAC;AAAA,IACtE;AAAA,EACF;AAEA,QAAM,kBAAkB,sBAAsB,uBAAuB;AAErE,SAAO;AAAA,IACL;AAAA,IACA,iBAAiB;AAAA,IACjB,iBAAiB;AAAA,IACjB;AAAA,IACA;AAAA,EACF;AACF;AAeA,eAAsB,sBAAsB,OAAmB,SAA4D;AACzH,QAAM;AAAA,IACJ,YAAY;AAAA,IACZ;AAAA,IACA;AAAA,EACF,IAAI;AAEJ,QAAM,QAAQ,MAAM,YAAY;AAChC,QAAM,WAAW,MAAM,MAAM,KAAK,EAAE,SAAS;AAC7C,QAAM,sBAAsB,SAAS;AACrC,QAAM,uBAAuB,SAAS;AAGtC,MAAI,wBAAwB,UAAa,yBAAyB,QAAW;AAC3E,UAAM,IAAI,MAAM,oEAAoE;AAAA,EACtF;AAEA,QAAM,WAAW,mBAAmB;AAAA,IAClC;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC;AAID,QAAM,aAAa,MAAM,MAAM,KAAK,EACjC,OAAO,qBAAqB,sBAAsB,EAAE,KAAK,QAAQ,CAAC,EAClE,KAAK,SAAS,EACd,SAAS;AAEZ,QAAM,aAAa,MAAM,MAAM,KAAK,EACjC,OAAO,SAAS,qBAAqB,SAAS,sBAAsB,EAAE,KAAK,OAAO,CAAC,EACnF,SAAS;AAEZ,QAAM,WAAW,MAAM,MAAM,UAAU,EACpC,UAAU,CAAC;AAAA,IACV,OAAO;AAAA,IACP,MAAM,SAAS;AAAA,IACf,KAAK,SAAS;AAAA,EAChB,CAAC,CAAC,EACD,IAAI,EACJ,SAAS;AAEZ,SAAO,IAAI,WAAW,QAAQ;AAChC;AAQA,eAAe,cAAqC;AAClD,MAAI;AAEF,UAAM,cAAc,MAAM,OAAO,OAAO;AACxC,UAAM,UAAmB,YAAY;AACrC,WAAO;AAAA,EACT,SAAS,OAAgB;AAEvB,UAAM,IAAI;AAAA,MACR;AAAA,MAEA,EAAE,OAAO,MAAM;AAAA,IACjB;AAAA,EAEF;AACF;AAUA,SAAS,sBAAsB,OAAe,QAAwB;AACpE,QAAM,UAAU,KAAK,MAAM,KAAK;AAChC,OAAK,SAAS,WAAW,iBAAiB,GAAG;AAC3C,WAAO;AAAA,EACT;AAIA,SAAO,SAAS,UAAU,UAAU,IAAI,UAAU;AACpD;",
  "names": []
}


package/dist/lib/esm/index.d.mts

@@ -22,6 +22,8 @@ export type { ElectronCompatibility, ElectronCompatibilityTier, ResolveElectronC
 export { resolveElectronCompatibility } from './electron-compatibility.mjs';
 export type { EvalInObsidianParams, HoverElementParams, Lib, MoveMouseParams, PressKeyParams, TypeIntoEditorParams, UnhoverElementParams, WaitUntilParams } from './eval-in-obsidian.mjs';
 export { evalInObsidian } from './eval-in-obsidian.mjs';
+export type { ComputeFitToCanvasParams, FitScreenshotToCanvasOptions, FitToCanvasGeometry } from './fit-screenshot.mjs';
+export { computeFitToCanvas, fitScreenshotToCanvas } from './fit-screenshot.mjs';
 export type { IncompatibleInstallerVersionErrorConstructorParams } from './incompatible-installer-version-error.mjs';
 export { IncompatibleInstallerVersionError } from './incompatible-installer-version-error.mjs';
 export type { InstallerCompatibility, InstallerCompatibilityTier, ResolveInstallerCompatibilityParams } from './installer-compatibility.mjs';

package/dist/lib/esm/index.mjs

@@ -16,6 +16,10 @@ import { buildDemoVaultPopulate } from "./demo-vault-populate.mjs";
 import { readDemoVaultTree } from "./demo-vault-tree.mjs";
 import { resolveElectronCompatibility } from "./electron-compatibility.mjs";
 import { evalInObsidian } from "./eval-in-obsidian.mjs";
+import {
+  computeFitToCanvas,
+  fitScreenshotToCanvas
+} from "./fit-screenshot.mjs";
 import { IncompatibleInstallerVersionError } from "./incompatible-installer-version-error.mjs";
 import { resolveInstallerCompatibility } from "./installer-compatibility.mjs";
 import { registerLibResolver } from "./lib-registry.mjs";
@@ -51,10 +55,12 @@ export {
   buildDemoVaultPopulate,
   buildDeviceMetricsOverride,
   captureObsidianScreenshot,
+  computeFitToCanvas,
   connectToCdp,
   createTransportFromOptions,
   decodeBase64Png,
   evalInObsidian,
+  fitScreenshotToCanvas,
   getVersionMetadata,
   isPng,
   pollInObsidian,
@@ -70,4 +76,4 @@ export {
   setVaultPathResolver,
   unregisterVault
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/library.mjs

@@ -1,4 +1,4 @@
-const LIBRARY_VERSION = false ? "dev" : "10.0.0";
+const LIBRARY_VERSION = false ? "dev" : "10.1.0";
 export {
   LIBRARY_VERSION
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-integration-testing",
-  "version": "10.1.0",
+  "version": "10.2.0",
   "description": "Simplifies integration testing of Obsidian plugins.",
   "keywords": [
     "obsidian",
@@ -227,6 +227,7 @@
     "obsidian": "^1.13.1",
     "satori": "^0.29.0",
     "semver": "^7.8.5",
+    "sharp": "^0.35.3",
     "starlight-github-alerts": "^0.4.0",
     "ts-jest": "^29.4.12",
     "ts-morph": "^28.0.0",
@@ -241,6 +242,12 @@
   },
   "peerDependencies": {
     "obsidian": "^1.12.3",
+    "sharp": "^0.35.3",
     "type-fest": "^5.6.0"
+  },
+  "peerDependenciesMeta": {
+    "sharp": {
+      "optional": true
+    }
   }
 }