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

package/lib/node/lib/zxing-js/src/core/common/BitArray.d.ts

@@ -0,0 +1,111 @@
+/**
+ * <p>A simple, fast array of bits, represented compactly by an array of ints internally.</p>
+ *
+ * @author Sean Owen
+ */
+export default class BitArray {
+    private size;
+    private bits;
+    constructor(size?: number, bits?: Int32Array);
+    getSize(): number;
+    getSizeInBytes(): number;
+    private ensureCapacity;
+    /**
+     * @param i bit to get
+     * @return true iff bit i is set
+     */
+    get(i: number): boolean;
+    /**
+     * Sets bit i.
+     *
+     * @param i bit to set
+     */
+    set(i: number): void;
+    /**
+     * Flips bit i.
+     *
+     * @param i bit to set
+     */
+    flip(i: number): void;
+    /**
+     * @param from first bit to check
+     * @return index of first bit that is set, starting from the given index, or size if none are set
+     *  at or beyond this given index
+     * @see #getNextUnset(int)
+     */
+    getNextSet(from: number): number;
+    /**
+     * @param from index to start looking for unset bit
+     * @return index of next unset bit, or {@code size} if none are unset until the end
+     * @see #getNextSet(int)
+     */
+    getNextUnset(from: number): number;
+    /**
+     * Sets a block of 32 bits, starting at bit i.
+     *
+     * @param i first bit to set
+     * @param newBits the new value of the next 32 bits. Note again that the least-significant bit
+     * corresponds to bit i, the next-least-significant to i+1, and so on.
+     */
+    setBulk(i: number, newBits: number): void;
+    /**
+     * Sets a range of bits.
+     *
+     * @param start start of range, inclusive.
+     * @param end end of range, exclusive
+     */
+    setRange(start: number, end: number): void;
+    /**
+     * Clears all bits (sets to false).
+     */
+    clear(): void;
+    /**
+     * Efficient method to check if a range of bits is set, or not set.
+     *
+     * @param start start of range, inclusive.
+     * @param end end of range, exclusive
+     * @param value if true, checks that bits in range are set, otherwise checks that they are not set
+     * @return true iff all bits are set or not set in range, according to value argument
+     * @throws IllegalArgumentException if end is less than start or the range is not contained in the array
+     */
+    isRange(start: number, end: number, value: boolean): boolean;
+    appendBit(bit: boolean): void;
+    /**
+     * Appends the least-significant bits, from value, in order from most-significant to
+     * least-significant. For example, appending 6 bits from 0x000001E will append the bits
+     * 0, 1, 1, 1, 1, 0 in that order.
+     *
+     * @param value {@code int} containing bits to append
+     * @param numBits bits from value to append
+     */
+    appendBits(value: number, numBits: number): void;
+    appendBitArray(other: BitArray): void;
+    xor(other: BitArray): void;
+    /**
+     *
+     * @param bitOffset first bit to start writing
+     * @param array array to write into. Bytes are written most-significant byte first. This is the opposite
+     *  of the internal representation, which is exposed by {@link #getBitArray()}
+     * @param offset position in array to start writing
+     * @param numBytes how many bytes to write
+     */
+    toBytes(bitOffset: number, array: Uint8Array, offset: number, numBytes: number): void;
+    /**
+     * @return underlying array of ints. The first element holds the first 32 bits, and the least
+     *         significant bit is bit 0.
+     */
+    getBitArray(): Int32Array;
+    /**
+     * Reverses all bits in the array.
+     */
+    reverse(): void;
+    private static makeArray;
+    equals(o: any): boolean;
+    hashCode(): number;
+    toString(): string;
+    clone(): BitArray;
+    /**
+     * converts to boolean array.
+     */
+    toArray(): Array<boolean>;
+}

package/lib/node/lib/zxing-js/src/core/common/BitMatrix.d.ts

