gestament 0.1.0

package/dist/testing.mjs

@@ -0,0 +1,1158 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { PNG } from "pngjs";
+import { ssim } from "ssim.js";
+import __screwUpDefaultImportModule1 from "@tesseract.js-data/eng";
+function pixelmatch$1(img1, img2, output, width, height, options = {}) {
+  const {
+    threshold = 0.1,
+    alpha = 0.1,
+    aaColor = [255, 255, 0],
+    diffColor = [255, 0, 0],
+    checkerboard = true,
+    includeAA,
+    diffColorAlt,
+    diffMask
+  } = options;
+  if (!isPixelData(img1) || !isPixelData(img2) || output && !isPixelData(output))
+    throw new Error("Image data: Uint8Array, Uint8ClampedArray or Buffer expected.");
+  if (img1.length !== img2.length || output && output.length !== img1.length)
+    throw new Error(`Image sizes do not match. Image 1 size: ${img1.length}, image 2 size: ${img2.length}`);
+  if (img1.length !== width * height * 4) throw new Error(`Image data size does not match width/height. Expecting ${width * height * 4}. Got ${img1.length}`);
+  const len = width * height;
+  const a32 = new Uint32Array(img1.buffer, img1.byteOffset, len);
+  const b32 = new Uint32Array(img2.buffer, img2.byteOffset, len);
+  let identical = true;
+  for (let i = 0; i < len; i++) {
+    if (a32[i] !== b32[i]) {
+      identical = false;
+      break;
+    }
+  }
+  if (identical) {
+    if (output && !diffMask) {
+      for (let i = 0, pos = 0; i < len; i++, pos += 4) drawGrayPixel(img1, pos, alpha, output);
+    }
+    return 0;
+  }
+  const maxDelta = 35215 * threshold * threshold;
+  const [aaR, aaG, aaB] = aaColor;
+  const [diffR, diffG, diffB] = diffColor;
+  const [altR, altG, altB] = diffColorAlt || diffColor;
+  let diff = 0;
+  for (let i = 0, pos = 0; i < len; i++, pos += 4) {
+    const delta = a32[i] === b32[i] ? 0 : colorDelta(img1, img2, pos, pos, checkerboard);
+    if (Math.abs(delta) > maxDelta) {
+      const x = i % width;
+      const y = i / width | 0;
+      const isExcludedAA = !includeAA && (antialiased(img1, x, y, width, height, a32, b32, checkerboard) || antialiased(img2, x, y, width, height, b32, a32, checkerboard));
+      if (isExcludedAA) {
+        if (output && !diffMask) drawPixel(output, pos, aaR, aaG, aaB);
+      } else {
+        if (output) {
+          if (delta < 0) {
+            drawPixel(output, pos, altR, altG, altB);
+          } else {
+            drawPixel(output, pos, diffR, diffG, diffB);
+          }
+        }
+        diff++;
+      }
+    } else if (output && !diffMask) {
+      drawGrayPixel(img1, pos, alpha, output);
+    }
+  }
+  return diff;
+}
+function isPixelData(arr) {
+  return ArrayBuffer.isView(arr) && arr.BYTES_PER_ELEMENT === 1;
+}
+function antialiased(img, x1, y1, width, height, a32, b32, checkerboard) {
+  const x0 = Math.max(x1 - 1, 0);
+  const y0 = Math.max(y1 - 1, 0);
+  const x2 = Math.min(x1 + 1, width - 1);
+  const y2 = Math.min(y1 + 1, height - 1);
+  const pos4 = (y1 * width + x1) * 4;
+  const cr = img[pos4];
+  const cg = img[pos4 + 1];
+  const cb = img[pos4 + 2];
+  const ca = img[pos4 + 3];
+  let zeroes = x1 === x0 || x1 === x2 || y1 === y0 || y1 === y2 ? 1 : 0;
+  let min = 0;
+  let max = 0;
+  let minX = 0;
+  let minY = 0;
+  let maxX = 0;
+  let maxY = 0;
+  for (let x = x0; x <= x2; x++) {
+    for (let y = y0; y <= y2; y++) {
+      if (x === x1 && y === y1) continue;
+      const delta = brightnessDelta(img, pos4, (y * width + x) * 4, cr, cg, cb, ca, checkerboard);
+      if (delta === 0) {
+        zeroes++;
+        if (zeroes > 2) return false;
+      } else if (delta < min) {
+        min = delta;
+        minX = x;
+        minY = y;
+      } else if (delta > max) {
+        max = delta;
+        maxX = x;
+        maxY = y;
+      }
+    }
+  }
+  if (min === 0 || max === 0) return false;
+  return hasManySiblings(a32, minX, minY, width, height) && hasManySiblings(b32, minX, minY, width, height) || hasManySiblings(a32, maxX, maxY, width, height) && hasManySiblings(b32, maxX, maxY, width, height);
+}
+function hasManySiblings(img, x1, y1, width, height) {
+  const x0 = Math.max(x1 - 1, 0);
+  const y0 = Math.max(y1 - 1, 0);
+  const x2 = Math.min(x1 + 1, width - 1);
+  const y2 = Math.min(y1 + 1, height - 1);
+  const val = img[y1 * width + x1];
+  let zeroes = x1 === x0 || x1 === x2 || y1 === y0 || y1 === y2 ? 1 : 0;
+  for (let x = x0; x <= x2; x++) {
+    for (let y = y0; y <= y2; y++) {
+      if (x === x1 && y === y1) continue;
+      zeroes += +(val === img[y * width + x]);
+      if (zeroes > 2) return true;
+    }
+  }
+  return false;
+}
+function colorDelta(img1, img2, k, m, checkerboard) {
+  const r1 = img1[k];
+  const g1 = img1[k + 1];
+  const b1 = img1[k + 2];
+  const a1 = img1[k + 3];
+  const r2 = img2[m];
+  const g2 = img2[m + 1];
+  const b2 = img2[m + 2];
+  const a2 = img2[m + 3];
+  let dr = r1 - r2;
+  let dg = g1 - g2;
+  let db = b1 - b2;
+  const da = a1 - a2;
+  if (a1 < 255 || a2 < 255) {
+    let rb = 255, gb = 255, bb = 255;
+    if (checkerboard) {
+      rb = 48 + 159 * (k % 2);
+      gb = 48 + 159 * ((k / 1.618033988749895 | 0) % 2);
+      bb = 48 + 159 * ((k / 2.618033988749895 | 0) % 2);
+    }
+    dr = (r1 * a1 - r2 * a2 - rb * da) / 255;
+    dg = (g1 * a1 - g2 * a2 - gb * da) / 255;
+    db = (b1 * a1 - b2 * a2 - bb * da) / 255;
+  }
+  const y = dr * 0.29889531 + dg * 0.58662247 + db * 0.11448223;
+  const i = dr * 0.59597799 - dg * 0.2741761 - db * 0.32180189;
+  const q = dr * 0.21147017 - dg * 0.52261711 + db * 0.31114694;
+  const delta = 0.5053 * y * y + 0.299 * i * i + 0.1957 * q * q;
+  return y > 0 ? -delta : delta;
+}
+function brightnessDelta(img, k, m, r1, g1, b1, a1, checkerboard) {
+  const r2 = img[m];
+  const g2 = img[m + 1];
+  const b2 = img[m + 2];
+  const a2 = img[m + 3];
+  let dr = r1 - r2;
+  let dg = g1 - g2;
+  let db = b1 - b2;
+  const da = a1 - a2;
+  if (!dr && !dg && !db && !da) return 0;
+  if (a1 < 255 || a2 < 255) {
+    let rb = 255, gb = 255, bb = 255;
+    if (checkerboard) {
+      rb = 48 + 159 * (k % 2);
+      gb = 48 + 159 * ((k / 1.618033988749895 | 0) % 2);
+      bb = 48 + 159 * ((k / 2.618033988749895 | 0) % 2);
+    }
+    dr = (r1 * a1 - r2 * a2 - rb * da) / 255;
+    dg = (g1 * a1 - g2 * a2 - gb * da) / 255;
+    db = (b1 * a1 - b2 * a2 - bb * da) / 255;
+  }
+  return dr * 0.29889531 + dg * 0.58662247 + db * 0.11448223;
+}
+function drawPixel(output, pos, r, g, b) {
+  output[pos] = r;
+  output[pos + 1] = g;
+  output[pos + 2] = b;
+  output[pos + 3] = 255;
+}
+function drawGrayPixel(img, i, alpha, output) {
+  const val = 255 + (img[i] * 0.29889531 + img[i + 1] * 0.58662247 + img[i + 2] * 0.11448223 - 255) * alpha * img[i + 3] / 255;
+  drawPixel(output, i, val, val, val);
+}
+const __screwUpDefaultImportModule0 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  default: pixelmatch$1
+}, Symbol.toStringTag, { value: "Module" }));
+const pixelmatch = __resolveDefaultExport(__screwUpDefaultImportModule0, true);
+const englishLanguageData = __resolveDefaultExport(__screwUpDefaultImportModule1, false);
+globalThis.__screwUpIsInCJS_249951a7145e = false;
+function __resolveDefaultExport(module, isESM) {
+  const __isInCJS = typeof globalThis !== "undefined" && globalThis.__screwUpIsInCJS_249951a7145e === true;
+  const maybe = module;
+  const hasDefault = !!(maybe && typeof maybe === "object" && "default" in maybe);
+  const unwrapNamespaceDefault = (value) => {
+    if (!value || typeof value !== "object") {
+      return value;
+    }
+    const inner = value;
+    const isModule = inner.__esModule === true || typeof Symbol !== "undefined" && inner[Symbol.toStringTag] === "Module";
+    if (isModule && "default" in inner) {
+      return inner.default;
+    }
+    return value;
+  };
+  const resolvedDefault = hasDefault ? unwrapNamespaceDefault(maybe.default) : void 0;
+  if (__isInCJS) {
+    return hasDefault ? resolvedDefault ?? module : module;
+  }
+  if (isESM) {
+    if (hasDefault) {
+      return resolvedDefault;
+    }
+    throw new Error("Default export not found.");
+  }
+  return hasDefault ? resolvedDefault ?? module : module;
+}
+const padNumber = (value, width) => value.toString().padStart(width, "0");
+const hashText = (value) => createHash("sha256").update(value).digest("hex").slice(0, 10);
+const defaultOcrPageSegmentationModes = [
+  "singleBlock",
+  "sparseText",
+  "singleLine",
+  "singleWord"
+];
+const pageSegmentationModeValues = {
+  auto: "3",
+  autoOnly: "2",
+  autoOsd: "1",
+  circleWord: "9",
+  osdOnly: "0",
+  rawLine: "13",
+  singleBlock: "6",
+  singleBlockVerticalText: "5",
+  singleChar: "10",
+  singleColumn: "4",
+  singleLine: "7",
+  singleWord: "8",
+  sparseText: "11",
+  sparseTextOsd: "12"
+};
+let tesseractModulePromise;
+const loadTesseractModule = async () => {
+  tesseractModulePromise ??= import("tesseract.js").then((loaded) => {
+    const module = loaded;
+    return "default" in module ? module.default : module;
+  });
+  return tesseractModulePromise;
+};
+const normalizePathSegment = (value, fallback) => {
+  const trimmed = value.trim();
+  const normalized = trimmed.replace(/[\x00-\x1f<>:"/\\|?*]+/g, "_").replace(/\s+/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+  if (normalized.length === 0) {
+    return fallback;
+  }
+  if (normalized.length <= 140) {
+    return normalized;
+  }
+  return `${normalized.slice(0, 129)}-${hashText(normalized)}`;
+};
+const serializeBounds = (bounds) => ({
+  height: bounds.height,
+  width: bounds.width,
+  x: bounds.x,
+  y: bounds.y
+});
+const resolveDefaults = (defaults, options) => {
+  const outputResultPath = options?.outputResultPath ?? defaults.outputResultPath ?? process.env.GESTAMENT_VISUAL_OUTPUT_RESULT_PATH;
+  if (outputResultPath === void 0) {
+    return void 0;
+  }
+  return {
+    outputResultPath: resolve(outputResultPath),
+    variant: options?.variant ?? defaults.variant ?? process.env.GESTAMENT_VISUAL_VARIANT ?? process.env.GESTAMENT_TEST_BACKEND ?? "default"
+  };
+};
+const loadExpectedImage = async (expectedImage) => {
+  if (Buffer.isBuffer(expectedImage)) {
+    return {
+      data: expectedImage,
+      source: "buffer",
+      sourcePath: void 0
+    };
+  }
+  if (typeof expectedImage === "string") {
+    const sourcePath2 = resolve(expectedImage);
+    return {
+      data: await readFile(sourcePath2),
+      source: "path",
+      sourcePath: sourcePath2
+    };
+  }
+  if (expectedImage.protocol !== "file:") {
+    throw new TypeError("expectedImage URL must use the file: protocol.");
+  }
+  const sourcePath = fileURLToPath(expectedImage);
+  return {
+    data: await readFile(sourcePath),
+    source: "file-url",
+    sourcePath
+  };
+};
+const decodePng = (image) => {
+  const png = PNG.sync.read(image);
+  return {
+    data: png.data,
+    height: png.height,
+    width: png.width
+  };
+};
+const validateCaptureImage = (capture, png) => {
+  if (png.width !== capture.visibleBounds.width || png.height !== capture.visibleBounds.height) {
+    throw new Error(
+      `Capture PNG size ${png.width}x${png.height} does not match visible bounds ${capture.visibleBounds.width}x${capture.visibleBounds.height}.`
+    );
+  }
+};
+const validateFiniteInteger = (value, label) => {
+  if (!Number.isInteger(value)) {
+    throw new TypeError(`${label} must be an integer.`);
+  }
+};
+const validateRegion = (region, imageWidth, imageHeight, label) => {
+  validateFiniteInteger(region.x, `${label}.x`);
+  validateFiniteInteger(region.y, `${label}.y`);
+  validateFiniteInteger(region.width, `${label}.width`);
+  validateFiniteInteger(region.height, `${label}.height`);
+  if (region.x < 0 || region.y < 0) {
+    throw new TypeError(`${label} origin must be inside the capture image.`);
+  }
+  if (region.width <= 0 || region.height <= 0) {
+    throw new TypeError(`${label} size must be positive.`);
+  }
+  if (region.x + region.width > imageWidth || region.y + region.height > imageHeight) {
+    throw new TypeError(`${label} must be inside the capture image.`);
+  }
+};
+const validateRatio = (value, label) => {
+  if (!Number.isFinite(value) || value < 0 || value > 1) {
+    throw new TypeError(`${label} must be a number from 0 to 1.`);
+  }
+};
+const validateNonNegativeInteger = (value, label) => {
+  if (!Number.isInteger(value) || value < 0) {
+    throw new TypeError(`${label} must be a non-negative integer.`);
+  }
+};
+const getComparisonRegion = (options, imageWidth, imageHeight) => {
+  const region = options?.region ?? { height: imageHeight, width: imageWidth, x: 0, y: 0 };
+  validateRegion(region, imageWidth, imageHeight, "region");
+  return region;
+};
+const validateMasks = (masks, imageWidth, imageHeight) => {
+  if (masks === void 0) {
+    return;
+  }
+  for (const [index, mask] of masks.entries()) {
+    validateRegion(mask, imageWidth, imageHeight, `masks[${index}]`);
+  }
+};
+const copyRegionData = (source, region) => {
+  const data = new Uint8Array(region.width * region.height * 4);
+  for (let y = 0; y < region.height; y += 1) {
+    const sourceStart = ((region.y + y) * source.width + region.x) * 4;
+    const sourceEnd = sourceStart + region.width * 4;
+    const targetStart = y * region.width * 4;
+    data.set(source.data.subarray(sourceStart, sourceEnd), targetStart);
+  }
+  return data;
+};
+const applyMasks = (actualData, expectedData, region, masks) => {
+  if (masks === void 0) {
+    return;
+  }
+  for (const mask of masks) {
+    const left = Math.max(region.x, mask.x);
+    const top = Math.max(region.y, mask.y);
+    const right = Math.min(region.x + region.width, mask.x + mask.width);
+    const bottom = Math.min(region.y + region.height, mask.y + mask.height);
+    if (left >= right || top >= bottom) {
+      continue;
+    }
+    for (let y = top; y < bottom; y += 1) {
+      for (let x = left; x < right; x += 1) {
+        const index = ((y - region.y) * region.width + (x - region.x)) * 4;
+        actualData[index] = 0;
+        actualData[index + 1] = 0;
+        actualData[index + 2] = 0;
+        actualData[index + 3] = 0;
+        expectedData[index] = 0;
+        expectedData[index + 1] = 0;
+        expectedData[index + 2] = 0;
+        expectedData[index + 3] = 0;
+      }
+    }
+  }
+};
+const prepareComparison = (actualPng, expectedPng, options) => {
+  if (actualPng.width !== expectedPng.width || actualPng.height !== expectedPng.height) {
+    throw new Error(
+      `Expected image size ${expectedPng.width}x${expectedPng.height} does not match actual capture size ${actualPng.width}x${actualPng.height}.`
+    );
+  }
+  const region = getComparisonRegion(
+    options,
+    actualPng.width,
+    actualPng.height
+  );
+  validateMasks(options?.masks, actualPng.width, actualPng.height);
+  const actualData = copyRegionData(actualPng, region);
+  const expectedData = copyRegionData(expectedPng, region);
+  applyMasks(actualData, expectedData, region, options?.masks);
+  return {
+    actualData,
+    expectedData,
+    height: region.height,
+    totalPixels: region.width * region.height,
+    width: region.width
+  };
+};
+const createDiffPng = (comparison, threshold) => {
+  const diffPng = new PNG({
+    height: comparison.height,
+    width: comparison.width
+  });
+  const diffPixels = pixelmatch(
+    comparison.expectedData,
+    comparison.actualData,
+    diffPng.data,
+    comparison.width,
+    comparison.height,
+    { threshold }
+  );
+  return {
+    diffPixels,
+    diffPng
+  };
+};
+const createContext = async (defaults, options, name, counter) => {
+  const resolved = resolveDefaults(defaults, options);
+  if (resolved === void 0) {
+    return {
+      artifactsEnabled: false
+    };
+  }
+  const safeVariant = normalizePathSegment(resolved.variant, "default");
+  const safeName = normalizePathSegment(name, "capture");
+  const outputResultPath = join(
+    resolved.outputResultPath,
+    safeVariant,
+    `${safeName}-${padNumber(counter, 6)}`
+  );
+  await mkdir(outputResultPath, { recursive: true });
+  return {
+    actualImagePath: join(outputResultPath, "actual.png"),
+    outputResultPath,
+    artifactsEnabled: true,
+    diffImagePath: join(outputResultPath, "diff.png"),
+    expectedImagePath: join(outputResultPath, "expected.png"),
+    metadataJsonPath: join(outputResultPath, "metadata.json"),
+    ocrInputImagePath: join(outputResultPath, "ocr-input.png"),
+    resolved
+  };
+};
+const writeMetadata = async (context, capture, name, matcher, options, expectedImage) => {
+  await writeFile(
+    context.metadataJsonPath,
+    `${JSON.stringify(
+      {
+        bounds: serializeBounds(capture.bounds),
+        clipped: capture.clipped,
+        expectedImageSource: expectedImage.source,
+        expectedImageSourcePath: expectedImage.sourcePath,
+        imageBytes: capture.image.length,
+        matcher,
+        masks: options?.masks,
+        name,
+        region: options?.region,
+        variant: context.resolved.variant,
+        visibleBounds: serializeBounds(capture.visibleBounds)
+      },
+      void 0,
+      2
+    )}
+`
+  );
+};
+const createVisualError = (message, result) => Object.assign(new Error(message), {
+  result
+});
+const saveActualAndMetadata = async (context, capture, name, matcher, options, expectedImage) => {
+  if (!context.artifactsEnabled) {
+    return;
+  }
+  await writeFile(context.actualImagePath, capture.image);
+  await writeMetadata(context, capture, name, matcher, options, expectedImage);
+};
+const buildBaseResult = (context) => {
+  if (!context.artifactsEnabled) {
+    return {
+      pass: true
+    };
+  }
+  return {
+    actualImagePath: context.actualImagePath,
+    outputResultPath: context.outputResultPath,
+    metadataJsonPath: context.metadataJsonPath,
+    pass: true
+  };
+};
+const writeFailureArtifacts = async (context, expectedImage, diffPng) => {
+  if (!context.artifactsEnabled) {
+    return {};
+  }
+  await writeFile(context.expectedImagePath, expectedImage);
+  await writeFile(context.diffImagePath, PNG.sync.write(diffPng));
+  return {
+    diffImagePath: context.diffImagePath,
+    expectedImagePath: context.expectedImagePath
+  };
+};
+const isLookSimilarPass = (diffPixels, diffRatio, options) => {
+  const ratioPass = diffRatio <= options.maxDiffRatio;
+  const pixelsPass = options.maxDiffPixels === void 0 || diffPixels <= options.maxDiffPixels;
+  return ratioPass && pixelsPass;
+};
+const resolveLookSimilarOptions = (options) => {
+  const resolved = {
+    maxDiffPixels: options?.maxDiffPixels,
+    maxDiffRatio: options?.maxDiffRatio ?? 0.01,
+    threshold: options?.threshold ?? 0.1
+  };
+  validateRatio(resolved.threshold, "threshold");
+  validateRatio(resolved.maxDiffRatio, "maxDiffRatio");
+  if (resolved.maxDiffPixels !== void 0) {
+    validateNonNegativeInteger(resolved.maxDiffPixels, "maxDiffPixels");
+  }
+  return resolved;
+};
+const resolveSimilarityOptions = (options) => {
+  const resolved = {
+    minSimilarity: options?.minSimilarity ?? 0.985
+  };
+  validateRatio(resolved.minSimilarity, "minSimilarity");
+  return resolved;
+};
+const validateOcrPageSegmentationMode = (value, label) => {
+  if (!(value in pageSegmentationModeValues)) {
+    throw new TypeError(
+      `${label} must be a supported OCR page segmentation mode.`
+    );
+  }
+};
+const validateThreshold = (value, label) => {
+  if (!Number.isInteger(value) || value < 0 || value > 255) {
+    throw new TypeError(`${label} must be an integer from 0 to 255.`);
+  }
+};
+const validatePositiveInteger = (value, label) => {
+  if (!Number.isInteger(value) || value <= 0) {
+    throw new TypeError(`${label} must be a positive integer.`);
+  }
+};
+const normalizeWhitespace = (value) => value.replace(/\s+/g, " ").trim();
+const resolveOcrPreprocessOptions = (options) => {
+  const resolved = {
+    grayscale: options?.grayscale ?? false,
+    invert: options?.invert ?? false,
+    scale: options?.scale ?? 1,
+    threshold: options?.threshold ?? -1
+  };
+  validatePositiveInteger(resolved.scale, "preprocess.scale");
+  if (resolved.threshold !== -1) {
+    validateThreshold(resolved.threshold, "preprocess.threshold");
+  }
+  return resolved;
+};
+const resolveOcrOptions = (options, imageWidth, imageHeight) => {
+  const pageSegmentationModes = options?.pageSegmentationModes ?? defaultOcrPageSegmentationModes;
+  if (pageSegmentationModes.length === 0) {
+    throw new TypeError("pageSegmentationModes must not be empty.");
+  }
+  for (const [index, mode] of pageSegmentationModes.entries()) {
+    validateOcrPageSegmentationMode(mode, `pageSegmentationModes[${index}]`);
+  }
+  const region = options?.region ?? { height: imageHeight, width: imageWidth, x: 0, y: 0 };
+  validateRegion(region, imageWidth, imageHeight, "region");
+  return {
+    pageSegmentationModes,
+    parameters: options?.parameters ?? {},
+    preprocess: resolveOcrPreprocessOptions(options?.preprocess),
+    region
+  };
+};
+const hasOcrPreprocessing = (options, region, imageWidth, imageHeight) => options.grayscale || options.invert || options.scale !== 1 || options.threshold !== -1 || region.x !== 0 || region.y !== 0 || region.width !== imageWidth || region.height !== imageHeight;
+const getLuminance = (red, green, blue) => Math.round(red * 0.2126 + green * 0.7152 + blue * 0.0722);
+const prepareOcrImage = (originalImage, png, options) => {
+  if (!hasOcrPreprocessing(
+    options.preprocess,
+    options.region,
+    png.width,
+    png.height
+  )) {
+    return {
+      image: originalImage,
+      preprocess: options.preprocess,
+      region: options.region
+    };
+  }
+  const output = new PNG({
+    height: options.region.height * options.preprocess.scale,
+    width: options.region.width * options.preprocess.scale
+  });
+  for (let y = 0; y < output.height; y += 1) {
+    for (let x = 0; x < output.width; x += 1) {
+      const sourceX = options.region.x + Math.floor(x / options.preprocess.scale);
+      const sourceY = options.region.y + Math.floor(y / options.preprocess.scale);
+      const sourceIndex = (sourceY * png.width + sourceX) * 4;
+      const targetIndex = (y * output.width + x) * 4;
+      const red = png.data[sourceIndex];
+      const green = png.data[sourceIndex + 1];
+      const blue = png.data[sourceIndex + 2];
+      const alpha = png.data[sourceIndex + 3];
+      const luminance = getLuminance(red, green, blue);
+      const thresholded = options.preprocess.threshold === -1 ? luminance : luminance >= options.preprocess.threshold ? 255 : 0;
+      const value = options.preprocess.grayscale || options.preprocess.threshold !== -1 ? thresholded : void 0;
+      output.data[targetIndex] = options.preprocess.invert ? 255 - (value ?? red) : value ?? red;
+      output.data[targetIndex + 1] = options.preprocess.invert ? 255 - (value ?? green) : value ?? green;
+      output.data[targetIndex + 2] = options.preprocess.invert ? 255 - (value ?? blue) : value ?? blue;
+      output.data[targetIndex + 3] = alpha;
+    }
+  }
+  return {
+    image: PNG.sync.write(output),
+    preprocess: options.preprocess,
+    region: options.region
+  };
+};
+const isEnglishOnlyLanguage = (languages) => {
+  if (languages === void 0) {
+    return true;
+  }
+  if (typeof languages === "string") {
+    return languages === "eng";
+  }
+  return languages.length === 1 && languages[0] === "eng";
+};
+const resolveOcrWorkerOptions = (defaults) => {
+  const languages = defaults?.languages === void 0 ? englishLanguageData.code : typeof defaults.languages === "string" ? defaults.languages : [...defaults.languages];
+  const useBundledEnglishData = defaults?.langPath === void 0 && isEnglishOnlyLanguage(languages);
+  const workerOptions = {
+    logger: () => void 0
+  };
+  if (defaults?.cachePath !== void 0) {
+    workerOptions.cachePath = defaults.cachePath;
+  }
+  if (defaults?.corePath !== void 0) {
+    workerOptions.corePath = defaults.corePath;
+  }
+  if (defaults?.workerPath !== void 0) {
+    workerOptions.workerPath = defaults.workerPath;
+  }
+  if (defaults?.langPath !== void 0) {
+    workerOptions.langPath = defaults.langPath;
+  } else if (useBundledEnglishData) {
+    workerOptions.langPath = englishLanguageData.langPath;
+  }
+  if (defaults?.gzip !== void 0) {
+    workerOptions.gzip = defaults.gzip;
+  } else if (useBundledEnglishData) {
+    workerOptions.gzip = englishLanguageData.gzip;
+  }
+  if (defaults?.cacheMethod !== void 0) {
+    workerOptions.cacheMethod = defaults.cacheMethod;
+  } else if (useBundledEnglishData) {
+    workerOptions.cacheMethod = "none";
+  }
+  return {
+    languages,
+    options: workerOptions
+  };
+};
+const createOcrWorker = async (defaults) => {
+  const tesseract = await loadTesseractModule();
+  const resolved = resolveOcrWorkerOptions(defaults);
+  return await tesseract.createWorker(
+    resolved.languages,
+    void 0,
+    resolved.options
+  );
+};
+const recognizeWithWorker = async (worker, preparedImage, options) => {
+  const attempts = [];
+  for (const pageSegmentationMode of options.pageSegmentationModes) {
+    await worker.setParameters({
+      ...options.parameters,
+      tessedit_pageseg_mode: pageSegmentationModeValues[pageSegmentationMode]
+    });
+    const recognized = await worker.recognize(preparedImage.image);
+    attempts.push({
+      confidence: Number.isFinite(recognized.data.confidence) ? recognized.data.confidence : 0,
+      normalizedText: normalizeWhitespace(recognized.data.text),
+      pageSegmentationMode,
+      text: recognized.data.text
+    });
+  }
+  return attempts;
+};
+const createOcrWorkerController = (defaults) => {
+  if (defaults?.workerMode !== "shared") {
+    return {
+      recognize: async (preparedImage, options) => {
+        const worker = await createOcrWorker(defaults);
+        try {
+          return await recognizeWithWorker(worker, preparedImage, options);
+        } finally {
+          await worker.terminate();
+        }
+      },
+      release: async () => void 0
+    };
+  }
+  let workerPromise;
+  let queue = Promise.resolve();
+  const getWorker = () => {
+    workerPromise ??= createOcrWorker(defaults);
+    return workerPromise;
+  };
+  const enqueue = async (operation) => {
+    const previous = queue;
+    let resolveNext = () => void 0;
+    queue = new Promise((resolve2) => {
+      resolveNext = resolve2;
+    });
+    await previous;
+    try {
+      return await operation();
+    } finally {
+      resolveNext();
+    }
+  };
+  return {
+    recognize: async (preparedImage, options) => await enqueue(
+      async () => recognizeWithWorker(await getWorker(), preparedImage, options)
+    ),
+    release: async () => {
+      await queue;
+      if (workerPromise === void 0) {
+        return;
+      }
+      const worker = await workerPromise;
+      workerPromise = void 0;
+      await worker.terminate();
+    }
+  };
+};
+const validateConfidence = (value, label) => {
+  if (!Number.isFinite(value) || value < 0 || value > 100) {
+    throw new TypeError(`${label} must be a number from 0 to 100.`);
+  }
+};
+const formatExpectedText = (expected) => typeof expected === "string" ? expected : expected.toString();
+const serializeExpectedText = (expected) => {
+  if (expected === void 0) {
+    return void 0;
+  }
+  if (typeof expected === "string") {
+    return {
+      type: "string",
+      value: expected
+    };
+  }
+  return {
+    flags: expected.flags,
+    source: expected.source,
+    type: "regexp"
+  };
+};
+const selectBestOcrAttempt = (attempts) => {
+  const [firstAttempt] = attempts;
+  if (firstAttempt === void 0) {
+    throw new Error("OCR did not return any recognition attempts.");
+  }
+  return attempts.reduce(
+    (best, current) => current.confidence > best.confidence ? current : best
+  );
+};
+const createOcrTextData = (context, attempts) => {
+  const bestAttempt = selectBestOcrAttempt(attempts);
+  if (!context.artifactsEnabled) {
+    return {
+      actualImagePath: void 0,
+      attempts,
+      confidence: bestAttempt.confidence,
+      metadataJsonPath: void 0,
+      normalizedText: bestAttempt.normalizedText,
+      ocrInputImagePath: void 0,
+      outputResultPath: void 0,
+      pageSegmentationMode: bestAttempt.pageSegmentationMode,
+      text: bestAttempt.text
+    };
+  }
+  return {
+    actualImagePath: context.actualImagePath,
+    attempts,
+    confidence: bestAttempt.confidence,
+    metadataJsonPath: context.metadataJsonPath,
+    normalizedText: bestAttempt.normalizedText,
+    ocrInputImagePath: context.ocrInputImagePath,
+    outputResultPath: context.outputResultPath,
+    pageSegmentationMode: bestAttempt.pageSegmentationMode,
+    text: bestAttempt.text
+  };
+};
+const writeOcrMetadata = async (context, capture, name, matcher, options, preparedImage, attempts, expected) => {
+  await writeFile(
+    context.metadataJsonPath,
+    `${JSON.stringify(
+      {
+        attempts,
+        bounds: serializeBounds(capture.bounds),
+        clipped: capture.clipped,
+        expectedText: serializeExpectedText(expected),
+        imageBytes: capture.image.length,
+        matcher,
+        name,
+        ocrInputBytes: preparedImage.image.length,
+        pageSegmentationModes: options?.pageSegmentationModes,
+        parameters: options?.parameters,
+        preprocess: preparedImage.preprocess,
+        region: preparedImage.region,
+        variant: context.resolved.variant,
+        visibleBounds: serializeBounds(capture.visibleBounds)
+      },
+      void 0,
+      2
+    )}
+`
+  );
+};
+const saveOcrArtifactsAndMetadata = async (context, capture, name, matcher, options, preparedImage, attempts, expected) => {
+  if (!context.artifactsEnabled) {
+    return;
+  }
+  await writeFile(context.actualImagePath, capture.image);
+  await writeFile(context.ocrInputImagePath, preparedImage.image);
+  await writeOcrMetadata(
+    context,
+    capture,
+    name,
+    matcher,
+    options,
+    preparedImage,
+    attempts,
+    expected
+  );
+};
+const matchOcrAttempt = (attempt, expected, options) => {
+  const normalize = options?.normalizeWhitespace ?? true;
+  const candidate = normalize ? attempt.normalizedText : attempt.text;
+  const minConfidence = options?.minConfidence;
+  if (minConfidence !== void 0) {
+    validateConfidence(minConfidence, "minConfidence");
+    if (attempt.confidence < minConfidence) {
+      return false;
+    }
+  }
+  if (typeof expected === "string") {
+    if (expected.length === 0) {
+      throw new TypeError("expected text must not be empty.");
+    }
+    const expectedText = normalize ? normalizeWhitespace(expected) : expected;
+    if (expectedText.length === 0) {
+      throw new TypeError(
+        "expected text must not be empty after normalization."
+      );
+    }
+    if (options?.caseSensitive ?? false) {
+      return candidate.includes(expectedText);
+    }
+    return candidate.toLocaleLowerCase().includes(expectedText.toLocaleLowerCase());
+  }
+  expected.lastIndex = 0;
+  const matched = expected.test(candidate);
+  expected.lastIndex = 0;
+  return matched;
+};
+const createOcrResult = (data, expected, pass, selectedAttempt) => {
+  const artifactPaths = data.outputResultPath === void 0 ? {} : {
+    actualImagePath: data.actualImagePath,
+    metadataJsonPath: data.metadataJsonPath,
+    ocrInputImagePath: data.ocrInputImagePath,
+    outputResultPath: data.outputResultPath
+  };
+  return {
+    ...artifactPaths,
+    attempts: data.attempts,
+    confidence: selectedAttempt.confidence,
+    expectedText: formatExpectedText(expected),
+    normalizedText: selectedAttempt.normalizedText,
+    pageSegmentationMode: selectedAttempt.pageSegmentationMode,
+    pass,
+    text: selectedAttempt.text
+  };
+};
+const assertOcrText = async (data, expected, options) => {
+  const matchedAttempt = data.attempts.find(
+    (attempt) => matchOcrAttempt(attempt, expected, options)
+  );
+  if (matchedAttempt !== void 0) {
+    return createOcrResult(data, expected, true, matchedAttempt);
+  }
+  const bestAttempt = selectBestOcrAttempt(data.attempts);
+  const failedResult = createOcrResult(data, expected, false, bestAttempt);
+  throw createVisualError(
+    `Capture OCR text did not contain ${formatExpectedText(
+      expected
+    )}. Recognized text: ${JSON.stringify(bestAttempt.normalizedText)}.`,
+    failedResult
+  );
+};
+const createOcrText = (data) => {
+  const artifactPaths = data.outputResultPath === void 0 ? {} : {
+    actualImagePath: data.actualImagePath,
+    metadataJsonPath: data.metadataJsonPath,
+    ocrInputImagePath: data.ocrInputImagePath,
+    outputResultPath: data.outputResultPath
+  };
+  return {
+    ...artifactPaths,
+    attempts: data.attempts,
+    confidence: data.confidence,
+    normalizedText: data.normalizedText,
+    pageSegmentationMode: data.pageSegmentationMode,
+    text: data.text,
+    toContainText: async (expected, options) => await assertOcrText(data, expected, options)
+  };
+};
+const readCaptureText = async (defaults, nextCounter, workerController, capture, name, matcher, options, expected) => {
+  const context = await createContext(defaults, options, name, nextCounter());
+  const actualPng = decodePng(capture.image);
+  validateCaptureImage(capture, actualPng);
+  const ocrOptions = resolveOcrOptions(
+    options,
+    actualPng.width,
+    actualPng.height
+  );
+  const preparedImage = prepareOcrImage(capture.image, actualPng, ocrOptions);
+  const attempts = await workerController.recognize(preparedImage, ocrOptions);
+  await saveOcrArtifactsAndMetadata(
+    context,
+    capture,
+    name,
+    matcher,
+    options,
+    preparedImage,
+    attempts,
+    expected
+  );
+  return createOcrText(createOcrTextData(context, attempts));
+};
+const createLookSimilarAssertion = (defaults, nextCounter, capture, name) => {
+  const toLookSimilar = async (expectedImage, options) => {
+    const context = await createContext(defaults, options, name, nextCounter());
+    const actualPng = decodePng(capture.image);
+    validateCaptureImage(capture, actualPng);
+    const loadedExpectedImage = await loadExpectedImage(expectedImage);
+    const expectedPng = decodePng(loadedExpectedImage.data);
+    await saveActualAndMetadata(
+      context,
+      capture,
+      name,
+      "toLookSimilar",
+      options,
+      loadedExpectedImage
+    );
+    const comparisonOptions = resolveLookSimilarOptions(options);
+    const comparison = prepareComparison(actualPng, expectedPng, options);
+    const { diffPixels, diffPng } = createDiffPng(
+      comparison,
+      comparisonOptions.threshold
+    );
+    const diffRatio = diffPixels / comparison.totalPixels;
+    const result = {
+      ...buildBaseResult(context),
+      diffPixels,
+      diffRatio,
+      totalPixels: comparison.totalPixels
+    };
+    if (isLookSimilarPass(diffPixels, diffRatio, comparisonOptions)) {
+      return result;
+    }
+    const failureArtifacts = await writeFailureArtifacts(
+      context,
+      loadedExpectedImage.data,
+      diffPng
+    );
+    const failedResult = {
+      ...result,
+      ...failureArtifacts,
+      pass: false
+    };
+    throw createVisualError(
+      `Capture image differs: ${diffPixels} pixels (${diffRatio.toFixed(
+        6
+      )}) exceeded maxDiffRatio ${comparisonOptions.maxDiffRatio}${comparisonOptions.maxDiffPixels === void 0 ? "" : ` and maxDiffPixels ${comparisonOptions.maxDiffPixels}`}.`,
+      failedResult
+    );
+  };
+  return toLookSimilar;
+};
+const createSimilarityAssertion = (defaults, nextCounter, capture, name) => {
+  const toHaveSimilarity = async (expectedImage, options) => {
+    const context = await createContext(defaults, options, name, nextCounter());
+    const actualPng = decodePng(capture.image);
+    validateCaptureImage(capture, actualPng);
+    const loadedExpectedImage = await loadExpectedImage(expectedImage);
+    const expectedPng = decodePng(loadedExpectedImage.data);
+    await saveActualAndMetadata(
+      context,
+      capture,
+      name,
+      "toHaveSimilarity",
+      options,
+      loadedExpectedImage
+    );
+    const comparisonOptions = resolveSimilarityOptions(options);
+    const comparison = prepareComparison(actualPng, expectedPng, options);
+    const similarity = ssim(
+      {
+        data: new Uint8ClampedArray(comparison.expectedData),
+        height: comparison.height,
+        width: comparison.width
+      },
+      {
+        data: new Uint8ClampedArray(comparison.actualData),
+        height: comparison.height,
+        width: comparison.width
+      }
+    ).mssim;
+    const { diffPixels, diffPng } = createDiffPng(comparison, 0.1);
+    const diffRatio = diffPixels / comparison.totalPixels;
+    const result = {
+      ...buildBaseResult(context),
+      diffPixels,
+      diffRatio,
+      similarity,
+      totalPixels: comparison.totalPixels
+    };
+    if (similarity >= comparisonOptions.minSimilarity) {
+      return result;
+    }
+    const failureArtifacts = await writeFailureArtifacts(
+      context,
+      loadedExpectedImage.data,
+      diffPng
+    );
+    const failedResult = {
+      ...result,
+      ...failureArtifacts,
+      pass: false
+    };
+    throw createVisualError(
+      `Capture image similarity ${similarity.toFixed(
+        6
+      )} is below minSimilarity ${comparisonOptions.minSimilarity}.`,
+      failedResult
+    );
+  };
+  return toHaveSimilarity;
+};
+const createReadTextAssertion = (defaults, nextCounter, workerController, capture, name) => {
+  const readText = async (options) => await readCaptureText(
+    defaults,
+    nextCounter,
+    workerController,
+    capture,
+    name,
+    "readText",
+    options,
+    void 0
+  );
+  return readText;
+};
+const createContainTextAssertion = (defaults, nextCounter, workerController, capture, name) => {
+  const toContainText = async (expected, options) => {
+    const ocrText = await readCaptureText(
+      defaults,
+      nextCounter,
+      workerController,
+      capture,
+      name,
+      "toContainText",
+      options,
+      expected
+    );
+    return await ocrText.toContainText(expected, options);
+  };
+  return toContainText;
+};
+const createGtkCaptureExpect = (defaults) => {
+  const resolvedDefaults = defaults ?? {};
+  const workerController = createOcrWorkerController(resolvedDefaults.ocr);
+  let counter = 0;
+  const nextCounter = () => {
+    const value = counter;
+    counter += 1;
+    return value;
+  };
+  const release = async () => {
+    await workerController.release();
+  };
+  const expectCapture2 = (capture, name) => ({
+    readText: createReadTextAssertion(
+      resolvedDefaults,
+      nextCounter,
+      workerController,
+      capture,
+      name
+    ),
+    toContainText: createContainTextAssertion(
+      resolvedDefaults,
+      nextCounter,
+      workerController,
+      capture,
+      name
+    ),
+    toHaveSimilarity: createSimilarityAssertion(
+      resolvedDefaults,
+      nextCounter,
+      capture,
+      name
+    ),
+    toLookSimilar: createLookSimilarAssertion(
+      resolvedDefaults,
+      nextCounter,
+      capture,
+      name
+    )
+  });
+  return {
+    expectCapture: expectCapture2,
+    release,
+    [Symbol.asyncDispose]: release
+  };
+};
+const defaultGtkCaptureExpect = createGtkCaptureExpect();
+const expectCapture = (capture, name) => defaultGtkCaptureExpect.expectCapture(capture, name);
+export {
+  createGtkCaptureExpect,
+  expectCapture
+};
+//# sourceMappingURL=testing.mjs.map