Function findRowSkip has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    private findRowSkip(): number /*int*/ {
        const max = this.possibleCenters.length;
        if (max <= 1) {
            return 0;
        }

• Read up
  Read up

Function isOnlyDoubleByteKanji has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    private static isOnlyDoubleByteKanji(content: string): boolean {
        let bytes: Uint8Array;
        try {
            bytes = StringEncoding.encode(content, CharacterSetECI.SJIS); // content.getBytes("Shift_JIS"))
        } catch (ignored/*: UnsupportedEncodingException*/) {

• Read up
  Read up

Function textCompaction has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

  private static textCompaction(codewords: Int32Array, codeIndex: int, result: StringBuilder): int {
    // 2 character per codeword
    let textCompactionData: Int32Array = new Int32Array((codewords[0] - codeIndex) * 2);
    // Used to hold the byte compaction value if there is a mode shift
    let byteCompactionData: Int32Array = new Int32Array((codewords[0] - codeIndex) * 2);

• Read up
  Read up

Function callback has 6 arguments (exceeds 4 allowed). Consider refactoring.

Open

    function callback(exp: string | number, p0: any, p1: any, p2: any, p3: any, p4: any) {

Avoid deeply nested control flow statements.

Open

                        if (bitsRead === 8) {
                            result[resultOffset++] = /*(byte) */currentByte;
                            bitsRead = 0;
                            currentByte = 0;
                        }

Avoid deeply nested control flow statements.

Open

                        if (currentState === 2) { // A winner?
                            if (this.foundPatternCross(stateCount)) { // Yes
                                const confirmed = this.handlePossibleCenter(stateCount, i, j);
                                if (confirmed !== null) {
                                    return confirmed;

Function handlePossibleCenter has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    private handlePossibleCenter(stateCount: Int32Array, i: number /*int*/, j: number /*int*/): AlignmentPattern {
        const stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2];
        const centerJ: number /*float*/ = AlignmentPatternFinder.centerFromEnd(stateCount, j);
        const centerI: number /*float*/ = this.crossCheckVertical(i, /*(int) */centerJ, 2 * stateCount[1], stateCountTotal);
        if (!isNaN(centerI)) {

• Read up
  Read up

Function equals has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

  public static equals(first: any, second: any): boolean {
    if (!first) {
      return false;
    }
    if (!second) {

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

            if (rowNumber >= 0) {
              if (rowNumber >= barcodeMatrix.length) {
                // We have more rows than the barcode metadata allows for, ignore them.
                continue;
              }

Avoid deeply nested control flow statements.

Open

                        while (((theBits << (31 - bit)) & 0xFFFFFFFF) === 0) {
                            bit++;
                        }

Avoid deeply nested control flow statements.

Open

                        if ((x32 * 32 + bit) < left) {
                            left = x32 * 32 + bit;
                        }

Avoid deeply nested control flow statements.

Open

                        if (min < averageNeighborBlackPoint) {
                            average = averageNeighborBlackPoint;
                        }

Avoid deeply nested control flow statements.

Open

        } else if (value > 0x7F) {
          sjisBytesLeft++;
          // sjisDoubleBytesChars++
          sjisCurKatakanaWordLength = 0;
          sjisCurDoubleBytesWordLength++;

Avoid deeply nested control flow statements.

Open

                        if (pixel < min) {
                            min = pixel;
                        }

Function runEuclideanAlgorithm has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

  private runEuclideanAlgorithm(a: ModulusPoly, b: ModulusPoly, R: int): ModulusPoly[] {
    // Assume a's degree is >= b's
    if (a.getDegree() < b.getDegree()) {
      let temp: ModulusPoly = a;
      a = b;

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

                        for (yy++ , offset += width; yy < HybridBinarizer.BLOCK_SIZE; yy++ , offset += width) {
                            for (let xx = 0; xx < HybridBinarizer.BLOCK_SIZE; xx++) {
                                sum += luminances[offset + xx] & 0xFF;
                            }
                        }

Avoid deeply nested control flow statements.

Open

                        while ((theBits >>> bit) === 0) {
                            bit--;
                        }

Avoid deeply nested control flow statements.

Open

                        if ((x32 * 32 + bit) > right) {
                            right = x32 * 32 + bit;
                        }

Function getBlackMatrix has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

    public getBlackMatrix(): BitMatrix /*throws NotFoundException*/ {
        if (this.matrix !== null) {
            return this.matrix;
        }
        const source = this.getLuminanceSource();

• Read up
  Read up

Function setRange has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.

Open

  public setRange(start: number /*int*/, end: number /*int*/): void {
    if (end < start || start < 0 || end > this.size) {
      throw new IllegalArgumentException();
    }
    if (end === start) {

• Read up
  Read up