@@ -0,0 +1,98 @@
+import { int } from '../../customTypings';
+import BitArray from './BitArray';
+export default class BitMatrix {
+    private width;
+    private height?;
+    private rowSize?;
+    private bits?;
+    constructor(width: number, height?: number | undefined, rowSize?: number | undefined, bits?: Int32Array | undefined);
+    /**
+     * Interprets a 2D array of booleans as a BitMatrix, where "true" means an "on" bit.
+     */
+    static parseFromBooleanArray(image: boolean[][]): BitMatrix;
+    /**
+     * Parses a string representation of the bit matrix.
+     */
+    static parseFromString(stringRepresentation: string, setString: string, unsetString: string): BitMatrix;
+    /**
+     * Gets the bit at position (x, y).
+     */
+    get(x: number, y: number): boolean;
+    /**
+     * Sets the bit at position (x, y) to true.
+     */
+    set(x: number, y: number): void;
+    /**
+     * Unsets the bit at position (x, y) (sets it to false).
+     */
+    unset(x: number, y: number): void;
+    /**
+     * Flips the bit at position (x, y).
+     */
+    flip(x: number, y: number): void;
+    /**
+     * XORs this matrix with another matrix.
+     */
+    xor(mask: BitMatrix): void;
+    /**
+     * Clears all bits (sets to false).
+     */
+    clear(): void;
+    /**
+     * Sets a square region of the matrix to true.
+     */
+    setRegion(left: number, top: number, width: number, height: number): void;
+    /**
+     * Retrieves a row as a BitArray.
+     */
+    getRow(y: number, row?: BitArray): BitArray;
+    /**
+     * Sets a row from a BitArray.
+     */
+    setRow(y: number, row: BitArray): void;
+    /**
+     * Rotates the matrix 180 degrees.
+     */
+    rotate180(): void;
+    /**
+     * Returns the smallest rectangle that encloses all set bits.
+     */
+    getEnclosingRectangle(): Int32Array;
+    /**
+     * Returns the coordinate of the top-left set bit.
+     */
+    getTopLeftOnBit(): Int32Array;
+    /**
+     * Returns the coordinate of the bottom-right set bit.
+     */
+    getBottomRightOnBit(): Int32Array;
+    /**
+     * Returns the width of the matrix.
+     */
+    getWidth(): number;
+    /**
+     * Returns the height of the matrix.
+     */
+    getHeight(): number;
+    /**
+     * Returns the row size of the matrix.
+     */
+    getRowSize(): number;
+    /**
+     * Checks equality with another BitMatrix.
+     */
+    equals(o: Object): boolean;
+    /**
+     * Computes the hash code.
+     */
+    hashCode(): int;
+    /**
+     * Returns a string representation of the matrix.
+     */
+    toString(setString?: string, unsetString?: string, lineSeparator?: string): string;
+    private buildToString;
+    /**
+     * Returns a clone of this BitMatrix.
+     */
+    clone(): BitMatrix;
+}

package/lib/node/lib/zxing-js/src/core/common/BitSource.d.ts

@@ -0,0 +1,38 @@
+/**
+ * <p>This provides an easy abstraction to read bits at a time from a sequence of bytes, where the
+ * number of bits read is not often a multiple of 8.</p>
+ *
+ * <p>This class is thread-safe but not reentrant -- unless the caller modifies the bytes array
+ * it passed in, in which case all bets are off.</p>
+ *
+ * @author Sean Owen
+ */
+export default class BitSource {
+    private bytes;
+    private byteOffset;
+    private bitOffset;
+    /**
+     * @param bytes bytes from which this will read bits. Bits will be read from the first byte first.
+     * Bits are read within a byte from most-significant to least-significant bit.
+     */
+    constructor(bytes: Uint8Array);
+    /**
+     * @return index of next bit in current byte which would be read by the next call to {@link #readBits(int)}.
+     */
+    getBitOffset(): number;
+    /**
+     * @return index of next byte in input byte array which would be read by the next call to {@link #readBits(int)}.
+     */
+    getByteOffset(): number;
+    /**
+     * @param numBits number of bits to read
+     * @return int representing the bits read. The bits will appear as the least-significant
+     *         bits of the int
+     * @throws IllegalArgumentException if numBits isn't in [1,32] or more than is available
+     */
+    readBits(numBits: number): number;
+    /**
+     * @return number of bits that can be read successfully
+     */
+    available(): number;
+}

package/lib/node/lib/zxing-js/src/core/common/CharacterSetECI.d.ts

