@qr-platform/qr-code.js 0.9.0 → 0.9.1

package/lib/node/lib/zxing-js/src/core/qrcode/decoder/Version.d.ts

@@ -0,0 +1,44 @@
+import BitMatrix from '../../common/BitMatrix';
+import ECBlocks from './ECBlocks';
+import ErrorCorrectionLevel from './ErrorCorrectionLevel';
+/**
+ * See ISO 18004:2006 Annex D
+ *
+ * @author Sean Owen
+ */
+export default class Version {
+    private versionNumber;
+    private alignmentPatternCenters;
+    /**
+     * See ISO 18004:2006 Annex D.
+     * Element i represents the raw version bits that specify version i + 7
+     */
+    private static VERSION_DECODE_INFO;
+    /**
+     * See ISO 18004:2006 6.5.1 Table 9
+     */
+    private static VERSIONS;
+    private ecBlocks;
+    private totalCodewords;
+    private constructor();
+    getVersionNumber(): number;
+    getAlignmentPatternCenters(): Int32Array;
+    getTotalCodewords(): number;
+    getDimensionForVersion(): number;
+    getECBlocksForLevel(ecLevel: ErrorCorrectionLevel): ECBlocks;
+    /**
+     * <p>Deduces version information purely from QR Code dimensions.</p>
+     *
+     * @param dimension dimension in modules
+     * @return Version for a QR Code of that dimension
+     * @throws FormatException if dimension is not 1 mod 4
+     */
+    static getProvisionalVersionForDimension(dimension: number): Version;
+    static getVersionForNumber(versionNumber: number): Version;
+    static decodeVersionInformation(versionBits: number): Version | null;
+    /**
+     * See ISO 18004:2006 Annex E
+     */
+    buildFunctionPattern(): BitMatrix;
+    toString(): string;
+}

package/lib/node/lib/zxing-js/src/core/qrcode/detector/AlignmentPattern.d.ts

@@ -0,0 +1,21 @@
+import ResultPoint from '../../ResultPoint';
+/**
+ * <p>Encapsulates an alignment pattern, which are the smaller square patterns found in
+ * all but the simplest QR Codes.</p>
+ *
+ * @author Sean Owen
+ */
+export default class AlignmentPattern extends ResultPoint {
+    private estimatedModuleSize;
+    constructor(posX: number, posY: number, estimatedModuleSize: number);
+    /**
+     * <p>Determines if this alignment pattern "about equals" an alignment pattern at the stated
+     * position and size -- meaning, it is at nearly the same center with nearly the same size.</p>
+     */
+    aboutEquals(moduleSize: number, i: number, j: number): boolean;
+    /**
+     * Combines this object's current estimate of a finder pattern position and module size
+     * with a new estimate. It returns a new {@code FinderPattern} containing an average of the two.
+     */
+    combineEstimate(i: number, j: number, newModuleSize: number): AlignmentPattern;
+}

package/lib/node/lib/zxing-js/src/core/qrcode/detector/AlignmentPatternFinder.d.ts

