tapirscan 1.2.1 → 1.3.0

package/dist/index.js

@@ -1,49 +1,61 @@
-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 { commonFormats, commonLinearFormats, formatBits, linearFormats, matrixFormats, retailFormats, } from "./multiformat/formats.js";
-import { IndependentScanner, } from "./completion-host.mjs";
-export { ScannerError } from "./completion-host.mjs";
+import { hasKey, maskFor, resolveFormats, } from "./multiformat/formats.js";
+import { freeze } from "./freeze.js";
+import { pixelLayout } from "./layout.js";
+import { RustScannerSession, ScannerError } from "./rust-session.js";
+export { commonFormats, commonLinearFormats, linearFormats, matrixFormats, retailFormats, } from "./multiformat/formats.js";
+export { ScannerError } from "./rust-session.js";
+const modes = {
+    low: { id: 0, file: "low.wasm" },
+    medium: { id: 1, file: "medium.wasm" },
+    high: { id: 2, file: "high.wasm" },
+    "very-high": { id: 3, file: "very-high.wasm" },
+};
+const turboFiles = {
+    2: "experimental-turbo2.wasm",
+    4: "experimental-turbo4.wasm",
+    8: "experimental-turbo8.wasm",
+    16: "experimental-turbo16.wasm",
+};
+const addOnPolicies = { ignore: 0, read: 1, require: 2 };
 function pixels(image) {
-    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)");
+    const { data, width, height, channels, stride } = pixelLayout(image);
     return {
-        data: new Uint8Array(image.data.buffer, image.data.byteOffset, image.data.byteLength),
-        width: image.width,
-        height: image.height,
+        data: new Uint8Array(data.buffer, data.byteOffset, data.byteLength),
+        width,
+        height,
         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);
+// The package's wasm/ directory. Bundlers (Turbopack, webpack, Vite) resolve
+// `new URL("literal", import.meta.url)` as a file and fail on a directory; browser
+// bundles load WASM through tapirscan/browser's static per-file URLs instead.
+function packagedWasm() {
+    const url = new URL(import.meta.url);
+    url.pathname = url.pathname.replace(/[^/]*\/[^/]*$/, "wasm/");
+    return url;
+}
+// Bound retained WASM bytes across stable modes, experimental presets and custom URLs.
+const wasmLoads = new Map();
+function loadDefault(url) {
+    const key = url.href;
+    const cached = wasmLoads.get(key);
+    if (cached)
+        return cached;
+    const pending = readWasm(url).catch((error) => {
+        if (wasmLoads.get(key) === pending)
+            wasmLoads.delete(key);
+        throw error;
+    });
+    wasmLoads.set(key, pending);
+    if (wasmLoads.size > 4) {
+        const oldest = wasmLoads.keys().next().value;
+        if (oldest !== undefined)
+            wasmLoads.delete(oldest);
+    }
+    return pending;
 }
