@sythos/js_barcode_universal 1.5.6 → 1.5.8

package/src/ts/oned/addons.d.ts

@@ -0,0 +1,181 @@
+/*!
+ * Sythos Barcode Suite
+ *
+ * MIT License
+ *
+ * Copyright (c) 2026 Sythos
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * SPDX-FileCopyrightText: 2026 Sythos (https://www.sythos.net)
+ * SPDX-License-Identifier: MIT
+ *
+ * Original work. No code from any other barcode implementation.
+ */
+/**
+ * UPC/EAN two- and five-digit supplements.
+ *
+ * Supplements are small symbols printed to the right of an EAN/UPC symbol.
+ * They use the ordinary EAN odd/even digit patterns, a 1011 start guard and
+ * 01 separators between digits. EAN-2 selects its parity from the numeric
+ * value modulo four. EAN-5 derives a checksum from the five digits and uses
+ * that value to select one of ten parity rows.
+ *
+ * This module intentionally keeps supplements separate from the base EAN/UPC
+ * writers. `composeEANAddon` and the `*WithAddon` helpers are opt-in; existing
+ * EAN/UPC APIs continue to return their original one-row matrices unchanged.
+ *
+ * @module oned/addons
+ */
+import { BitMatrix } from '../core/bit-matrix.js';
+/** EAN-2 parity rows, indexed by the two-digit value modulo four. */
+export declare const EAN2_PARITY: readonly string[];
+/** EAN-5 parity rows, indexed by the supplemental checksum. */
+export declare const EAN5_PARITY: readonly string[];
+/** Start guard used by both UPC/EAN supplemental symbols. */
+export declare const EAN_ADDON_START = "1011";
+/** Separator inserted between adjacent supplemental digits. */
+export declare const EAN_ADDON_SEPARATOR = "01";
+export declare const EAN2_WIDTH: number;
+export declare const EAN5_WIDTH: number;
+/**
+ * EAN-5 supplemental checksum.
+ *
+ * The first, third and fifth digits carry weight three; the second and fourth
+ * carry weight nine. The checksum is not printed as a sixth digit: it selects
+ * the odd/even parity row for the five encoded digits.
+ *
+ * @param {string|number} value Five digits.
+ * @returns {number} Checksum value, 0-9.
+ */
+export declare function ean5Checksum(value: string | number): number;
+/** Alias for callers that use the EAN family check-digit terminology. */
+export declare const ean5CheckDigit: typeof ean5Checksum;
+/**
+ * Resolve the EAN-2 parity row for a payload.
+ *
+ * @param {string|number} value Two digits.
+ * @returns {string} Two-character A/B parity row.
+ */
+export declare function ean2Parity(value: string | number): string;
+/**
+ * Resolve the EAN-5 parity row for a payload.
+ *
+ * @param {string|number} value Five digits.
+ * @returns {string} Five-character A/B parity row.
+ */
+export declare function ean5Parity(value: string | number): string;
+/**
+ * Encode an EAN-2 supplement.
+ *
+ * @param {string|number} value Exactly two decimal digits.
+ * @returns {BitMatrix} A 20-module, one-row supplement.
+ */
+export declare function encodeEAN2(value: string | number): BitMatrix;
+/**
+ * Encode an EAN-5 supplement.
+ *
+ * @param {string|number} value Exactly five decimal digits.
+ * @returns {BitMatrix} A 47-module, one-row supplement.
+ */
+export declare function encodeEAN5(value: string | number): BitMatrix;
+/**
+ * Encode either supported supplement length.
+ *
+ * @param {string|number} value Two or five decimal digits.
+ * @returns {BitMatrix}
+ */
+export declare function encodeEANAddon(value: string | number): BitMatrix;
+/** Alias using the spelling used by some EAN documentation. */
+export declare const encodeEANAddOn: typeof encodeEANAddon;
+/**
+ * Validate and decode an EAN-2 supplement. A leading quiet zone is accepted;
+ * the decoder searches the row for a valid start guard so a composed base
+ * EAN/UPC matrix can be passed directly as well.
+ *
+ * @param {BitMatrix} matrix One-row, module-aligned supplement or composition.
+ * @returns {{format:'ean2',text:string,parity:string}}
+ * @throws {FormatError} When no valid supplement is found.
+ */
+export declare function decodeEAN2(matrix: BitMatrix): {
+    format: 'ean2';
+    text: string;
+    parity: string;
+};
+/**
+ * Validate and decode an EAN-5 supplement.
+ *
+ * @param {BitMatrix} matrix One-row, module-aligned supplement or composition.
+ * @returns {{format:'ean5',text:string,parity:string,checksum:number}}
+ * @throws {FormatError} When no valid supplement is found.
+ */
+export declare function decodeEAN5(matrix: BitMatrix): {
+    format: 'ean5';
+    text: string;
+    parity: string;
+    checksum: number;
+};
+/**
+ * Decode either supported supplement length.
+ *
+ * @param {BitMatrix} matrix One-row, module-aligned supplement or composition.
+ * @returns {{format:'ean2'|'ean5',text:string,parity:string,checksum?:number}}
+ * @throws {FormatError} When neither supplement grammar matches.
+ */
+export declare function decodeEANAddon(matrix: BitMatrix): {
+    format: 'ean2' | 'ean5';
+    text: string;
+    parity: string;
+    checksum?: number;
+};
+/** Alias using the spelling used by some EAN documentation. */
+export declare const decodeEANAddOn: typeof decodeEANAddon;
+/**
+ * Join a base EAN/UPC matrix and a supplement with the standard quiet gap.
+ *
+ * The helper does not alter either input. By default it inserts nine light
+ * modules, the conventional separation between the base symbol and an add-on.
+ * The result carries the supplement metadata under `eanAddon` for renderers or
+ * callers that need to label the composed symbol.
+ *
+ * @param {BitMatrix} base Base EAN/UPC matrix.
+ * @param {BitMatrix|string|number} addon Add-on matrix or two/five digits.
+ * @param {{gap?:number}} [options]
+ * @returns {BitMatrix}
+ */
+export declare function composeEANAddon(base: BitMatrix, addon: BitMatrix | string | number, options?: {
+    gap?: number;
+}): BitMatrix;
+/**
+ * Compose an EAN-13 symbol with an EAN-2 or EAN-5 supplement.
+ *
+ * @param {string} value Base EAN-13 payload.
+ * @param {string|number} addon Two or five supplemental digits.
+ * @param {{gap?:number}} [options]
+ * @returns {BitMatrix}
+ */
+export declare function encodeEAN13WithAddon(value: string, addon: string | number, options?: {
+    gap?: number;
+}): BitMatrix;
+/** @see encodeEAN13WithAddon */
+export declare function encodeEAN8WithAddon(value: any, addon: any, options?: {}): BitMatrix;
+/** @see encodeEAN13WithAddon */
+export declare function encodeUPCAWithAddon(value: any, addon: any, options?: {}): BitMatrix;
+/** @see encodeEAN13WithAddon */
+export declare function encodeUPCEWithAddon(value: any, addon: any, options?: {}): BitMatrix;

