@sythos/js_barcode_universal 1.5.6 → 1.5.8

package/src/ts/qr/detector.d.ts

@@ -0,0 +1,93 @@
+/*!
+ * 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.
+ */
+export type Candidate = {
+    x: number;
+    y: number;
+    moduleSize: number;
+    hits: number;
+};
+export type Detection = {
+    /**
+     * Outer corners of the
+     * symbol, ordered top-left, top-right, bottom-right, bottom-left.
+     */
+    corners: Array<{
+        x: number;
+        y: number;
+    }>;
+    /**
+     * Modules per side.
+     */
+    dimension: number;
+    version: number;
+    /**
+     * Estimated pixels per module.
+     */
+    moduleSize: number;
+    alignmentFound: boolean;
+};
+/**
+ * @typedef {object} Detection
+ * @property {Array<{x: number, y: number}>} corners Outer corners of the
+ *   symbol, ordered top-left, top-right, bottom-right, bottom-left.
+ * @property {number} dimension Modules per side.
+ * @property {number} version
+ * @property {number} moduleSize Estimated pixels per module.
+ * @property {boolean} alignmentFound
+ */
+/**
+ * Find QR Code symbols in a binarized image.
+ *
+ * @param {import('../core/bit-matrix.js').BitMatrix} binaryImage Set bit = dark.
+ * @returns {Detection[]} Possibly empty; ordered by descending module size, so
+ *   the most prominent symbol comes first.
+ */
+export declare function detectQR(binaryImage: import('../core/bit-matrix.js').BitMatrix): Detection[];
+/**
+ * Find and decode every QR Code in a binarized image.
+ *
+ * Each candidate gets up to four attempts: a plain centre sample, a 3x3
+ * majority vote for noisy input, and both of those rotated 180 degrees. The
+ * rotation retry matters because three finders in a right isoceles triangle
+ * look identical to the same three rotated half a turn — the orientation is
+ * only settled once the format information reads cleanly, which is to say once
+ * the decode succeeds.
+ *
+ * @param {import('../core/bit-matrix.js').BitMatrix} binaryImage
+ * @returns {Array<import('./decoder.js').DecodeResult & {corners: Array<{x: number, y: number}>}>}
+ *   Empty when nothing decodes; never throws for "no symbol here".
+ */
+export declare function detectAndDecodeQR(binaryImage: import('../core/bit-matrix.js').BitMatrix): Array<import('./decoder.js').DecodeResult & {
+    corners: Array<{
+        x: number;
+        y: number;
+    }>;
+}>;

package/src/ts/qr/encoder.d.ts