-async function loadDefault(url) {
+async function readWasm(url) {
     if (url.protocol === "file:") {
         const nodeFs = "node:fs/promises";
         const fs = (await import(/* @vite-ignore */ nodeFs));
@@ -54,96 +66,66 @@ 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,
+function wireResult(value) {
+    if (value === null ||
+        typeof value !== "object" ||
+        !("barcodes" in value) ||
+        !Array.isArray(value.barcodes) ||
+        !("undecoded" in value) ||
+        !Array.isArray(value.undecoded) ||
+        !("image" in value) ||
+        value.image === null ||
+        typeof value.image !== "object" ||
+        !("mode" in value) ||
+        typeof value.mode !== "string" ||
+        !hasKey(modes, value.mode))
+        throw new ScannerError("invalid_output", "Scanner returned an invalid result");
+    return value;
+}
+function publicResult(raw, elapsedMs, experimentalTurbo) {
+    if (!raw.debug)
+        throw new ScannerError("invalid_output", "Scanner omitted requested diagnostics");
+    const barcodes = raw.barcodes;
+    const undecoded = raw.undecoded.map(({ format, polygon }) => ({
+        format: format ?? "Unknown",
+        polygon,
+    }));
+    const regions = {
+        proposals: raw.debug.localization?.proposals ?? null,
+        searchWindows: raw.debug.searchWindows ?? null,
         undecoded,
     };
-}
-function publicResult(raw, image, debug) {
-    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,
-                width: Math.ceil(Math.max(...polygon.map((p) => p[0]))) - left,
-                height: Math.ceil(Math.max(...polygon.map((p) => p[1]))) - top,
-            },
-        };
-    });
-    let bestIndex = -1;
-    for (let i = 0; i < barcodes.length; i++)
-        if (bestIndex < 0 || raw.scan.barcodes[i].support > raw.scan.barcodes[bestIndex].support)
-            bestIndex = i;
-    const regions = regionEvidence(raw);
     return freeze({
         barcodes,
         values: barcodes.map((b) => b.text),
-        best: barcodes[bestIndex],
-        undecoded: regions.undecoded,
-        image: { width: image.width, height: image.height },
-        mode: raw.mode,
-        elapsedMs: raw.elapsedMs,
-        unfinished: raw.scan.unfinished || raw.localizationLimited || (raw.localization?.omitted ?? 0) > 0,
-        ...(debug ? { debug: { ...raw, regions } } : {}),
+        best: bestOf(barcodes),
+        image: raw.image,
+        ...(experimentalTurbo === undefined ? { mode: raw.mode } : { experimentalTurbo }),
+        elapsedMs,
+        undecoded,
+        diagnostics: { ...raw.debug, regions },
     });
 }