@@ -0,0 +1,82 @@
+import BitMatrix from '../../common/BitMatrix';
+import ResultPointCallback from '../../ResultPointCallback';
+import AlignmentPattern from './AlignmentPattern';
+/**
+ * <p>This class attempts to find alignment patterns in a QR Code. Alignment patterns look like finder
+ * patterns but are smaller and appear at regular intervals throughout the image.</p>
+ *
+ * <p>At the moment this only looks for the bottom-right alignment pattern.</p>
+ *
+ * <p>This is mostly a simplified copy of {@link FinderPatternFinder}. It is copied,
+ * pasted and stripped down here for maximum performance but does unfortunately duplicate
+ * some code.</p>
+ *
+ * <p>This class is thread-safe but not reentrant. Each thread must allocate its own object.</p>
+ *
+ * @author Sean Owen
+ */
+export default class AlignmentPatternFinder {
+    private image;
+    private startX;
+    private startY;
+    private width;
+    private height;
+    private moduleSize;
+    private resultPointCallback;
+    private possibleCenters;
+    private crossCheckStateCount;
+    /**
+     * <p>Creates a finder that will look in a portion of the whole image.</p>
+     *
+     * @param image image to search
+     * @param startX left column from which to start searching
+     * @param startY top row from which to start searching
+     * @param width width of region to search
+     * @param height height of region to search
+     * @param moduleSize estimated module size so far
+     */
+    constructor(image: BitMatrix, startX: number, startY: number, width: number, height: number, moduleSize: number, resultPointCallback: ResultPointCallback);
+    /**
+     * <p>This method attempts to find the bottom-right alignment pattern in the image. It is a bit messy since
+     * it's pretty performance-critical and so is written to be fast foremost.</p>
+     *
+     * @return {@link AlignmentPattern} if found
+     * @throws NotFoundException if not found
+     */
+    find(): AlignmentPattern;
+    /**
+     * Given a count of black/white/black pixels just seen and an end position,
+     * figures the location of the center of this black/white/black run.
+     */
+    private static centerFromEnd;
+    /**
+     * @param stateCount count of black/white/black pixels just read
+     * @return true iff the proportions of the counts is close enough to the 1/1/1 ratios
+     *         used by alignment patterns to be considered a match
+     */
+    private foundPatternCross;
+    /**
+     * <p>After a horizontal scan finds a potential alignment pattern, this method
+     * "cross-checks" by scanning down vertically through the center of the possible
+     * alignment pattern to see if the same proportion is detected.</p>
+     *
+     * @param startI row where an alignment pattern was detected
+     * @param centerJ center of the section that appears to cross an alignment pattern
+     * @param maxCount maximum reasonable number of modules that should be
+     * observed in any reading state, based on the results of the horizontal scan
+     * @return vertical center of alignment pattern, or {@link Float#NaN} if not found
+     */
+    private crossCheckVertical;
+    /**
+     * <p>This is called when a horizontal scan finds a possible alignment pattern. It will
+     * cross check with a vertical scan, and if successful, will see if this pattern had been
+     * found on a previous horizontal scan. If so, we consider it confirmed and conclude we have
+     * found the alignment pattern.</p>
+     *
+     * @param stateCount reading state module counts from horizontal scan
+     * @param i row where alignment pattern may be found
+     * @param j end of possible alignment pattern in row
+     * @return {@link AlignmentPattern} if we have found the same pattern twice, or null if not
+     */
+    private handlePossibleCenter;
+}

package/lib/node/lib/zxing-js/src/core/qrcode/detector/Detector.d.ts

@@ -0,0 +1,87 @@
+import BitMatrix from '../../common/BitMatrix';
+import DetectorResult from '../../common/DetectorResult';
+import DecodeHintType from '../../DecodeHintType';
+import ResultPoint from '../../ResultPoint';
+import ResultPointCallback from '../../ResultPointCallback';
+import AlignmentPattern from './AlignmentPattern';
+import FinderPatternInfo from './FinderPatternInfo';
+/**
+ * <p>Encapsulates logic that can detect a QR Code in an image, even if the QR Code
+ * is rotated or skewed, or partially obscured.</p>
+ *
+ * @author Sean Owen
+ */
+export default class Detector {
+    private image;
+    private resultPointCallback?;
+    constructor(image: BitMatrix);
+    protected getImage(): BitMatrix;
+    protected getResultPointCallback(): ResultPointCallback | undefined;
+    /**
+     * <p>Detects a QR Code in an image.</p>
+     *
+     * @return {@link DetectorResult} encapsulating results of detecting a QR Code
+     * @throws NotFoundException if QR Code cannot be found
+     * @throws FormatException if a QR Code cannot be decoded
+     */
+    /**
+     * <p>Detects a QR Code in an image.</p>
+     *
+     * @param hints optional hints to detector
+     * @return {@link DetectorResult} encapsulating results of detecting a QR Code
+     * @throws NotFoundException if QR Code cannot be found
+     * @throws FormatException if a QR Code cannot be decoded
+     */
+    detect(hints: Map<DecodeHintType, any>): DetectorResult;
+    protected processFinderPatternInfo(info: FinderPatternInfo): DetectorResult;
+    private static createTransform;
+    private static sampleGrid;
+    /**
+     * <p>Computes the dimension (number of modules on a size) of the QR Code based on the position
+     * of the finder patterns and estimated module size.</p>
+     */
+    private static computeDimension;
+    /**
+     * <p>Computes an average estimated module size based on estimated derived from the positions
+     * of the three finder patterns.</p>
+     *
+     * @param topLeft detected top-left finder pattern center
+     * @param topRight detected top-right finder pattern center
+     * @param bottomLeft detected bottom-left finder pattern center
+     * @return estimated module size
+     */
+    protected calculateModuleSize(topLeft: ResultPoint, topRight: ResultPoint, bottomLeft: ResultPoint): number;
+    /**
+     * <p>Estimates module size based on two finder patterns -- it uses
+     * {@link #sizeOfBlackWhiteBlackRunBothWays(int, int, int, int)} to figure the
+     * width of each, measuring along the axis between their centers.</p>
+     */
+    private calculateModuleSizeOneWay;
+    /**
+     * See {@link #sizeOfBlackWhiteBlackRun(int, int, int, int)}; computes the total width of
+     * a finder pattern by looking for a black-white-black run from the center in the direction
+     * of another point (another finder pattern center), and in the opposite direction too.
+     */
+    private sizeOfBlackWhiteBlackRunBothWays;
+    /**
+     * <p>This method traces a line from a point in the image, in the direction towards another point.
+     * It begins in a black region, and keeps going until it finds white, then black, then white again.
+     * It reports the distance from the start to this point.</p>
+     *
+     * <p>This is used when figuring out how wide a finder pattern is, when the finder pattern
+     * may be skewed or rotated.</p>
+     */
+    private sizeOfBlackWhiteBlackRun;
+    /**
+     * <p>Attempts to locate an alignment pattern in a limited region of the image, which is
+     * guessed to contain it. This method uses {@link AlignmentPattern}.</p>
+     *
+     * @param overallEstModuleSize estimated module size so far
+     * @param estAlignmentX x coordinate of center of area probably containing alignment pattern
+     * @param estAlignmentY y coordinate of above
+     * @param allowanceFactor number of pixels in all directions to search from the center
+     * @return {@link AlignmentPattern} if found, or null otherwise
+     * @throws NotFoundException if an unexpected error occurs during detection
+     */
+    protected findAlignmentInRegion(overallEstModuleSize: number, estAlignmentX: number, estAlignmentY: number, allowanceFactor: number): AlignmentPattern;
+}

