@qr-platform/qr-code.js 0.8.17

package/lib/lib/zxing-js/src/core/qrcode/encoder/MaskUtil.d.ts

@@ -0,0 +1,47 @@
+import ByteMatrix from './ByteMatrix';
+/**
+ * @author Satoru Takabayashi
+ * @author Daniel Switkin
+ * @author Sean Owen
+ */
+export default class MaskUtil {
+    private static N1;
+    private static N2;
+    private static N3;
+    private static N4;
+    private constructor();
+    /**
+     * Apply mask penalty rule 1 and return the penalty. Find repetitive cells with the same color and
+     * give penalty to them. Example: 00000 or 11111.
+     */
+    static applyMaskPenaltyRule1(matrix: ByteMatrix): number;
+    /**
+     * Apply mask penalty rule 2 and return the penalty. Find 2x2 blocks with the same color and give
+     * penalty to them. This is actually equivalent to the spec's rule, which is to find MxN blocks and give a
+     * penalty proportional to (M-1)x(N-1), because this is the number of 2x2 blocks inside such a block.
+     */
+    static applyMaskPenaltyRule2(matrix: ByteMatrix): number;
+    /**
+     * Apply mask penalty rule 3 and return the penalty. Find consecutive runs of 1:1:3:1:1:4
+     * starting with black, or 4:1:1:3:1:1 starting with white, and give penalty to them.  If we
+     * find patterns like 000010111010000, we give penalty once.
+     */
+    static applyMaskPenaltyRule3(matrix: ByteMatrix): number;
+    private static isWhiteHorizontal;
+    private static isWhiteVertical;
+    /**
+     * Apply mask penalty rule 4 and return the penalty. Calculate the ratio of dark cells and give
+     * penalty if the ratio is far from 50%. It gives 10 penalty for 5% distance.
+     */
+    static applyMaskPenaltyRule4(matrix: ByteMatrix): number;
+    /**
+     * Return the mask bit for "getMaskPattern" at "x" and "y". See 8.8 of JISX0510:2004 for mask
+     * pattern conditions.
+     */
+    static getDataMaskBit(maskPattern: number, x: number, y: number): boolean;
+    /**
+     * Helper function for applyMaskPenaltyRule1. We need this for doing this calculation in both
+     * vertical and horizontal orders respectively.
+     */
+    private static applyMaskPenaltyRule1Internal;
+}

package/lib/lib/zxing-js/src/core/qrcode/encoder/MatrixUtil.d.ts

@@ -0,0 +1,37 @@
+import BitArray from '../../common/BitArray';
+import ErrorCorrectionLevel from '../decoder/ErrorCorrectionLevel';
+import Version from '../decoder/Version';
+import ByteMatrix from './ByteMatrix';
+/**
+ * @author satorux@google.com (Satoru Takabayashi) - creator
+ * @author dswitkin@google.com (Daniel Switkin) - ported from C++
+ */
+export default class MatrixUtil {
+    private constructor();
+    private static POSITION_DETECTION_PATTERN;
+    private static POSITION_ADJUSTMENT_PATTERN;
+    private static POSITION_ADJUSTMENT_PATTERN_COORDINATE_TABLE;
+    private static TYPE_INFO_COORDINATES;
+    private static VERSION_INFO_POLY;
+    private static TYPE_INFO_POLY;
+    private static TYPE_INFO_MASK_PATTERN;
+    static clearMatrix(matrix: ByteMatrix): void;
+    static buildMatrix(dataBits: BitArray, ecLevel: ErrorCorrectionLevel, version: Version, maskPattern: number, matrix: ByteMatrix): void;
+    static embedBasicPatterns(version: Version, matrix: ByteMatrix): void;
+    static embedTypeInfo(ecLevel: ErrorCorrectionLevel, maskPattern: number, matrix: ByteMatrix): void;
+    static maybeEmbedVersionInfo(version: Version, matrix: ByteMatrix): void;
+    static embedDataBits(dataBits: BitArray, maskPattern: number, matrix: ByteMatrix): void;
+    static findMSBSet(value: number): number;
+    static calculateBCHCode(value: number, poly: number): number;
+    static makeTypeInfoBits(ecLevel: ErrorCorrectionLevel, maskPattern: number, bits: BitArray): void;
+    static makeVersionInfoBits(version: Version, bits: BitArray): void;
+    private static isEmpty;
+    private static embedTimingPatterns;
+    private static embedDarkDotAtLeftBottomCorner;
+    private static embedHorizontalSeparationPattern;
+    private static embedVerticalSeparationPattern;
+    private static embedPositionAdjustmentPattern;
+    private static embedPositionDetectionPattern;
+    private static embedPositionDetectionPatternsAndSeparators;
+    private static maybeEmbedPositionAdjustmentPatterns;
+}