@@ -0,0 +1,166 @@
+/*!
+ * 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.
+ */
+/**
+ * QR Code encoder.
+ *
+ * Pipeline: analyse the text into mode segments, pick the smallest version that
+ * holds them, serialise the bitstream, split it into Reed-Solomon blocks,
+ * interleave data and parity, lay the result into the module grid along the
+ * zig-zag path, then choose the mask that scores best under the four penalty
+ * rules.
+ *
+ * Segment selection is a shortest-path problem, not a greedy scan. "1234ABCD"
+ * is cheaper as one alphanumeric segment than as numeric plus alphanumeric,
+ * because a mode switch costs a mode indicator plus a character count field;
+ * whether that trade pays depends on run lengths that a left-to-right scan
+ * cannot see yet. The dynamic program below weighs it properly.
+ *
+ * It also has to run *per version band*, because the character count field
+ * widens at versions 10 and 27 — so the cheapest segmentation depends on the
+ * version, and the smallest sufficient version depends on the segmentation.
+ * {@link encodeQR} resolves the circularity by solving each band independently
+ * and taking the first version that fits.
+ *
+ * @module qr/encoder
+ */
+import { BitMatrix } from '../core/bit-matrix.js';
+/** Alphanumeric mode character set; a character's index is its encoded value. */
+export declare const ALPHANUMERIC_CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:";
+/** ECI designator for UTF-8. */
+export declare const ECI_UTF8 = 26;
+export type EncodeOptions = {
+    /**
+     * Error correction level. Default 'M'.
+     */
+    ecc?: 'L' | 'M' | 'Q' | 'H';
+    /**
+     * Force a version 1-40 instead of the smallest fit.
+     */
+    version?: number;
+    /**
+     * Force a mask 0-7 instead of the best-scoring one.
+     */
+    mask?: number;
+    /**
+     * Byte mode interpretation.
+     * 'auto' uses ISO-8859-1 when the text allows it and UTF-8 with an ECI
+     * header otherwise.
+     */
+    charset?: 'auto' | 'utf-8' | 'iso-8859-1';
+    /**
+     * Allow kanji mode. Default true; ignored when the
+     * platform cannot supply a Shift_JIS codec.
+     */
+    kanji?: boolean;
+};
+/**
+ * Pack a Shift_JIS double byte into the 13-bit kanji mode value.
+ *
+ * The two covered ranges are folded onto a single contiguous space by
+ * subtracting a different offset from each, then re-basing the low byte to 0xC0
+ * values per high byte.
+ *
+ * @param {number} sjis 16-bit Shift_JIS value.
+ * @returns {number} 13-bit value, or -1 if outside the kanji mode ranges.
+ */
+export declare function sjisToThirteenBits(sjis: number): number;
+export type CharInfo = {
+    /**
+     * Code points.
+     */
+    points: string[];
+    numeric: Uint8Array;
+    /**
+     * Alphanumeric value, or -1.
+     */
+    alnum: Int32Array;
+    /**
+     * Bytes this code point costs in byte mode.
+     */
+    byteLen: Int32Array;
+    /**
+     * 13-bit kanji value, or -1.
+     */
+    kanji: Int32Array;
+    utf8: boolean;
+};
+export type Segment = {
+    mode: number;
+    /**
+     * Inclusive index into the code point array.
+     */
+    start: number;
+    /**
+     * Exclusive.
+     */
+    end: number;
+};
+/**
+ * The 15-bit masked format information.
+ *
+ * @param {string} ecc @param {number} mask
+ * @returns {number}
+ */
+export declare function formatInfoBits(ecc: string, mask: number): number;
+/**
+ * The 18-bit version information, for versions 7 and up.
+ *
+ * @param {number} version
+ * @returns {number}
+ */
+export declare function versionInfoBits(version: number): number;
+/**
+ * The four penalty rules. Lower is better.
+ *
+ * These exist to keep a symbol readable: long uniform runs and large blocks
+ * confuse the binarizer, finder lookalikes confuse the detector, and a symbol
+ * far from half dark loses contrast headroom. Scoring is a heuristic, not a
+ * correctness surface — any of the eight masks decodes, because the format
+ * information says which one was used.
+ *
+ * @param {BitMatrix} m
+ * @returns {number}
+ */
+export declare function maskPenalty(m: BitMatrix): number;
+/**
+ * Encode text as a QR Code.
+ *
+ * The result carries no quiet zone; callers add one with
+ * `matrix.withMargin(4)`. Keeping the margin out of the encoder means the
+ * renderer decides it, which is where the decision belongs — a symbol embedded
+ * in a design and a symbol printed on a label want different borders.
+ *
+ * @param {string} text
+ * @param {EncodeOptions} [options]
+ * @returns {BitMatrix} Set bit = dark module.
+ * @throws {EncodeError} If the text does not fit, or the options are invalid.
+ */
+export declare function encodeQR(text: string, options?: EncodeOptions): BitMatrix;

package/src/{qr/index.js → ts/qr/index.d.ts}

@@ -28,7 +28,6 @@
  *
  * Original work. No code from any other barcode implementation.
  */
-
 /**
  * QR Code, re-exported.
  *
@@ -38,7 +37,6 @@
  *
  * @module qr
  */