package/lib/node/lib/zxing-js/src/core/qrcode/detector/FinderPattern.d.ts

@@ -0,0 +1,26 @@
+import ResultPoint from '../../ResultPoint';
+/**
+ * <p>Encapsulates a finder pattern, which are the three square patterns found in
+ * the corners of QR Codes. It also encapsulates a count of similar finder patterns,
+ * as a convenience to the finder's bookkeeping.</p>
+ *
+ * @author Sean Owen
+ */
+export default class FinderPattern extends ResultPoint {
+    private estimatedModuleSize;
+    private count?;
+    constructor(posX: number, posY: number, estimatedModuleSize: number, count?: number | undefined);
+    getEstimatedModuleSize(): number;
+    getCount(): number | undefined;
+    /**
+     * <p>Determines if this finder pattern "about equals" a finder pattern at the stated
+     * position and size -- meaning, it is at nearly the same center with nearly the same size.</p>
+     */
+    aboutEquals(moduleSize: number, i: number, j: number): boolean;
+    /**
+     * Combines this object's current estimate of a finder pattern position and module size
+     * with a new estimate. It returns a new {@code FinderPattern} containing a weighted average
+     * based on count.
+     */
+    combineEstimate(i: number, j: number, newModuleSize: number): FinderPattern;
+}

package/lib/node/lib/zxing-js/src/core/qrcode/detector/FinderPatternFinder.d.ts