@@ -0,0 +1,89 @@
+export declare enum CharacterSetValueIdentifiers {
+    Cp437 = 0,
+    ISO8859_1 = 1,
+    ISO8859_2 = 2,
+    ISO8859_3 = 3,
+    ISO8859_4 = 4,
+    ISO8859_5 = 5,
+    ISO8859_6 = 6,
+    ISO8859_7 = 7,
+    ISO8859_8 = 8,
+    ISO8859_9 = 9,
+    ISO8859_10 = 10,
+    ISO8859_11 = 11,
+    ISO8859_13 = 12,
+    ISO8859_14 = 13,
+    ISO8859_15 = 14,
+    ISO8859_16 = 15,
+    SJIS = 16,
+    Cp1250 = 17,
+    Cp1251 = 18,
+    Cp1252 = 19,
+    Cp1256 = 20,
+    UnicodeBigUnmarked = 21,
+    UTF8 = 22,
+    ASCII = 23,
+    Big5 = 24,
+    GB18030 = 25,
+    EUC_KR = 26
+}
+/**
+ * Encapsulates a Character Set ECI, according to "Extended Channel Interpretations" 5.3.1.1
+ * of ISO 18004.
+ *
+ * @author Sean Owen
+ */
+export default class CharacterSetECI {
+    valueIdentifier: CharacterSetValueIdentifiers;
+    name: string;
+    private static VALUE_IDENTIFIER_TO_ECI;
+    private static VALUES_TO_ECI;
+    private static NAME_TO_ECI;
+    static readonly Cp437: CharacterSetECI;
+    static readonly ISO8859_1: CharacterSetECI;
+    static readonly ISO8859_2: CharacterSetECI;
+    static readonly ISO8859_3: CharacterSetECI;
+    static readonly ISO8859_4: CharacterSetECI;
+    static readonly ISO8859_5: CharacterSetECI;
+    static readonly ISO8859_6: CharacterSetECI;
+    static readonly ISO8859_7: CharacterSetECI;
+    static readonly ISO8859_8: CharacterSetECI;
+    static readonly ISO8859_9: CharacterSetECI;
+    static readonly ISO8859_10: CharacterSetECI;
+    static readonly ISO8859_11: CharacterSetECI;
+    static readonly ISO8859_13: CharacterSetECI;
+    static readonly ISO8859_14: CharacterSetECI;
+    static readonly ISO8859_15: CharacterSetECI;
+    static readonly ISO8859_16: CharacterSetECI;
+    static readonly SJIS: CharacterSetECI;
+    static readonly Cp1250: CharacterSetECI;
+    static readonly Cp1251: CharacterSetECI;
+    static readonly Cp1252: CharacterSetECI;
+    static readonly Cp1256: CharacterSetECI;
+    static readonly UnicodeBigUnmarked: CharacterSetECI;
+    static readonly UTF8: CharacterSetECI;
+    static readonly ASCII: CharacterSetECI;
+    static readonly Big5: CharacterSetECI;
+    static readonly GB18030: CharacterSetECI;
+    static readonly EUC_KR: CharacterSetECI;
+    values: Int32Array;
+    otherEncodingNames: string[];
+    constructor(valueIdentifier: CharacterSetValueIdentifiers, valuesParam: Int32Array | number, name: string, ...otherEncodingNames: string[]);
+    getValueIdentifier(): CharacterSetValueIdentifiers;
+    getName(): string;
+    getValue(): number;
+    /**
+     * @param value character set ECI value
+     * @return {@code CharacterSetECI} representing ECI of given value, or null if it is legal but
+     *   unsupported
+     * @throws FormatException if ECI value is invalid
+     */
+    static getCharacterSetECIByValue(value: number): CharacterSetECI;
+    /**
+     * @param name character set ECI encoding name
+     * @return CharacterSetECI representing ECI for character encoding, or null if it is legal
+     *   but unsupported
+     */
+    static getCharacterSetECIByName(name: string): CharacterSetECI;
+    equals(o: CharacterSetECI): boolean;
+}

package/lib/node/lib/zxing-js/src/core/common/DecoderResult.d.ts