package/lib/lib/zxing-js/src/core/qrcode/encoder/QRCode.d.ts

@@ -0,0 +1,29 @@
+import ErrorCorrectionLevel from '../decoder/ErrorCorrectionLevel';
+import Mode from '../decoder/Mode';
+import Version from '../decoder/Version';
+import ByteMatrix from './ByteMatrix';
+/**
+ * @author satorux@google.com (Satoru Takabayashi) - creator
+ * @author dswitkin@google.com (Daniel Switkin) - ported from C++
+ */
+export default class QRCode {
+    static NUM_MASK_PATTERNS: number;
+    private mode;
+    private ecLevel;
+    private version;
+    private maskPattern;
+    private matrix;
+    constructor();
+    getMode(): Mode;
+    getECLevel(): ErrorCorrectionLevel;
+    getVersion(): Version;
+    getMaskPattern(): number;
+    getMatrix(): ByteMatrix;
+    toString(): string;
+    setMode(value: Mode): void;
+    setECLevel(value: ErrorCorrectionLevel): void;
+    setVersion(version: Version): void;
+    setMaskPattern(value: number): void;
+    setMatrix(value: ByteMatrix): void;
+    static isValidMaskPattern(maskPattern: number): boolean;
+}

package/lib/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/lib/zxing-js/src/core/util/ByteArrayOutputStream.d.ts

@@ -0,0 +1,174 @@
+import { int } from '../../customTypings';
+import OutputStream from './OutputStream';
+/**
+ * This class implements an output stream in which the data is
+ * written into a byte array. The buffer automatically grows as data
+ * is written to it.
+ * The data can be retrieved using <code>toByteArray()</code> and
+ * <code>toString()</code>.
+ * <p>
+ * Closing a <tt>ByteArrayOutputStream</tt> has no effect. The methods in
+ * this class can be called after the stream has been closed without
+ * generating an <tt>IOException</tt>.
+ *
+ * @author  Arthur van Hoff
+ * @since   JDK1.0
+ */
+export default class ByteArrayOutputStream extends OutputStream {
+    /**
+     * The buffer where data is stored.
+     */
+    protected buf: Uint8Array;
+    /**
+     * The number of valid bytes in the buffer.
+     */
+    protected count: int;
+    /**
+     * Creates a new byte array output stream. The buffer capacity is
+     * initially 32 bytes, though its size increases if necessary.
+     */
+    /**
+     * Creates a new byte array output stream, with a buffer capacity of
+     * the specified size, in bytes.
+     *
+     * @param   size   the initial size.
+     * @exception  IllegalArgumentException if size is negative.
+     */
+    constructor(size?: int);
+    /**
+     * Increases the capacity if necessary to ensure that it can hold
+     * at least the number of elements specified by the minimum
+     * capacity argument.
+     *
+     * @param minCapacity the desired minimum capacity
+     * @throws OutOfMemoryError if {@code minCapacity < 0}.  This is
+     * interpreted as a request for the unsatisfiably large capacity
+     * {@code (long) Integer.MAX_VALUE + (minCapacity - Integer.MAX_VALUE)}.
+     */
+    private ensureCapacity;
+    /**
+     * Increases the capacity to ensure that it can hold at least the
+     * number of elements specified by the minimum capacity argument.
+     *
+     * @param minCapacity the desired minimum capacity
+     */
+    private grow;
+    /**
+     * Writes the specified byte to this byte array output stream.
+     *
+     * @param   b   the byte to be written.
+     */
+    write(b: int): void;
+    /**
+     * Writes <code>len</code> bytes from the specified byte array
+     * starting at offset <code>off</code> to this byte array output stream.
+     *
+     * @param   b     the data.
+     * @param   off   the start offset in the data.
+     * @param   len   the number of bytes to write.
+     */
+    writeBytesOffset(b: Uint8Array, off: int, len: int): void;
+    /**
+     * Writes the complete contents of this byte array output stream to
+     * the specified output stream argument, as if by calling the output
+     * stream's write method using <code>out.write(buf, 0, count)</code>.
+     *
+     * @param      out   the output stream to which to write the data.
+     * @exception  IOException  if an I/O error occurs.
+     */
+    writeTo(out: OutputStream): void;
+    /**
+     * Resets the <code>count</code> field of this byte array output
+     * stream to zero, so that all currently accumulated output in the
+     * output stream is discarded. The output stream can be used again,
+     * reusing the already allocated buffer space.
+     *
+     * @see     java.io.ByteArrayInputStream#count
+     */
+    reset(): void;
+    /**
+     * Creates a newly allocated byte array. Its size is the current
+     * size of this output stream and the valid contents of the buffer
+     * have been copied into it.
+     *
+     * @return  the current contents of this output stream, as a byte array.
+     * @see     java.io.ByteArrayOutputStream#size()
+     */
+    toByteArray(): Uint8Array;
+    /**
+     * Returns the current size of the buffer.
+     *
+     * @return  the value of the <code>count</code> field, which is the number
+     *          of valid bytes in this output stream.
+     * @see     java.io.ByteArrayOutputStream#count
+     */
+    size(): int;
+    toString(param?: number | string): string;
+    /**
+     * Converts the buffer's contents into a string decoding bytes using the
+     * platform's default character set. The length of the new <tt>String</tt>
+     * is a function of the character set, and hence may not be equal to the
+     * size of the buffer.
+     *
+     * <p> This method always replaces malformed-input and unmappable-character
+     * sequences with the default replacement string for the platform's
+     * default character set. The {@linkplain java.nio.charset.CharsetDecoder}
+     * class should be used when more control over the decoding process is
+     * required.
+     *
+     * @return String decoded from the buffer's contents.
+     * @since  JDK1.1
+     */
+    toString_void(): string;
+    /**
+     * Converts the buffer's contents into a string by decoding the bytes using
+     * the specified {@link java.nio.charset.Charset charsetName}. The length of
+     * the new <tt>String</tt> is a function of the charset, and hence may not be
+     * equal to the length of the byte array.
+     *
+     * <p> This method always replaces malformed-input and unmappable-character
+     * sequences with this charset's default replacement string. The {@link
+     * java.nio.charset.CharsetDecoder} class should be used when more control
+     * over the decoding process is required.
+     *
+     * @param  charsetName  the name of a supported
+     *              {@linkplain java.nio.charset.Charset </code>charset<code>}
+     * @return String decoded from the buffer's contents.
+     * @exception  UnsupportedEncodingException
+     *             If the named charset is not supported
+     * @since   JDK1.1
+     */
+    toString_string(charsetName: string): string;
+    /**
+     * Creates a newly allocated string. Its size is the current size of
+     * the output stream and the valid contents of the buffer have been
+     * copied into it. Each character <i>c</i> in the resulting string is
+     * constructed from the corresponding element <i>b</i> in the byte
+     * array such that:
+     * <blockquote><pre>
+     *     c == (char)(((hibyte &amp; 0xff) &lt;&lt; 8) | (b &amp; 0xff))
+     * </pre></blockquote>
+     *
+     * @deprecated This method does not properly convert bytes into characters.
+     * As of JDK&nbsp;1.1, the preferred way to do this is via the
+     * <code>toString(String enc)</code> method, which takes an encoding-name
+     * argument, or the <code>toString()</code> method, which uses the
+     * platform's default character encoding.
+     *
+     * @param      hibyte    the high byte of each resulting Unicode character.
+     * @return     the current contents of the output stream, as a string.
+     * @see        java.io.ByteArrayOutputStream#size()
+     * @see        java.io.ByteArrayOutputStream#toString(String)
+     * @see        java.io.ByteArrayOutputStream#toString()
+     */
+    toString_number(hibyte: int): string;
+    /**
+     * Closing a <tt>ByteArrayOutputStream</tt> has no effect. The methods in
+     * this class can be called after the stream has been closed without
+     * generating an <tt>IOException</tt>.
+     * <p>
+     *
+     * @throws IOException
+     */
+    close(): void;
+}

