// Module ID: 14145
// Function ID: 108791
// Name: thumbHashToRGBA
// Dependencies: [57]
// Exports: rgbaToThumbHash, thumbHashToAverageRGBA, thumbHashToDataURL

// Module 14145 (thumbHashToRGBA)
import _slicedToArray from "_slicedToArray";

function thumbHashToRGBA(arg0) {
  let _slicedToArray = arg0;
  let result = (63 & tmp) / 63;
  const tmp6 = (arg0[0] | arg0[1] << 8 | arg0[2] << 16) >> 23;
  const diff = (tmp >> 6 & 63) / 31.5 - 1;
  const diff1 = (tmp >> 12 & 63) / 31.5 - 1;
  if ((arg0[3] | arg0[4] << 8) >> 15) {
    let num = 7;
    if (tmp6) {
      num = 5;
    }
    let tmp8 = num;
  } else {
    tmp8 = 7 & tmp2;
  }
  const maxResult = max(3, tmp8);
  if ((arg0[3] | arg0[4] << 8) >> 15) {
    let num2 = 7 & tmp2;
  } else {
    num2 = 7;
    if (tmp6) {
      num2 = 5;
    }
  }
  const maxResult1 = max(3, num2);
  let num3 = 1;
  if (tmp6) {
    num3 = (15 & arg0[5]) / 15;
  }
  let num5 = 5;
  if (tmp6) {
    num5 = 6;
  }
  const thumbHashToApproximateAspectRatio = 0;
  function decodeChannel(maxResult, maxResult1, arg2) {
    const items = [];
    for (let num = 0; num < maxResult1; num = num + 1) {
      let num2 = 1;
      if (num) {
        num2 = 0;
      }
      if (num2 * maxResult1 < maxResult * (maxResult1 - num)) {
        do {
          let tmp = table;
          let tmp2 = num5;
          let tmp3 = c2;
          let tmp4 = c2;
          let tmp5 = +c2;
          c2 = tmp5 + 1;
          let arr = items.push(((table[num5 + (c2 >> 1)] >> ((1 & tmp5) << 2) & 15) / 7.5 - 1) * arg2);
          num2 = num2 + 1;
          result = num2 * maxResult1;
          result1 = maxResult * (maxResult1 - num);
        } while (result < result1);
      }
    }
    return items;
  }
  const decodeChannelResult = decodeChannel(maxResult, maxResult1, ((arg0[0] | arg0[1] << 8 | arg0[2] << 16) >> 18 & 31) / 31);
  const tmp11 = arg0[5] >> 4;
  let decodeChannelResult3 = tmp6;
  const decodeChannelResult1 = decodeChannel(3, 3, 1.25 * (((arg0[3] | arg0[4] << 8) >> 3 & 63) / 63));
  if (tmp6) {
    decodeChannelResult3 = decodeChannel(5, 5, tmp11 / 15);
  }
  const tmp16 = thumbHashToApproximateAspectRatio(arg0);
  let num6 = 32;
  if (tmp16 <= 1) {
    num6 = 32 * tmp16;
  }
  const w = round(num6);
  let num7 = 32;
  if (tmp16 > 1) {
    num7 = 32 / tmp16;
  }
  const h = round(num7);
  const rgba = new Uint8Array(w * h * 4);
  let items = [];
  const items1 = [];
  let num8 = 0;
  let num9 = 0;
  if (0 < h) {
    do {
      let sum11 = num9;
      let tmp28 = tmp21;
      let tmp29 = tmp22;
      let tmp30 = tmp23;
      let tmp31 = tmp24;
      let tmp32 = tmp25;
      let tmp33 = tmp26;
      let num10 = 0;
      if (0 < w) {
        do {
          let num11 = 3;
          if (tmp6) {
            num11 = 5;
          }
          let maxResult2 = max(maxResult, num11);
          let num12 = 0;
          let num13 = 0;
          if (0 < maxResult2) {
            do {
              items[num12] = cos(PI / w * (num10 + 0.5) * num12);
              num12 = num12 + 1;
              num13 = num12;
            } while (num12 < maxResult2);
          }
          let num14 = 3;
          if (tmp6) {
            num14 = 5;
          }
          let maxResult3 = max(maxResult1, num14);
          let num15 = 0;
          let num16 = 0;
          if (0 < maxResult3) {
            do {
              items1[num15] = cos(PI / h * (num8 + 0.5) * num15);
              num15 = num15 + 1;
              num16 = num15;
            } while (num15 < maxResult3);
          }
          let tmp36 = result;
          let num17 = 0;
          let num18 = 0;
          let tmp37 = result;
          let num19 = 0;
          let num20 = 0;
          if (0 < maxResult1) {
            do {
              let num21 = 1;
              if (num17) {
                num21 = 0;
              }
              let result1 = 2 * items1[num17];
              let tmp39 = num21;
              let sum = tmp36;
              let sum2 = num18;
              let tmp42 = tmp36;
              let tmp43 = num18;
              let tmp44 = num21;
              if (num21 * maxResult1 < maxResult * (maxResult1 - num17)) {
                do {
                  sum = sum + decodeChannelResult[sum2] * items[tmp39] * result1;
                  let sum1 = tmp39 + 1;
                  sum2 = sum2 + 1;
                  tmp39 = sum1;
                  tmp42 = sum;
                  tmp43 = sum2;
                  tmp44 = sum1;
                  result2 = sum1 * maxResult1;
                  result3 = maxResult * (maxResult1 - num17);
                } while (result2 < result3);
              }
              num17 = num17 + 1;
              tmp36 = tmp42;
              num18 = tmp43;
              tmp28 = tmp44;
              tmp37 = tmp42;
              num20 = tmp43;
              tmp29 = result1;
              num19 = num17;
            } while (num17 < maxResult1);
          }
          let tmp48 = tmp28;
          let tmp49 = tmp29;
          let tmp50 = diff;
          let tmp51 = diff1;
          let num22 = 0;
          let num23 = 0;
          do {
            let num24 = 1;
            if (num22) {
              num24 = 0;
            }
            let result4 = 2 * items1[num22];
            let sum5 = num24;
            let sum3 = tmp50;
            let sum4 = tmp51;
            let sum6 = num23;
            let tmp57 = tmp50;
            let tmp58 = tmp51;
            let tmp59 = num23;
            let tmp60 = num24;
            if (num24 < 3 - num22) {
              do {
                let result5 = items[sum5] * result4;
                sum3 = sum3 + decodeChannelResult1[sum6] * result5;
                sum4 = sum4 + decodeChannelResult2[sum6] * result5;
                sum5 = sum5 + 1;
                sum6 = sum6 + 1;
                tmp57 = sum3;
                tmp58 = sum4;
                tmp59 = sum6;
                tmp60 = sum5;
                diff2 = 3 - num22;
              } while (sum5 < diff2);
            }
            sum7 = num22 + 1;
            tmp50 = tmp57;
            tmp51 = tmp58;
            num22 = sum7;
            num23 = tmp59;
          } while (sum7 < 3);
          let tmp64 = num3;
          let num25 = 0;
          let num26 = 0;
          let tmp65 = num3;
          if (tmp6) {
            do {
              let num27 = 1;
              if (num25) {
                num27 = 0;
              }
              let result6 = 2 * items1[num25];
              let sum9 = num27;
              let sum8 = tmp64;
              let sum10 = num26;
              let tmp70 = tmp64;
              let tmp71 = num26;
              let tmp72 = num27;
              if (num27 < 5 - num25) {
                do {
                  sum8 = sum8 + decodeChannelResult3[sum10] * items[sum9] * result6;
                  sum9 = sum9 + 1;
                  sum10 = sum10 + 1;
                  tmp70 = sum8;
                  tmp71 = sum10;
                  tmp72 = sum9;
                  diff3 = 5 - num25;
                } while (sum9 < diff3);
              }
              num25 = num25 + 1;
              tmp64 = tmp70;
              num26 = tmp71;
              tmp32 = tmp72;
              tmp65 = tmp70;
              tmp31 = tmp71;
              tmp33 = result6;
              tmp30 = num25;
            } while (num25 < 5);
          }
          let diff4 = tmp37 - 0.6666666666666666 * tmp57;
          let result7 = (3 * tmp37 - diff4 + tmp58) / 2;
          rgba[sum11] = max(0, 255 * min(1, result7));
          rgba[sum11 + 1] = max(0, 255 * min(1, result7 - tmp58));
          rgba[sum11 + 2] = max(0, 255 * min(1, diff4));
          rgba[sum11 + 3] = max(0, 255 * min(1, tmp65));
          num10 = num10 + 1;
          sum11 = sum11 + 4;
          let tmp76 = tmp65;
          num9 = sum11;
          let tmp77 = tmp37;
          let tmp78 = tmp57;
          let tmp79 = tmp58;
          let tmp80 = num13;
          let tmp81 = maxResult2;
          let tmp82 = num16;
          let tmp83 = maxResult3;
          let tmp84 = num19;
          let tmp85 = num20;
          tmp21 = tmp28;
          tmp22 = tmp29;
          let tmp86 = sum7;
          let tmp87 = tmp59;
          let tmp88 = tmp60;
          let tmp89 = result4;
          tmp23 = tmp30;
          tmp24 = tmp31;
          tmp25 = tmp32;
          tmp26 = tmp33;
        } while (num10 < w);
      }
      num8 = num8 + 1;
    } while (num8 < h);
  }
  return { w, h, rgba };
}
function thumbHashToApproximateAspectRatio(arg0) {
  if (128 & arg0[4]) {
    let num = 7;
    if (tmp2) {
      num = 5;
    }
    let tmp4 = num;
  } else {
    tmp4 = 7 & tmp;
  }
  if (128 & arg0[4]) {
    let num2 = 7 & tmp;
  } else {
    num2 = 7;
    if (tmp2) {
      num2 = 5;
    }
  }
  return tmp4 / num2;
}
function rgbaToDataURL(w, h, rgba) {
  let tmp59;
  let tmp60;
  const sum = 4 * w + 1;
  const sum1 = 6 + h * (5 + sum);
  const items = [137, 80, 78, 71, 13, 10, 26, 10, 0, 0, 0, 13, 73, 72, 68, 82, 0, 0, w >> 8, 255 & w, 0, 0, h >> 8, 255 & h, 8, 6, 0, 0, 0, 0, 0, 0, 0, sum1 >>> 24, sum1 >> 16 & 255, sum1 >> 8 & 255, 255 & sum1, 73, 68, 65, 84, 120, 1];
  let arr1 = items;
  const items1 = [0, 498536548, 997073096, 651767980, 1994146192, 1802195444, 1303535960, 1342533948, -306674912, -267414716, -690576408, -882789492, -1687895376, -2032938284, -1609899400, -1111625188];
  const diff = sum - 1;
  let num = 1;
  let num2 = 0;
  let num3 = 0;
  let num4 = 0;
  let sum3 = diff;
  let num5 = 1;
  let num6 = 0;
  if (0 < h) {
    do {
      let num7 = 1;
      let tmp10 = items;
      if (num3 + 1 < h) {
        num7 = 0;
      }
      let tmp11 = arr1;
      let tmp12 = num7;
      let tmp13 = tmp6;
      let tmp14 = tmp5;
      let tmp15 = tmp7;
      let tmp16 = tmp8;
      let num8 = 0;
      let arr = arr1.push(num7, tmp6, tmp5, tmp7, tmp8, 0);
      let result = (num2 + num) % 65521;
      let tmp19 = num;
      let sum2 = num4;
      let tmp21 = num;
      let tmp22 = result;
      if (num4 < sum3) {
        do {
          let tmp23 = 255 & rgba[sum2];
          let tmp24 = items;
          arr = arr1.push(tmp23);
          let result1 = (tmp19 + tmp23) % 65521;
          result = (result + result1) % 65521;
          sum2 = sum2 + 1;
          tmp19 = result1;
          tmp21 = result1;
          tmp22 = result;
          num4 = sum2;
        } while (sum2 < sum3);
      }
      num3 = num3 + 1;
      sum3 = sum3 + diff;
      num = tmp21;
      num2 = tmp22;
      num5 = tmp21;
      num6 = tmp22;
    } while (num3 < h);
  }
  arr1 = arr1.push(num6 >> 8, 255 & num6, num5 >> 8, 255 & num5, 0, 0, 0, 0, 0, 0, 0, 0, 73, 69, 78, 68, 174, 66, 96, 130);
  const items2 = [[12, 29], ];
  const items3 = [37, 41 + sum1];
  items2[1] = items3;
  while (tmp28 !== undefined) {
    let tmp57 = callback;
    let tmp58 = callback(tmp29, 2);
    [tmp59, tmp60] = tmp58;
    let tmp61 = tmp60;
    let num9 = -1;
    let tmp39 = tmp59;
    if (tmp59 < tmp60) {
      do {
        let tmp30 = num9;
        let tmp31 = items;
        let tmp32 = tmp39;
        let tmp33 = num9 ^ arr1[tmp39];
        let tmp34 = tmp33;
        let tmp35 = items1;
        let tmp36 = tmp33 >>> 4 ^ tmp3[15 & tmp33];
        let tmp37 = tmp36;
        num9 = tmp36 >>> 4 ^ tmp3[15 & tmp36];
        sum4 = tmp39 + 1;
        tmp39 = sum4;
        let tmp40 = tmp60;
      } while (sum4 < tmp61);
    }
    let tmp41 = num9;
    let tmp42 = ~num9;
    let tmp43 = tmp42;
    let tmp44 = items;
    let tmp45 = tmp60;
    let tmp46 = +tmp61;
    let sum5 = tmp46 + 1;
    let tmp48 = sum5;
    arr1[tmp46] = tmp42 >>> 24;
    let tmp49 = +sum5;
    let sum6 = tmp49 + 1;
    let tmp51 = sum6;
    arr1[tmp49] = tmp42 >> 16 & 255;
    let tmp52 = +sum6;
    let sum7 = tmp52 + 1;
    let tmp54 = sum7;
    arr1[tmp52] = tmp42 >> 8 & 255;
    let tmp55 = +sum7;
    let sum8 = tmp55 + 1;
    arr1[tmp55] = 255 & tmp42;
    continue;
  }
  return "data:image/png;base64," + btoa(fromCharCode.apply(String, items));
}