-const modes = {
-    low: "low-shared-retail-portable-20260919.wasm",
-    medium: "medium-shared-retail-portable-20260919.wasm",
-    high: "high-shared-retail-portable-20260919.wasm",
-    "very-high": "very-high-shared-retail-portable-20260919.wasm",
-};
-/** Mode selects a compiled implementation. Create another instance to switch. */
+/** A reusable scanner. Results own their data and remain valid after later scans or disposal. */
 export class Scanner {
     host;
     mode;
     configuredFormats;
     addOnPolicy;
-    constructor(host, mode, configuredFormats = resolveFormats(), addOnPolicy = "Ignore") {
+    experimentalTurbo;
+    constructor(host, 
+    /** Effort mode, fixed at creation; undefined for Turbo presets. */
+    mode, configuredFormats, addOnPolicy, 
+    /** @experimental Selected Turbo preset, fixed at creation. */
+    experimentalTurbo) {
         this.host = host;
         this.mode = mode;
         this.configuredFormats = configuredFormats;
         this.addOnPolicy = addOnPolicy;
+        this.experimentalTurbo = experimentalTurbo;
         Object.freeze(configuredFormats);
     }
-    /** Formats available for scanning, fixed at creation. */
+    /** Default formats, fixed at creation; individual scans may override them. */
     get formats() {
         return this.configuredFormats;
     }
@@ -155,15 +137,33 @@ export class Scanner {
         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", "wasmBaseUrl", "loadWasm", "eanAddOnPolicy"].includes(key))
+            if (![
+                "mode",
+                "experimentalTurbo",
+                "formats",
+                "wasmBaseUrl",
+                "loadWasm",
+                "eanAddOnPolicy",
+            ].includes(key))
                 throw new TypeError(`Unknown scanner option: ${key}`);
-        const mode = options.mode ?? "medium";
-        if (!Object.hasOwn(modes, mode))
+        const turbo = options.experimentalTurbo;
+        if (turbo !== undefined) {
+            if (typeof turbo !== "number" || !hasKey(turboFiles, turbo))
+                throw new TypeError("experimentalTurbo must be 2, 4, 8 or 16");
+            if (options.mode !== undefined)
+                throw new TypeError("Choose mode or experimentalTurbo, not both");
+            if (options.eanAddOnPolicy !== undefined && options.eanAddOnPolicy !== "ignore")
+                throw new TypeError('experimentalTurbo requires eanAddOnPolicy: "ignore"');
+        }
+        // Only undefined or a supported string: null or objects that stringify to a mode are errors.
+        if (options.mode !== undefined &&
+            (typeof options.mode !== "string" || !hasKey(modes, options.mode)))
             throw new TypeError("Unknown scanner mode");
+        const mode = turbo === undefined ? (options.mode ?? "medium") : "low";
         const formats = resolveFormats(options.formats);
-        const addonPolicy = options.eanAddOnPolicy === undefined ? "Ignore" : options.eanAddOnPolicy;
-        if (!["Ignore", "Read", "Require"].includes(addonPolicy))
-            throw new TypeError("eanAddOnPolicy must be Ignore, Read or Require");
+        const addOnPolicy = options.eanAddOnPolicy === undefined ? "ignore" : options.eanAddOnPolicy;
+        if (typeof addOnPolicy !== "string" || !hasKey(addOnPolicies, 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 &&
@@ -171,117 +171,76 @@ export class Scanner {
             !(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)
+            ? packagedWasm()
             : new URL(options.wasmBaseUrl, typeof location === "undefined" ? import.meta.url : location.href);
         if (!base.pathname.endsWith("/"))
             base.pathname += "/";
-        const load = options.loadWasm ?? loadDefault;
-        const sharedRetail = mode === "medium" && addonPolicy === "Ignore";
-        const needsPrimary = formats.some((f) => f === "EAN13" || f === "UPCA" || (sharedRetail && (f === "EAN8" || f === "UPCE")));
-        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" && (!sharedRetail || (f !== "EAN8" && f !== "UPCE")))
-            ? 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);
-        return new Scanner(host, mode, formats);
+        const selected = modes[mode];
+        const bytes = await (options.loadWasm ?? loadDefault)(new URL(turbo === undefined ? selected.file : turboFiles[turbo], base));
+        const host = await RustScannerSession.create(bytes, selected.id, maskFor(formats), addOnPolicies[addOnPolicy], turbo);
+        // Turbo presets run in the Low engine slot but have no effort mode of their own.
+        return new Scanner(host, turbo === undefined ? mode : undefined, formats, addOnPolicy, turbo);
     }
+    /** Decode barcodes with positions. Use inspect() for diagnostic evidence. */
     scan(inputImage, options = {}) {
+        const raw = this.run(inputImage, options, false);
+        if (raw === null ||
+            typeof raw !== "object" ||
+            !("barcodes" in raw) ||
+            !Array.isArray(raw.barcodes))
+            throw new ScannerError("invalid_output", "Scanner returned an invalid barcode list");
+        const barcodes = raw.barcodes;
+        return freeze({
+            barcodes,
+            values: barcodes.map((barcode) => barcode.text),
+            best: bestOf(barcodes),
+        });
+    }
+    /** Inspect barcodes, unread regions, timing and engine diagnostics. */
+    inspect(inputImage, options = {}) {
+        const start = performance.now();
+        const raw = wireResult(this.run(inputImage, options, true));
+        return publicResult(raw, performance.now() - start, this.experimentalTurbo);
+    }
+    run(inputImage, options, inspect) {
         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 !== "debug" && key !== "formats" && key !== "extendedBudget")
+            if (key !== "formats")
                 throw new TypeError(`Unknown scan option: ${key}`);
-        if (options.debug !== undefined && typeof options.debug !== "boolean")
-            throw new TypeError("debug must be a boolean");
-        if (options.extendedBudget !== undefined && typeof options.extendedBudget !== "boolean")
-            throw new TypeError("extendedBudget must be a boolean");
-        const finishCandidates = options.extendedBudget ?? false;
-        const debug = options.debug ?? false;
-        const scanPolicy = { ...policy, finishCandidates };
-        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) {
-            const frame = this.host.scan(image, formats, {
-                eanAddOnSymbol: this.eanAddOnPolicy,
-                finishCandidates,
-            });
-            const barcodes = frame.barcodes;
-            const primary = frame.primary;
-            const localization = primary?.localization;
-            return publicResult({
-                schemaVersion: 2,
-                mode: this.mode,
-                multiple: true,
-                elapsedMs: frame.scanMs,
-                // Preserve the aggregate limit flag when additional readers cannot separate causes.
-                localizationLimited: frame.unfinished,
-                scan: {
-                    ...primary?.scan,
-                    barcodes,
-                    unfinished: frame.unfinished,
-                    regions: frame.regions,
-                },
-                ...(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, scanPolicy, fitLimits[this.mode], true);
-        // Isolate the imported host's JSON result at the public ABI type boundary.
-        const localization = full.localization;
-        const barcodes = mergeLinearDuplicates(full.scan.barcodes.map((b) => ({
-            ...b,
-            format: "EAN13",
-        })), image);
-        return publicResult({
-            schemaVersion: 2,
-            mode: this.mode,
-            multiple: true,
-            elapsedMs: full.scanMs,
-            localizationLimited: localization.workLimited || localization.omitted > 0,
-            scan: { ...full.scan, barcodes },
-            localization,
-            searchWindows: full.searchWindows,
-            ...("recovery" in full && "detailRegions" in full
-                ? {
-                    recovery: full.recovery,
-                    detailRegions: full.detailRegions,
-                }
-                : {}),
-        }, image, debug);
+        const mask = options.formats === undefined ? 0 : maskFor(resolveFormats(options.formats));
+        return this.host.scan(image, inspect ? 2 : 0, mask);
     }
+    /** Release the WASM session. Repeated disposal is safe; scanning afterward fails. */
     dispose() {
         this.host.dispose();
     }
 }
+/** Highest support, keeping the first read on ties; undefined when empty. */
+function bestOf(barcodes) {
+    let winner;
+    for (const barcode of barcodes)
+        if (!winner || barcode.support > winner.support)
+            winner = barcode;
+    return winner;
+}
 /** Scan one image with automatic cleanup. Reuse Scanner for a stream of images. */
 export async function scan(image, options = {}) {
-    const input = options;
-    if (input === null || typeof input !== "object" || Array.isArray(input))
-        throw new TypeError("Invalid scan options");
-    const { debug, extendedBudget, ...creation } = options;
-    if (debug !== undefined && typeof debug !== "boolean")
-        throw new TypeError("debug must be a boolean");
-    const scanner = await Scanner.create(creation);
+    const scanner = await Scanner.create(options);
+    try {
+        return scanner.scan(image);
+    }
+    finally {
+        scanner.dispose();
+    }
+}
+/** Inspect one image with automatic cleanup. */
+export async function inspect(image, options = {}) {
+    const scanner = await Scanner.create(options);
     try {
-        return scanner.scan(image, { debug, extendedBudget });
+        return scanner.inspect(image);
     }
     finally {
         scanner.dispose();

package/dist/layout.d.ts

@@ -0,0 +1,19 @@
+/** Decoded pixels: `ImageData` or an explicit gray, RGB or RGBA buffer. */
+export interface PixelInput {
+    readonly data: Uint8Array | Uint8ClampedArray;
+    readonly width: number;
+    readonly height: number;
+    readonly channels?: 1 | 3 | 4;
+    readonly stride?: number;
+}
+/** A validated layout; `addressed` bytes from the start of `data` hold the image. */
+export interface PixelLayout {
+    readonly data: Uint8Array | Uint8ClampedArray;
+    readonly width: number;
+    readonly height: number;
+    readonly channels: 1 | 3 | 4;
+    readonly stride: number;
+    readonly addressed: number;
+}
+/** Validate decoded pixels against the scanner limits without copying them. */
+export declare function pixelLayout(image: unknown): PixelLayout;

package/dist/layout.js

@@ -0,0 +1,27 @@
+// Pixel layout rules shared by the core and the browser entry. No WASM imports, so
+// the browser entry can validate on the page without loading the core.
+/** Validate decoded pixels against the scanner limits without copying them. */
+export function pixelLayout(image) {
+    if (image === null || typeof image !== "object" || !("data" in image))
+        throw new TypeError("Expected ImageData or decoded pixels");
+    const { data, width, height } = image;
+    const explicit = "channels" in image;
+    if (!explicit && !(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 : undefined) ?? width * (channels ?? 0);
+    const addressed = (height - 1) * stride + width * (channels ?? 0);
+    if (!Number.isSafeInteger(width) ||
+        !Number.isSafeInteger(height) ||
+        width < 3 ||
+        height < 3 ||
+        width * height > 32 * 1024 * 1024 ||
+        (channels !== 1 && channels !== 3 && channels !== 4) ||
+        !Number.isSafeInteger(stride) ||
+        stride < width * channels ||
+        addressed > 128 * 1024 * 1024 ||
+        !(data instanceof Uint8Array || data instanceof Uint8ClampedArray) ||
+        data.byteLength < addressed)
+        throw new TypeError("Invalid image dimensions, channels, stride or buffer (maximum 128 MiB)");
+    return { data, width, height, channels, stride, addressed };
+}

package/dist/multiformat/format-registry.d.ts

@@ -0,0 +1,26 @@
+export declare const formatBits: Readonly<{
+    readonly EAN13: 1;
+    readonly UPCA: 2;
+    readonly EAN8: 4;
+    readonly UPCE: 8;
+    readonly Code128: 16;
+    readonly Code39: 32;
+    readonly ITF: 64;
+    readonly Codabar: 128;
+    readonly Code93: 256;
+    readonly QRCode: 512;
+    readonly DataMatrix: 1024;
+    readonly PDF417: 2048;
+    readonly Aztec: 4096;
+    readonly DataBar: 8192;
+    readonly DataBarExpanded: 16384;
+    readonly MaxiCode: 131072;
+}>;
+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 declare const eanAddOnReadFlag = 32768;
+export declare const eanAddOnRequireFlag = 65536;

package/dist/multiformat/format-registry.js

@@ -0,0 +1,63 @@
+// Generated by scripts/generate_formats.py from config/formats.json. Do not edit.
+// Frozen: these shared constants also back the scanner defaults.
+export const formatBits = Object.freeze({
+    EAN13: 1,
+    UPCA: 2,
+    EAN8: 4,
+    UPCE: 8,
+    Code128: 16,
+    Code39: 32,
+    ITF: 64,
+    Codabar: 128,
+    Code93: 256,
+    QRCode: 512,
+    DataMatrix: 1024,
+    PDF417: 2048,
+    Aztec: 4096,
+    DataBar: 8192,
+    DataBarExpanded: 16384,
+    MaxiCode: 131072,
+});
+export const retailFormats = Object.freeze(["EAN13", "UPCA", "EAN8", "UPCE"]);
+export const commonLinearFormats = Object.freeze([
+    "EAN13",
+    "UPCA",
+    "EAN8",
+    "UPCE",
+    "Code128",
+    "Code39",
+    "ITF",
+]);
+export const commonFormats = Object.freeze([
+    "EAN13",
+    "UPCA",
+    "EAN8",
+    "UPCE",
+    "Code128",
+    "Code39",
+    "ITF",
+    "QRCode",
+    "DataMatrix",
+]);
+export const linearFormats = Object.freeze([
+    "EAN13",
+    "UPCA",
+    "EAN8",
+    "UPCE",
+    "Code128",
+    "Code39",
+    "ITF",
+    "Codabar",
+    "Code93",
+    "DataBar",
+    "DataBarExpanded",
+]);
+export const matrixFormats = Object.freeze([
+    "QRCode",
+    "DataMatrix",
+    "PDF417",
+    "Aztec",
+    "MaxiCode",
+]);
+export const eanAddOnReadFlag = 32768;
+export const eanAddOnRequireFlag = 65536;

package/dist/multiformat/formats.d.ts

@@ -1,28 +1,8 @@
 /** Explicit opt-in formats for the independent Medium extension. */
-export declare const formatBits: {
-    readonly EAN13: 1;
-    readonly UPCA: 2;
-    readonly EAN8: 4;
-    readonly UPCE: 8;
-    readonly Code128: 16;
-    readonly Code39: 32;
-    readonly ITF: 64;
-    readonly Codabar: 128;
-    readonly Code93: 256;
-    readonly QRCode: 512;
-    readonly DataMatrix: 1024;
-    readonly PDF417: 2048;
-    readonly Aztec: 4096;
-    readonly DataBar: 8192;
-    readonly DataBarExpanded: 16384;
-    readonly MaxiCode: 131072;
-};
-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[];
+import { commonFormats, commonLinearFormats, formatBits, linearFormats, matrixFormats, retailFormats, type Format } from "./format-registry.js";
+export { commonFormats, commonLinearFormats, formatBits, linearFormats, matrixFormats, retailFormats, type Format, };
+/** Own-property check that works in Chrome 91 (`Object.hasOwn` needs Chrome 93). */
+export declare function hasKey(object: object, key: PropertyKey): boolean;
 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;