package/lib/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/lib/zxing-js/src/core/util/Collections.d.ts

@@ -0,0 +1,11 @@
+import { Collection, int } from '../../customTypings';
+export default class Collections {
+    /**
+     * The singletonList(T) method is used to return an immutable list containing only the specified object.
+     */
+    static singletonList<T = any>(item: T): Collection<T>;
+    /**
+     * The min(Collection<? extends T>, Comparator<? super T>) method is used to return the minimum element of the given collection, according to the order induced by the specified comparator.
+     */
+    static min<T = any>(collection: Collection<T>, comparator: (a: T, b: T) => int): T;
+}

package/lib/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/lib/zxing-js/src/core/util/Formatter.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Java Formatter class polyfill that works in the JS way.
+ */
+export default class Formatter {
+    /**
+     * The internal formatted value.
+     */
+    buffer: string;
+    constructor();
+    /**
+     *
+     * @see https://stackoverflow.com/a/13439711/4367683
+     *
+     * @param str
+     * @param arr
+     */
+    private static form;
+    /**
+     *
+     * @param append The new string to append.
+     * @param args Argumets values to be formated.
+     */
+    format(append: string, ...args: any): void;
+    /**
+     * Returns the Formatter string value.
+     */
+    toString(): string;
+}

package/lib/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/lib/zxing-js/src/core/util/Long.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Ponyfill for Java's Long class.
+ */
+export default class Long {
+    /**
+     * Parses a string to a number, since JS has no really Int64.
+     *
+     * @param num Numeric string.
+     * @param radix Destination radix.
+     */
+    static parseLong(num: string, radix?: number | undefined): number;
+}

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