@@ -0,0 +1,114 @@
+import BitMatrix from '../../common/BitMatrix';
+import DecodeHintType from '../../DecodeHintType';
+import ResultPointCallback from '../../ResultPointCallback';
+import FinderPattern from './FinderPattern';
+import FinderPatternInfo from './FinderPatternInfo';
+/**
+ * <p>This class attempts to find finder patterns in a QR Code. Finder patterns are the square
+ * markers at three corners of a QR Code.</p>
+ *
+ * <p>This class is thread-safe but not reentrant. Each thread must allocate its own object.
+ *
+ * @author Sean Owen
+ */
+export default class FinderPatternFinder {
+    private image;
+    private resultPointCallback;
+    private static CENTER_QUORUM;
+    protected static MIN_SKIP: number;
+    protected static MAX_MODULES: number;
+    private possibleCenters;
+    private hasSkipped?;
+    private crossCheckStateCount;
+    /**
+     * <p>Creates a finder that will search the image for three finder patterns.</p>
+     *
+     * @param image image to search
+     */
+    constructor(image: BitMatrix, resultPointCallback: ResultPointCallback);
+    protected getImage(): BitMatrix;
+    protected getPossibleCenters(): FinderPattern[];
+    find(hints: Map<DecodeHintType, any>): FinderPatternInfo;
+    /**
+     * Given a count of black/white/black/white/black pixels just seen and an end position,
+     * figures the location of the center of this run.
+     */
+    private static centerFromEnd;
+    /**
+     * @param stateCount count of black/white/black/white/black pixels just read
+     * @return true iff the proportions of the counts is close enough to the 1/1/3/1/1 ratios
+     *         used by finder patterns to be considered a match
+     */
+    protected static foundPatternCross(stateCount: Int32Array): boolean;
+    private getCrossCheckStateCount;
+    /**
+     * After a vertical and horizontal scan finds a potential finder pattern, this method
+     * "cross-cross-cross-checks" by scanning down diagonally through the center of the possible
+     * finder pattern to see if the same proportion is detected.
+     *
+     * @param startI row where a finder pattern was detected
+     * @param centerJ center of the section that appears to cross a finder pattern
+     * @param maxCount maximum reasonable number of modules that should be
+     *  observed in any reading state, based on the results of the horizontal scan
+     * @param originalStateCountTotal The original state count total.
+     * @return true if proportions are withing expected limits
+     */
+    private crossCheckDiagonal;
+    /**
+     * <p>After a horizontal scan finds a potential finder pattern, this method
+     * "cross-checks" by scanning down vertically through the center of the possible
+     * finder pattern to see if the same proportion is detected.</p>
+     *
+     * @param startI row where a finder pattern was detected
+     * @param centerJ center of the section that appears to cross a finder pattern
+     * @param maxCount maximum reasonable number of modules that should be
+     * observed in any reading state, based on the results of the horizontal scan
+     * @return vertical center of finder pattern, or {@link Float#NaN} if not found
+     */
+    private crossCheckVertical;
+    /**
+     * <p>Like {@link #crossCheckVertical(int, int, int, int)}, and in fact is basically identical,
+     * except it reads horizontally instead of vertically. This is used to cross-cross
+     * check a vertical cross check and locate the real center of the alignment pattern.</p>
+     */
+    private crossCheckHorizontal;
+    /**
+     * <p>This is called when a horizontal scan finds a possible alignment pattern. It will
+     * cross check with a vertical scan, and if successful, will, ah, cross-cross-check
+     * with another horizontal scan. This is needed primarily to locate the real horizontal
+     * center of the pattern in cases of extreme skew.
+     * And then we cross-cross-cross check with another diagonal scan.</p>
+     *
+     * <p>If that succeeds the finder pattern location is added to a list that tracks
+     * the number of times each location has been nearly-matched as a finder pattern.
+     * Each additional find is more evidence that the location is in fact a finder
+     * pattern center
+     *
+     * @param stateCount reading state module counts from horizontal scan
+     * @param i row where finder pattern may be found
+     * @param j end of possible finder pattern in row
+     * @param pureBarcode true if in "pure barcode" mode
+     * @return true if a finder pattern candidate was found this time
+     */
+    protected handlePossibleCenter(stateCount: Int32Array, i: number, j: number, pureBarcode: boolean): boolean;
+    /**
+     * @return number of rows we could safely skip during scanning, based on the first
+     *         two finder patterns that have been located. In some cases their position will
+     *         allow us to infer that the third pattern must lie below a certain point farther
+     *         down in the image.
+     */
+    private findRowSkip;
+    /**
+     * @return true iff we have found at least 3 finder patterns that have been detected
+     *         at least {@link #CENTER_QUORUM} times each, and, the estimated module size of the
+     *         candidates is "pretty similar"
+     */
+    private haveMultiplyConfirmedCenters;
+    /**
+     * @return the 3 best {@link FinderPattern}s from our list of candidates. The "best" are
+     *         those that have been detected at least {@link #CENTER_QUORUM} times, and whose module
+     *         size differs from the average among those patterns the least
+     * @throws NotFoundException if 3 such finder patterns do not exist
+     */
+    private selectBestPatterns;
+}

package/lib/node/lib/zxing-js/src/core/qrcode/detector/FinderPatternInfo.d.ts

