@cloudbase/framework-plugin-low-code 0.4.44 → 0.4.45

package/template/node_modules/@zxing/library/cjs/core/pdf417/decoder/DecodedBitStreamParser.js

@@ -0,0 +1,779 @@
+"use strict";
+/*
+ * Copyright 2009 ZXing authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+// package com.google.zxing.pdf417.decoder;
+// import com.google.zxing.FormatException;
+var FormatException_1 = require("../../FormatException");
+// import com.google.zxing.common.CharacterSetECI;
+var CharacterSetECI_1 = require("../../common/CharacterSetECI");
+// import com.google.zxing.common.DecoderResult;
+var DecoderResult_1 = require("../../common/DecoderResult");
+// import com.google.zxing.pdf417.PDF417ResultMetadata;
+var PDF417ResultMetadata_1 = require("../PDF417ResultMetadata");
+// import java.io.ByteArrayOutputStream;
+// import java.math.BigInteger;
+// import java.nio.charset.Charset;
+// import java.nio.charset.StandardCharsets;
+// import java.util.Arrays;
+var Arrays_1 = require("../../util/Arrays");
+var StringBuilder_1 = require("../../util/StringBuilder");
+var Integer_1 = require("../../util/Integer");
+var Long_1 = require("../../util/Long");
+var ByteArrayOutputStream_1 = require("../../util/ByteArrayOutputStream");
+var StringEncoding_1 = require("../../util/StringEncoding");
+/*private*/ var Mode;
+(function (Mode) {
+    Mode[Mode["ALPHA"] = 0] = "ALPHA";
+    Mode[Mode["LOWER"] = 1] = "LOWER";
+    Mode[Mode["MIXED"] = 2] = "MIXED";
+    Mode[Mode["PUNCT"] = 3] = "PUNCT";
+    Mode[Mode["ALPHA_SHIFT"] = 4] = "ALPHA_SHIFT";
+    Mode[Mode["PUNCT_SHIFT"] = 5] = "PUNCT_SHIFT";
+})(Mode || (Mode = {}));
+/**
+ * Indirectly access the global BigInt constructor, it
+ * allows browsers that doesn't support BigInt to run
+ * the library without breaking due to "undefined BigInt"
+ * errors.
+ */
+function getBigIntConstructor() {
+    if (typeof window !== 'undefined') {
+        return window['BigInt'] || null;
+    }
+    if (typeof global !== 'undefined') {
+        return global['BigInt'] || null;
+    }
+    if (typeof self !== 'undefined') {
+        return self['BigInt'] || null;
+    }
+    throw new Error('Can\'t search globals for BigInt!');
+}
+/**
+ * Used to store the BigInt constructor.
+ */
+var BigInteger;
+/**
+ * This function creates a bigint value. It allows browsers
+ * that doesn't support BigInt to run the rest of the library
+ * by not directly accessing the BigInt constructor.
+ */
+function createBigInt(num) {
+    if (typeof BigInteger === 'undefined') {
+        BigInteger = getBigIntConstructor();
+    }
+    if (BigInteger === null) {
+        throw new Error('BigInt is not supported!');
+    }
+    return BigInteger(num);
+}
+function getEXP900() {
+    // in Java - array with length = 16
+    var EXP900 = [];
+    EXP900[0] = createBigInt(1);
+    var nineHundred = createBigInt(900);
+    EXP900[1] = nineHundred;
+    // in Java - array with length = 16
+    for (var i /*int*/ = 2; i < 16; i++) {
+        EXP900[i] = EXP900[i - 1] * nineHundred;
+    }
+    return EXP900;
+}
+/**
+ * <p>This class contains the methods for decoding the PDF417 codewords.</p>
+ *
+ * @author SITA Lab (kevin.osullivan@sita.aero)
+ * @author Guenther Grau
+ */
+var DecodedBitStreamParser = /** @class */ (function () {
+    function DecodedBitStreamParser() {
+    }
+    //   private DecodedBitStreamParser() {
+    // }
+    /**
+     *
+     * @param codewords
+     * @param ecLevel
+     *
+     * @throws FormatException
+     */
+    DecodedBitStreamParser.decode = function (codewords, ecLevel) {
+        // pass encoding to result (will be used for decode symbols in byte mode)
+        var result = new StringBuilder_1.default('');
+        // let encoding: Charset = StandardCharsets.ISO_8859_1;
+        var encoding = CharacterSetECI_1.default.ISO8859_1;
+        /**
+         * @note the next command is specific from this TypeScript library
+         * because TS can't properly cast some values to char and
+         * convert it to string later correctly due to encoding
+         * differences from Java version. As reported here:
+         * https://github.com/zxing-js/library/pull/264/files#r382831593
+         */
+        result.enableDecoding(encoding);
+        // Get compaction mode
+        var codeIndex = 1;
+        var code = codewords[codeIndex++];
+        var resultMetadata = new PDF417ResultMetadata_1.default();
+        while (codeIndex < codewords[0]) {
+            switch (code) {
+                case DecodedBitStreamParser.TEXT_COMPACTION_MODE_LATCH:
+                    codeIndex = DecodedBitStreamParser.textCompaction(codewords, codeIndex, result);
+                    break;
+                case DecodedBitStreamParser.BYTE_COMPACTION_MODE_LATCH:
+                case DecodedBitStreamParser.BYTE_COMPACTION_MODE_LATCH_6:
+                    codeIndex = DecodedBitStreamParser.byteCompaction(code, codewords, encoding, codeIndex, result);
+                    break;
+                case DecodedBitStreamParser.MODE_SHIFT_TO_BYTE_COMPACTION_MODE:
+                    result.append(/*(char)*/ codewords[codeIndex++]);
+                    break;
+                case DecodedBitStreamParser.NUMERIC_COMPACTION_MODE_LATCH:
+                    codeIndex = DecodedBitStreamParser.numericCompaction(codewords, codeIndex, result);
+                    break;
+                case DecodedBitStreamParser.ECI_CHARSET:
+                    var charsetECI = CharacterSetECI_1.default.getCharacterSetECIByValue(codewords[codeIndex++]);
+                    // encoding = Charset.forName(charsetECI.getName());
+                    break;
+                case DecodedBitStreamParser.ECI_GENERAL_PURPOSE:
+                    // Can't do anything with generic ECI; skip its 2 characters
+                    codeIndex += 2;
+                    break;
+                case DecodedBitStreamParser.ECI_USER_DEFINED:
+                    // Can't do anything with user ECI; skip its 1 character
+                    codeIndex++;
+                    break;
+                case DecodedBitStreamParser.BEGIN_MACRO_PDF417_CONTROL_BLOCK:
+                    codeIndex = DecodedBitStreamParser.decodeMacroBlock(codewords, codeIndex, resultMetadata);
+                    break;
+                case DecodedBitStreamParser.BEGIN_MACRO_PDF417_OPTIONAL_FIELD:
+                case DecodedBitStreamParser.MACRO_PDF417_TERMINATOR:
+                    // Should not see these outside a macro block
+                    throw new FormatException_1.default();
+                default:
+                    // Default to text compaction. During testing numerous barcodes
+                    // appeared to be missing the starting mode. In these cases defaulting
+                    // to text compaction seems to work.
+                    codeIndex--;
+                    codeIndex = DecodedBitStreamParser.textCompaction(codewords, codeIndex, result);
+                    break;
+            }
+            if (codeIndex < codewords.length) {
+                code = codewords[codeIndex++];
+            }
+            else {
+                throw FormatException_1.default.getFormatInstance();
+            }
+        }
+        if (result.length() === 0) {
+            throw FormatException_1.default.getFormatInstance();
+        }
+        var decoderResult = new DecoderResult_1.default(null, result.toString(), null, ecLevel);
+        decoderResult.setOther(resultMetadata);
+        return decoderResult;
+    };
+    /**
+     *
+     * @param int
+     * @param param1
+     * @param codewords
+     * @param int
+     * @param codeIndex
+     * @param PDF417ResultMetadata
+     * @param resultMetadata
+     *
+     * @throws FormatException
+     */
+    // @SuppressWarnings("deprecation")
+    DecodedBitStreamParser.decodeMacroBlock = function (codewords, codeIndex, resultMetadata) {
+        if (codeIndex + DecodedBitStreamParser.NUMBER_OF_SEQUENCE_CODEWORDS > codewords[0]) {
+            // we must have at least two bytes left for the segment index
+            throw FormatException_1.default.getFormatInstance();
+        }
+        var segmentIndexArray = new Int32Array(DecodedBitStreamParser.NUMBER_OF_SEQUENCE_CODEWORDS);
+        for (var i /*int*/ = 0; i < DecodedBitStreamParser.NUMBER_OF_SEQUENCE_CODEWORDS; i++, codeIndex++) {
+            segmentIndexArray[i] = codewords[codeIndex];
+        }
+        resultMetadata.setSegmentIndex(Integer_1.default.parseInt(DecodedBitStreamParser.decodeBase900toBase10(segmentIndexArray, DecodedBitStreamParser.NUMBER_OF_SEQUENCE_CODEWORDS)));
+        var fileId = new StringBuilder_1.default();
+        codeIndex = DecodedBitStreamParser.textCompaction(codewords, codeIndex, fileId);
+        resultMetadata.setFileId(fileId.toString());
+        var optionalFieldsStart = -1;
+        if (codewords[codeIndex] === DecodedBitStreamParser.BEGIN_MACRO_PDF417_OPTIONAL_FIELD) {
+            optionalFieldsStart = codeIndex + 1;
+        }
+        while (codeIndex < codewords[0]) {
+            switch (codewords[codeIndex]) {
+                case DecodedBitStreamParser.BEGIN_MACRO_PDF417_OPTIONAL_FIELD:
+                    codeIndex++;
+                    switch (codewords[codeIndex]) {
+                        case DecodedBitStreamParser.MACRO_PDF417_OPTIONAL_FIELD_FILE_NAME:
+                            var fileName = new StringBuilder_1.default();
+                            codeIndex = DecodedBitStreamParser.textCompaction(codewords, codeIndex + 1, fileName);
+                            resultMetadata.setFileName(fileName.toString());
+                            break;
+                        case DecodedBitStreamParser.MACRO_PDF417_OPTIONAL_FIELD_SENDER:
+                            var sender = new StringBuilder_1.default();
+                            codeIndex = DecodedBitStreamParser.textCompaction(codewords, codeIndex + 1, sender);
+                            resultMetadata.setSender(sender.toString());
+                            break;
+                        case DecodedBitStreamParser.MACRO_PDF417_OPTIONAL_FIELD_ADDRESSEE:
+                            var addressee = new StringBuilder_1.default();
+                            codeIndex = DecodedBitStreamParser.textCompaction(codewords, codeIndex + 1, addressee);
+                            resultMetadata.setAddressee(addressee.toString());
+                            break;
+                        case DecodedBitStreamParser.MACRO_PDF417_OPTIONAL_FIELD_SEGMENT_COUNT:
+                            var segmentCount = new StringBuilder_1.default();
+                            codeIndex = DecodedBitStreamParser.numericCompaction(codewords, codeIndex + 1, segmentCount);
+                            resultMetadata.setSegmentCount(Integer_1.default.parseInt(segmentCount.toString()));
+                            break;
+                        case DecodedBitStreamParser.MACRO_PDF417_OPTIONAL_FIELD_TIME_STAMP:
+                            var timestamp = new StringBuilder_1.default();
+                            codeIndex = DecodedBitStreamParser.numericCompaction(codewords, codeIndex + 1, timestamp);
+                            resultMetadata.setTimestamp(Long_1.default.parseLong(timestamp.toString()));
+                            break;
+                        case DecodedBitStreamParser.MACRO_PDF417_OPTIONAL_FIELD_CHECKSUM:
+                            var checksum = new StringBuilder_1.default();
+                            codeIndex = DecodedBitStreamParser.numericCompaction(codewords, codeIndex + 1, checksum);
+                            resultMetadata.setChecksum(Integer_1.default.parseInt(checksum.toString()));
+                            break;
+                        case DecodedBitStreamParser.MACRO_PDF417_OPTIONAL_FIELD_FILE_SIZE:
+                            var fileSize = new StringBuilder_1.default();
+                            codeIndex = DecodedBitStreamParser.numericCompaction(codewords, codeIndex + 1, fileSize);
+                            resultMetadata.setFileSize(Long_1.default.parseLong(fileSize.toString()));
+                            break;
+                        default:
+                            throw FormatException_1.default.getFormatInstance();
+                    }
+                    break;
+                case DecodedBitStreamParser.MACRO_PDF417_TERMINATOR:
+                    codeIndex++;
+                    resultMetadata.setLastSegment(true);
+                    break;
+                default:
+                    throw FormatException_1.default.getFormatInstance();
+            }
+        }
+        // copy optional fields to additional options
+        if (optionalFieldsStart !== -1) {
+            var optionalFieldsLength = codeIndex - optionalFieldsStart;
+            if (resultMetadata.isLastSegment()) {
+                // do not include terminator
+                optionalFieldsLength--;
+            }
+            resultMetadata.setOptionalData(Arrays_1.default.copyOfRange(codewords, optionalFieldsStart, optionalFieldsStart + optionalFieldsLength));
+        }
+        return codeIndex;
+    };
+    /**
+     * Text Compaction mode (see 5.4.1.5) permits all printable ASCII characters to be
+     * encoded, i.e. values 32 - 126 inclusive in accordance with ISO/IEC 646 (IRV), as
+     * well as selected control characters.
+     *
+     * @param codewords The array of codewords (data + error)
+     * @param codeIndex The current index into the codeword array.
+     * @param result    The decoded data is appended to the result.
+     * @return The next index into the codeword array.
+     */
+    DecodedBitStreamParser.textCompaction = function (codewords, codeIndex, result) {
+        // 2 character per codeword
+        var textCompactionData = new Int32Array((codewords[0] - codeIndex) * 2);
+        // Used to hold the byte compaction value if there is a mode shift
+        var byteCompactionData = new Int32Array((codewords[0] - codeIndex) * 2);
+        var index = 0;
+        var end = false;
+        while ((codeIndex < codewords[0]) && !end) {
+            var code = codewords[codeIndex++];
+            if (code < DecodedBitStreamParser.TEXT_COMPACTION_MODE_LATCH) {
+                textCompactionData[index] = code / 30;
+                textCompactionData[index + 1] = code % 30;
+                index += 2;
+            }
+            else {
+                switch (code) {
+                    case DecodedBitStreamParser.TEXT_COMPACTION_MODE_LATCH:
+                        // reinitialize text compaction mode to alpha sub mode
+                        textCompactionData[index++] = DecodedBitStreamParser.TEXT_COMPACTION_MODE_LATCH;
+                        break;
+                    case DecodedBitStreamParser.BYTE_COMPACTION_MODE_LATCH:
+                    case DecodedBitStreamParser.BYTE_COMPACTION_MODE_LATCH_6:
+                    case DecodedBitStreamParser.NUMERIC_COMPACTION_MODE_LATCH:
+                    case DecodedBitStreamParser.BEGIN_MACRO_PDF417_CONTROL_BLOCK:
+                    case DecodedBitStreamParser.BEGIN_MACRO_PDF417_OPTIONAL_FIELD:
+                    case DecodedBitStreamParser.MACRO_PDF417_TERMINATOR:
+                        codeIndex--;
+                        end = true;
+                        break;
+                    case DecodedBitStreamParser.MODE_SHIFT_TO_BYTE_COMPACTION_MODE:
+                        // The Mode Shift codeword 913 shall cause a temporary
+                        // switch from Text Compaction mode to Byte Compaction mode.
+                        // This switch shall be in effect for only the next codeword,
+                        // after which the mode shall revert to the prevailing sub-mode
+                        // of the Text Compaction mode. Codeword 913 is only available
+                        // in Text Compaction mode; its use is described in 5.4.2.4.
+                        textCompactionData[index] = DecodedBitStreamParser.MODE_SHIFT_TO_BYTE_COMPACTION_MODE;
+                        code = codewords[codeIndex++];
+                        byteCompactionData[index] = code;
+                        index++;
+                        break;
+                }
+            }
+        }
+        DecodedBitStreamParser.decodeTextCompaction(textCompactionData, byteCompactionData, index, result);
+        return codeIndex;
+    };
+    /**
+     * The Text Compaction mode includes all the printable ASCII characters
+     * (i.e. values from 32 to 126) and three ASCII control characters: HT or tab
+     * (9: e), LF or line feed (10: e), and CR or carriage
+     * return (13: e). The Text Compaction mode also includes various latch
+     * and shift characters which are used exclusively within the mode. The Text
+     * Compaction mode encodes up to 2 characters per codeword. The compaction rules
+     * for converting data into PDF417 codewords are defined in 5.4.2.2. The sub-mode
+     * switches are defined in 5.4.2.3.
+     *
+     * @param textCompactionData The text compaction data.
+     * @param byteCompactionData The byte compaction data if there
+     *                           was a mode shift.
+     * @param length             The size of the text compaction and byte compaction data.
+     * @param result             The decoded data is appended to the result.
+     */
+    DecodedBitStreamParser.decodeTextCompaction = function (textCompactionData, byteCompactionData, length, result) {
+        // Beginning from an initial state of the Alpha sub-mode
+        // The default compaction mode for PDF417 in effect at the start of each symbol shall always be Text
+        // Compaction mode Alpha sub-mode (alphabetic: uppercase). A latch codeword from another mode to the Text
+        // Compaction mode shall always switch to the Text Compaction Alpha sub-mode.
+        var subMode = Mode.ALPHA;
+        var priorToShiftMode = Mode.ALPHA;
+        var i = 0;
+        while (i < length) {
+            var subModeCh = textCompactionData[i];
+            var ch = /*char*/ '';
+            switch (subMode) {
+                case Mode.ALPHA:
+                    // Alpha (alphabetic: uppercase)
+                    if (subModeCh < 26) {
+                        // Upper case Alpha Character
+                        // Note: 65 = 'A' ASCII -> there is byte code of symbol
+                        ch = /*(char)('A' + subModeCh) */ String.fromCharCode(65 + subModeCh);
+                    }
+                    else {
+                        switch (subModeCh) {
+                            case 26:
+                                ch = ' ';
+                                break;
+                            case DecodedBitStreamParser.LL:
+                                subMode = Mode.LOWER;
+                                break;
+                            case DecodedBitStreamParser.ML:
+                                subMode = Mode.MIXED;
+                                break;
+                            case DecodedBitStreamParser.PS:
+                                // Shift to punctuation
+                                priorToShiftMode = subMode;
+                                subMode = Mode.PUNCT_SHIFT;
+                                break;
+                            case DecodedBitStreamParser.MODE_SHIFT_TO_BYTE_COMPACTION_MODE:
+                                result.append(/*(char)*/ byteCompactionData[i]);
+                                break;
+                            case DecodedBitStreamParser.TEXT_COMPACTION_MODE_LATCH:
+                                subMode = Mode.ALPHA;
+                                break;
+                        }
+                    }
+                    break;
+                case Mode.LOWER:
+                    // Lower (alphabetic: lowercase)
+                    if (subModeCh < 26) {
+                        ch = /*(char)('a' + subModeCh)*/ String.fromCharCode(97 + subModeCh);
+                    }
+                    else {
+                        switch (subModeCh) {
+                            case 26:
+                                ch = ' ';
+                                break;
+                            case DecodedBitStreamParser.AS:
+                                // Shift to alpha
+                                priorToShiftMode = subMode;
+                                subMode = Mode.ALPHA_SHIFT;
+                                break;
+                            case DecodedBitStreamParser.ML:
+                                subMode = Mode.MIXED;
+                                break;
+                            case DecodedBitStreamParser.PS:
+                                // Shift to punctuation
+                                priorToShiftMode = subMode;
+                                subMode = Mode.PUNCT_SHIFT;
+                                break;
+                            case DecodedBitStreamParser.MODE_SHIFT_TO_BYTE_COMPACTION_MODE:
+                                // TODO Does this need to use the current character encoding? See other occurrences below
+                                result.append(/*(char)*/ byteCompactionData[i]);
+                                break;
+                            case DecodedBitStreamParser.TEXT_COMPACTION_MODE_LATCH:
+                                subMode = Mode.ALPHA;
+                                break;
+                        }
+                    }
+                    break;
+                case Mode.MIXED:
+                    // Mixed (punctuation: e)
+                    if (subModeCh < DecodedBitStreamParser.PL) {
+                        ch = DecodedBitStreamParser.MIXED_CHARS[subModeCh];
+                    }
+                    else {
+                        switch (subModeCh) {
+                            case DecodedBitStreamParser.PL:
+                                subMode = Mode.PUNCT;
+                                break;
+                            case 26:
+                                ch = ' ';
+                                break;
+                            case DecodedBitStreamParser.LL:
+                                subMode = Mode.LOWER;
+                                break;
+                            case DecodedBitStreamParser.AL:
+                                subMode = Mode.ALPHA;
+                                break;
+                            case DecodedBitStreamParser.PS:
+                                // Shift to punctuation
+                                priorToShiftMode = subMode;
+                                subMode = Mode.PUNCT_SHIFT;
+                                break;
+                            case DecodedBitStreamParser.MODE_SHIFT_TO_BYTE_COMPACTION_MODE:
+                                result.append(/*(char)*/ byteCompactionData[i]);
+                                break;
+                            case DecodedBitStreamParser.TEXT_COMPACTION_MODE_LATCH:
+                                subMode = Mode.ALPHA;
+                                break;
+                        }
+                    }
+                    break;
+                case Mode.PUNCT:
+                    // Punctuation
+                    if (subModeCh < DecodedBitStreamParser.PAL) {
+                        ch = DecodedBitStreamParser.PUNCT_CHARS[subModeCh];
+                    }
+                    else {
+                        switch (subModeCh) {
+                            case DecodedBitStreamParser.PAL:
+                                subMode = Mode.ALPHA;
+                                break;
+                            case DecodedBitStreamParser.MODE_SHIFT_TO_BYTE_COMPACTION_MODE:
+                                result.append(/*(char)*/ byteCompactionData[i]);
+                                break;
+                            case DecodedBitStreamParser.TEXT_COMPACTION_MODE_LATCH:
+                                subMode = Mode.ALPHA;
+                                break;
+                        }
+                    }
+                    break;
+                case Mode.ALPHA_SHIFT:
+                    // Restore sub-mode
+                    subMode = priorToShiftMode;
+                    if (subModeCh < 26) {
+                        ch = /*(char)('A' + subModeCh)*/ String.fromCharCode(65 + subModeCh);
+                    }
+                    else {
+                        switch (subModeCh) {
+                            case 26:
+                                ch = ' ';
+                                break;
+                            case DecodedBitStreamParser.TEXT_COMPACTION_MODE_LATCH:
+                                subMode = Mode.ALPHA;
+                                break;
+                        }
+                    }
+                    break;
+                case Mode.PUNCT_SHIFT:
+                    // Restore sub-mode
+                    subMode = priorToShiftMode;
+                    if (subModeCh < DecodedBitStreamParser.PAL) {
+                        ch = DecodedBitStreamParser.PUNCT_CHARS[subModeCh];
+                    }
+                    else {
+                        switch (subModeCh) {
+                            case DecodedBitStreamParser.PAL:
+                                subMode = Mode.ALPHA;
+                                break;
+                            case DecodedBitStreamParser.MODE_SHIFT_TO_BYTE_COMPACTION_MODE:
+                                // PS before Shift-to-Byte is used as a padding character,
+                                // see 5.4.2.4 of the specification
+                                result.append(/*(char)*/ byteCompactionData[i]);
+                                break;
+                            case DecodedBitStreamParser.TEXT_COMPACTION_MODE_LATCH:
+                                subMode = Mode.ALPHA;
+                                break;
+                        }
+                    }
+                    break;
+            }
+            // if (ch !== 0) {
+            if (ch !== '') {
+                // Append decoded character to result
+                result.append(ch);
+            }
+            i++;
+        }
+    };
+    /**
+     * Byte Compaction mode (see 5.4.3) permits all 256 possible 8-bit byte values to be encoded.
+     * This includes all ASCII characters value 0 to 127 inclusive and provides for international
+     * character set support.
+     *
+     * @param mode      The byte compaction mode i.e. 901 or 924
+     * @param codewords The array of codewords (data + error)
+     * @param encoding  Currently active character encoding
+     * @param codeIndex The current index into the codeword array.
+     * @param result    The decoded data is appended to the result.
+     * @return The next index into the codeword array.
+     */
+    DecodedBitStreamParser.byteCompaction = function (mode, codewords, encoding, codeIndex, result) {
+        var decodedBytes = new ByteArrayOutputStream_1.default();
+        var count = 0;
+        var value = /*long*/ 0;
+        var end = false;
+        switch (mode) {
+            case DecodedBitStreamParser.BYTE_COMPACTION_MODE_LATCH:
+                // Total number of Byte Compaction characters to be encoded
+                // is not a multiple of 6
+                var byteCompactedCodewords = new Int32Array(6);
+                var nextCode = codewords[codeIndex++];
+                while ((codeIndex < codewords[0]) && !end) {
+                    byteCompactedCodewords[count++] = nextCode;
+                    // Base 900
+                    value = 900 * value + nextCode;
+                    nextCode = codewords[codeIndex++];
+                    // perhaps it should be ok to check only nextCode >= TEXT_COMPACTION_MODE_LATCH
+                    switch (nextCode) {
+                        case DecodedBitStreamParser.TEXT_COMPACTION_MODE_LATCH:
+                        case DecodedBitStreamParser.BYTE_COMPACTION_MODE_LATCH:
+                        case DecodedBitStreamParser.NUMERIC_COMPACTION_MODE_LATCH:
+                        case DecodedBitStreamParser.BYTE_COMPACTION_MODE_LATCH_6:
+                        case DecodedBitStreamParser.BEGIN_MACRO_PDF417_CONTROL_BLOCK:
+                        case DecodedBitStreamParser.BEGIN_MACRO_PDF417_OPTIONAL_FIELD:
+                        case DecodedBitStreamParser.MACRO_PDF417_TERMINATOR:
+                            codeIndex--;
+                            end = true;
+                            break;
+                        default:
+                            if ((count % 5 === 0) && (count > 0)) {
+                                // Decode every 5 codewords
+                                // Convert to Base 256
+                                for (var j /*int*/ = 0; j < 6; ++j) {
+                                    /* @note
+                                     * JavaScript stores numbers as 64 bits floating point numbers, but all bitwise operations are performed on 32 bits binary numbers.
+                                     * So the next bitwise operation could not be done with simple numbers
+                                     */
+                                    decodedBytes.write(/*(byte)*/ Number(createBigInt(value) >> createBigInt(8 * (5 - j))));
+                                }
+                                value = 0;
+                                count = 0;
+                            }
+                            break;
+                    }
+                }
+                // if the end of all codewords is reached the last codeword needs to be added
+                if (codeIndex === codewords[0] && nextCode < DecodedBitStreamParser.TEXT_COMPACTION_MODE_LATCH) {
+                    byteCompactedCodewords[count++] = nextCode;
+                }
+                // If Byte Compaction mode is invoked with codeword 901,
+                // the last group of codewords is interpreted directly
+                // as one byte per codeword, without compaction.
+                for (var i /*int*/ = 0; i < count; i++) {
+                    decodedBytes.write(/*(byte)*/ byteCompactedCodewords[i]);
+                }
+                break;
+            case DecodedBitStreamParser.BYTE_COMPACTION_MODE_LATCH_6:
+                // Total number of Byte Compaction characters to be encoded
+                // is an integer multiple of 6
+                while (codeIndex < codewords[0] && !end) {
+                    var code = codewords[codeIndex++];
+                    if (code < DecodedBitStreamParser.TEXT_COMPACTION_MODE_LATCH) {
+                        count++;
+                        // Base 900
+                        value = 900 * value + code;
+                    }
+                    else {
+                        switch (code) {
+                            case DecodedBitStreamParser.TEXT_COMPACTION_MODE_LATCH:
+                            case DecodedBitStreamParser.BYTE_COMPACTION_MODE_LATCH:
+                            case DecodedBitStreamParser.NUMERIC_COMPACTION_MODE_LATCH:
+                            case DecodedBitStreamParser.BYTE_COMPACTION_MODE_LATCH_6:
+                            case DecodedBitStreamParser.BEGIN_MACRO_PDF417_CONTROL_BLOCK:
+                            case DecodedBitStreamParser.BEGIN_MACRO_PDF417_OPTIONAL_FIELD:
+                            case DecodedBitStreamParser.MACRO_PDF417_TERMINATOR:
+                                codeIndex--;
+                                end = true;
+                                break;
+                        }
+                    }
+                    if ((count % 5 === 0) && (count > 0)) {
+                        // Decode every 5 codewords
+                        // Convert to Base 256
+                        /* @note
+                         * JavaScript stores numbers as 64 bits floating point numbers, but all bitwise operations are performed on 32 bits binary numbers.
+                         * So the next bitwise operation could not be done with simple numbers
+                        */
+                        for (var j /*int*/ = 0; j < 6; ++j) {
+                            decodedBytes.write(/*(byte)*/ Number(createBigInt(value) >> createBigInt(8 * (5 - j))));
+                        }
+                        value = 0;
+                        count = 0;
+                    }
+                }
+                break;
+        }
+        result.append(StringEncoding_1.default.decode(decodedBytes.toByteArray(), encoding));
+        return codeIndex;
+    };
+    /**
+     * Numeric Compaction mode (see 5.4.4) permits efficient encoding of numeric data strings.
+     *
+     * @param codewords The array of codewords (data + error)
+     * @param codeIndex The current index into the codeword array.
+     * @param result    The decoded data is appended to the result.
+     * @return The next index into the codeword array.
+     *
+     * @throws FormatException
+     */
+    DecodedBitStreamParser.numericCompaction = function (codewords, codeIndex /*int*/, result) {
+        var count = 0;
+        var end = false;
+        var numericCodewords = new Int32Array(DecodedBitStreamParser.MAX_NUMERIC_CODEWORDS);
+        while (codeIndex < codewords[0] && !end) {
+            var code = codewords[codeIndex++];
+            if (codeIndex === codewords[0]) {
+                end = true;
+            }
+            if (code < DecodedBitStreamParser.TEXT_COMPACTION_MODE_LATCH) {
+                numericCodewords[count] = code;
+                count++;
+            }
+            else {
+                switch (code) {
+                    case DecodedBitStreamParser.TEXT_COMPACTION_MODE_LATCH:
+                    case DecodedBitStreamParser.BYTE_COMPACTION_MODE_LATCH:
+                    case DecodedBitStreamParser.BYTE_COMPACTION_MODE_LATCH_6:
+                    case DecodedBitStreamParser.BEGIN_MACRO_PDF417_CONTROL_BLOCK:
+                    case DecodedBitStreamParser.BEGIN_MACRO_PDF417_OPTIONAL_FIELD:
+                    case DecodedBitStreamParser.MACRO_PDF417_TERMINATOR:
+                        codeIndex--;
+                        end = true;
+                        break;
+                }
+            }
+            if ((count % DecodedBitStreamParser.MAX_NUMERIC_CODEWORDS === 0 || code === DecodedBitStreamParser.NUMERIC_COMPACTION_MODE_LATCH || end) && count > 0) {
+                // Re-invoking Numeric Compaction mode (by using codeword 902
+                // while in Numeric Compaction mode) serves  to terminate the
+                // current Numeric Compaction mode grouping as described in 5.4.4.2,
+                // and then to start a new one grouping.
+                result.append(DecodedBitStreamParser.decodeBase900toBase10(numericCodewords, count));
+                count = 0;
+            }
+        }
+        return codeIndex;
+    };
+    /**
+     * Convert a list of Numeric Compacted codewords from Base 900 to Base 10.
+     *
+     * @param codewords The array of codewords
+     * @param count     The number of codewords
+     * @return The decoded string representing the Numeric data.
+     *
+     * EXAMPLE
+     * Encode the fifteen digit numeric string 000213298174000
+     * Prefix the numeric string with a 1 and set the initial value of
+     * t = 1 000 213 298 174 000
+     * Calculate codeword 0
+     * d0 = 1 000 213 298 174 000 mod 900 = 200
+     *
+     * t = 1 000 213 298 174 000 div 900 = 1 111 348 109 082
+     * Calculate codeword 1
+     * d1 = 1 111 348 109 082 mod 900 = 282
+     *
+     * t = 1 111 348 109 082 div 900 = 1 234 831 232
+     * Calculate codeword 2
+     * d2 = 1 234 831 232 mod 900 = 632
+     *
+     * t = 1 234 831 232 div 900 = 1 372 034
+     * Calculate codeword 3
+     * d3 = 1 372 034 mod 900 = 434
+     *
+     * t = 1 372 034 div 900 = 1 524
+     * Calculate codeword 4
+     * d4 = 1 524 mod 900 = 624
+     *
+     * t = 1 524 div 900 = 1
+     * Calculate codeword 5
+     * d5 = 1 mod 900 = 1
+     * t = 1 div 900 = 0
+     * Codeword sequence is: 1, 624, 434, 632, 282, 200
+     *
+     * Decode the above codewords involves
+     *   1 x 900 power of 5 + 624 x 900 power of 4 + 434 x 900 power of 3 +
+     * 632 x 900 power of 2 + 282 x 900 power of 1 + 200 x 900 power of 0 = 1000213298174000
+     *
+     * Remove leading 1 =>  Result is 000213298174000
+     *
+     * @throws FormatException
+     */
+    DecodedBitStreamParser.decodeBase900toBase10 = function (codewords, count) {
+        var result = createBigInt(0);
+        for (var i /*int*/ = 0; i < count; i++) {
+            result += DecodedBitStreamParser.EXP900[count - i - 1] * createBigInt(codewords[i]);
+        }
+        var resultString = result.toString();
+        if (resultString.charAt(0) !== '1') {
+            throw new FormatException_1.default();
+        }
+        return resultString.substring(1);
+    };
+    DecodedBitStreamParser.TEXT_COMPACTION_MODE_LATCH = 900;
+    DecodedBitStreamParser.BYTE_COMPACTION_MODE_LATCH = 901;
+    DecodedBitStreamParser.NUMERIC_COMPACTION_MODE_LATCH = 902;
+    DecodedBitStreamParser.BYTE_COMPACTION_MODE_LATCH_6 = 924;
+    DecodedBitStreamParser.ECI_USER_DEFINED = 925;
+    DecodedBitStreamParser.ECI_GENERAL_PURPOSE = 926;
+    DecodedBitStreamParser.ECI_CHARSET = 927;
+    DecodedBitStreamParser.BEGIN_MACRO_PDF417_CONTROL_BLOCK = 928;
+    DecodedBitStreamParser.BEGIN_MACRO_PDF417_OPTIONAL_FIELD = 923;
+    DecodedBitStreamParser.MACRO_PDF417_TERMINATOR = 922;
+    DecodedBitStreamParser.MODE_SHIFT_TO_BYTE_COMPACTION_MODE = 913;
+    DecodedBitStreamParser.MAX_NUMERIC_CODEWORDS = 15;
+    DecodedBitStreamParser.MACRO_PDF417_OPTIONAL_FIELD_FILE_NAME = 0;
+    DecodedBitStreamParser.MACRO_PDF417_OPTIONAL_FIELD_SEGMENT_COUNT = 1;
+    DecodedBitStreamParser.MACRO_PDF417_OPTIONAL_FIELD_TIME_STAMP = 2;
+    DecodedBitStreamParser.MACRO_PDF417_OPTIONAL_FIELD_SENDER = 3;
+    DecodedBitStreamParser.MACRO_PDF417_OPTIONAL_FIELD_ADDRESSEE = 4;
+    DecodedBitStreamParser.MACRO_PDF417_OPTIONAL_FIELD_FILE_SIZE = 5;
+    DecodedBitStreamParser.MACRO_PDF417_OPTIONAL_FIELD_CHECKSUM = 6;
+    DecodedBitStreamParser.PL = 25;
+    DecodedBitStreamParser.LL = 27;
+    DecodedBitStreamParser.AS = 27;
+    DecodedBitStreamParser.ML = 28;
+    DecodedBitStreamParser.AL = 28;
+    DecodedBitStreamParser.PS = 29;
+    DecodedBitStreamParser.PAL = 29;
+    DecodedBitStreamParser.PUNCT_CHARS = ';<>@[\\]_`~!\r\t,:\n-.$/"|*()?{}\'';
+    DecodedBitStreamParser.MIXED_CHARS = '0123456789&\r\t,:#-.$/+%*=^';
+    /**
+     * Table containing values for the exponent of 900.
+     * This is used in the numeric compaction decode algorithm.
+     */
+    DecodedBitStreamParser.EXP900 = getBigIntConstructor() ? getEXP900() : [];
+    DecodedBitStreamParser.NUMBER_OF_SEQUENCE_CODEWORDS = 2;
+    return DecodedBitStreamParser;
+}());
+exports.default = DecodedBitStreamParser;
+//# sourceMappingURL=DecodedBitStreamParser.js.map