tapirscan 1.0.0 → 1.1.0

package/dist/index.d.ts

@@ -1,35 +1,50 @@
 import type { Recovery, DetailRegion } from "./detail-20260914/scanner.mjs";
 import { type Barcode as FormatBarcode } from "./multiformat/scanner.js";
 import { type Format, type FormatSelection } from "./multiformat/formats.js";
-export { formatBits, linearFormats, matrixFormats, retailFormats } from "./multiformat/formats.js";
+export { commonFormats, commonLinearFormats, formatBits, linearFormats, matrixFormats, retailFormats, } from "./multiformat/formats.js";
 export type { Format, FormatSelection } from "./multiformat/formats.js";
-import { type Image, type ScanFrame, type Quad } from "./host.js";
-export type { Image, Quad } from "./host.js";
-export { ScannerError } from "./host.js";
-export type DiagnosticBarcode = FormatBarcode | (ScanFrame["barcodes"][number] & {
+import { type ScanFrame, type Quad as HostQuad } from "./completion-host.mjs";
+/** Source-image corners, in pixels. */
+export type Quad = readonly [
+    readonly [number, number],
+    readonly [number, number],
+    readonly [number, number],
+    readonly [number, number]
+];
+/** Decoded pixels; stride defaults to width * channels. Alpha is ignored. */
+export interface Image {
+    readonly data: Uint8Array;
+    readonly width: number;
+    readonly height: number;
+    readonly channels: 1 | 3 | 4;
+    readonly stride?: number;
+}
+export { ScannerError } from "./completion-host.mjs";
+type RawDiagnosticBarcode = FormatBarcode | (ScanFrame["barcodes"][number] & {
     format: "EAN13";
 });
 export type Mode = "low" | "medium" | "high" | "very-high";
 export interface ScanOptions {
-    multiple?: boolean;
+    /** Finish effort-selected EAN13/UPCA work beyond shared frame budgets. */
+    finishCandidates?: boolean;
+    /** Per-call subset of the formats configured at creation. */
+    formats?: FormatSelection;
     debug?: boolean;
-    /** Compatibility alias; use debug. Decoded polygons are always returned. */
-    includeRegions?: boolean;
 }
-export interface Diagnostics {
+interface RawDiagnostics {
     schemaVersion: 2;
     mode: Mode;
     multiple: boolean;
     elapsedMs: number;
     localizationLimited: boolean;
     scan: {
-        barcodes: DiagnosticBarcode[];
+        barcodes: RawDiagnosticBarcode[];
         unfinished: boolean;
         regions?: FormatBarcode[];
     } & Partial<Omit<ScanFrame, "barcodes" | "unfinished">>;
     localization?: {
         proposals: {
-            polygon: Quad;
+            polygon: HostQuad;
             score: number;
             text: string;
         }[];
@@ -45,33 +60,74 @@ export interface Diagnostics {
         candidateIndex: number;
     }[];
 }
+/** Deeply immutable scan evidence, independent of the scanner lifetime. */
+type ReadonlyDeep<T> = T extends object ? {
+    readonly [K in keyof T]: ReadonlyDeep<T[K]>;
+} : T;
+export type DiagnosticBarcode = ReadonlyDeep<RawDiagnosticBarcode>;
+/** Source geometry with no accepted decode; format is a reader hint. */
+export interface UndecodedRegion {
+    readonly format: Format | "Unknown";
+    readonly polygon: Quad;
+}
+/** Stable region evidence. null means this reader did not expose that evidence. */
+export interface RegionEvidence {
+    readonly proposals: ReadonlyDeep<NonNullable<RawDiagnostics["localization"]>["proposals"]> | null;
+    readonly searchWindows: ReadonlyDeep<NonNullable<RawDiagnostics["searchWindows"]>> | null;
+    readonly undecoded: readonly UndecodedRegion[];
+}
+export type Diagnostics = ReadonlyDeep<RawDiagnostics> & {
+    readonly regions: RegionEvidence;
+};
+export interface StructuredAppend {
+    /** One-based symbol index; symbols are not automatically assembled. */
+    readonly index: number;
+    readonly count: number;
+    readonly id?: string;
+    readonly parity?: number;
+}
 export interface Barcode {
-    text: string;
-    format: Format | "Unknown";
-    polygon: Quad;
-    rect: {
-        left: number;
-        top: number;
-        width: number;
-        height: number;
+    /** Payload bytes before character-set interpretation; absent when unavailable. */
+    readonly payloadBytes?: readonly number[];
+    readonly text: string;
+    readonly format: Format | "Unknown";
+    /** Reader-specific ranking evidence, not a probability or cross-reader confidence. */
+    readonly support: number;
+    readonly gs1?: boolean;
+    readonly readerInitialization?: boolean;
+    readonly structuredAppend?: StructuredAppend;
+    readonly eanAddOn?: string;
+    readonly polygon: Quad;
+    readonly rect: {
+        readonly left: number;
+        readonly top: number;
+        readonly width: number;
+        readonly height: number;
     };
 }
 export interface ScanResult {
-    barcodes: Barcode[];
-    values: string[];
-    best: Barcode | undefined;
-    image: {
-        width: number;
-        height: number;
+    readonly barcodes: readonly Barcode[];
+    readonly values: readonly string[];
+    /** Largest reader-specific support; not a cross-format confidence comparison. */
+    readonly best: Barcode | undefined;
+    readonly image: {
+        readonly width: number;
+        readonly height: number;
     };
-    mode: Mode;
-    elapsedMs: number;
-    unfinished: boolean;
-    debug?: Diagnostics;
+    readonly mode: Mode;
+    readonly elapsedMs: number;
+    readonly unfinished: boolean;
+    readonly debug?: Diagnostics;
 }
+export type EanAddOnPolicy = "Ignore" | "Read" | "Require";
 export interface ScannerOptions {
+    /** Optional EAN/UPC supplement policy, fixed at creation. */
+    eanAddOnPolicy?: EanAddOnPolicy;
     mode?: Mode;
     formats?: FormatSelection;
+    /** Directory containing the packaged WASMs; relative to the page in browsers. */
+    wasmBaseUrl?: string | URL;
+    /** Advanced loader, receiving URLs resolved against wasmBaseUrl. */
     loadWasm?: (url: URL) => Promise<ArrayBuffer>;
 }
 export type PixelImage = Image | Pick<ImageData, "data" | "width" | "height">;
@@ -79,13 +135,14 @@ export type PixelImage = Image | Pick<ImageData, "data" | "width" | "height">;
 export declare class Scanner {
     private readonly host;
     readonly mode: Mode;
-    private readonly additional?;
-    private readonly formats;
+    private readonly configuredFormats;
+    private readonly addOnPolicy;
     private constructor();
+    /** Formats available for scanning, fixed at creation. */
+    get formats(): readonly Format[];
+    get eanAddOnPolicy(): EanAddOnPolicy;
     static create(options?: ScannerOptions): Promise<Scanner>;
     scan(inputImage: PixelImage, options?: ScanOptions): ScanResult;
-    /** Convenience alias for result.best. */
-    best(result: ScanResult): Barcode | undefined;
     dispose(): void;
 }
 /** Scan one image with automatic cleanup. Reuse Scanner for a stream of images. */

package/dist/index.js

@@ -1,23 +1,48 @@
+import { mergeLinearDuplicates } from "./multiformat/linear-duplicates.js";
 import { ReleaseDetailScanner, fitLimits } from "./detail.js";
 import { policy } from "./policy.js";
 import { MediumMultiformatScanner } from "./multiformat/scanner.js";
 import { resolveFormats } from "./multiformat/formats.js";
-export { formatBits, linearFormats, matrixFormats, retailFormats } from "./multiformat/formats.js";
-import { IndependentScanner } from "./host.js";
-export { ScannerError } from "./host.js";
+export { commonFormats, commonLinearFormats, formatBits, linearFormats, matrixFormats, retailFormats, } from "./multiformat/formats.js";
+import { IndependentScanner, } from "./completion-host.mjs";
+export { ScannerError } from "./completion-host.mjs";
 function pixels(image) {
-    if ("channels" in image)
-        return image;
-    if (!(image.data instanceof Uint8ClampedArray))
-        throw new TypeError("Use ImageData or an explicit buffer with channels and stride");
+    const input = image;
+    if (input === null || typeof input !== "object")
+        throw new TypeError("Expected ImageData or decoded pixels");
+    const explicit = "channels" in image;
+    if (!explicit && !(image.data instanceof Uint8ClampedArray))
+        throw new TypeError("Use ImageData or an explicit buffer with channels");
+    const channels = explicit ? image.channels : 4;
+    const stride = explicit ? (image.stride ?? image.width * channels) : image.width * 4;
+    const required = (image.height - 1) * stride + image.width * channels;
+    if (!Number.isSafeInteger(image.width) ||
+        !Number.isSafeInteger(image.height) ||
+        image.width < 3 ||
+        image.height < 3 ||
+        image.width * image.height > 32 * 1024 * 1024 ||
+        ![1, 3, 4].includes(channels) ||
+        !Number.isSafeInteger(stride) ||
+        stride < image.width * channels ||
+        required > 128 * 1024 * 1024 ||
+        !(image.data instanceof Uint8Array || image.data instanceof Uint8ClampedArray) ||
+        image.data.byteLength < required)
+        throw new TypeError("Invalid image dimensions, channels, stride or buffer (maximum 128 MiB)");
     return {
         data: new Uint8Array(image.data.buffer, image.data.byteOffset, image.data.byteLength),
         width: image.width,
         height: image.height,
-        channels: 4,
-        stride: image.width * 4,
+        channels,
+        stride,
     };
 }
+/** Freeze only plain result data, never caller-owned input buffers. */
+function freeze(value) {
+    for (const child of Object.values(value))
+        if (child !== null && typeof child === "object")
+            freeze(child);
+    return Object.freeze(value);
+}
 async function loadDefault(url) {
     if (url.protocol === "file:") {
         const nodeFs = "node:fs/promises";
@@ -29,14 +54,51 @@ async function loadDefault(url) {
         throw new Error(`WASM load failed: ${String(response.status)}`);
     return response.arrayBuffer();
 }
+function regionEvidence(raw) {
+    const undecoded = [];
+    if (raw.scan.regions) {
+        for (const region of raw.scan.regions) {
+            if (!raw.scan.barcodes.includes(region))
+                undecoded.push({ format: region.format, polygon: region.polygon });
+        }
+    }
+    else {
+        const decoded = new Set(raw.scan.barcodes.flatMap((b) => ("candidate_indices" in b ? b.candidate_indices : [])));
+        raw.localization?.proposals.forEach((p, i) => {
+            if (!decoded.has(i))
+                undecoded.push({ format: "Unknown", polygon: p.polygon });
+        });
+        for (const attempt of raw.recovery?.attempts ?? []) {
+            const decoded = new Set(attempt.reads.flatMap((b) => b.candidate_indices));
+            attempt.proposals.forEach((p, i) => {
+                if (!decoded.has(i))
+                    undecoded.push({ format: "Unknown", polygon: p.polygon });
+            });
+        }
+    }
+    return {
+        proposals: raw.localization?.proposals ?? null,
+        searchWindows: raw.searchWindows ?? null,
+        undecoded,
+    };
+}
 function publicResult(raw, image, debug) {
-    const barcodes = raw.scan.barcodes.map(({ text, format, polygon }) => {
+    const barcodes = raw.scan.barcodes.map((read) => {
+        const { text, format, polygon, support } = read;
         const left = Math.floor(Math.min(...polygon.map((p) => p[0])));
         const top = Math.floor(Math.min(...polygon.map((p) => p[1])));
         return {
             text,
             format,
             polygon,
+            support,
+            ...("bytes" in read ? { payloadBytes: read.bytes } : {}),
+            ...("gs1" in read ? { gs1: read.gs1 } : {}),
+            ...("readerInitialization" in read
+                ? { readerInitialization: read.readerInitialization }
+                : {}),
+            ...("structuredAppend" in read ? { structuredAppend: read.structuredAppend } : {}),
+            ...("eanAddOn" in read ? { eanAddOn: read.eanAddOn } : {}),
             rect: {
                 left,
                 top,
@@ -49,121 +111,150 @@ function publicResult(raw, image, debug) {
     for (let i = 0; i < barcodes.length; i++)
         if (bestIndex < 0 || raw.scan.barcodes[i].support > raw.scan.barcodes[bestIndex].support)
             bestIndex = i;
-    return {
+    return freeze({
         barcodes,
         values: barcodes.map((b) => b.text),
         best: barcodes[bestIndex],
         image: { width: image.width, height: image.height },
         mode: raw.mode,
         elapsedMs: raw.elapsedMs,
-        unfinished: raw.scan.unfinished,
-        ...(debug ? { debug: raw } : {}),
-    };
+        unfinished: raw.scan.unfinished || raw.localizationLimited || (raw.localization?.omitted ?? 0) > 0,
+        ...(debug ? { debug: { ...raw, regions: regionEvidence(raw) } } : {}),
+    });
 }
 const modes = {
-    low: "low-release-20260915.wasm",
-    medium: "medium-release-20260915.wasm",
-    high: "high-release-20260915.wasm",
-    "very-high": "very-high-release-20260915.wasm",
+    low: "low-complete-release-20260916.wasm",
+    medium: "medium-complete-release-20260916.wasm",
+    high: "high-complete-release-20260916.wasm",
+    "very-high": "very-high-complete-release-20260916.wasm",
 };
 /** Mode selects a compiled implementation. Create another instance to switch. */
 export class Scanner {
     host;
     mode;
-    additional;
-    formats;
-    constructor(host, mode, additional, formats = ["EAN13"]) {
+    configuredFormats;
+    addOnPolicy;
+    constructor(host, mode, configuredFormats = ["EAN13"], addOnPolicy = "Ignore") {
         this.host = host;
         this.mode = mode;
-        this.additional = additional;
-        this.formats = formats;
+        this.configuredFormats = configuredFormats;
+        this.addOnPolicy = addOnPolicy;
+        Object.freeze(configuredFormats);
+    }
+    /** Formats available for scanning, fixed at creation. */
+    get formats() {
+        return this.configuredFormats;
+    }
+    get eanAddOnPolicy() {
+        return this.addOnPolicy;
     }
     static async create(options = {}) {
         const input = options;
         if (input === null || typeof input !== "object" || Array.isArray(input))
             throw new TypeError("Invalid scanner options");
         for (const key of Object.keys(options))
-            if (!["mode", "formats", "loadWasm"].includes(key))
+            if (!["mode", "formats", "wasmBaseUrl", "loadWasm", "eanAddOnPolicy"].includes(key))
                 throw new TypeError(`Unknown scanner option: ${key}`);
         const mode = options.mode ?? "medium";
         if (!Object.hasOwn(modes, mode))
             throw new TypeError("Unknown scanner mode");
-        const extraAsset = "../wasm/multiformat.wasm";
         const formats = resolveFormats(options.formats);
-        const url = new URL("../wasm/" + modes[mode], import.meta.url);
+        const addonPolicy = options.eanAddOnPolicy === undefined ? "Ignore" : options.eanAddOnPolicy;
+        if (!["Ignore", "Read", "Require"].includes(addonPolicy))
+            throw new TypeError("eanAddOnPolicy must be Ignore, Read or Require");
+        if (options.loadWasm !== undefined && typeof options.loadWasm !== "function")
+            throw new TypeError("loadWasm must be a function");
+        if (options.wasmBaseUrl !== undefined &&
+            typeof options.wasmBaseUrl !== "string" &&
+            !(options.wasmBaseUrl instanceof URL))
+            throw new TypeError("wasmBaseUrl must be a string or URL");
+        const base = options.wasmBaseUrl === undefined
+            ? new URL(/* @vite-ignore */ "../wasm/", import.meta.url)
+            : new URL(options.wasmBaseUrl, typeof location === "undefined" ? import.meta.url : location.href);
+        if (!base.pathname.endsWith("/"))
+            base.pathname += "/";
         const load = options.loadWasm ?? loadDefault;
-        const bytes = await load(url);
-        const recovery = mode === "low" ? undefined : await load(new URL("../wasm/" + modes.low, import.meta.url));
+        const needsPrimary = formats.some((f) => f === "EAN13" || f === "UPCA");
+        const bytes = needsPrimary ? await load(new URL(modes[mode], base)) : undefined;
+        const recovery = !needsPrimary || mode === "low" ? undefined : await load(new URL(modes.low, base));
+        const multiformat = addonPolicy !== "Ignore" || formats.length !== 1 || formats[0] !== "EAN13";
+        const extra = addonPolicy !== "Ignore" || formats.some((f) => f !== "EAN13" && f !== "UPCA")
+            ? await load(new URL("multiformat.wasm", base))
+            : undefined;
+        if (multiformat)
+            return new Scanner(await MediumMultiformatScanner.create(bytes, extra, mode, recovery), mode, formats, addonPolicy);
+        if (!bytes)
+            throw new Error("EAN13 engine was not loaded");
         const host = recovery
             ? await ReleaseDetailScanner.create(bytes, recovery, mode)
             : await IndependentScanner.create(bytes);
-        try {
-            const extra = formats.some((f) => f !== "EAN13" && f !== "UPCA")
-                ? await load(new URL(extraAsset, import.meta.url))
-                : undefined;
-            const additional = formats.length !== 1 || formats[0] !== "EAN13"
-                ? await MediumMultiformatScanner.create(bytes, extra, mode, recovery)
-                : undefined;
-            return new Scanner(host, mode, additional, formats);
-        }
-        catch (error) {
-            host.dispose();
-            throw error;
-        }
+        return new Scanner(host, mode, formats);
     }
     scan(inputImage, options = {}) {
         const image = pixels(inputImage);
         const input = options;
         if (input === null || typeof input !== "object" || Array.isArray(input))
             throw new TypeError("Invalid scan options");
-        for (const key of Object.keys(options)) {
-            if (key !== "multiple" && key !== "includeRegions" && key !== "debug")
+        for (const key of Object.keys(options))
+            if (key !== "debug" && key !== "formats" && key !== "finishCandidates")
                 throw new TypeError(`Unknown scan option: ${key}`);
-        }
-        for (const key of ["multiple", "includeRegions", "debug"]) {
-            if (options[key] !== undefined && typeof options[key] !== "boolean")
-                throw new TypeError(`Invalid ${key}`);
-        }
-        const multiple = options.multiple ?? true;
-        if (options.debug !== undefined &&
-            options.includeRegions !== undefined &&
-            options.debug !== options.includeRegions)
-            throw new TypeError("debug and includeRegions disagree");
-        const includeRegions = options.debug ?? options.includeRegions ?? false;
-        if (this.additional) {
-            const frame = this.additional.scan(image, this.formats);
-            const barcodes = multiple ? frame.barcodes : frame.barcodes.slice(0, 1);
+        if (options.debug !== undefined && typeof options.debug !== "boolean")
+            throw new TypeError("debug must be a boolean");
+        if (options.finishCandidates !== undefined && typeof options.finishCandidates !== "boolean")
+            throw new TypeError("finishCandidates must be a boolean");
+        const debug = options.debug ?? false;
+        const scanPolicy = { ...policy, finishCandidates: options.finishCandidates ?? false };
+        const formats = options.formats === undefined ? this.formats : resolveFormats(options.formats);
+        if (formats.some((format) => !this.formats.includes(format)))
+            throw new TypeError(`Scan formats must be a subset of configured formats. Requested: ${formats.join(", ")}; configured: ${this.formats.join(", ")}`);
+        if (this.host instanceof MediumMultiformatScanner) {
+            if (options.finishCandidates && !formats.some((f) => f === "EAN13" || f === "UPCA"))
+                throw new TypeError("finishCandidates requires EAN13 or UPCA");
+            const frame = this.host.scan(image, formats, {
+                eanAddOnSymbol: this.eanAddOnPolicy,
+                finishCandidates: options.finishCandidates,
+            });
+            const barcodes = frame.barcodes;
+            const primary = frame.primary;
+            const localization = primary?.localization;
             return publicResult({
                 schemaVersion: 2,
                 mode: this.mode,
-                multiple,
+                multiple: true,
                 elapsedMs: frame.scanMs,
+                // Preserve the aggregate limit flag when additional readers cannot separate causes.
                 localizationLimited: frame.unfinished,
                 scan: {
+                    ...(debug ? primary?.scan : {}),
                     barcodes,
                     unfinished: frame.unfinished,
-                    ...(includeRegions ? { regions: frame.regions } : {}),
+                    ...(debug ? { regions: frame.regions } : {}),
                 },
-            }, image, includeRegions);
+                ...(debug && primary
+                    ? {
+                        localization,
+                        searchWindows: primary.searchWindows,
+                        ...("recovery" in primary ? { recovery: primary.recovery } : {}),
+                        ...("detailRegions" in primary ? { detailRegions: primary.detailRegions } : {}),
+                    }
+                    : {}),
+            }, image, debug);
         }
-        const full = this.host.scanLocalized(image, policy, fitLimits[this.mode], true);
+        const full = this.host.scanLocalized(image, scanPolicy, fitLimits[this.mode], true);
         // Isolate the imported host's JSON result at the public ABI type boundary.
         const localization = full.localization;
-        const best = multiple ? undefined : this.host.best(full.scan);
-        const barcodes = (multiple ? full.scan.barcodes : best ? [best] : []).map((b) => ({
+        const barcodes = mergeLinearDuplicates(full.scan.barcodes.map((b) => ({
             ...b,
             format: "EAN13",
-        }));
+        })), image);
         return publicResult({
             schemaVersion: 2,
             mode: this.mode,
-            multiple,
+            multiple: true,
             elapsedMs: full.scanMs,
-            localizationLimited: localization.workLimited,
-            scan: includeRegions
-                ? { ...full.scan, barcodes }
-                : { barcodes, unfinished: full.scan.unfinished },
-            ...(includeRegions
+            localizationLimited: localization.workLimited || localization.omitted > 0,
+            scan: debug ? { ...full.scan, barcodes } : { barcodes, unfinished: full.scan.unfinished },
+            ...(debug
                 ? {
                     localization,
                     searchWindows: full.searchWindows,
@@ -175,23 +266,23 @@ export class Scanner {
                         : {}),
                 }
                 : {}),
-        }, image, includeRegions);
-    }
-    /** Convenience alias for result.best. */
-    best(result) {
-        return result.best;
+        }, image, debug);
     }
     dispose() {
-        this.additional?.dispose();
         this.host.dispose();
     }
 }
 /** Scan one image with automatic cleanup. Reuse Scanner for a stream of images. */
 export async function scan(image, options = {}) {
-    const { multiple, debug, includeRegions, ...creation } = options;
+    const input = options;
+    if (input === null || typeof input !== "object" || Array.isArray(input))
+        throw new TypeError("Invalid scan options");
+    const { debug, finishCandidates, ...creation } = options;
+    if (debug !== undefined && typeof debug !== "boolean")
+        throw new TypeError("debug must be a boolean");
     const scanner = await Scanner.create(creation);
     try {
-        return scanner.scan(image, { multiple, debug, includeRegions });
+        return scanner.scan(image, { debug, finishCandidates });
     }
     finally {
         scanner.dispose();

package/dist/multiformat/coverage.d.ts

@@ -0,0 +1,7 @@
+import type { Quad } from "../host.js";
+/** Convex containment, including the boundary; reject degenerate coverage. */
+export declare function containsPoint(point: readonly number[], quad: Quad): boolean;
+/** Only deep retries are deferred. Normal proposals and the full-frame bit remain. */
+export declare function uncoveredRetryMask(proposals: readonly {
+    polygon: Quad;
+}[], coverage: readonly Quad[], initial?: readonly number[]): [number, number];

package/dist/multiformat/coverage.js

@@ -0,0 +1,26 @@
+/** Convex containment, including the boundary; reject degenerate coverage. */
+export function containsPoint(point, quad) {
+    if (!point.every(Number.isFinite) || quad.some((p) => !p.every(Number.isFinite)))
+        return false;
+    let positive = false;
+    let negative = false;
+    let area = 0;
+    for (let i = 0; i < 4; i++) {
+        const a = quad[i], b = quad[(i + 1) % 4];
+        const cross = (b[0] - a[0]) * (point[1] - a[1]) - (b[1] - a[1]) * (point[0] - a[0]);
+        positive ||= cross > 1e-6;
+        negative ||= cross < -1e-6;
+        area += a[0] * b[1] - b[0] * a[1];
+    }
+    return Math.abs(area) > 1e-6 && !(positive && negative);
+}
+/** Only deep retries are deferred. Normal proposals and the full-frame bit remain. */
+export function uncoveredRetryMask(proposals, coverage, initial = [0xffffffff, 0xffffffff]) {
+    const mask = [initial[0] >>> 0, initial[1] >>> 0];
+    proposals.forEach((proposal, index) => {
+        if (coverage.some((quad) => proposal.polygon.every((point) => containsPoint(point, quad)))) {
+            mask[index >>> 5] = (mask[index >>> 5] & ~(1 << (index & 31))) >>> 0;
+        }
+    });
+    return mask;
+}

package/dist/multiformat/formats.d.ts

@@ -19,8 +19,10 @@ export declare const formatBits: {
 };
 export type Format = keyof typeof formatBits;
 export declare const retailFormats: readonly Format[];
+export declare const commonLinearFormats: readonly Format[];
+export declare const commonFormats: readonly Format[];
 export declare const linearFormats: readonly Format[];
 export declare const matrixFormats: readonly Format[];
-export type FormatSelection = readonly Format[] | "1D" | "2D" | "all";
-export declare function resolveFormats(input?: readonly string[] | "1D" | "2D" | "all"): Format[];
+export type FormatSelection = Format | readonly Format[] | "retail" | "common1D" | "common" | "1D" | "2D" | "all";
+export declare function resolveFormats(input?: readonly string[] | string): Format[];
 export declare function maskFor(formats: readonly Format[]): number;

package/dist/multiformat/formats.js

@@ -18,11 +18,15 @@ export const formatBits = {
     MaxiCode: 131072,
 };
 export const retailFormats = ["EAN13", "UPCA", "EAN8", "UPCE"];
-export const linearFormats = [
+export const commonLinearFormats = [
     ...retailFormats,
     "Code128",
     "Code39",
     "ITF",
+];
+export const commonFormats = [...commonLinearFormats, "QRCode", "DataMatrix"];
+export const linearFormats = [
+    ...commonLinearFormats,
     "Codabar",
     "Code93",
     "DataBar",
@@ -36,6 +40,12 @@ export const matrixFormats = [
     "MaxiCode",
 ];
 export function resolveFormats(input) {
+    if (input === "retail")
+        return [...retailFormats];
+    if (input === "common1D")
+        return [...commonLinearFormats];
+    if (input === "common")
+        return [...commonFormats];
     if (input === "1D")
         return [...linearFormats];
     if (input === "2D")
@@ -44,6 +54,8 @@ export function resolveFormats(input) {
         return [...linearFormats, ...matrixFormats];
     if (input === undefined)
         return ["EAN13"];
+    if (typeof input === "string" && Object.hasOwn(formatBits, input))
+        return [input];
     if (!Array.isArray(input) || input.length === 0)
         throw Error("Choose at least one barcode format.");
     for (const value of input) {

package/dist/multiformat/geometry.d.ts

@@ -2,6 +2,11 @@ import type { Quad } from "../host.js";
 export type Transform = readonly number[];
 export declare function project(t: Transform, x: number, y: number): [number, number];
 export declare function transformFor(quad: Quad, width: number, height: number): Transform;
+export declare function rectificationPlan(quad: Quad): {
+    width: number;
+    height: number;
+    transform: number[];
+};
 export declare function rectify(gray: Uint8Array, width: number, height: number, quad: Quad): {
     data: Uint8Array<ArrayBuffer>;
     width: number;