@@ -0,0 +1,16 @@
+import FinderPattern from './FinderPattern';
+/**
+ * <p>Encapsulates information about finder patterns in an image, including the location of
+ * the three finder patterns, and their estimated module size.</p>
+ *
+ * @author Sean Owen
+ */
+export default class FinderPatternInfo {
+    private bottomLeft;
+    private topLeft;
+    private topRight;
+    constructor(patternCenters: FinderPattern[]);
+    getBottomLeft(): FinderPattern;
+    getTopLeft(): FinderPattern;
+    getTopRight(): FinderPattern;
+}

package/lib/node/lib/zxing-js/src/core/util/Arrays.d.ts

@@ -0,0 +1,45 @@
+import { int } from '../../customTypings';
+export default class Arrays {
+    /**
+     * Assigns the specified int value to each element of the specified array
+     * of ints.
+     *
+     * @param a the array to be filled
+     * @param val the value to be stored in all elements of the array
+     */
+    static fill(a: Int32Array | Uint8Array | any[], val: int): void;
+    /**
+     * Assigns the specified int value to each element of the specified
+     * range of the specified array of ints.  The range to be filled
+     * extends from index {@code fromIndex}, inclusive, to index
+     * {@code toIndex}, exclusive.  (If {@code fromIndex==toIndex}, the
+     * range to be filled is empty.)
+     *
+     * @param a the array to be filled
+     * @param fromIndex the index of the first element (inclusive) to be
+     *        filled with the specified value
+     * @param toIndex the index of the last element (exclusive) to be
+     *        filled with the specified value
+     * @param val the value to be stored in all elements of the array
+     * @throws IllegalArgumentException if {@code fromIndex > toIndex}
+     * @throws ArrayIndexOutOfBoundsException if {@code fromIndex < 0} or
+     *         {@code toIndex > a.length}
+     */
+    static fillWithin(a: Int32Array, fromIndex: int, toIndex: int, val: int): void;
+    /**
+     * Checks that {@code fromIndex} and {@code toIndex} are in
+     * the range and throws an exception if they aren't.
+     */
+    static rangeCheck(arrayLength: int, fromIndex: int, toIndex: int): void;
+    static asList<T = any>(...args: T[]): T[];
+    static create<T = any>(rows: int, cols: int, value?: T): T[][];
+    static createInt32Array(rows: int, cols: int, value?: int): Int32Array[];
+    static equals(first: any, second: any): boolean;
+    static hashCode(a: any): number;
+    static fillUint8Array(a: Uint8Array, value: number): void;
+    static copyOf(original: Int32Array, newLength: number): Int32Array;
+    static copyOfUint8Array(original: Uint8Array, newLength: number): Uint8Array;
+    static copyOfRange(original: Int32Array, from: number, to: number): Int32Array;
+    static binarySearch(ar: Int32Array, el: number, comparator?: (a: number, b: number) => number): number;
+    static numberComparator(a: number, b: number): number;
+}

package/lib/node/lib/zxing-js/src/core/util/Charset.d.ts

@@ -0,0 +1,7 @@
+import CharacterSetECI from '../common/CharacterSetECI';
+/**
+ * Just to make a shortcut between Java code and TS code.
+ */
+export default class Charset extends CharacterSetECI {
+    static forName(name: string): Charset;
+}

package/lib/node/lib/zxing-js/src/core/util/Float.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Ponyfill for Java's Float class.
+ */
+export default class Float {
+    /**
+     * The float max value in JS is the number max value.
+     */
+    static MAX_VALUE: number;
+    /**
+     * SincTS has no difference between int and float, there's all numbers,
+     * this is used only to polyfill Java code.
+     */
+    static floatToIntBits(f: number): number;
+}

package/lib/node/lib/zxing-js/src/core/util/Integer.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Ponyfill for Java's Integer class.
+ */
+export default class Integer {
+    static MIN_VALUE_32_BITS: number;
+    static MAX_VALUE: number;
+    static numberOfTrailingZeros(i: number): number;
+    static numberOfLeadingZeros(i: number): number;
+    static toHexString(i: number): string;
+    static toBinaryString(intNumber: number): string;
+    static bitCount(i: number): number;
+    static truncDivision(dividend: number, divisor: number): number;
+    /**
+     * Converts A string to an integer.
+     * @param s A string to convert into a number.
+     * @param radix A value between 2 and 36 that specifies the base of the number in numString. If this argument is not supplied, strings with a prefix of '0x' are considered hexadecimal. All other strings are considered decimal.
+     */
+    static parseInt(num: string, radix?: number): number;
+}