package/src/ts/oned/index.d.ts

@@ -0,0 +1,55 @@
+/*!
+ * Sythos Barcode Suite
+ *
+ * MIT License
+ *
+ * Copyright (c) 2026 Sythos
+ * SPDX-FileCopyrightText: 2026 Sythos (https://www.sythos.net)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Original work. No code from any other barcode implementation.
+ */
+/**
+ * Linear symbologies.
+ *
+ * @module oned
+ */
+export { encodeEAN13, encodeEAN8, encodeUPCA, encodeUPCE, encodeISBN, encodeCode39, encodeCode93, encodeCode128, encodeITF, encodeITF14, encodeCodabar, encodeCode11, encodeMSI, encodePharmacode, ean13CheckDigit, } from './writers.js';
+export { EAN2_PARITY, EAN5_PARITY, EAN2_WIDTH, EAN5_WIDTH, EAN_ADDON_START, EAN_ADDON_SEPARATOR, ean2Parity, ean5Checksum, ean5CheckDigit, ean5Parity, encodeEAN2, encodeEAN5, encodeEANAddon, encodeEANAddOn, decodeEAN2, decodeEAN5, decodeEANAddon, decodeEANAddOn, composeEANAddon, encodeEAN13WithAddon, encodeEAN8WithAddon, encodeUPCAWithAddon, encodeUPCEWithAddon, } from './addons.js';
+export { decodeOneD, decodeOneDStrict, decodeCode11, decodeMSI, patternVariance, recordPattern, toNarrowWidePattern, } from './reader.js';
+export { validateTables } from './patterns.js';
+/**
+ * Writers by format id, for the top-level `encode()` dispatcher.
+ *
+ * `readable` marks the formats this suite can also decode. Writing is a table
+ * lookup and easy to support broadly; reading needs a detector per symbology,
+ * so the two lists legitimately differ and the API says so rather than
+ * failing at runtime.
+ *
+ * @type {Record<string, {encode: Function, readable: boolean, label: string, role?: string}>}
+ */
+export declare const ONED_FORMATS: Record<string, {
+    encode: Function;
+    readable: boolean;
+    label: string;
+    role?: string;
+}>;

