// Module ID: 12427
// Function ID: 12428
// Name: QRCode
// Dependencies: [12428, 12430, 12432, 12433, 12434]

// Module 12427 (QRCode)
import QR8bitByte from "QR8bitByte" /* 12428 */;
import QRRSBlock from "QRRSBlock" /* 12430 */;
import QRBitBuffer from "QRBitBuffer" /* 12432 */;
import _mod12433 from "module_12433" /* 12433 */;
import QRPolynomial from "QRPolynomial" /* 12434 */;

class QRCode {
  constructor(arg0, arg1) {
    return;
  }
}
const prototype = QRCode.prototype;
prototype.addData = function(arg0) {
  const dataList = this.dataList;
  dataList.push(new QR8bitByte(arg0));
  this.dataCache = null;
};
prototype.isDark = function(arg0, arg1) {
  if (arg0 >= 0) {
    const self = this;
    if (this.moduleCount > arg0) {
      if (arg1 >= 0) {
        if (self.moduleCount > arg1) {
          return self.modules[arg0][arg1];
        }
      }
    }
  }
  error = new Error(arg0 + "," + arg1);
  throw error;
};
prototype.getModuleCount = function() {
  return this.moduleCount;
};
prototype.make = function() {
  let tmp13;
  const self = this;
  let num = 1;
  if (this.typeNumber < 1) {
    while (true) {
      let tmp = require;
      let tmp2 = dependencyMap;
      let obj = QRRSBlock;
      let rSBlocks = obj.getRSBlocks(num, self.errorCorrectLevel);
      let tmp3 = new.target;
      let tmp4 = new.target;
      let obj2 = new QRBitBuffer();
      let tmp5 = num;
      let num2 = 0;
      let num3 = 0;
      let num4 = 0;
      if (0 < rSBlocks.length) {
        do {
          num3 = num3 + rSBlocks[num2].dataCount;
          num2 = num2 + 1;
          num4 = num3;
          length = rSBlocks.length;
        } while (num2 < length);
      }
      let tmp6 = obj2;
      let num5 = 0;
      if (0 < self.dataList.length) {
        do {
          let obj3 = self.dataList[num5];
          let putResult = obj2.put(obj3.mode, 4);
          let tmp9 = require;
          let tmp10 = dependencyMap;
          length = obj3.getLength();
          let obj4 = _mod12433;
          let putResult1 = obj2.put(length, obj4.getLengthInBits(obj3.mode, num));
          let writeResult = obj3.write(obj2);
          num5 = num5 + 1;
          length2 = self.dataList.length;
        } while (num5 < length2);
      }
      tmp13 = num;
      if (obj2.getLengthInBits() <= 8 * num4) {
        break;
      } else {
        num = num + 1;
        tmp13 = num;
        if (num >= 40) {
          break;
        }
      }
    }
    self.typeNumber = tmp13;
  }
  const impl = self.makeImpl(false, self.getBestMaskPattern());
};
prototype.makeImpl = function(arg0, arg1) {
  const self = this;
  this.moduleCount = 4 * this.typeNumber + 17;
  let array = new Array(this.moduleCount);
  this.modules = array;
  let num = 0;
  if (0 < this.moduleCount) {
    do {
      let _Array = Array;
      let tmp2 = new.target;
      let tmp3 = new.target;
      array = new Array(self.moduleCount);
      let tmp5 = array;
      self.modules[num] = array;
      let tmp6 = num;
      let num2 = 0;
      if (0 < self.moduleCount) {
        do {
          self.modules[num][num2] = null;
          num2 = num2 + 1;
          moduleCount = self.moduleCount;
        } while (num2 < moduleCount);
      }
      num = num + 1;
    } while (num < self.moduleCount);
  }
  const result = self.setupPositionProbePattern(0, 0);
  const result1 = self.setupPositionProbePattern(self.moduleCount - 7, 0);
  const result2 = self.setupPositionProbePattern(0, self.moduleCount - 7);
  const result3 = self.setupPositionAdjustPattern();
  self.setupTimingPattern();
  self.setupTypeInfo(arg0, arg1);
  if (self.typeNumber >= 7) {
    self.setupTypeNumber(arg0);
  }
  if (null == self.dataCache) {
    self.dataCache = QRCode.createData(self.typeNumber, self.errorCorrectLevel, self.dataList);
  }
  self.mapData(self.dataCache, arg1);
};
prototype.setupPositionProbePattern = function(arg0, arg1) {
  const self = this;
  let num = -1;
  do {
    let tmp = num;
    if (arg0 + num > -1) {
      let num2 = -1;
      if (self.moduleCount > arg0 + num) {
        do {
          let tmp2 = arg1 + num2 <= -1;
          let tmp3 = num2;
          if (!tmp2) {
            tmp2 = self.moduleCount <= arg1 + num2;
          }
          if (!tmp2) {
            let tmp5 = tmp15;
            let sum = arg1 + num2;
            if (0 <= num) {
              tmp5 = tmp14;
            }
            if (tmp5) {
              let tmp6 = 0 === num2;
              if (0 !== num2) {
                tmp6 = 6 === num2;
              }
              tmp5 = tmp6;
            }
            if (!tmp5) {
              let tmp7 = 0 <= num2;
              if (0 <= num2) {
                tmp7 = num2 <= 6;
              }
              if (tmp7) {
                let tmp8 = tmp13;
                if (0 !== num) {
                  tmp8 = tmp12;
                }
                tmp7 = tmp8;
              }
              tmp5 = tmp7;
            }
            if (!tmp5) {
              let tmp9 = tmp11;
              if (2 <= num) {
                tmp9 = tmp10;
              }
              if (tmp9) {
                tmp9 = 2 <= num2;
              }
              if (tmp9) {
                tmp9 = num2 <= 4;
              }
              tmp5 = tmp9;
            }
            self.modules[arg0 + num][sum] = tmp5;
          }
          num2 = num2 + 1;
        } while (num2 <= 7);
      }
    }
    num = num + 1;
  } while (num <= 7);
};
prototype.getBestMaskPattern = function() {
  let tmp7;
  const self = this;
  let num = 0;
  let num2 = 0;
  let num3 = 0;
  do {
    let impl = self.makeImpl(true, num);
    let tmp2 = require;
    let tmp3 = dependencyMap;
    let obj = _mod12433;
    let lostPoint = obj.getLostPoint(self);
    let tmp5 = 0 === num;
    let tmp6 = num;
    tmp7 = num2;
    let tmp8 = num3;
    if (0 !== num) {
      tmp5 = tmp8 > lostPoint;
    }
    if (tmp5) {
      tmp7 = num;
      tmp8 = lostPoint;
    }
    num = num + 1;
    num3 = tmp8;
    num2 = tmp7;
  } while (num < 8);
  return tmp7;
};
prototype.createMovieClip = function(createEmptyMovieClip) {
  const self = this;
  const emptyMovieClip = createEmptyMovieClip.createEmptyMovieClip(arg1, arg2);
  this.make();
  let num = 0;
  if (0 < this.modules.length) {
    do {
      let tmp2 = num;
      let sum = tmp2 + 1;
      let tmp4 = num;
      for (let num2 = 0; num2 < self.modules[num].length; num2 = num2 + 1) {
        let tmp5 = num2;
        if (self.modules[num][num2]) {
          let tmp6 = num2;
          let beginFillResult = emptyMovieClip.beginFill(0, 100);
          let moveToResult = emptyMovieClip.moveTo(tmp6, tmp2);
          let sum1 = tmp6 + 1;
          let lineToResult = emptyMovieClip.lineTo(sum1, tmp2);
          let lineToResult1 = emptyMovieClip.lineTo(sum1, sum);
          let lineToResult2 = emptyMovieClip.lineTo(tmp6, sum);
          let endFillResult = emptyMovieClip.endFill();
        }
      }
      num = num + 1;
    } while (num < self.modules.length);
  }
  return emptyMovieClip;
};
prototype.setupTimingPattern = function() {
  const self = this;
  let num = 8;
  if (8 < this.moduleCount - 8) {
    do {
      let tmp = num;
      if (null == self.modules[num][6]) {
        self.modules[num][6] = num % 2 === 0;
      }
      num = num + 1;
    } while (num < self.moduleCount - 8);
  }
  let num2 = 8;
  if (8 < self.moduleCount - 8) {
    do {
      let tmp2 = num2;
      if (null == self.modules[6][num2]) {
        self.modules[6][num2] = num2 % 2 === 0;
      }
      num2 = num2 + 1;
    } while (num2 < self.moduleCount - 8);
  }
};
prototype.setupPositionAdjustPattern = function() {
  const self = this;
  const patternPosition = _mod12433.getPatternPosition(this.typeNumber);
  for (let num = 0; num < patternPosition.length; num = num + 1) {
    let tmp = num;
    for (let num2 = 0; num2 < patternPosition.length; num2 = num2 + 1) {
      let tmp2 = patternPosition[num];
      let tmp3 = patternPosition[num2];
      let tmp4 = num2;
      let num3 = -2;
      if (null == self.modules[tmp2][tmp3]) {
        let tmp8 = num3;
        let num4 = -2;
        do {
          do {
            let tmp10 = num4;
            let tmp11 = tmp7;
            let sum = tmp3 + num4;
            if (-2 !== num3) {
              tmp11 = tmp6;
            }
            if (!tmp11) {
              tmp11 = -2 === num4;
            }
            if (!tmp11) {
              tmp11 = 2 === num4;
            }
            if (!tmp11) {
              let tmp12 = tmp5;
              if (0 === num3) {
                tmp12 = 0 === num4;
              }
              tmp11 = tmp12;
            }
            self.modules[tmp2 + num3][sum] = tmp11;
            num4 = num4 + 1;
          } while (num4 <= 2);
          num3 = num3 + 1;
        } while (num3 <= 2);
      }
    }
  }
};
prototype.setupTypeNumber = function(arg0) {
  let num2;
  const self = this;
  const bCHTypeNumber = _mod12433.getBCHTypeNumber(this.typeNumber);
  let num = 0;
  do {
    let tmp2 = !arg0;
    let tmp3 = num;
    if (!arg0) {
      tmp2 = 1 === (bCHTypeNumber >> num & 1);
    }
    let _Math = Math;
    self.modules[Math.floor(Math, num / 3)][num % 3 + self.moduleCount - 8 - 3] = tmp2;
    num = num + 1;
    num2 = 0;
  } while (num < 18);
  do {
    let tmp4 = !arg0;
    let tmp5 = num2;
    if (!arg0) {
      tmp4 = 1 === (bCHTypeNumber >> num2 & 1);
    }
    let _Math2 = Math;
    self.modules[num2 % 3 + self.moduleCount - 8 - 3][Math.floor(num2 / 3)] = tmp4;
    num2 = num2 + 1;
  } while (num2 < 18);
};
prototype.setupTypeInfo = function(arg0, arg1) {
  let num2;
  const self = this;
  const bCHTypeInfo = _mod12433.getBCHTypeInfo(this.errorCorrectLevel << 3 | arg1);
  let num = 0;
  do {
    let tmp3 = !arg0;
    let tmp4 = num;
    if (!arg0) {
      tmp3 = 1 === (bCHTypeInfo >> num & 1);
    }
    if (num < 6) {
      self.modules[num][8] = tmp3;
    } else if (num < 8) {
      self.modules[num + 1][8] = tmp3;
    } else {
      self.modules[self.moduleCount - 15 + num][8] = tmp3;
    }
    num = num + 1;
    num2 = 0;
  } while (num < 15);
  do {
    let tmp5 = !arg0;
    let tmp6 = num2;
    if (!arg0) {
      tmp5 = 1 === (bCHTypeInfo >> num2 & 1);
    }
    if (num2 < 8) {
      self.modules[8][self.moduleCount - num2 - 1] = tmp5;
    } else if (num2 < 9) {
      self.modules[8][15 - num2 - 1 + 1] = tmp5;
    } else {
      self.modules[8][15 - num2 - 1] = tmp5;
    }
    num2 = num2 + 1;
  } while (num2 < 15);
  self.modules[self.moduleCount - 8][8] = !arg0;
};
prototype.mapData = function(arg0, arg1) {
  const self = this;
  const diff = this.moduleCount - 1;
  const diff1 = this.moduleCount - 1;
  if (0 < diff1) {
    while (true) {
      let tmp3 = diff1;
      let tmp4 = num;
      let tmp5 = num2;
      let tmp6 = diff;
      let tmp7 = num3;
      let tmp8 = num;
      let tmp9 = num2;
      let tmp10 = diff;
      let diff2 = diff1;
      if (6 === diff1) {
        diff2 = diff1 - 1;
        tmp8 = num;
        tmp9 = num2;
        tmp10 = diff;
      }
      let tmp12 = diff2;
      let tmp13 = tmp8;
      let tmp14 = tmp9;
      let tmp15 = tmp10;
      let num4 = 0;
      while (true) {
        do {
          let diff3 = diff2 - num4;
          let tmp17 = num4;
          let tmp18 = tmp13;
          let tmp19 = tmp14;
          let sum = tmp13;
          let num5 = tmp14;
          if (null == self.modules[tmp10][diff3]) {
            let flag = false;
            if (tmp13 < arg0.length) {
              flag = 1 === (arg0[tmp13] >>> tmp14 & 1);
            }
            let tmp21 = require;
            let tmp22 = dependencyMap;
            let obj = _mod12433;
            let tmp23 = flag;
            if (obj.getMask(arg1, tmp10, diff3)) {
              tmp23 = !flag;
            }
            self.modules[tmp10][diff3] = tmp23;
            num5 = tmp14 - 1;
            sum = tmp13;
            if (-1 === num5) {
              sum = tmp13 + 1;
              num5 = 7;
            }
          }
          num4 = num4 + 1;
          tmp13 = sum;
          tmp14 = num5;
        } while (num4 < 2);
        let sum1 = tmp10 + num3;
        if (sum1 < 0) {
          break;
        } else {
          tmp8 = sum;
          tmp9 = num5;
          tmp10 = sum1;
          if (self.moduleCount <= sum1) {
            break;
          }
        }
      }
    }
  }
};
QRCode.PAD0 = 236;
QRCode.PAD1 = 17;
QRCode.createData = (arg0, arg1, arg2) => {
  let length;
  let length2;
  let result1;
  const rSBlocks = QRRSBlock.getRSBlocks(arg0, arg1);
  const obj2 = new QRBitBuffer();
  let num = 0;
  if (0 < arg2.length) {
    do {
      let obj3 = arg2[num];
      let putResult = obj2.put(obj3.mode, 4);
      let tmp3 = require;
      let tmp4 = dependencyMap;
      length = obj3.getLength();
      let obj4 = _mod12433;
      let putResult1 = obj2.put(length, obj4.getLengthInBits(obj3.mode, arg0));
      let writeResult = obj3.write(obj2);
      num = num + 1;
      length = arg2.length;
    } while (num < length);
  }
  let num2 = 0;
  let num3 = 0;
  let num4 = 0;
  if (0 < rSBlocks.length) {
    do {
      num2 = num2 + rSBlocks[num3].dataCount;
      num3 = num3 + 1;
      num4 = num2;
      length2 = rSBlocks.length;
    } while (num3 < length2);
  }
  const result = 8 * num4;
  if (obj2.getLengthInBits() > result) {
    const _Error = Error;
    error = new Error("code length overflow. (" + obj2.getLengthInBits() + ">" + result + ")");
    throw error;
  } else {
    if (obj2.getLengthInBits() + 4 <= result) {
      obj2.put(0, 4);
    }
    if (obj2.getLengthInBits() % 8 !== 0) {
      do {
        let putBitResult = obj2.putBit(false);
        result1 = obj2.getLengthInBits() % 8;
      } while (result1 !== 0);
    }
    if (obj2.getLengthInBits() < result) {
      obj2.put(QRCode.PAD0, 8);
      if (obj2.getLengthInBits() < result) {
        obj2.put(QRCode.PAD1, 8);
        while (obj2.getLengthInBits() < result) {
          let putResult5 = obj2.put(tmp13.PAD0, 8);
          if (obj2.getLengthInBits() >= result) {
            break;
          }
        }
        tmp13 = QRCode;
      }
    }
    return QRCode.createBytes(obj2, rSBlocks);
  }
  const obj = QRRSBlock;
};
QRCode.createBytes = (arg0, arg1) => {
  let length2;
  let array = new Array(arg1.length);
  array = new Array(arg1.length);
  let num = 0;
  let num2 = 0;
  let num3 = 0;
  let num4 = 0;
  let num5 = 0;
  let num6 = 0;
  if (0 < arg1.length) {
    do {
      let dataCount = arg1[num].dataCount;
      let diff = arg1[num].totalCount - dataCount;
      let _Math = Math;
      let bound = Math.max(num3, dataCount);
      let _Math2 = Math;
      let bound1 = Math.max(num2, diff);
      let _Array = Array;
      let tmp6 = new.target;
      let tmp7 = new.target;
      let tmp8 = dataCount;
      let array1 = new Array(dataCount);
      let tmp10 = array1;
      array[num] = array1;
      let tmp11 = num;
      let tmp12 = num4;
      let num7 = 0;
      if (0 < array[num].length) {
        do {
          array[num][num7] = 255 & arg0.buffer[num7 + num4];
          num7 = num7 + 1;
          length = array[num].length;
        } while (num7 < length);
      }
      let tmp14 = require;
      let tmp15 = dependencyMap;
      let sum = num4 + dataCount;
      let obj = _mod12433;
      let errorCorrectPolynomial = obj.getErrorCorrectPolynomial(diff);
      let tmp16 = QRPolynomial;
      let tmp17 = new.target;
      let tmp18 = new.target;
      tmp16 = new tmp16(array[num], errorCorrectPolynomial.getLength() - 1);
      let tmp19 = tmp16;
      let modResult = tmp16.mod(errorCorrectPolynomial);
      let _Array2 = Array;
      let tmp20 = new.target;
      let tmp21 = new.target;
      let array2 = new Array(errorCorrectPolynomial.getLength() - 1);
      let tmp23 = array2;
      array[num] = array2;
      for (let num8 = 0; num8 < array[num].length; num8 = num8 + 1) {
        let diff1 = num8 + modResult.getLength() - array[num].length;
        let tmp25 = num8;
        let num9 = 0;
        if (0 <= diff1) {
          num9 = modResult.get(diff1);
        }
        array[num][num8] = num9;
      }
      num = num + 1;
      num2 = bound1;
      num3 = bound;
      num4 = sum;
      num5 = bound1;
      num6 = bound;
    } while (num < arg1.length);
  }
  let num10 = 0;
  let num11 = 0;
  let num12 = 0;
  if (0 < arg1.length) {
    do {
      num10 = num10 + arg1[num11].totalCount;
      num11 = num11 + 1;
      num12 = num10;
      length2 = arg1.length;
    } while (num11 < length2);
  }
  const array3 = new Array(num12);
  let num13 = 0;
  let num14 = 0;
  let num15 = 0;
  if (0 < num6) {
    do {
      let tmp27 = num13;
      let tmp28 = num14;
      let num16 = 0;
      let tmp29 = num13;
      if (0 < arg1.length) {
        do {
          let tmp30 = tmp27;
          let tmp31 = num16;
          let sum1 = tmp27;
          if (num14 < array[num16].length) {
            sum1 = tmp27 + 1;
            array3[tmp27] = array[num16][num14];
          }
          num16 = num16 + 1;
          tmp27 = sum1;
          tmp29 = sum1;
        } while (num16 < arg1.length);
      }
      num14 = num14 + 1;
      num13 = tmp29;
      num15 = tmp29;
    } while (num14 < num6);
  }
  let num17 = 0;
  if (0 < num5) {
    do {
      let tmp33 = num15;
      let tmp34 = num17;
      let num18 = 0;
      let tmp35 = num15;
      if (0 < arg1.length) {
        do {
          let tmp36 = tmp33;
          let tmp37 = num18;
          let sum2 = tmp33;
          if (num17 < array[num18].length) {
            sum2 = tmp33 + 1;
            array3[tmp33] = array[num18][num17];
          }
          num18 = num18 + 1;
          tmp33 = sum2;
          tmp35 = sum2;
        } while (num18 < arg1.length);
      }
      num17 = num17 + 1;
      num15 = tmp35;
    } while (num17 < num5);
  }
  return array3;
};

export default QRCode;