@@ -0,0 +1,106 @@
+/**
+ * This abstract class is the superclass of all classes representing
+ * an output stream of bytes. An output stream accepts output bytes
+ * and sends them to some sink.
+ * <p>
+ * Applications that need to define a subclass of
+ * <code>OutputStream</code> must always provide at least a method
+ * that writes one byte of output.
+ *
+ * @author  Arthur van Hoff
+ * @see     java.io.BufferedOutputStream
+ * @see     java.io.ByteArrayOutputStream
+ * @see     java.io.DataOutputStream
+ * @see     java.io.FilterOutputStream
+ * @see     java.io.InputStream
+ * @see     java.io.OutputStream#write(int)
+ * @since   JDK1.0
+ */
+export default abstract class OutputStream {
+    /**
+     * Writes the specified byte to this output stream. The general
+     * contract for <code>write</code> is that one byte is written
+     * to the output stream. The byte to be written is the eight
+     * low-order bits of the argument <code>b</code>. The 24
+     * high-order bits of <code>b</code> are ignored.
+     * <p>
+     * Subclasses of <code>OutputStream</code> must provide an
+     * implementation for this method.
+     *
+     * @param      b   the <code>byte</code>.
+     * @exception  IOException  if an I/O error occurs. In particular,
+     *             an <code>IOException</code> may be thrown if the
+     *             output stream has been closed.
+     */
+    abstract write(b: number): void;
+    /**
+     * Writes <code>b.length</code> bytes from the specified byte array
+     * to this output stream. The general contract for <code>write(b)</code>
+     * is that it should have exactly the same effect as the call
+     * <code>write(b, 0, b.length)</code>.
+     *
+     * @param      b   the data.
+     * @exception  IOException  if an I/O error occurs.
+     * @see        java.io.OutputStream#write(byte[], int, int)
+     */
+    writeBytes(b: Uint8Array): void;
+    /**
+     * Writes <code>len</code> bytes from the specified byte array
+     * starting at offset <code>off</code> to this output stream.
+     * The general contract for <code>write(b, off, len)</code> is that
+     * some of the bytes in the array <code>b</code> are written to the
+     * output stream in order; element <code>b[off]</code> is the first
+     * byte written and <code>b[off+len-1]</code> is the last byte written
+     * by this operation.
+     * <p>
+     * The <code>write</code> method of <code>OutputStream</code> calls
+     * the write method of one argument on each of the bytes to be
+     * written out. Subclasses are encouraged to override this method and
+     * provide a more efficient implementation.
+     * <p>
+     * If <code>b</code> is <code>null</code>, a
+     * <code>NullPointerException</code> is thrown.
+     * <p>
+     * If <code>off</code> is negative, or <code>len</code> is negative, or
+     * <code>off+len</code> is greater than the length of the array
+     * <code>b</code>, then an <tt>IndexOutOfBoundsException</tt> is thrown.
+     *
+     * @param      b     the data.
+     * @param      off   the start offset in the data.
+     * @param      len   the number of bytes to write.
+     * @exception  IOException  if an I/O error occurs. In particular,
+     *             an <code>IOException</code> is thrown if the output
+     *             stream is closed.
+     */
+    writeBytesOffset(b: Uint8Array, off: number, len: number): void;
+    /**
+     * Flushes this output stream and forces any buffered output bytes
+     * to be written out. The general contract of <code>flush</code> is
+     * that calling it is an indication that, if any bytes previously
+     * written have been buffered by the implementation of the output
+     * stream, such bytes should immediately be written to their
+     * intended destination.
+     * <p>
+     * If the intended destination of this stream is an abstraction provided by
+     * the underlying operating system, for example a file, then flushing the
+     * stream guarantees only that bytes previously written to the stream are
+     * passed to the operating system for writing; it does not guarantee that
+     * they are actually written to a physical device such as a disk drive.
+     * <p>
+     * The <code>flush</code> method of <code>OutputStream</code> does nothing.
+     *
+     * @exception  IOException  if an I/O error occurs.
+     */
+    flush(): void;
+    /**
+     * Closes this output stream and releases any system resources
+     * associated with this stream. The general contract of <code>close</code>
+     * is that it closes the output stream. A closed stream cannot perform
+     * output operations and cannot be reopened.
+     * <p>
+     * The <code>close</code> method of <code>OutputStream</code> does nothing.
+     *
+     * @exception  IOException  if an I/O error occurs.
+     */
+    close(): void;
+}

package/lib/lib/zxing-js/src/core/util/StandardCharsets.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 StandardCharsets {
+    static ISO_8859_1: CharacterSetECI;
+}

package/lib/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/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/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/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/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/lib/zxing-js/src/node.d.ts

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