package/src/ts/oned/patterns.d.ts

@@ -0,0 +1,259 @@
+/*!
+ * Sythos Barcode Suite
+ *
+ * MIT License
+ *
+ * Copyright (c) 2026 Sythos
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * SPDX-FileCopyrightText: 2026 Sythos (https://www.sythos.net)
+ * SPDX-License-Identifier: MIT
+ *
+ * Original work. No code from any other barcode implementation.
+ */
+/**
+ * Pattern tables for the linear symbologies.
+ *
+ * Every table here is a published fact about a symbology, expressed in this
+ * project's own notation and validated by structural invariants rather than
+ * trusted. `validateTables()` at the bottom asserts the properties each
+ * symbology guarantees — module counts, wide-element counts, uniqueness — and
+ * the test suite runs it. A transcription slip that breaks an invariant fails
+ * the build; the invariants are chosen so that most single-character slips do.
+ *
+ * Two notations appear:
+ *
+ *   width strings  "212222"  — element widths in modules, bar first, then
+ *                              alternating space/bar. Used by Code 128, 93,
+ *                              Codabar, ITF, Code 39, Code 11.
+ *   module strings "0001101" — one character per module, 1 = dark. Used by
+ *                              EAN/UPC, where every element is a whole number
+ *                              of modules out of a fixed 7.
+ *
+ * @module oned/patterns
+ */
+/** Odd-parity ("L") digit patterns, 7 modules each. */
+export declare const EAN_L: string[];
+/** Even-parity ("G") patterns: the R pattern reversed. */
+export declare const EAN_G: string[];
+/** Right-hand ("R") patterns: the L pattern complemented. */
+export declare const EAN_R: string[];
+/**
+ * Which parity set each of the six left-hand EAN-13 digits uses, indexed by
+ * the first digit. This is how the thirteenth digit is carried without a
+ * thirteenth symbol position.
+ */
+export declare const EAN13_PARITY: string[];
+/** UPC-E parity patterns, indexed by check digit. Used when the number system is 0. */
+export declare const UPCE_PARITY: string[];
+export declare const EAN_START_END = "101";
+export declare const EAN_MIDDLE = "01010";
+export declare const UPCE_END = "010101";
+/**
+ * Code 39 is "three of nine": nine elements per character, of which exactly
+ * three are wide. `n` and `w` below are narrow and wide; elements alternate
+ * bar, space, bar, ... starting and ending with a bar.
+ */
+export declare const CODE39: {
+    '0': string;
+    '1': string;
+    '2': string;
+    '3': string;
+    '4': string;
+    '5': string;
+    '6': string;
+    '7': string;
+    '8': string;
+    '9': string;
+    A: string;
+    B: string;
+    C: string;
+    D: string;
+    E: string;
+    F: string;
+    G: string;
+    H: string;
+    I: string;
+    J: string;
+    K: string;
+    L: string;
+    M: string;
+    N: string;
+    O: string;
+    P: string;
+    Q: string;
+    R: string;
+    S: string;
+    T: string;
+    U: string;
+    V: string;
+    W: string;
+    X: string;
+    Y: string;
+    Z: string;
+    '-': string;
+    '.': string;
+    ' ': string;
+    $: string;
+    '/': string;
+    '+': string;
+    '%': string;
+    '*': string;
+};
+/** Character set for the optional modulo-43 check digit; '*' is excluded. */
+export declare const CODE39_CHECK_SET = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%";
+/** Two-character escapes giving Code 39 the full ASCII range. */
+export declare const CODE39_EXTENDED: any[];
+/** Nine modules per character across six elements. */
+export declare const CODE93: {
+    '0': string;
+    '1': string;
+    '2': string;
+    '3': string;
+    '4': string;
+    '5': string;
+    '6': string;
+    '7': string;
+    '8': string;
+    '9': string;
+    A: string;
+    B: string;
+    C: string;
+    D: string;
+    E: string;
+    F: string;
+    G: string;
+    H: string;
+    I: string;
+    J: string;
+    K: string;
+    L: string;
+    M: string;
+    N: string;
+    O: string;
+    P: string;
+    Q: string;
+    R: string;
+    S: string;
+    T: string;
+    U: string;
+    V: string;
+    W: string;
+    X: string;
+    Y: string;
+    Z: string;
+    '-': string;
+    '.': string;
+    ' ': string;
+    $: string;
+    '/': string;
+    '+': string;
+    '%': string;
+    S$: string;
+    'S%': string;
+    'S/': string;
+    'S+': string;
+};
+/**
+ * Symbol values 0..46 in order, as keys into {@link CODE93}. An array rather
+ * than a string, because the four shift characters have multi-character keys.
+ */
+export declare const CODE93_VALUES: string[];
+export declare const CODE93_START_STOP = "111141";
+/**
+ * All 107 symbol patterns. Eleven modules each across six elements; the stop
+ * pattern is the sole exception at thirteen modules across seven.
+ *
+ * The eleven-module invariant is checked below and catches the overwhelming
+ * majority of transcription slips, since almost any single-digit change to a
+ * pattern breaks the sum.
+ */
+export declare const CODE128: string[];
+export declare const CODE128_START_A = 103;
+export declare const CODE128_START_B = 104;
+export declare const CODE128_START_C = 105;
+export declare const CODE128_STOP = 106;
+export declare const CODE128_FNC1 = 102;
+export declare const CODE128_FNC2 = 97;
+export declare const CODE128_FNC3 = 96;
+export declare const CODE128_FNC4_A = 101;
+export declare const CODE128_FNC4_B = 100;
+export declare const CODE128_SHIFT = 98;
+export declare const CODE128_CODE_A = 101;
+export declare const CODE128_CODE_B = 100;
+export declare const CODE128_CODE_C = 99;
+/** Five elements per digit, exactly two of them wide. */
+export declare const ITF: string[];
+/** Seven elements per character. */
+export declare const CODABAR: {
+    '0': string;
+    '1': string;
+    '2': string;
+    '3': string;
+    '4': string;
+    '5': string;
+    '6': string;
+    '7': string;
+    '8': string;
+    '9': string;
+    '-': string;
+    $: string;
+    ':': string;
+    '/': string;
+    '.': string;
+    '+': string;
+    A: string;
+    B: string;
+    C: string;
+    D: string;
+};
+export declare const CODABAR_START_STOP = "ABCD";
+/** Five elements per character, one or two of them wide. */
+export declare const CODE11: {
+    '0': string;
+    '1': string;
+    '2': string;
+    '3': string;
+    '4': string;
+    '5': string;
+    '6': string;
+    '7': string;
+    '8': string;
+    '9': string;
+    '-': string;
+};
+export declare const CODE11_START_STOP = "nnwwn";
+/** Each bit of a digit becomes a bar pair: 1 is wide-then-narrow, 0 the reverse. */
+export declare const MSI_BIT: {
+    0: string;
+    1: string;
+};
+export declare const MSI_START = "110";
+export declare const MSI_STOP = "1001";
+/**
+ * Assert every invariant these tables are supposed to satisfy.
+ *
+ * This is the first of the correctness mechanisms described in NOTICE.md:
+ * the tables are redundant with the symbology rules, so the rules can check
+ * the tables. Called from the test suite; cheap enough to call anywhere.
+ *
+ * @returns {string[]} Problems found; empty means all invariants hold.
+ */
+export declare function validateTables(): string[];