@@ -0,0 +1,64 @@
+/**
+ * <p>Encapsulates the result of decoding a matrix of bits. This typically
+ * applies to 2D barcode formats. For now it contains the raw bytes obtained,
+ * as well as a String interpretation of those bytes, if applicable.</p>
+ *
+ * @author Sean Owen
+ */
+export default class DecoderResult {
+    private rawBytes;
+    private text;
+    private byteSegments;
+    private ecLevel;
+    private structuredAppendSequenceNumber;
+    private structuredAppendParity;
+    private numBits;
+    private errorsCorrected;
+    private erasures;
+    private other;
+    constructor(rawBytes: Uint8Array, text: string, byteSegments: Uint8Array[], ecLevel: string, structuredAppendSequenceNumber?: number, structuredAppendParity?: number);
+    /**
+     * @return raw bytes representing the result, or {@code null} if not applicable
+     */
+    getRawBytes(): Uint8Array;
+    /**
+     * @return how many bits of {@link #getRawBytes()} are valid; typically 8 times its length
+     * @since 3.3.0
+     */
+    getNumBits(): number;
+    /**
+     * @param numBits overrides the number of bits that are valid in {@link #getRawBytes()}
+     * @since 3.3.0
+     */
+    setNumBits(numBits: number): void;
+    /**
+     * @return text representation of the result
+     */
+    getText(): string;
+    /**
+     * @return list of byte segments in the result, or {@code null} if not applicable
+     */
+    getByteSegments(): Uint8Array[];
+    /**
+     * @return name of error correction level used, or {@code null} if not applicable
+     */
+    getECLevel(): string;
+    /**
+     * @return number of errors corrected, or {@code null} if not applicable
+     */
+    getErrorsCorrected(): number | undefined;
+    setErrorsCorrected(errorsCorrected: number): void;
+    /**
+     * @return number of erasures corrected, or {@code null} if not applicable
+     */
+    getErasures(): number | undefined;
+    setErasures(erasures: number): void;
+    /**
+     * @return arbitrary additional metadata
+     */
+    getOther(): any;
+    setOther(other: any): void;
+    hasStructuredAppend(): boolean;
+    getStructuredAppendParity(): number;
+    getStructuredAppendSequenceNumber(): number;
+}

package/lib/node/lib/zxing-js/src/core/common/DefaultGridSampler.d.ts

@@ -0,0 +1,10 @@
+import BitMatrix from './BitMatrix';
+import GridSampler from './GridSampler';
+import PerspectiveTransform from './PerspectiveTransform';
+/**
+ * @author Sean Owen
+ */
+export default class DefaultGridSampler extends GridSampler {
+    sampleGrid(image: BitMatrix, dimensionX: number, dimensionY: number, p1ToX: number, p1ToY: number, p2ToX: number, p2ToY: number, p3ToX: number, p3ToY: number, p4ToX: number, p4ToY: number, p1FromX: number, p1FromY: number, p2FromX: number, p2FromY: number, p3FromX: number, p3FromY: number, p4FromX: number, p4FromY: number): BitMatrix;
+    sampleGridWithTransform(image: BitMatrix, dimensionX: number, dimensionY: number, transform: PerspectiveTransform): BitMatrix;
+}

package/lib/node/lib/zxing-js/src/core/common/DetectorResult.d.ts

@@ -0,0 +1,16 @@
+import ResultPoint from '../ResultPoint';
+import BitMatrix from './BitMatrix';
+/**
+ * <p>Encapsulates the result of detecting a barcode in an image. This includes the raw
+ * matrix of black/white pixels corresponding to the barcode, and possibly points of interest
+ * in the image, like the location of finder patterns or corners of the barcode in the image.</p>
+ *
+ * @author Sean Owen
+ */
+export default class DetectorResult {
+    private bits;
+    private points;
+    constructor(bits: BitMatrix, points: Array<ResultPoint>);
+    getBits(): BitMatrix;
+    getPoints(): Array<ResultPoint>;
+}

package/lib/node/lib/zxing-js/src/core/common/GlobalHistogramBinarizer.d.ts

@@ -0,0 +1,29 @@
+import Binarizer from '../Binarizer';
+import LuminanceSource from '../LuminanceSource';
+import BitArray from './BitArray';
+import BitMatrix from './BitMatrix';
+/**
+ * This Binarizer implementation uses the old ZXing global histogram approach. It is suitable
+ * for low-end mobile devices which don't have enough CPU or memory to use a local thresholding
+ * algorithm. However, because it picks a global black point, it cannot handle difficult shadows
+ * and gradients.
+ *
+ * Faster mobile devices and all desktop applications should probably use HybridBinarizer instead.
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ * @author Sean Owen
+ */
+export default class GlobalHistogramBinarizer extends Binarizer {
+    private static LUMINANCE_BITS;
+    private static LUMINANCE_SHIFT;
+    private static LUMINANCE_BUCKETS;
+    private static EMPTY;
+    private luminances;
+    private buckets;
+    constructor(source: LuminanceSource);
+    getBlackRow(y: number, row: BitArray): BitArray;
+    getBlackMatrix(): BitMatrix;
+    createBinarizer(source: LuminanceSource): Binarizer;
+    private initArrays;
+    private static estimateBlackPoint;
+}

package/lib/node/lib/zxing-js/src/core/common/GridSampler.d.ts