package/lib/node/lib/zxing-js/src/core/util/StringBuilder.d.ts

@@ -0,0 +1,21 @@
+import { char, int } from '../../customTypings';
+import CharacterSetECI from '../common/CharacterSetECI';
+export default class StringBuilder {
+    private value;
+    private encoding?;
+    constructor(value?: string);
+    enableDecoding(encoding: CharacterSetECI): StringBuilder;
+    append(s: string | number): StringBuilder;
+    appendChars(str: char[] | string[], offset: int, len: int): StringBuilder;
+    length(): number;
+    charAt(n: number): string;
+    deleteCharAt(n: number): void;
+    setCharAt(n: number, c: string): void;
+    substring(start: int, end: int): string;
+    /**
+     * @note helper method for RSS Expanded
+     */
+    setLengthToZero(): void;
+    toString(): string;
+    insert(n: number, c: string): void;
+}

package/lib/node/lib/zxing-js/src/core/util/StringEncoding.d.ts

@@ -0,0 +1,51 @@
+import CharacterSetECI from '../common/CharacterSetECI';
+/**
+ * Responsible for en/decoding strings.
+ */
+export default class StringEncoding {
+    /**
+     * Allows the user to set a custom decoding function
+     * so more encoding formats the native ones can be supported.
+     */
+    static customDecoder: (bytes: Uint8Array, encodingName: string) => string;
+    /**
+     * Allows the user to set a custom encoding function
+     * so more encoding formats the native ones can be supported.
+     */
+    static customEncoder: (s: string, encodingName: string) => Uint8Array;
+    /**
+     * Decodes some Uint8Array to a string format.
+     */
+    static decode(bytes: Uint8Array, encoding: string | CharacterSetECI): string;
+    /**
+     * Checks if the decoding method should use the fallback for decoding
+     * once Node TextDecoder doesn't support all encoding formats.
+     *
+     * @param encodingName
+     */
+    private static shouldDecodeOnFallback;
+    /**
+     * Encodes some string into a Uint8Array.
+     */
+    static encode(s: string, encoding: string | CharacterSetECI): Uint8Array;
+    private static isBrowser;
+    /**
+     * Returns the string value from some encoding character set.
+     */
+    static encodingName(encoding: string | CharacterSetECI): string;
+    /**
+     * Returns character set from some encoding character set.
+     */
+    static encodingCharacterSet(encoding: string | CharacterSetECI): CharacterSetECI;
+    /**
+     * Runs a fallback for the native decoding funcion.
+     */
+    private static decodeFallback;
+    private static isDecodeFallbackSupported;
+    /**
+     * Runs a fallback for the native encoding funcion.
+     *
+     * @see https://stackoverflow.com/a/17192845/4367683
+     */
+    private static encodeFallback;
+}

package/lib/node/lib/zxing-js/src/core/util/System.d.ts

@@ -0,0 +1,10 @@
+export default class System {
+    /**
+     * Makes a copy of a array.
+     */
+    static arraycopy(src: any, srcPos: number, dest: any, destPos: number, length: number): void;
+    /**
+     * Returns the current time in milliseconds.
+     */
+    static currentTimeMillis(): number;
+}

package/lib/node/lib/zxing-js/src/customTypings.d.ts

@@ -0,0 +1,16 @@
+/**
+ * This file contains some types to make our
+ * lifes easier when copy and pasting Java code.
+ * With it we can keep int, float, etc., references
+ * in code to keep as close as possible as the Java version
+ * but without the need to sacrifice ourselves with boring
+ * and annoying things.
+ */
+export declare type byte = number;
+export declare type short = number;
+export declare type int = number;
+export declare type float = number;
+export type char = number;
+export type List<T> = T[];
+export type Collection<T> = T[];
+export type Deque<T> = T[];

package/lib/node/lib/zxing-js/src/index.d.ts

@@ -0,0 +1,5 @@
+export * from './browser';
+export { default as BinaryBitmap } from './core/BinaryBitmap';
+export { default as InvertedLuminanceSource } from './core/InvertedLuminanceSource';
+export { default as LuminanceSource } from './core/LuminanceSource';
+export { default as HybridBinarizer } from './core/common/HybridBinarizer';

package/lib/node/lib/zxing-js/src/node.d.ts

@@ -0,0 +1 @@
+export { NodeLuminanceSource } from './core/NodeLuminanceSource';