package/src/ts/oned/reader.d.ts

@@ -0,0 +1,129 @@
+/*!
+ * Sythos Barcode Suite
+ *
+ * MIT License
+ *
+ * Copyright (c) 2026 Sythos
+ * SPDX-FileCopyrightText: 2026 Sythos (https://www.sythos.net)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * Original work. No code from any other barcode implementation.
+ */
+/**
+ * Compare measured run lengths against an ideal pattern, scale-independently.
+ *
+ * Returns a normalised mismatch score, or Infinity when any single element is
+ * further out of proportion than `maxIndividual` allows. Rejecting on the
+ * worst element as well as the total is what stops a run of noise whose widths
+ * happen to average out from being accepted as a character.
+ *
+ * @param {number[]} counters Measured widths, in pixels.
+ * @param {number[]} pattern Ideal widths, in modules.
+ * @param {number} maxIndividual Tolerance per element, as a fraction of a module.
+ * @returns {number}
+ */
+export declare function patternVariance(counters: number[], pattern: number[], maxIndividual: number): number;
+/**
+ * Measure alternating run lengths starting at `start`.
+ *
+ * @param {Uint8Array} row One byte per pixel, 1 = dark.
+ * @param {number} start
+ * @param {number[]} counters Filled in place; its length sets how many runs to read.
+ * @returns {boolean} False if the row ended before the runs were filled.
+ */
+export declare function recordPattern(row: Uint8Array, start: number, counters: number[]): boolean;
+/**
+ * Classify run lengths into narrow and wide, for the n/w symbologies.
+ *
+ * The wide:narrow ratio is not fixed by these formats — it is anywhere from
+ * 2:1 to 3:1 and varies with the printer — so the split has to be discovered
+ * from the data. Candidate thresholds are tried from the smallest counter
+ * upward until exactly the expected number of wide elements falls out.
+ *
+ * @param {number[]} counters
+ * @param {number} expectedWide How many elements must be wide.
+ * @returns {number} Bit pattern, MSB = first element wide; -1 if undecidable.
+ */
+export declare function toNarrowWidePattern(counters: number[], expectedWide: number): number;
+/**
+ * Decode Code 11 from one binarized scanline.
+ *
+ * @param {Uint8Array} row
+ * @param {object} [options]
+ * @param {boolean} [options.checkDigit]
+ * @returns {{format:'code11', text:string}|null}
+ */
+export declare function decodeCode11(row: Uint8Array, options?: {
+    checkDigit?: boolean;
+}): {
+    format: 'code11';
+    text: string;
+} | null;
+/**
+ * Decode MSI/Plessey from one binarized scanline.
+ *
+ * @param {Uint8Array} row
+ * @param {object} [options]
+ * @param {boolean} [options.checkDigit]
+ * @returns {{format:'msi', text:string}|null}
+ */
+export declare function decodeMSI(row: Uint8Array, options?: {
+    checkDigit?: boolean;
+}): {
+    format: 'msi';
+    text: string;
+} | null;
+/**
+ * Read every linear symbol found in a binarized image.
+ *
+ * @param {import('../core/bit-matrix.js').BitMatrix} image Binarized; set bit = dark.
+ * @param {object} [options]
+ * @param {string[]} [options.formats] Restrict to these format ids.
+ * @param {number} [options.rows] How many horizontal slices to try.
+ * @param {boolean} [options.tryHarder] Also scan reversed rows, for mirrored symbols.
+ * @param {'camera'} [options.profile] Require stable, quiet-zone-qualified reads.
+ * @param {0|90|180|270} [options.cameraRotation] Orientation already normalized by the caller.
+ * @returns {Array<{format: string, text: string, row: number}>}
+ */
+export declare function decodeOneD(image: import('../core/bit-matrix.js').BitMatrix, options?: {
+    formats?: string[];
+    rows?: number;
+    tryHarder?: boolean;
+    profile?: 'camera';
+    cameraRotation?: 0 | 90 | 180 | 270;
+}): Array<{
+    format: string;
+    text: string;
+    row: number;
+}>;
+/**
+ * Convenience wrapper that throws when nothing is found.
+ *
+ * @param {import('../core/bit-matrix.js').BitMatrix} image
+ * @param {object} [options]
+ * @returns {{format: string, text: string, row: number}}
+ */
+export declare function decodeOneDStrict(image: import('../core/bit-matrix.js').BitMatrix, options?: object): {
+    format: string;
+    text: string;
+    row: number;
+};