@@ -0,0 +1,36 @@
+import BitMatrix from './BitMatrix';
+import PerspectiveTransform from './PerspectiveTransform';
+/**
+ * Implementations of this class can, given locations of finder patterns for a QR code in an
+ * image, sample the right points in the image to reconstruct the QR code, accounting for
+ * perspective distortion. It is abstracted since it is relatively expensive and should be allowed
+ * to take advantage of platform-specific optimized implementations, like Sun's Java Advanced
+ * Imaging library, but which may not be available in other environments such as J2ME, and vice
+ * versa.
+ *
+ * The implementation used can be controlled by calling {@link #setGridSampler(GridSampler)}
+ * with an instance of a class which implements this interface.
+ *
+ * @author Sean Owen
+ */
+declare abstract class GridSampler {
+    abstract sampleGrid(image: BitMatrix, dimensionX: number, dimensionY: number, p1ToX: number, p1ToY: number, p2ToX: number, p2ToY: number, p3ToX: number, p3ToY: number, p4ToX: number, p4ToY: number, p1FromX: number, p1FromY: number, p2FromX: number, p2FromY: number, p3FromX: number, p3FromY: number, p4FromX: number, p4FromY: number): BitMatrix;
+    abstract sampleGridWithTransform(image: BitMatrix, dimensionX: number, dimensionY: number, transform: PerspectiveTransform): BitMatrix;
+    /**
+     * Checks a set of points that have been transformed to sample points on an image against
+     * the image's dimensions to see if the points are even within the image.
+     *
+     * This method will actually "nudge" the endpoints back onto the image if they are found to be
+     * barely (less than 1 pixel) off the image. This accounts for imperfect detection of finder
+     * patterns in an image where the QR Code runs all the way to the image border.
+     *
+     * For efficiency, the method will check points from either end of the line until one is found
+     * to be within the image. Because the set of points are assumed to be linear, this is valid.
+     *
+     * @param image image into which the points should map
+     * @param points actual points in x1,y1,...,xn,yn form
+     * @throws NotFoundException if an endpoint lies outside the image boundaries
+     */
+    protected static checkAndNudgePoints(image: BitMatrix, points: Float32Array): void;
+}
+export default GridSampler;

package/lib/node/lib/zxing-js/src/core/common/GridSamplerInstance.d.ts

@@ -0,0 +1,18 @@
+import GridSampler from './GridSampler';
+export default class GridSamplerInstance {
+    private static gridSampler;
+    /**
+     * Sets the implementation of GridSampler used by the library. One global
+     * instance is stored, which may sound problematic. But, the implementation provided
+     * ought to be appropriate for the entire platform, and all uses of this library
+     * in the whole lifetime of the JVM. For instance, an Android activity can swap in
+     * an implementation that takes advantage of native platform libraries.
+     *
+     * @param newGridSampler The platform-specific object to install.
+     */
+    static setGridSampler(newGridSampler: GridSampler): void;
+    /**
+     * @return the current implementation of GridSampler
+     */
+    static getInstance(): GridSampler;
+}

package/lib/node/lib/zxing-js/src/core/common/HybridBinarizer.d.ts

@@ -0,0 +1,54 @@
+import Binarizer from '../Binarizer';
+import LuminanceSource from '../LuminanceSource';
+import BitMatrix from './BitMatrix';
+import GlobalHistogramBinarizer from './GlobalHistogramBinarizer';
+/**
+ * This class implements a local thresholding algorithm, which while slower than the
+ * GlobalHistogramBinarizer, is fairly efficient for what it does. It is designed for
+ * high frequency images of barcodes with black data on white backgrounds. For this application,
+ * it does a much better job than a global blackpoint with severe shadows and gradients.
+ * However it tends to produce artifacts on lower frequency images and is therefore not
+ * a good general purpose binarizer for uses outside ZXing.
+ *
+ * This class extends GlobalHistogramBinarizer, using the older histogram approach for 1D readers,
+ * and the newer local approach for 2D readers. 1D decoding using a per-row histogram is already
+ * inherently local, and only fails for horizontal gradients. We can revisit that problem later,
+ * but for now it was not a win to use local blocks for 1D.
+ *
+ * This Binarizer is the default for the unit tests and the recommended class for library users.
+ *
+ * @author dswitkin@google.com (Daniel Switkin)
+ */
+export default class HybridBinarizer extends GlobalHistogramBinarizer {
+    private static BLOCK_SIZE_POWER;
+    private static BLOCK_SIZE;
+    private static BLOCK_SIZE_MASK;
+    private static MINIMUM_DIMENSION;
+    private static MIN_DYNAMIC_RANGE;
+    private matrix;
+    constructor(source: LuminanceSource);
+    /**
+     * Calculates the final BitMatrix once for all requests. This could be called once from the
+     * constructor instead, but there are some advantages to doing it lazily, such as making
+     * profiling easier, and not doing heavy lifting when callers don't expect it.
+     */
+    getBlackMatrix(): BitMatrix;
+    createBinarizer(source: LuminanceSource): Binarizer;
+    /**
+     * For each block in the image, calculate the average black point using a 5x5 grid
+     * of the blocks around it. Also handles the corner cases (fractional blocks are computed based
+     * on the last pixels in the row/column which are also used in the previous block).
+     */
+    private static calculateThresholdForBlock;
+    private static cap;
+    /**
+     * Applies a single threshold to a block of pixels.
+     */
+    private static thresholdBlock;
+    /**
+     * Calculates a single black point for each block of pixels and saves it away.
+     * See the following thread for a discussion of this algorithm:
+     *  http://groups.google.com/group/zxing/browse_thread/thread/d06efa2c35a7ddc0
+     */
+    private static calculateBlackPoints;
+}