export const rgbaToThumbHash = function rgbaToThumbHash(arg0, arg1, arg2) {
  let result10;
  let result2;
  let tmp24;
  let tmp25;
  let tmp26;
  let tmp29;
  let tmp30;
  let tmp31;
  let tmp34;
  let tmp35;
  let tmp36;
  const callback = arg0;
  let closure_1 = arg1;
  if (arg0 <= 100) {
    if (arg1 <= 100) {
      const _Math = Math;
      const _Math2 = Math;
      const _Math3 = Math;
      const _Math4 = Math;
      const _Math5 = Math;
      let num = 0;
      let num2 = 0;
      let num3 = 0;
      let num4 = 0;
      let num5 = 0;
      let num6 = 0;
      let num7 = 0;
      let num8 = 0;
      let num9 = 0;
      let num10 = 0;
      if (0 < arg0 * arg1) {
        do {
          let result = arg2[num6 + 3] / 255;
          let result1 = result / 255;
          num = num + result1 * arg2[num6];
          num2 = num2 + result1 * arg2[num6 + 1];
          num3 = num3 + result1 * arg2[num6 + 2];
          num4 = num4 + result;
          num5 = num5 + 1;
          num6 = num6 + 4;
          num7 = num;
          num8 = num2;
          num9 = num3;
          num10 = num4;
          result2 = arg0 * arg1;
        } while (num5 < result2);
      }
      let result3 = num7;
      let result4 = num8;
      let result5 = num9;
      if (num10) {
        result3 = num7 / num10;
        result4 = num8 / num10;
        result5 = num9 / num10;
      }
      let num11 = 7;
      if (num10 < arg0 * arg1) {
        num11 = 5;
      }
      const result6 = num11 * arg0;
      let maxResult = max(1, round(result6 / max(arg0, arg1)));
      const result7 = num11 * arg1;
      const maxResult1 = max(1, round(result7 / max(arg0, arg1)));
      let items = [];
      let items1 = [];
      let items2 = [];
      const items3 = [];
      let num12 = 0;
      let num13 = 0;
      if (0 < arg0 * arg1) {
        do {
          let result8 = arg2[num13 + 3] / 255;
          let diff = 1 - result8;
          let result9 = result8 / 255;
          let sum = result3 * diff + result9 * arg2[num13];
          let sum1 = result4 * diff + result9 * arg2[num13 + 1];
          let sum2 = result5 * diff + result9 * arg2[num13 + 2];
          let sum3 = sum + sum1;
          items[num12] = (sum3 + sum2) / 3;
          items1[num12] = sum3 / 2 - sum2;
          items2[num12] = sum - sum1;
          items3[num12] = result8;
          num12 = num12 + 1;
          num13 = num13 + 4;
          result10 = arg0 * arg1;
        } while (num12 < result10);
      }
      function encodeChannel(items, maxResult2, arg2) {
        let length;
        items = [];
        const items1 = [];
        let num = 0;
        let num2 = 0;
        let num3 = 0;
        let num4 = 0;
        let num5 = 0;
        if (0 < arg2) {
          do {
            let tmp3 = num;
            let tmp4 = num2;
            let tmp5 = tmp;
            let tmp6 = tmp2;
            let num6 = 0;
            let tmp7 = num;
            let tmp8 = num2;
            if (0 < maxResult2 * (arg2 - num3)) {
              do {
                let tmp9 = _slicedToArray;
                let num7 = 0;
                let num8 = 0;
                if (0 < _slicedToArray) {
                  do {
                    let tmp10 = cos;
                    let tmp11 = PI;
                    let tmp12 = _slicedToArray;
                    items1[num7] = cos(PI / _slicedToArray * num6 * (num7 + 0.5));
                    num7 = num7 + 1;
                    num8 = num7;
                  } while (num7 < _slicedToArray);
                }
                let tmp13 = closure_1;
                let num9 = 0;
                let num10 = 0;
                let num11 = 0;
                let num12 = 0;
                if (0 < closure_1) {
                  do {
                    let tmp14 = cos;
                    let tmp15 = PI;
                    let tmp16 = closure_1;
                    let tmp17 = cos(PI / closure_1 * num3 * (num10 + 0.5));
                    let tmp18 = _slicedToArray;
                    let sum = num9;
                    let num13 = 0;
                    let tmp20 = num9;
                    let num14 = 0;
                    if (0 < _slicedToArray) {
                      do {
                        let tmp21 = _slicedToArray;
                        sum = sum + items[num13 + num10 * _slicedToArray] * items1[num13] * tmp17;
                        num13 = num13 + 1;
                        tmp20 = sum;
                        num14 = num13;
                      } while (num13 < _slicedToArray);
                    }
                    num10 = num10 + 1;
                    let tmp22 = closure_1;
                    num9 = tmp20;
                    tmp5 = num14;
                    num11 = tmp20;
                    tmp6 = tmp17;
                    num12 = num10;
                  } while (num10 < closure_1);
                }
                let tmp23 = _slicedToArray;
                let tmp24 = closure_1;
                let result = num11 / (_slicedToArray * closure_1);
                let tmp26 = tmp5;
                let tmp27 = tmp6;
                if (num6) {
                  let arr = items.push(result);
                  let tmp31 = max;
                  let tmp32 = abs;
                  let tmp29 = max(tmp4, abs(result));
                  let tmp28 = tmp3;
                } else {
                  tmp28 = result;
                  tmp29 = tmp4;
                }
                num6 = num6 + 1;
                tmp3 = tmp28;
                tmp4 = tmp29;
                tmp7 = tmp28;
                tmp8 = tmp29;
                let tmp33 = result;
                let tmp34 = num8;
                let tmp35 = num12;
                tmp = tmp5;
                tmp2 = tmp6;
              } while (num6 * arg2 < maxResult2 * (arg2 - num3));
            }
            num3 = num3 + 1;
            num = tmp7;
            num2 = tmp8;
            num4 = tmp7;
            num5 = tmp8;
          } while (num3 < arg2);
        }
        if (num5) {
          let num15 = 0;
          if (0 < items.length) {
            do {
              items[num15] = 0.5 + 0.5 / num5 * items[num15];
              num15 = num15 + 1;
              length = items.length;
            } while (num15 < length);
          }
        }
        const items2 = [num4, items, num5];
        return items2;
      }
      const maxResult2 = max(3, maxResult);
      [tmp24, tmp25, tmp26] = callback(encodeChannel(items, max(3, maxResult), max(3, maxResult1)), 3);
      let tmp23 = callback(encodeChannel(items, max(3, maxResult), max(3, maxResult1)), 3);
      [tmp29, tmp30, tmp31] = callback(encodeChannel(items1, 3, 3), 3);
      let tmp28 = callback(encodeChannel(items1, 3, 3), 3);
      [tmp34, tmp35, tmp36] = callback(encodeChannel(items2, 3, 3), 3);
      if (num10 < arg0 * arg1) {
        let encodeChannelResult = encodeChannel(items3, 5, 5);
      } else {
        encodeChannelResult = [];
      }
      const tmp38 = callback(encodeChannelResult, 3);
      let tmp39 = tmp38[1];
      let tmp33 = callback(encodeChannel(items2, 3, 3), 3);
      const roundResult = round(63 * tmp24);
      const tmp43 = round(63 * tmp24) | round(31.5 + 31.5 * tmp29) << 6;
      const tmp45 = tmp43 | round(31.5 + 31.5 * tmp34) << 12 | round(31 * tmp26) << 18 | (num10 < arg0 * arg1) << 23;
      if (arg0 > arg1) {
        maxResult = maxResult1;
      }
      const tmp44 = round(31.5 + 31.5 * tmp34) << 12;
      const tmp48 = maxResult | round(63 * tmp31) << 3 | round(63 * tmp36) << 9 | (arg0 > arg1) << 15;
      const items4 = [255 & tmp45, tmp45 >> 8 & 255, tmp45 >> 16, 255 & tmp48, tmp48 >> 8];
      let num26 = 5;
      if (num10 < arg0 * arg1) {
        num26 = 6;
      }
      if (num10 < arg0 * arg1) {
        arr7.push(round(15 * tmp38[0]) | round(15 * tmp38[2]) << 4);
        const roundResult1 = round(15 * tmp38[0]);
      }
      if (num10 < arg0 * arg1) {
        const items5 = [tmp25, tmp30, tmp35, tmp39];
        let items6 = items5;
      } else {
        items6 = [tmp25, tmp30, tmp35];
      }
      tmp39 = items6[Symbol.iterator]();
      arr7 = items4;
      const tmp47 = maxResult | round(63 * tmp31) << 3;
    }
  }
  const error = new Error("" + arg0 + "x" + arg1 + " doesn't fit in 100x100");
  throw error;
};
export { thumbHashToRGBA };
export const thumbHashToAverageRGBA = function thumbHashToAverageRGBA(arg0) {
  const result = (63 & tmp) / 63;
  const diff = (tmp >> 12 & 63) / 31.5 - 1;
  let num = 1;
  if ((arg0[0] | arg0[1] << 8 | arg0[2] << 16) >> 23) {
    num = (15 & arg0[5]) / 15;
  }
  const diff1 = result - 0.6666666666666666 * ((tmp >> 6 & 63) / 31.5 - 1);
  const result1 = (3 * result - diff1 + diff) / 2;
  const obj = { r: max(0, min(1, result1)), g: max(0, min(1, result1 - diff)), b: max(0, min(1, diff1)), a: num };
  return obj;
};
export { thumbHashToApproximateAspectRatio };
export { rgbaToDataURL };
export const thumbHashToDataURL = function thumbHashToDataURL(arg0) {
  const tmp = thumbHashToRGBA(arg0);
  return rgbaToDataURL(tmp.w, tmp.h, tmp.rgba);
};