tapirscan 1.2.0 → 1.2.2

package/dist/host64.js

@@ -1,184 +0,0 @@
-/** Explicit indices reject sparse arrays; nonfinite numeric geometry reaches Rust. */
-export function isQuadShape(value) {
-    if (!Array.isArray(value) || value.length !== 4)
-        return false;
-    for (let i = 0; i < 4; i++) {
-        if (!Object.hasOwn(value, i))
-            return false;
-        const point = value[i];
-        if (!Array.isArray(point) || point.length !== 2)
-            return false;
-        for (let j = 0; j < 2; j++)
-            if (!Object.hasOwn(point, j) || typeof point[j] !== 'number')
-                return false;
-    }
-    return true;
-}
-export class ScannerError extends Error {
-    code;
-    constructor(code, message) { super(message); this.name = 'ScannerError'; this.code = code; }
-}
-function integer(value, min, max, name) {
-    if (!Number.isSafeInteger(value) || value < min || value > max)
-        throw new ScannerError('invalid_input', `Invalid ${name}`);
-    return value;
-}
-function status(code) {
-    if (code !== 0)
-        throw new ScannerError(`core_${code}`, `Independent scanner rejected operation (${code})`);
-}
-function parseFrame(text, count) {
-    const v = JSON.parse(text);
-    if (!v || typeof v !== 'object')
-        throw new ScannerError('invalid_output', 'Expected frame object');
-    const f = v;
-    if (!Array.isArray(f.candidates) || f.candidates.length !== count || !Array.isArray(f.barcodes) || typeof f.unfinished !== 'boolean' || !f.reconciliation)
-        throw new ScannerError('invalid_output', 'Invalid frame shape');
-    for (let i = 0; i < f.candidates.length; i++) {
-        const c = f.candidates[i];
-        if (c.candidate_index !== i || !Array.isArray(c.coverage) || c.coverage.length !== 4 || !Array.isArray(c.observations) || !Array.isArray(c.detections) || typeof c.error !== 'boolean')
-            throw new ScannerError('invalid_output', 'Invalid candidate shape');
-    }
-    for (const b of f.barcodes)
-        if (!/^\d{13}$/.test(b.text) || !Array.isArray(b.polygon) || b.polygon.length !== 4 || !Array.isArray(b.candidate_indices) || b.candidate_indices.some(i => !Number.isInteger(i) || i < 0 || i >= count))
-            throw new ScannerError('invalid_output', 'Invalid barcode shape');
-    return f;
-}
-/** Validate before asynchronous work; returned bytes are owned by the caller. */
-export function snapshotImage(image) {
-    if (!image || typeof image !== 'object')
-        throw new ScannerError('invalid_input', 'Invalid image');
-    const width = integer(image.width, 1, 0xffffffff, 'width'), height = integer(image.height, 1, 0xffffffff, 'height');
-    if (![1, 3, 4].includes(image.channels) || !(image.data instanceof Uint8Array))
-        throw new ScannerError('invalid_input', 'Invalid image buffer/channels');
-    const stride = integer(image.stride, width * image.channels, 0xffffffff, 'stride');
-    const required = integer((height - 1) * stride + width * image.channels, 1, 128 * 1024 * 1024, 'image length');
-    if (image.data.byteLength < required)
-        throw new ScannerError('invalid_input', 'Image buffer is too short');
-    return { data: new Uint8Array(image.data.subarray(0, required)), width, height, channels: image.channels, stride };
-}
-export function snapshotPolicy(policy) {
-    if (!policy || typeof policy !== 'object')
-        throw new ScannerError('invalid_input', 'Invalid policy');
-    const copy = { ...policy };
-    for (const key of ['transitionCleanup', 'sourceIdentity', 'interiorNormalization', 'guardBias', 'allowSingleRow'])
-        if (copy[key] !== undefined && typeof copy[key] !== 'boolean')
-            throw new ScannerError('invalid_input', `Invalid ${key}`);
-    integer(copy.maxRetryPathsPerCandidate ?? 512, 0, 4096, 'candidate budget');
-    integer(copy.maxRetryPathsPerFrame ?? 8192, 0, 65536, 'frame budget');
-    integer(copy.maxAssociationChecks ?? 200000, 0, 2000000, 'comparison budget');
-    integer(copy.maxAssociationPixels ?? 2000000, 0, 16000000, 'pixel budget');
-    integer(copy.maxResults ?? 1024, 1, 4096, 'result budget');
-    return copy;
-}
-/** Uncalibrated support ordering; ties preserve spatial output order. */
-export function rankBarcodes(barcodes) {
-    return [...barcodes].sort((a, b) => b.support - a.support);
-}
-export class IndependentScanner {
-    #exports;
-    #handle;
-    constructor(exports) {
-        this.#exports = exports;
-        if (exports.regions_version() !== 1)
-            throw new ScannerError('abi_version', 'Unsupported scanner ABI');
-        this.#handle = exports.regions_new();
-        if (!this.#handle)
-            throw new ScannerError('capacity', 'Scanner handle capacity exhausted');
-    }
-    static async create(bytes) {
-        const module = await WebAssembly.compile(bytes);
-        const instance = await WebAssembly.instantiate(module, {});
-        const exports = instance.exports;
-        for (const name of ['regions_localize', 'regions_version', 'regions_new', 'regions_destroy', 'regions_prepare', 'regions_input_ptr', 'regions_input_len', 'regions_quads_ptr', 'regions_output_ptr', 'regions_output_len', 'regions_scan']) {
-            if (typeof instance.exports[name] !== 'function')
-                throw new ScannerError('abi_shape', `Missing ${name}`);
-        }
-        if (!(exports.memory instanceof WebAssembly.Memory))
-            throw new ScannerError('abi_shape', 'Missing memory');
-        return new IndependentScanner(exports);
-    }
-    /** All supplied regions receive the cheap pass; successful reads do not end scanning. */
-    scan(image, quads, policy = {}) {
-        return this.#scan(image, quads, policy, false);
-    }
-    /** Synchronous transaction: upload once, localize, decode the same owned pixels. */
-    scanLocalized(image, policy = {}, fitLimit = 8, fullFrame = false) {
-        const start = performance.now();
-        if (!this.#handle)
-            throw new ScannerError('disposed', 'Scanner is disposed');
-        if (!image || typeof image !== 'object')
-            throw new ScannerError('invalid_input', 'Invalid image');
-        const width = integer(image.width, 3, 0xffffffff, 'width'), height = integer(image.height, 3, 0xffffffff, 'height');
-        if (![1, 3, 4].includes(image.channels) || !(image.data instanceof Uint8Array))
-            throw new ScannerError('invalid_input', 'Invalid image buffer/channels');
-        const stride = integer(image.stride, width * image.channels, 0xffffffff, 'stride');
-        const required = integer((height - 1) * stride + width * image.channels, 1, 128 * 1024 * 1024, 'image length');
-        if (image.data.byteLength < required)
-            throw new ScannerError('invalid_input', 'Image buffer is too short');
-        integer(fitLimit, 0, 8, 'shear limit');
-        const e = this.#exports, id = this.#handle;
-        status(e.regions_prepare(id, width, height, image.channels, stride));
-        if (e.regions_input_len(id) !== required)
-            throw new ScannerError('abi_shape', 'Input allocation mismatch');
-        new Uint8Array(e.memory.buffer, e.regions_input_ptr(id), required).set(image.data.subarray(0, required));
-        status(e.regions_localize(id, fitLimit));
-        const localization = JSON.parse(new TextDecoder().decode(new Uint8Array(e.memory.buffer, e.regions_output_ptr(id), e.regions_output_len(id))));
-        if (!Array.isArray(localization.proposals) || localization.proposals.length > (fullFrame ? 63 : 64) || localization.proposals.some((p) => !isQuadShape(p.polygon)))
-            throw new ScannerError('abi_shape', 'Invalid localization');
-        const searchWindows = fullFrame ? [{ kind: 'full_frame_search', polygon: [[0, 0], [width - 1, 0], [width - 1, height - 1], [0, height - 1]], candidateIndex: localization.proposals.length }] : [];
-        const localizationMs = performance.now() - start, decodeStart = performance.now();
-        const scan = this.#scan(image, [...localization.proposals.map((p) => p.polygon), ...searchWindows.map(p => p.polygon)], policy, true);
-        return { localization, searchWindows, scan, localizationMs, decodingMs: performance.now() - decodeStart, scanMs: performance.now() - start };
-    }
-    #scan(image, quads, policy, prepared) {
-        const start = performance.now();
-        if (!this.#handle)
-            throw new ScannerError('disposed', 'Scanner is disposed');
-        if (!image || typeof image !== 'object' || !Array.isArray(quads) || !policy || typeof policy !== 'object')
-            throw new ScannerError('invalid_input', 'Invalid scan arguments');
-        for (const key of ['transitionCleanup', 'sourceIdentity', 'interiorNormalization', 'guardBias', 'allowSingleRow'])
-            if (policy[key] !== undefined && typeof policy[key] !== 'boolean')
-                throw new ScannerError('invalid_input', `Invalid ${key}`);
-        const e = this.#exports, id = this.#handle;
-        const width = integer(image.width, 1, 0xffffffff, 'width'), height = integer(image.height, 1, 0xffffffff, 'height');
-        if (![1, 3, 4].includes(image.channels) || !(image.data instanceof Uint8Array))
-            throw new ScannerError('invalid_input', 'Invalid image buffer/channels');
-        const stride = integer(image.stride, width * image.channels, 0xffffffff, 'stride');
-        const required = integer((height - 1) * stride + width * image.channels, 1, 128 * 1024 * 1024, 'image length');
-        if (image.data.byteLength < required)
-            throw new ScannerError('invalid_input', 'Image buffer is too short');
-        integer(quads.length, 0, 64, 'candidate count');
-        for (const q of quads)
-            if (!isQuadShape(q))
-                throw new ScannerError('invalid_input', 'Invalid quad shape');
-        const perCandidate = integer(policy.maxRetryPathsPerCandidate ?? 512, 0, 4096, 'candidate budget');
-        const perFrame = integer(policy.maxRetryPathsPerFrame ?? 8192, 0, 65536, 'frame budget');
-        const checks = integer(policy.maxAssociationChecks ?? 200000, 0, 2000000, 'comparison budget');
-        const pixels = integer(policy.maxAssociationPixels ?? 2000000, 0, 16000000, 'pixel budget');
-        const results = integer(policy.maxResults ?? 1024, 1, 4096, 'result budget');
-        const flags = (policy.transitionCleanup ? 1 : 0) | (policy.sourceIdentity ? 2 : 0) | (policy.interiorNormalization ? 4 : 0) | (policy.guardBias ? 8 : 0) | (policy.allowSingleRow ? 16 : 0);
-        if (!prepared) {
-            status(e.regions_prepare(id, width, height, image.channels, stride));
-            if (e.regions_input_len(id) !== required)
-                throw new ScannerError('abi_shape', 'Input allocation mismatch');
-            new Uint8Array(e.memory.buffer, e.regions_input_ptr(id), required).set(image.data.subarray(0, required));
-        }
-        const coordinates = new Float64Array(e.memory.buffer, e.regions_quads_ptr(id), 512);
-        quads.forEach((q, i) => q.forEach((p, j) => { coordinates[i * 8 + j * 2] = p[0]; coordinates[i * 8 + j * 2 + 1] = p[1]; }));
-        status(e.regions_scan(id, quads.length, flags, perCandidate, perFrame, checks, pixels, results));
-        // Scan can grow memory. Never reuse the earlier input/coordinate views.
-        const output = new Uint8Array(e.memory.buffer, e.regions_output_ptr(id), e.regions_output_len(id)).slice();
-        const frame = parseFrame(new TextDecoder().decode(output), quads.length);
-        return { ...frame, candidateTimingsAvailable: false, elapsedMs: performance.now() - start };
-    }
-    /** Separate convenience; it never changes find-all work or suppresses frame evidence. */
-    best(result) {
-        return rankBarcodes(result.barcodes)[0];
-    }
-    dispose() { if (this.#handle) {
-        const id = this.#handle;
-        this.#handle = 0;
-        status(this.#exports.regions_destroy(id));
-    } }
-}

package/dist/multiformat/coverage.d.ts

@@ -1,7 +0,0 @@
-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

@@ -1,26 +0,0 @@
-/** 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/geometry.d.ts

@@ -1,37 +0,0 @@
-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;
-    height: number;
-    transform: number[];
-};
-/** Convex intersection, including opposite winding and projective quadrilaterals. */
-export declare function polygonOverlap(a: Quad, b: Quad): {
-    iou: number;
-    smaller: number;
-    a: number;
-    b: number;
-};
-/** Suppress overlapping reads of the same physical symbol, never by text alone. */
-export declare function distinctReads<T extends {
-    text: string;
-    format: string;
-    polygon: Quad;
-    support: number;
-    eanAddOn?: string;
-    readerInitialization?: boolean;
-    structuredAppend?: {
-        index: number;
-        count: number;
-        id?: string;
-        parity?: number;
-    };
-}>(reads: readonly T[]): T[];

package/dist/multiformat/geometry.js

@@ -1,132 +0,0 @@
-export function project(t, x, y) {
-    const z = t[6] * x + t[7] * y + 1;
-    return [(t[0] * x + t[1] * y + t[2]) / z, (t[3] * x + t[4] * y + t[5]) / z];
-}
-export function transformFor(quad, width, height) {
-    const source = [
-        [0, 0],
-        [width, 0],
-        [width, height],
-        [0, height],
-    ];
-    const a = [];
-    for (let i = 0; i < 4; i++) {
-        const [x, y] = source[i], [u, v] = quad[i];
-        a.push([x, y, 1, 0, 0, 0, -u * x, -u * y, u], [0, 0, 0, x, y, 1, -v * x, -v * y, v]);
-    }
-    for (let col = 0; col < 8; col++) {
-        let pivot = col;
-        for (let i = col + 1; i < 8; i++)
-            if (Math.abs(a[i][col]) > Math.abs(a[pivot][col]))
-                pivot = i;
-        if (Math.abs(a[pivot][col]) < 1e-9)
-            throw Error("Degenerate barcode region.");
-        [a[col], a[pivot]] = [a[pivot], a[col]];
-        const divisor = a[col][col];
-        for (let j = col; j <= 8; j++)
-            a[col][j] /= divisor;
-        for (let i = 0; i < 8; i++) {
-            if (i === col)
-                continue;
-            const scale = a[i][col];
-            for (let j = col; j <= 8; j++)
-                a[i][j] -= scale * a[col][j];
-        }
-    }
-    return a.map((row) => row[8]);
-}
-export function rectificationPlan(quad) {
-    const distance = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1]);
-    const w = Math.max(8, Math.ceil(Math.max(distance(quad[0], quad[1]), distance(quad[3], quad[2]))));
-    const h = Math.max(8, Math.ceil(Math.max(distance(quad[0], quad[3]), distance(quad[1], quad[2]))));
-    if (w * h > 8 * 1024 * 1024)
-        throw Error("Barcode region exceeds rectification budget.");
-    const base = transformFor(quad, w, h);
-    const pad = 8, divisor = 1 - pad * (base[6] + base[7]);
-    const t = [
-        base[0] / divisor,
-        base[1] / divisor,
-        (base[2] - pad * (base[0] + base[1])) / divisor,
-        base[3] / divisor,
-        base[4] / divisor,
-        (base[5] - pad * (base[3] + base[4])) / divisor,
-        base[6] / divisor,
-        base[7] / divisor,
-    ];
-    const paddedWidth = w + 2 * pad, paddedHeight = h + 2 * pad;
-    return { width: paddedWidth, height: paddedHeight, transform: t };
-}
-export function rectify(gray, width, height, quad) {
-    const { width: paddedWidth, height: paddedHeight, transform: t } = rectificationPlan(quad);
-    const data = new Uint8Array(paddedWidth * paddedHeight);
-    for (let y = 0; y < paddedHeight; y++) {
-        const cy = y + 0.5;
-        const yX = t[1] * cy, yY = t[4] * cy, yZ = t[7] * cy;
-        for (let x = 0; x < paddedWidth; x++) {
-            const cx = x + 0.5;
-            const z = t[6] * cx + yZ + 1;
-            const xx = (t[0] * cx + yX + t[2]) / z;
-            const yy = (t[3] * cx + yY + t[5]) / z;
-            if (xx < 0 || yy < 0 || xx > width - 1 || yy > height - 1) {
-                data[y * paddedWidth + x] = 255;
-                continue;
-            }
-            const x0 = Math.floor(xx), y0 = Math.floor(yy), fx = xx - x0, fy = yy - y0;
-            const x1 = Math.min(width - 1, x0 + 1), y1 = Math.min(height - 1, y0 + 1);
-            data[y * paddedWidth + x] = Math.round((gray[y0 * width + x0] * (1 - fx) + gray[y0 * width + x1] * fx) * (1 - fy) +
-                (gray[y1 * width + x0] * (1 - fx) + gray[y1 * width + x1] * fx) * fy);
-        }
-    }
-    return { data, width: paddedWidth, height: paddedHeight, transform: t };
-}
-/** Convex intersection, including opposite winding and projective quadrilaterals. */
-export function polygonOverlap(a, b) {
-    const signedArea = (p) => p.reduce((sum, q, i) => {
-        const r = p[(i + 1) % p.length];
-        return sum + q[0] * r[1] - q[1] * r[0];
-    }, 0) / 2;
-    const aa = Math.abs(signedArea(a)), bb = Math.abs(signedArea(b));
-    if (Math.min(aa, bb) < 1e-6)
-        return { iou: 0, smaller: 0, a: 0, b: 0 };
-    const winding = Math.sign(signedArea(b));
-    let points = [...a];
-    for (let i = 0; i < 4 && points.length; i++) {
-        const p = b[i], q = b[(i + 1) % 4];
-        const side = (r) => winding * ((q[0] - p[0]) * (r[1] - p[1]) - (q[1] - p[1]) * (r[0] - p[0]));
-        const clipped = [];
-        for (let j = 0; j < points.length; j++) {
-            const u = points[j], v = points[(j + 1) % points.length], su = side(u), sv = side(v);
-            if (su >= 0)
-                clipped.push(u);
-            if (su >= 0 !== sv >= 0) {
-                const t = su / (su - sv);
-                clipped.push([u[0] + t * (v[0] - u[0]), u[1] + t * (v[1] - u[1])]);
-            }
-        }
-        points = clipped;
-    }
-    const intersection = Math.min(aa, bb, Math.abs(signedArea(points)));
-    return {
-        iou: intersection / (aa + bb - intersection),
-        smaller: intersection / Math.min(aa, bb),
-        a: intersection / aa,
-        b: intersection / bb,
-    };
-}
-/** Suppress overlapping reads of the same physical symbol, never by text alone. */
-export function distinctReads(reads) {
-    const result = [];
-    for (const read of [...reads].sort((a, b) => b.support - a.support)) {
-        if (!result.some((r) => r.text === read.text &&
-            r.format === read.format &&
-            r.eanAddOn === read.eanAddOn &&
-            Boolean(r.readerInitialization) === Boolean(read.readerInitialization) &&
-            r.structuredAppend?.index === read.structuredAppend?.index &&
-            r.structuredAppend?.count === read.structuredAppend?.count &&
-            r.structuredAppend?.id === read.structuredAppend?.id &&
-            r.structuredAppend?.parity === read.structuredAppend?.parity &&
-            polygonOverlap(r.polygon, read.polygon).smaller >= 0.65))
-            result.push(read);
-    }
-    return result;
-}

package/dist/multiformat/linear-duplicates.d.ts

@@ -1,16 +0,0 @@
-import type { Image, Quad } from "../host.js";
-type Read = {
-    text: string;
-    format: string;
-    polygon: Quad;
-    support: number;
-    eanAddOn?: string;
-    gs1?: boolean;
-    readerInitialization?: boolean;
-};
-/** Only merge equal-value, aligned bands when source pixels connect their bars.
- * This does not change search coverage or retry budgets. Exhausting the small
- * evidence budget leaves detections separate, never drops an unchecked read.
- */
-export declare function mergeLinearDuplicates<T extends Read>(reads: readonly T[], image: Image): T[];
-export {};

package/dist/multiformat/linear-duplicates.js

@@ -1,163 +0,0 @@
-import { polygonOverlap } from "./geometry.js";
-const formats = new Set(["EAN13", "UPCA", "EAN8", "UPCE", "Code128", "Code39", "ITF"]);
-function bitCount(value) {
-    let bits = value - ((value >>> 1) & 0x55555555);
-    bits = (bits & 0x33333333) + ((bits >>> 2) & 0x33333333);
-    return (((bits + (bits >>> 4)) & 0x0f0f0f0f) * 0x01010101) >>> 24;
-}
-const midpoint = (a, b) => [
-    (a[0] + b[0]) / 2,
-    (a[1] + b[1]) / 2,
-];
-const line = (q) => [midpoint(q[0], q[3]), midpoint(q[1], q[2])];
-/** Only merge equal-value, aligned bands when source pixels connect their bars.
- * This does not change search coverage or retry budgets. Exhausting the small
- * evidence budget leaves detections separate, never drops an unchecked read.
- */
-export function mergeLinearDuplicates(reads, image) {
-    if (reads.length < 2)
-        return [...reads];
-    const seen = new Set();
-    let repeated = false;
-    for (const read of reads) {
-        if (!read.text || !formats.has(read.format))
-            continue;
-        const key = `${read.format}:${read.text}`;
-        if (seen.has(key)) {
-            repeated = true;
-            break;
-        }
-        seen.add(key);
-    }
-    if (!repeated)
-        return [...reads];
-    let remaining = 32768;
-    const result = [];
-    let values;
-    const profile = (left, right) => {
-        if (remaining < 64)
-            return undefined;
-        remaining -= 64;
-        values ??= new Float64Array(64);
-        let lo = 255, hi = 0;
-        for (let i = 0; i < 64; i++) {
-            const f = (i + 0.5) / 64;
-            const x = Math.round(left[0] + (right[0] - left[0]) * f);
-            const y = Math.round(left[1] + (right[1] - left[1]) * f);
-            if (x < 0 || y < 0 || x >= image.width || y >= image.height)
-                return undefined;
-            const p = y * image.stride + x * image.channels;
-            const value = image.channels === 1
-                ? image.data[p]
-                : (77 * image.data[p] + 150 * image.data[p + 1] + 29 * image.data[p + 2]) / 256;
-            values[i] = value;
-            lo = Math.min(lo, value);
-            hi = Math.max(hi, value);
-        }
-        if (hi - lo < 24)
-            return undefined;
-        const threshold = (lo + hi) / 2;
-        let first = 0, second = 0;
-        for (let i = 0; i < 32; i++) {
-            if (values[i] < threshold)
-                first |= 1 << i;
-            if (values[i + 32] < threshold)
-                second |= 1 << i;
-        }
-        return [first, second];
-    };
-    const connected = (a, inputB) => {
-        if (!a.every((p) => p.every(Number.isFinite)) || !inputB.every((p) => p.every(Number.isFinite)))
-            return undefined;
-        const al = line(a), bl = line(inputB);
-        const ax = al[1][0] - al[0][0], ay = al[1][1] - al[0][1];
-        let bx = bl[1][0] - bl[0][0], by = bl[1][1] - bl[0][1];
-        const aw = Math.hypot(ax, ay), bw = Math.hypot(bx, by);
-        if (aw < 24 || bw / aw < 0.9 || bw / aw > 1.1)
-            return undefined;
-        let b = inputB;
-        if (ax * bx + ay * by < 0) {
-            b = [inputB[2], inputB[3], inputB[0], inputB[1]];
-            bx = -bx;
-            by = -by;
-        }
-        if ((ax * bx + ay * by) / (aw * bw) < 0.996)
-            return undefined;
-        const ac = midpoint(al[0], al[1]), bline = line(b), bc = midpoint(bline[0], bline[1]);
-        const dx = bc[0] - ac[0], dy = bc[1] - ac[1];
-        if (Math.abs(dx * ax + dy * ay) / aw > aw * 0.06)
-            return undefined;
-        // Bound endpoint movement too: rotation/perspective can move an edge farther
-        // than the centers. Every interpolated sample then moves at most one pixel.
-        const distance = Math.max(Math.hypot(bline[0][0] - al[0][0], bline[0][1] - al[0][1]), Math.hypot(bline[1][0] - al[1][0], bline[1][1] - al[1][1]));
-        const steps = Math.ceil(distance);
-        if (steps < 1 || steps > 384 || (steps + 2) * 64 > remaining)
-            return undefined;
-        const reference = profile(al[0], al[1]);
-        if (!reference)
-            return undefined;
-        let dark0 = reference[0], dark1 = reference[1];
-        let light0 = ~dark0, light1 = ~dark1;
-        const minimumDark = Math.max(4, Math.ceil((bitCount(dark0) + bitCount(dark1)) / 4));
-        const minimumLight = Math.max(4, Math.ceil((bitCount(light0) + bitCount(light1)) / 4));
-        for (let step = 1; step <= steps; step++) {
-            const f = step / steps;
-            const l = [
-                al[0][0] + (bline[0][0] - al[0][0]) * f,
-                al[0][1] + (bline[0][1] - al[0][1]) * f,
-            ];
-            const r = [
-                al[1][0] + (bline[1][0] - al[1][0]) * f,
-                al[1][1] + (bline[1][1] - al[1][1]) * f,
-            ];
-            const sample = profile(l, r);
-            if (!sample)
-                return undefined;
-            const disagreement = bitCount(reference[0] ^ sample[0]) + bitCount(reference[1] ^ sample[1]);
-            if (disagreement > 12)
-                return undefined;
-            dark0 &= sample[0];
-            dark1 &= sample[1];
-            light0 &= ~sample[0];
-            light1 &= ~sample[1];
-            // A skewed separator may cross columns at different heights. Require
-            // individual bars AND spaces to survive the entire bridge, not just rows.
-            if (bitCount(dark0) + bitCount(dark1) < minimumDark ||
-                bitCount(light0) + bitCount(light1) < minimumLight)
-                return undefined;
-        }
-        const along = (p) => (-ay * p[0] + ax * p[1]) / aw;
-        const top = along(midpoint(a[0], a[1])) < along(midpoint(b[0], b[1])) ? a : b;
-        const bottom = along(midpoint(a[2], a[3])) > along(midpoint(b[2], b[3])) ? a : b;
-        return [top[0], top[1], bottom[2], bottom[3]];
-    };
-    for (const read of [...reads].sort((a, b) => b.support - a.support)) {
-        if (!formats.has(read.format) || !read.text || remaining < 192) {
-            result.push(read);
-            continue;
-        }
-        let merged = false;
-        for (let i = 0; i < result.length; i++) {
-            const other = result[i];
-            if (read.format !== other.format ||
-                read.text !== other.text ||
-                read.eanAddOn !== other.eanAddOn ||
-                Boolean(read.gs1) !== Boolean(other.gs1) ||
-                Boolean(read.readerInitialization) !== Boolean(other.readerInitialization))
-                continue;
-            if (polygonOverlap(other.polygon, read.polygon).smaller >= 0.65) {
-                merged = true;
-                break;
-            }
-            const polygon = connected(other.polygon, read.polygon);
-            if (!polygon)
-                continue;
-            result[i] = { ...other, polygon }; // Keep strongest support; observations may overlap.
-            merged = true;
-            break;
-        }
-        if (!merged)
-            result.push(read);
-    }
-    return result;
-}

package/dist/multiformat/pixels.d.ts

@@ -1,3 +0,0 @@
-import type { Image } from "../multiformat-host.js";
-/** Input dimensions are validated by the scanner. Preserve its integer luma rule. */
-export declare function toGray({ data, width, height, channels, stride }: Image): Uint8Array;

package/dist/multiformat/pixels.js

@@ -1,36 +0,0 @@
-const littleEndian = new Uint8Array(new Uint32Array([1]).buffer)[0] === 1;
-/** Input dimensions are validated by the scanner. Preserve its integer luma rule. */
-export function toGray({ data, width, height, channels, stride }) {
-    const count = width * height;
-    if (channels === 1 && stride === width)
-        return data.slice(0, count);
-    const gray = new Uint8Array(count);
-    if (channels === 4 && stride === width * 4 && littleEndian && data.byteOffset % 4 === 0) {
-        const words = new Uint32Array(data.buffer, data.byteOffset, count);
-        for (let i = 0; i < count; i++) {
-            const value = words[i];
-            gray[i] =
-                ((value & 255) * 77 + ((value >>> 8) & 255) * 150 + ((value >>> 16) & 255) * 29 + 128) >>>
-                    8;
-        }
-    }
-    else if (channels === 4 && stride === width * 4) {
-        for (let i = 0, j = 0; j < count; i += 4, j++)
-            gray[j] = (data[i] * 77 + data[i + 1] * 150 + data[i + 2] * 29 + 128) >> 8;
-    }
-    else if (channels === 3 && stride === width * 3) {
-        for (let i = 0, j = 0; j < count; i += 3, j++)
-            gray[j] = (data[i] * 77 + data[i + 1] * 150 + data[i + 2] * 29 + 128) >> 8;
-    }
-    else if (channels === 1) {
-        for (let y = 0; y < height; y++)
-            gray.set(data.subarray(y * stride, y * stride + width), y * width);
-    }
-    else {
-        for (let y = 0; y < height; y++) {
-            for (let x = 0, i = y * stride, j = y * width; x < width; x++, i += channels, j++)
-                gray[j] = (data[i] * 77 + data[i + 1] * 150 + data[i + 2] * 29 + 128) >> 8;
-        }
-    }
-    return gray;
-}