@sythos/js_barcode_universal 1.5.13 → 1.5.15

package/src/js/composite/index.js

@@ -0,0 +1,570 @@
+/*!
+ * Sythos Barcode Suite
+ *
+ * MIT License
+ *
+ * Copyright (c) 2026 Sythos
+ * SPDX-FileCopyrightText: 2026 Sythos (https://www.sythos.net)
+ * SPDX-License-Identifier: MIT
+ *
+ * Original work. No code from any other barcode implementation.
+ */
+/**
+ * Bounded GS1 DataBar Composite profile.
+ *
+ * The complete ISO/IEC 24723 composite symbology has several component
+ * layouts and a dedicated compaction system. This SDK profile keeps the
+ * pairing contract deliberately narrow: one validated GS1 DataBar host is
+ * linked to one strict MicroPDF417-derived CC-A or CC-B component. The marker
+ * and geometry checks make the profile safe for round trips without claiming
+ * interchange certification for every normative composite variant.
+ *
+ * @module composite
+ */
+import { BitMatrix } from '../core/bit-matrix.js';
+import { EncodeError, FormatError } from '../core/errors.js';
+import * as databar from '../databar/index.js';
+import { decodeGS1ElementString, encodeGS1ElementString, formatGS1Elements, } from '../databar/gs1.js';
+import * as micropdf417 from '../micropdf417/index.js';
+export const GS1_COMPOSITE_PROFILE = 'sythos-gs1-composite-bounded';
+export const GS1_COMPOSITE_HOSTS = Object.freeze([
+    'databar14',
+    'databar-truncated',
+    'databar-stacked',
+    'databar-stacked-omnidirectional',
+    'databar-limited',
+    'databar-expanded',
+]);
+const COMPONENT_WIDTH = 55;
+const COMPONENT_VARIANTS = Object.freeze({
+    'cc-a': Object.freeze([7]),
+    'cc-b': Object.freeze([8, 9, 10, 11, 12, 13]),
+});
+const ALL_COMPONENT_VARIANTS = Object.freeze([7, 8, 9, 10, 11, 12, 13]);
+const MAX_SCALE = 8;
+const MAX_DIMENSION = 16777216;
+const MAX_MODULES = 67108864;
+// A short, private marker is part of this bounded profile. It is intentionally
+// not presented as the ISO/IEC composite linkage flag or an interoperability
+// claim; it only prevents a standalone component from being accepted here.
+const COMPONENT_PREFIX = Object.freeze({ 'cc-a': 'A|', 'cc-b': 'B|' });
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function positiveInteger(value, fallback, label, maximum = MAX_SCALE) {
+    const result = value ?? fallback;
+    if (!Number.isSafeInteger(result) || result < 1 || result > maximum) {
+        throw new EncodeError(`GS1 Composite ${label} must be an integer in 1..${maximum}`);
+    }
+    return result;
+}
+function normalizeHost(value) {
+    if (typeof value !== 'string')
+        throw new EncodeError('GS1 Composite linear.format must be a string');
+    const id = value.toLowerCase().replace(/_/g, '-');
+    if (id === 'databar' || id === 'databar14' || id === 'gs1databar14' || id === 'gs1-databar14'
+        || id === 'databar-omnidirectional' || id === 'omnidirectional')
+        return 'databar14';
+    if (id === 'databar-truncated' || id === 'gs1-databar-truncated' || id === 'truncated')
+        return 'databar-truncated';
+    if (id === 'databar-stacked' || id === 'gs1databar-stacked' || id === 'gs1-databar-stacked')
+        return 'databar-stacked';
+    if (id === 'databar-stacked-omnidirectional' || id === 'gs1databar-stacked-omnidirectional'
+        || id === 'gs1-databar-stacked-omni' || id === 'databar-stacked-omni')
+        return 'databar-stacked-omnidirectional';
+    if (id === 'databar-limited' || id === 'gs1databar-limited' || id === 'gs1-databar-limited')
+        return 'databar-limited';
+    if (id === 'databar-expanded' || id === 'gs1databar-expanded' || id === 'gs1-databar-expanded')
+        return 'databar-expanded';
+    throw new EncodeError(`GS1 Composite linear format is not supported: ${value}`);
+}
+function hostWidth(host) {
+    if (host === 'databar14' || host === 'databar-truncated')
+        return 96;
+    if (host === 'databar-stacked' || host === 'databar-stacked-omnidirectional')
+        return 50;
+    if (host === 'databar-limited')
+        return 79;
+    return null;
+}
+function encodeHost(host, value, options) {
+    if (host === 'databar14') {
+        return databar.encodeDataBar14(value, { ...options, linkage: true, variant: 'omnidirectional' });
+    }
+    if (host === 'databar-truncated') {
+        return databar.encodeDataBar14(value, { ...options, linkage: true, variant: 'truncated' });
+    }
+    if (host === 'databar-stacked') {
+        return databar.encodeDataBar14Stacked(value, { ...options, linkage: true });
+    }
+    if (host === 'databar-stacked-omnidirectional') {
+        return databar.encodeDataBarStackedOmnidirectional(value, { ...options, linkage: true });
+    }
+    if (host === 'databar-limited') {
+        return databar.encodeDataBarLimited(value, { ...options, linkage: true });
+    }
+    return databar.encodeDataBarExpanded(value, { ...options, linkage: true });
+}
+function decodeHost(host, matrix) {
+    if (host === 'databar14' || host === 'databar-truncated')
+        return databar.decodeDataBar14(matrix);
+    if (host === 'databar-stacked')
+        return databar.decodeDataBar14Stacked(matrix);
+    if (host === 'databar-stacked-omnidirectional')
+        return databar.decodeDataBarStackedOmnidirectional(matrix);
+    if (host === 'databar-limited')
+        return databar.decodeDataBarLimited(matrix);
+    return databar.decodeDataBarExpanded(matrix);
+}
+function normalizedGS1Data(input) {
+    let raw;
+    if (Array.isArray(input)) {
+        raw = encodeGS1ElementString(input);
+    }
+    else if (typeof input === 'string') {
+        if (input.startsWith('('))
+            raw = encodeGS1ElementString(input);
+        else {
+            decodeGS1ElementString(input);
+            raw = input;
+        }
+    }
+    else {
+        throw new EncodeError('GS1 Composite data must be a GS1 element string or element array');
+    }
+    const elements = decodeGS1ElementString(raw);
+    return { raw, elements };
+}
+function expandedInput(value) {
+    if (typeof value !== 'string' || value.startsWith('('))
+        return value;
+    try {
+        return formatGS1Elements(decodeGS1ElementString(value));
+    }
+    catch {
+        return value;
+    }
+}
+function normalizedLinearOptions(options) {
+    if (!isRecord(options))
+        throw new EncodeError('GS1 Composite linear.options must be an object');
+    if (options.linkage === false)
+        throw new EncodeError('GS1 Composite linear host must use linkage=true');
+    for (const key of ['moduleScale', 'scale']) {
+        if (options[key] !== undefined && options[key] !== 1) {
+            throw new EncodeError('GS1 Composite controls the common module scale; linear scaling must be 1');
+        }
+    }
+    return { ...options, linkage: true };
+}
+function selectComponent(raw, requested, rowHeight) {
+    if (requested !== 'auto' && requested !== 'cc-a' && requested !== 'cc-b') {
+        throw new EncodeError('GS1 Composite component must be auto, cc-a or cc-b');
+    }
+    const order = requested === 'auto'
+        ? ALL_COMPONENT_VARIANTS
+        : COMPONENT_VARIANTS[requested];
+    const kindFor = (variant) => variant === 7 ? 'cc-a' : 'cc-b';
+    let lastError;
+    for (const variant of order) {
+        const kind = kindFor(variant);
+        const payload = `${COMPONENT_PREFIX[kind]}${raw}`;
+        try {
+            const matrix = micropdf417.encodeMicroPDF417(payload, {
+                variant,
+                rowHeight,
+                compaction: 'byte',
+                eci: 3,
+            });
+            return Object.freeze({ matrix, kind, variant, payload });
+        }
+        catch (error) {
+            lastError = error;
+            if (!(error instanceof EncodeError))
+                throw error;
+        }
+    }
+    throw new EncodeError(`GS1 Composite data does not fit the selected ${requested} component${lastError ? `: ${lastError.message}` : ''}`);
+}
+function copyMatrix(source, target, offsetX, offsetY) {
+    for (let y = 0; y < source.height; y++) {
+        for (let x = 0; x < source.width; x++) {
+            if (source.get(x, y))
+                target.set(offsetX + x, offsetY + y);
+        }
+    }
+}
+function metadataFor({ component, linear, width, height, scale, gap, host }) {
+    return Object.freeze({
+        profile: GS1_COMPOSITE_PROFILE,
+        component: component.kind,
+        componentVariant: component.variant,
+        componentRows: component.matrix.micropdf417?.rows ?? component.variant,
+        componentColumns: component.matrix.micropdf417?.columns ?? 2,
+        componentRowHeight: component.matrix.micropdf417?.rowHeight ?? 2,
+        componentX: component.x * scale,
+        componentY: component.y * scale,
+        componentWidth: component.matrix.width * scale,
+        componentHeight: component.matrix.height * scale,
+        linearFormat: host,
+        linearX: linear.x * scale,
+        linearY: linear.y * scale,
+        linearWidth: linear.matrix.width * scale,
+        linearHeight: linear.matrix.height * scale,
+        separatorGap: gap * scale,
+        moduleScale: scale,
+        width: width * scale,
+        height: height * scale,
+    });
+}
+/** Encode a bounded, linked GS1 DataBar Composite profile. */
+export function encodeGS1Composite(input, options = {}) {
+    if (!isRecord(input))
+        throw new EncodeError('GS1 Composite input must be an object');
+    if (!isRecord(options))
+        throw new EncodeError('GS1 Composite options must be an object');
+    if (!isRecord(input.linear))
+        throw new EncodeError('GS1 Composite linear host is required');
+    const host = normalizeHost(input.linear.format);
+    if (input.linear.value === undefined || input.linear.value === null) {
+        throw new EncodeError('GS1 Composite linear.value is required');
+    }
+    const data = normalizedGS1Data(input.data);
+    const rowHeight = positiveInteger(input.rowHeight ?? options.rowHeight, 2, 'rowHeight', 64);
+    if (rowHeight < 2)
+        throw new EncodeError('GS1 Composite rowHeight must be at least 2');
+    const separatorGap = positiveInteger(input.separatorGap ?? options.separatorGap, 1, 'separatorGap', 3);
+    const moduleScale = positiveInteger(input.moduleScale ?? options.moduleScale, 1, 'moduleScale', MAX_SCALE);
+    const requestedComponent = input.component ?? options.component ?? 'auto';
+    const linearOptions = normalizedLinearOptions(input.linear.options ?? {});
+    const linearValue = host === 'databar-expanded' ? expandedInput(input.linear.value) : input.linear.value;
+    const linearMatrix = encodeHost(host, linearValue, linearOptions);
+    if (linearMatrix.databar?.linkage !== true) {
+        throw new EncodeError('GS1 Composite host encoder did not preserve linkage=true');
+    }
+    const component = selectComponent(data.raw, requestedComponent, rowHeight);
+    const width = Math.max(linearMatrix.width, component.matrix.width);
+    const componentX = Math.floor((width - component.matrix.width) / 2);
+    const linearX = Math.floor((width - linearMatrix.width) / 2);
+    const linearY = component.matrix.height + separatorGap;
+    const height = linearY + linearMatrix.height;
+    if (width > MAX_DIMENSION || height > MAX_DIMENSION || width * height > MAX_MODULES) {
+        throw new EncodeError('GS1 Composite matrix exceeds the safe allocation budget');
+    }
+    const base = new BitMatrix(width, height);
+    copyMatrix(component.matrix, base, componentX, 0);
+    copyMatrix(linearMatrix, base, linearX, linearY);
+    const matrix = moduleScale === 1 ? base : base.scale(moduleScale);
+    const componentMeta = { ...component, x: componentX, y: 0 };
+    const linearMeta = { matrix: linearMatrix, x: linearX, y: linearY };
+    matrix.gs1composite = metadataFor({
+        component: componentMeta,
+        linear: linearMeta,
+        width,
+        height,
+        scale: moduleScale,
+        gap: separatorGap,
+        host,
+    });
+    return matrix;
+}
+function crop(source, x, y, width, height) {
+    if (!Number.isSafeInteger(x) || !Number.isSafeInteger(y) || !Number.isSafeInteger(width)
+        || !Number.isSafeInteger(height) || width < 1 || height < 1
+        || x < 0 || y < 0 || x + width > source.width || y + height > source.height)
+        return null;
+    const output = new BitMatrix(width, height);
+    for (let row = 0; row < height; row++) {
+        for (let column = 0; column < width; column++) {
+            if (source.get(x + column, y + row))
+                output.set(column, row);
+        }
+    }
+    return output;
+}
+function collapseScale(source, scale) {
+    if (!Number.isSafeInteger(scale) || scale < 1
+        || source.width % scale !== 0 || source.height % scale !== 0)
+        return null;
+    if (scale === 1)
+        return source;
+    const output = new BitMatrix(source.width / scale, source.height / scale);
+    for (let y = 0; y < output.height; y++) {
+        for (let x = 0; x < output.width; x++) {
+            const expected = Boolean(source.get(x * scale, y * scale));
+            for (let dy = 0; dy < scale; dy++) {
+                for (let dx = 0; dx < scale; dx++) {
+                    if (Boolean(source.get(x * scale + dx, y * scale + dy)) !== expected)
+                        return null;
+                }
+            }
+            if (expected)
+                output.set(x, y);
+        }
+    }
+    return output;
+}
+function hasDark(source, x, y, width, height) {
+    for (let row = y; row < y + height; row++) {
+        for (let column = x; column < x + width; column++) {
+            if (source.get(column, row))
+                return true;
+        }
+    }
+    return false;
+}
+function payloadFromComponent(decoded, kind) {
+    const prefix = COMPONENT_PREFIX[kind];
+    if (!decoded || typeof decoded.text !== 'string' || !decoded.text.startsWith(prefix)) {
+        throw new FormatError('GS1 Composite component marker is invalid');
+    }
+    const raw = decoded.text.slice(prefix.length);
+    const elements = decodeGS1ElementString(raw);
+    return { raw, elements };
+}
+function compositeResult(host, linear, component, kind, raw, elements, geometry = {}) {
+    if (linear.linkage !== true)
+        throw new FormatError('GS1 Composite linear host is not linked');
+    return Object.freeze({
+        format: 'gs1composite',
+        profile: GS1_COMPOSITE_PROFILE,
+        certified: false,
+        text: raw,
+        raw,
+        gs1: true,
+        linkage: true,
+        elements: Object.freeze(elements),
+        linearFormat: host,
+        linear: Object.freeze({ ...linear, format: host }),
+        component: kind,
+        componentVariant: component.variant,
+        componentRows: component.rows,
+        componentColumns: component.columns,
+        componentRowHeight: component.rowHeight,
+        corrections: component.corrections,
+        moduleScale: geometry.moduleScale ?? 1,
+        separatorGap: geometry.separatorGap,
+        symbologyIdentifier: kind === 'cc-a' ? ']e1' : ']e2',
+        ...geometry,
+    });
+}
+function decodeFromMetadata(matrix) {
+    const meta = matrix.gs1composite;
+    if (!isRecord(meta) || meta.profile !== GS1_COMPOSITE_PROFILE)
+        return null;
+    const componentMatrix = crop(matrix, meta.componentX, meta.componentY, meta.componentWidth, meta.componentHeight);
+    const linearMatrix = crop(matrix, meta.linearX, meta.linearY, meta.linearWidth, meta.linearHeight);
+    if (!componentMatrix || !linearMatrix)
+        throw new FormatError('GS1 Composite metadata points outside the matrix');
+    const logicalComponent = collapseScale(componentMatrix, meta.moduleScale ?? 1);
+    if (!logicalComponent)
+        throw new FormatError('GS1 Composite component is not integer-scaled');
+    const component = micropdf417.decodeMicroPDF417(logicalComponent, { variant: meta.componentVariant });
+    const payload = payloadFromComponent(component, meta.component);
+    const host = normalizeHost(meta.linearFormat);
+    const linear = decodeHost(host, linearMatrix);
+    return compositeResult(host, linear, component, meta.component, payload.raw, payload.elements, {
+        moduleScale: meta.moduleScale,
+        separatorGap: meta.separatorGap,
+        bounds: { x: 0, y: 0, width: matrix.width, height: matrix.height },
+    });
+}
+function attemptCandidate(image, host, variant, rowHeight, scale, canvasX, topY, gap, canvasWidth, bounds) {
+    const entry = micropdf417.microPdf417VariantByNumber(variant);
+    const componentHeight = entry.rows * rowHeight * scale;
+    const componentWidth = COMPONENT_WIDTH * scale;
+    // Centre in logical modules first, then apply the common raster scale. This
+    // preserves the encoder's floor-centering for odd width differences.
+    const logicalCanvasWidth = Math.floor(canvasWidth / scale);
+    const componentX = canvasX + Math.floor((logicalCanvasWidth - COMPONENT_WIDTH) / 2) * scale;
+    const hostWidthModules = hostWidth(host);
+    const linearWidth = hostWidthModules === null ? canvasWidth : hostWidthModules * scale;
+    const linearModules = hostWidthModules === null ? logicalCanvasWidth : hostWidthModules;
+    const linearX = canvasX + Math.floor((logicalCanvasWidth - linearModules) / 2) * scale;
+    const linearY = topY + componentHeight + gap * scale;
+    const linearHeight = bounds.maxY - linearY + 1;
+    if (linearHeight < 1 || linearX < 0 || linearX + linearWidth > image.width
+        || componentX < 0 || componentX + componentWidth > image.width)
+        return null;
+    // The two DataBar-14 host presentations share the same 96-module geometry;
+    // their normative heights provide the only reliable distinction after
+    // image metadata has been discarded.
+    if (host === 'databar14' && linearHeight < 33 * scale)
+        return null;
+    if (host === 'databar-truncated' && linearHeight >= 33 * scale)
+        return null;
+    if (hasDark(image, canvasX, topY + componentHeight, canvasWidth, gap * scale))
+        return null;
+    const componentMatrix = crop(image, componentX, topY, componentWidth, componentHeight);
+    const linearMatrix = crop(image, linearX, linearY, linearWidth, linearHeight);
+    if (!componentMatrix || !linearMatrix)
+        return null;
+    try {
+        const logicalComponent = collapseScale(componentMatrix, scale);
+        if (!logicalComponent)
+            return null;
+        const component = micropdf417.decodeMicroPDF417(logicalComponent, { variant });
+        const kind = variant === 7 ? 'cc-a' : 'cc-b';
+        const payload = payloadFromComponent(component, kind);
+        const linear = decodeHost(host, linearMatrix);
+        return {
+            result: compositeResult(host, linear, component, kind, payload.raw, payload.elements, {
+                moduleScale: scale,
+                separatorGap: gap * scale,
+                bounds: { x: canvasX, y: topY, width: canvasWidth, height: linearY + linearHeight - topY },
+            }),
+            matrix: componentMatrix,
+            geometry: { x: canvasX, y: topY, width: canvasWidth, height: linearY + linearHeight - topY },
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function fallbackDecode(image) {
+    const bounds = image.getBounds?.();
+    if (!bounds)
+        return null;
+    const topY = bounds.y;
+    for (let scale = 1; scale <= MAX_SCALE; scale++) {
+        const xStart = Math.max(0, bounds.x - 2 * scale);
+        const xEnd = Math.min(image.width - 1, bounds.x);
+        for (const host of ['databar-stacked', 'databar-stacked-omnidirectional', 'databar-limited', 'databar-truncated', 'databar14']) {
+            const modules = hostWidth(host);
+            const canvasModules = Math.max(modules, COMPONENT_WIDTH);
+            const canvasWidth = canvasModules * scale;
+            if (canvasWidth > image.width)
+                continue;
+            for (let canvasX = xStart; canvasX <= xEnd; canvasX++) {
+                for (let rowHeight = 2; rowHeight <= 6; rowHeight++) {
+                    for (const variant of ALL_COMPONENT_VARIANTS) {
+                        const found = attemptCandidate(image, host, variant, rowHeight, scale, canvasX, topY, 1, canvasWidth, {
+                            maxY: bounds.y + bounds.height - 1,
+                        });
+                        if (found)
+                            return found;
+                        for (const gap of [2, 3]) {
+                            const withGap = attemptCandidate(image, host, variant, rowHeight, scale, canvasX, topY, gap, canvasWidth, {
+                                maxY: bounds.y + bounds.height - 1,
+                            });
+                            if (withGap)
+                                return withGap;
+                        }
+                    }
+                }
+            }
+        }
+        // Expanded symbols have a payload-dependent width. Their dark bounds are
+        // already the logical width, so try a few light-edge corrections around it.
+        for (const delta of [-3, -2, -1, 0, 1, 2, 3]) {
+            const canvasWidth = bounds.width + delta * scale;
+            if (canvasWidth < COMPONENT_WIDTH * scale || canvasWidth > image.width)
+                continue;
+            for (const variant of ALL_COMPONENT_VARIANTS) {
+                for (let rowHeight = 2; rowHeight <= 6; rowHeight++) {
+                    const found = attemptCandidate(image, 'databar-expanded', variant, rowHeight, scale, bounds.x, topY, 1, canvasWidth, {
+                        maxY: bounds.y + bounds.height - 1,
+                    });
+                    if (found)
+                        return found;
+                }
+            }
+        }
+    }
+    return null;
+}
+function rotateClockwise(source) {
+    const output = new BitMatrix(source.height, source.width);
+    for (let y = 0; y < source.height; y++) {
+        for (let x = 0; x < source.width; x++)
+            if (source.get(x, y))
+                output.set(source.height - 1 - y, x);
+    }
+    return output;
+}
+function mapPoint(point, previous) {
+    return { x: point.y, y: previous.height - point.x };
+}
+function rectangle(bounds) {
+    return [
+        { x: bounds.x, y: bounds.y },
+        { x: bounds.x + bounds.width, y: bounds.y },
+        { x: bounds.x + bounds.width, y: bounds.y + bounds.height },
+        { x: bounds.x, y: bounds.y + bounds.height },
+    ];
+}
+function validImage(image) {
+    return isRecord(image) && typeof image.get === 'function'
+        && Number.isSafeInteger(image.width) && Number.isSafeInteger(image.height)
+        && image.width > 0 && image.height > 0
+        && image.width <= MAX_DIMENSION && image.height <= MAX_DIMENSION
+        && image.width * image.height <= MAX_MODULES;
+}
+/** Decode one complete, axis-aligned bounded GS1 Composite symbol. */
+export function decodeGS1Composite(matrix) {
+    if (!validImage(matrix))
+        throw new FormatError('GS1 Composite decoder expects a bounded BitMatrix-like value');
+    const fromMetadata = decodeFromMetadata(matrix);
+    if (fromMetadata)
+        return fromMetadata;
+    const found = fallbackDecode(matrix);
+    if (!found)
+        throw new FormatError('GS1 Composite geometry, linkage or component marker is invalid');
+    return found.result;
+}
+/** Detect one complete composite symbol in a clean binary raster. */
+export function detectGS1Composite(binaryImage) {
+    if (!validImage(binaryImage))
+        return null;
+    let oriented = binaryImage;
+    let toOriginal = (point) => ({ x: point.x, y: point.y });
+    for (let turns = 0; turns < 4; turns++) {
+        try {
+            const metadataResult = decodeFromMetadata(oriented);
+            if (metadataResult) {
+                const bounds = { x: 0, y: 0, width: oriented.width, height: oriented.height };
+                return Object.freeze({
+                    ...metadataResult,
+                    bounds,
+                    corners: rectangle(bounds).map(toOriginal),
+                    matrix: oriented,
+                    moduleSize: metadataResult.moduleScale ?? 1,
+                    rotation: (360 - turns * 90) % 360,
+                    confidence: 1,
+                    quality: { quietZone: true, checksum: true, rows: metadataResult.componentRows, consistency: 1 },
+                });
+            }
+        }
+        catch {
+            // Metadata may be stale after a caller edited the matrix. Fall back to geometry.
+        }
+        const found = fallbackDecode(oriented);
+        if (found) {
+            const bounds = found.geometry;
+            return Object.freeze({
+                ...found.result,
+                bounds,
+                corners: rectangle(bounds).map(toOriginal),
+                matrix: found.matrix,
+                moduleSize: found.result.moduleScale ?? 1,
+                rotation: (360 - turns * 90) % 360,
+                confidence: 1,
+                quality: {
+                    quietZone: bounds.x > 0 && bounds.y > 0
+                        && bounds.x + bounds.width < oriented.width
+                        && bounds.y + bounds.height < oriented.height,
+                    checksum: true,
+                    rows: found.result.componentRows,
+                    consistency: 1,
+                },
+            });
+        }
+        const previous = oriented;
+        const previousToOriginal = toOriginal;
+        oriented = rotateClockwise(previous);
+        toOriginal = (point) => previousToOriginal(mapPoint(point, previous));
+    }
+    return null;
+}
+/** Alias kept consistent with the other two-dimensional detectors. */
+export const detectAndDecodeGS1Composite = detectGS1Composite;