package/lib/node/lib/zxing-js/src/core/common/PerspectiveTransform.d.ts

@@ -0,0 +1,26 @@
+/**
+ * <p>This class implements a perspective transform in two dimensions. Given four source and four
+ * destination points, it will compute the transformation implied between them. The code is based
+ * directly upon section 3.4.2 of George Wolberg's "Digital Image Warping"; see pages 54-56.</p>
+ *
+ * @author Sean Owen
+ */
+export default class PerspectiveTransform {
+    private a11;
+    private a21;
+    private a31;
+    private a12;
+    private a22;
+    private a32;
+    private a13;
+    private a23;
+    private a33;
+    private constructor();
+    static quadrilateralToQuadrilateral(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number, x0p: number, y0p: number, x1p: number, y1p: number, x2p: number, y2p: number, x3p: number, y3p: number): PerspectiveTransform;
+    transformPoints(points: Float32Array): void;
+    transformPointsWithValues(xValues: Float32Array, yValues: Float32Array): void;
+    static squareToQuadrilateral(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): PerspectiveTransform;
+    static quadrilateralToSquare(x0: number, y0: number, x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): PerspectiveTransform;
+    protected buildAdjoint(): PerspectiveTransform;
+    protected times(other: PerspectiveTransform): PerspectiveTransform;
+}

package/lib/node/lib/zxing-js/src/core/common/StringUtils.d.ts

@@ -0,0 +1,48 @@
+import { int } from '../../customTypings';
+import DecodeHintType from '../DecodeHintType';
+import Charset from '../util/Charset';
+import CharacterSetECI from './CharacterSetECI';
+/**
+ * Common string-related functions.
+ *
+ * @author Sean Owen
+ * @author Alex Dupre
+ */
+export default class StringUtils {
+    static SHIFT_JIS: string;
+    static GB2312: string;
+    static ISO88591: string;
+    private static EUC_JP;
+    private static UTF8;
+    private static PLATFORM_DEFAULT_ENCODING;
+    private static ASSUME_SHIFT_JIS;
+    static castAsNonUtf8Char(code: number, encoding?: Charset): string;
+    /**
+     * @param bytes bytes encoding a string, whose encoding should be guessed
+     * @param hints decode hints if applicable
+     * @return name of guessed encoding; at the moment will only guess one of:
+     *  {@link #SHIFT_JIS}, {@link #UTF8}, {@link #ISO88591}, or the platform
+     *  default encoding if none of these can possibly be correct
+     */
+    static guessEncoding(bytes: Uint8Array, hints: Map<DecodeHintType, any>): string;
+    /**
+     *
+     * @see https://stackoverflow.com/a/13439711/4367683
+     *
+     * @param append The new string to append.
+     * @param args Argumets values to be formated.
+     */
+    static format(append: string, ...args: any[]): string;
+    /**
+     *
+     */
+    static getBytes(str: string, encoding: CharacterSetECI): Uint8Array;
+    /**
+     * Returns the charcode at the specified index or at index zero.
+     */
+    static getCharCode(str: string, index?: number): int;
+    /**
+     * Returns char for given charcode
+     */
+    static getCharAt(charCode: number): string;
+}