-
 export { encodeQR } from './encoder.js';
 export { decodeQR } from './decoder.js';
 export { detectQR, detectAndDecodeQR } from './detector.js';

package/src/ts/qr/tables.d.ts

@@ -0,0 +1,291 @@
+/*!
+ * 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.
+ */
+/**
+ * QR Code structural tables.
+ *
+ * The design principle here is that as little as possible is *recalled* and as
+ * much as possible is *derived*, because a barcode table is the one place where
+ * a single mistyped digit produces a symbol that looks perfect and scans as
+ * garbage — or, worse, scans correctly for the payload you tested and fails for
+ * the payload your user sends.
+ *
+ * So:
+ *
+ *   - Symbol size, function-pattern layout and total codeword capacity are
+ *     computed from geometry. Nothing is tabulated that the module grid already
+ *     knows.
+ *   - Alignment centres come from the spec's spacing rule, not a 40-row table.
+ *   - The group-1 / group-2 block split is arithmetic, not data.
+ *
+ * That leaves exactly three recalled numbers per (version, level): the error
+ * correction codewords per block, the block count, and the total data codeword
+ * count. Those three are deliberately redundant — they must satisfy
+ *
+ *     blocks * eccPerBlock + totalDataCodewords === geometricTotalCodewords(v)
+ *
+ * for all 160 combinations, where the right-hand side is counted off the module
+ * grid. Any single typo on either side breaks the identity. {@link validateTables}
+ * enforces it, and the test suite asserts it returns no problems.
+ *
+ * @module qr/tables
+ */
+import { BitMatrix } from '../core/bit-matrix.js';
+/** Error correction levels, weakest to strongest. */
+export declare const ECC_LEVELS: string[];
+/**
+ * Two-bit level indicator used in the format information.
+ * Note this is *not* the L/M/Q/H ordering — the spec assigns them out of order.
+ */
+export declare const ECC_LEVEL_BITS: {
+    L: number;
+    M: number;
+    Q: number;
+    H: number;
+};
+/** Inverse of {@link ECC_LEVEL_BITS}, indexed by the 2-bit value. */
+export declare const ECC_LEVEL_BY_BITS: string[];
+export declare const MIN_VERSION = 1;
+export declare const MAX_VERSION = 40;
+/** Version at and above which an 18-bit version information block is carried. */
+export declare const VERSION_INFO_MIN = 7;
+/** Mode indicator nibbles. */
+export declare const MODE: {
+    TERMINATOR: number;
+    NUMERIC: number;
+    ALPHANUMERIC: number;
+    STRUCTURED_APPEND: number;
+    BYTE: number;
+    FNC1_FIRST: number;
+    ECI: number;
+    KANJI: number;
+    FNC1_SECOND: number;
+};
+/**
+ * @param {number} version 1-40
+ * @returns {number} Modules per side.
+ */
+export declare function versionSize(version: number): number;
+/**
+ * Bits in the character count indicator.
+ *
+ * @param {number} mode One of {@link MODE}.
+ * @param {number} version
+ * @returns {number}
+ */
+export declare function countBits(mode: number, version: number): number;
+/**
+ * Centre coordinates of the alignment patterns for a version.
+ *
+ * The spec's rule: the first centre is always 6 and the last is always
+ * `size - 7`; the count grows by one every seven versions; and the centres are
+ * evenly spaced with the *first* gap absorbing the rounding slack. Expressing
+ * that as arithmetic rather than a 40-row table means there is no table to
+ * mistype, and {@link validateTables} can then assert the shape of the result.
+ *
+ * @param {number} version
+ * @returns {number[]} Ascending centres. Empty for version 1.
+ */
+export declare function alignmentCoordinates(version: number): number[];
+/**
+ * Centres of the alignment patterns actually drawn, as [x, y] pairs.
+ *
+ * The three combinations that would sit on top of a finder pattern are omitted.
+ *
+ * @param {number} version
+ * @returns {Array<[number, number]>}
+ */
+export declare function alignmentCentres(version: number): Array<[number, number]>;
+/**
+ * Map of modules that carry function patterns rather than payload.
+ *
+ * A set bit means "reserved": finder, separator, timing, alignment, format
+ * information, the dark module, and the version information blocks. This is the
+ * single source of truth used by the encoder to skip modules while laying out
+ * the bitstream, by the decoder to read them back in the same order, and by
+ * {@link geometricTotalCodewords} to count what is left.
+ *
+ * Deriving capacity this way rather than by hand arithmetic is what makes the
+ * awkward cases free: an alignment pattern that overlaps the timing pattern is
+ * counted once because it is the same set of modules, not because anyone
+ * remembered to subtract five.
+ *
+ * @param {number} version
+ * @returns {BitMatrix} Shared, cached — treat as immutable.
+ */
+export declare function reservedModules(version: number): BitMatrix;
+/**
+ * Module positions of the two format information copies.
+ *
+ * Index `i` in each array is bit `i` of the 15-bit format value, bit 0 being
+ * the least significant.
+ *
+ * CAVEAT WORTH READING: the *direction* of this numbering is the one thing in
+ * this file that a round-trip test cannot falsify. Encoder and decoder share
+ * these tables, so a mirrored layout would pass every test in the suite and
+ * fail only against a real scanner. The layout below is the standard one; both
+ * sides deliberately consume this single definition so there is no second place
+ * for the convention to drift.
+ *
+ * @param {number} size Modules per side.
+ * @returns {[Array<[number, number]>, Array<[number, number]>]} [copyA, copyB]
+ */
+export declare function formatInfoPositions(size: number): [Array<[number, number]>, Array<[number, number]>];
+/**
+ * Modules available to data and error correction, counted off the grid.
+ *
+ * @param {number} version
+ * @returns {number}
+ */
+export declare function freeModuleCount(version: number): number;
+/**
+ * Total codewords (data + error correction) a version holds.
+ *
+ * Geometric, not tabulated — this is the reference the ECC table is checked
+ * against.
+ *
+ * @param {number} version
+ * @returns {number}
+ */
+export declare function geometricTotalCodewords(version: number): number;
+/**
+ * Bits left over after the last whole codeword, written as zeroes.
+ *
+ * @param {number} version
+ * @returns {number} 0, 3, 4 or 7.
+ */
+export declare function remainderBits(version: number): number;
+/**
+ * Module positions in bitstream order, as interleaved x, y pairs.
+ *
+ * The layout walks two-module-wide columns from the bottom-right corner
+ * leftward, alternating upward and downward, right module of the pair before
+ * the left, skipping the vertical timing column and every reserved module.
+ *
+ * Encoder and decoder both consume this one function. That is not tidiness: a
+ * placement order that disagrees between the two would still round-trip
+ * perfectly within this library while producing symbols no scanner can read.
+ * There is only one order because there is only one implementation of it.
+ *
+ * @param {number} version
+ * @returns {Int32Array} Shared, cached — treat as immutable. Length is
+ *   `2 * freeModuleCount(version)`.
+ */
+export declare function dataModuleOrder(version: number): Int32Array;
+/**
+ * The eight data mask predicates.
+ *
+ * A true result means the module at (x, y) is inverted. Masks apply to payload
+ * modules only; function patterns are laid down after masking and are never
+ * touched.
+ *
+ * @param {number} mask 0-7
+ * @param {number} x Column.
+ * @param {number} y Row.
+ * @returns {boolean}
+ */
+export declare function maskBit(mask: number, x: number, y: number): boolean;
+export type BlockLayout = {
+    version: number;
+    ecc: string;
+    /**
+     * Data + error correction.
+     */
+    totalCodewords: number;
+    totalDataCodewords: number;
+    eccPerBlock: number;
+    blockCount: number;
+    /**
+     * Blocks holding the smaller data count.
+     */
+    group1Blocks: number;
+    group1DataCount: number;
+    /**
+     * Blocks holding one extra data codeword.
+     */
+    group2Blocks: number;
+    group2DataCount: number;
+    remainderBits: number;
+};
+/**
+ * @typedef {object} BlockLayout
+ * @property {number} version
+ * @property {string} ecc
+ * @property {number} totalCodewords    Data + error correction.
+ * @property {number} totalDataCodewords
+ * @property {number} eccPerBlock
+ * @property {number} blockCount
+ * @property {number} group1Blocks      Blocks holding the smaller data count.
+ * @property {number} group1DataCount
+ * @property {number} group2Blocks      Blocks holding one extra data codeword.
+ * @property {number} group2DataCount
+ * @property {number} remainderBits
+ */
+/**
+ * Block structure for a (version, level).
+ *
+ * The group split is derived: the spec distributes the remainder of
+ * `data / blocks` one codeword at a time into the *trailing* blocks, so the
+ * short blocks come first. That is arithmetic, and tabulating it would only
+ * create somewhere else for a typo to hide.
+ *
+ * @param {number} version
+ * @param {string} ecc 'L' | 'M' | 'Q' | 'H'
+ * @returns {BlockLayout}
+ */
+export declare function blockLayout(version: number, ecc: string): BlockLayout;
+/**
+ * Data capacity in codewords.
+ *
+ * @param {number} version
+ * @param {string} ecc
+ * @returns {number}
+ */
+export declare function dataCodewords(version: number, ecc: string): number;
+/**
+ * Data capacity in bits.
+ *
+ * @param {number} version
+ * @param {string} ecc
+ * @returns {number}
+ */
+export declare function dataBitCapacity(version: number, ecc: string): number;
+/**
+ * Self-check every table in this file.
+ *
+ * The load-bearing assertion is the capacity identity across all 160
+ * (version, level) combinations, but a pair of compensating typos could in
+ * principle slip past it, so the surrounding checks each constrain a different
+ * axis: monotonicity, the closed set of ECC block sizes, the field size limit,
+ * and the shape of the alignment coordinate sequence.
+ *
+ * @returns {string[]} Human-readable problems; empty means everything holds.
+ */
+export declare function validateTables(): string[];

package/src/ts/render/image-data.d.ts

@@ -0,0 +1,58 @@
+/*!
+ * 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.
+ */
+/**
+ * Render to an `ImageData`-shaped object.
+ *
+ * A plain object rather than a real `ImageData`, so this works in Node and in
+ * workers without a DOM. It is accepted directly by `ctx.putImageData` in the
+ * browser, and by this library's own reader.
+ *
+ * @param {import('../core/bit-matrix.js').BitMatrix} matrix
+ * @param {import('./options.js').RenderOptions} [options]
+ * @returns {{data: Uint8ClampedArray, width: number, height: number}}
+ */
+export declare function toImageData(matrix: import('../core/bit-matrix.js').BitMatrix, options?: import('./options.js').RenderOptions): {
+    data: Uint8ClampedArray;
+    width: number;
+    height: number;
+};
+/**
+ * Draw into a canvas using its 2D context.
+ *
+ * This is the universal fallback: every browser that runs JavaScript at all
+ * has a 2D context, including every iOS Safari version.
+ *
+ * @param {import('../core/bit-matrix.js').BitMatrix} matrix
+ * @param {HTMLCanvasElement | OffscreenCanvas} canvas
+ * @param {import('./options.js').RenderOptions} [options]
+ * @returns {boolean} True when it drew.
+ */
+export declare function toCanvas(matrix: import('../core/bit-matrix.js').BitMatrix, canvas: HTMLCanvasElement | OffscreenCanvas, options?: import('./options.js').RenderOptions): boolean;