// Module ID: 1446
// Function ID: 16836
// Name: error
// Dependencies: []

// Module 1446 (error)
const global = arg0;
let dependencyMap = arg4;
const exports = arg5;
((arg0) => {
  let tmp = arg0;
  function error(arg0) {
    const rangeError = new RangeError(table[arg0]);
    throw rangeError;
  }
  function map(arg0, arg1) {
    let tmp3;
    const items = [];
    let diff = tmp - 1;
    if (+arg0.length) {
      do {
        items[diff] = arg1(arg0[diff]);
        tmp3 = +diff;
        diff = tmp3 - 1;
      } while (tmp3);
    }
    return items;
  }
  function mapDomain(str) {
    const parts = str.split("@");
    let str2 = "";
    if (parts.length > 1) {
      str2 = `${arr[0]}@`;
      str = parts[1];
    }
    const str3 = str.replace(closure_5, ".");
    return str2 + map(str.replace(closure_5, ".").split("."), arg1).join(".");
  }
  function ucs2decode(str) {
    const items = [];
    let num = 0;
    if (0 < str.length) {
      while (true) {
        let tmp = +num;
        let sum = tmp + 1;
        let charCodeAtResult = str.charCodeAt(tmp);
        if (charCodeAtResult >= 55296) {
          if (charCodeAtResult <= 56319) {
            if (sum < length) {
              let tmp5 = +sum;
              let sum1 = tmp5 + 1;
              let charCodeAtResult1 = str.charCodeAt(tmp5);
              if (56320 === (64512 & charCodeAtResult1)) {
                let arr = items.push(((1023 & charCodeAtResult) << 10) + (1023 & charCodeAtResult1) + 65536);
                let tmp11 = charCodeAtResult1;
                num = sum1;
              } else {
                arr = items.push(charCodeAtResult);
                num = sum1 - 1;
                let tmp9 = charCodeAtResult1;
              }
              if (num >= length) {
                break;
              }
            }
          }
        }
        let arr1 = items.push(charCodeAtResult);
        num = sum;
      }
    }
    return items;
  }
  function ucs2encode(arg0) {
    return map(arg0, (arg0) => {
      let str = "";
      let tmp = arg0;
      if (arg0 > 65535) {
        const diff = arg0 - 65536;
        str = `${outer1_8(tmp3 >>> 10 & 1023 | 55296)}`;
        tmp = 56320 | 1023 & diff;
      }
      return str + outer1_8(tmp);
    }).join("");
  }
  function digitToBasic(arg0, arg1) {
    return arg0 + 22 + 75 * (arg0 < 26) - ((0 != 0) << 5);
  }
  function adapt(arg0, arg1, arg2) {
    if (arg2) {
      let tmp = floor(arg0 / 700);
    } else {
      tmp = arg0 >> 1;
    }
    let sum = tmp + floor(tmp / arg1);
    let num3 = 0;
    let num4 = 0;
    let tmp4 = sum;
    if (sum > 455) {
      do {
        let tmp5 = floor;
        sum = floor(sum / 35);
        let tmp6 = c2;
        num3 = num3 + c2;
        num4 = num3;
        tmp4 = sum;
      } while (sum > 455);
    }
    return floor(num4 + 36 * tmp4 / (tmp4 + 38));
  }
  function decode(arr) {
    const items = [];
    let num = arr.lastIndexOf("-");
    if (num < 0) {
      num = 0;
    }
    let num2 = 128;
    for (let num3 = 0; num3 < num; num3 = num3 + 1) {
      let tmp = num3;
      if (arr.charCodeAt(num3) >= num2) {
        let tmp2 = error;
        let tmp3 = error("not-basic");
      }
      arr = items.push(arr.charCodeAt(num3));
    }
    let num4 = 0;
    if (num > 0) {
      num4 = num + 1;
    }
    let num6 = 72;
    let num7 = 0;
    while (num4 < arr.length) {
      let sum2 = c2;
      if (num4 >= length) {
        let tmp6 = error;
        let tmp7 = error("invalid-input");
      }
      let tmp8 = +num4;
      let sum = tmp8 + 1;
      let charCodeAtResult = arr.charCodeAt(tmp8);
      if (charCodeAtResult - 48 < 10) {
        let diff = charCodeAtResult - 22;
      } else if (charCodeAtResult - 65 < 26) {
        diff = charCodeAtResult - 65;
      } else {
        diff = charCodeAtResult - 97 < 26 ? charCodeAtResult - 97 : c2;
      }
      let tmp12 = c2;
      let tmp13 = diff >= c2;
      if (!tmp13) {
        let tmp14 = floor;
        let tmp15 = c1;
        tmp13 = diff > floor(c1 - num7);
      }
      if (tmp13) {
        let tmp16 = error;
        let tmp17 = error("overflow");
      }
      let sum1 = num7 + diff;
      let num8 = 1;
      if (sum2 > num6) {
        let num9 = 26;
        if (sum2 < num6 + 26) {
          num9 = sum2 - num6;
        }
        num8 = num9;
      }
      let tmp19 = sum;
      let num10 = 1;
      let tmp20 = sum1;
      num4 = sum;
      let tmp21 = sum1;
      if (diff >= num8) {
        do {
          let tmp22 = floor;
          let tmp23 = c1;
          let tmp24 = c2;
          let diff1 = c2 - num8;
          if (num10 > floor(c1 / diff1)) {
            let tmp26 = error;
            let tmp27 = error("overflow");
          }
          num10 = num10 * diff1;
          let tmp28 = c2;
          sum2 = sum2 + c2;
          if (tmp19 >= length) {
            let tmp29 = error;
            let tmp30 = error("invalid-input");
          }
          let tmp31 = +tmp19;
          let sum3 = tmp31 + 1;
          let charCodeAtResult1 = arr.charCodeAt(tmp31);
          if (charCodeAtResult1 - 48 < 10) {
            diff2 = charCodeAtResult1 - 22;
          } else if (charCodeAtResult1 - 65 < 26) {
            diff2 = charCodeAtResult1 - 65;
          } else {
            diff2 = charCodeAtResult1 - 97 < 26 ? charCodeAtResult1 - 97 : c2;
          }
          let tmp35 = c2;
          let tmp36 = diff2 >= c2;
          if (!tmp36) {
            let tmp37 = floor;
            let tmp38 = c1;
            tmp36 = diff2 > floor((c1 - tmp20) / num10);
          }
          if (tmp36) {
            let tmp39 = error;
            let tmp40 = error("overflow");
          }
          let sum4 = tmp20 + diff2 * num10;
          num8 = 1;
          if (sum2 > num6) {
            let num11 = 26;
            if (sum2 < num6 + 26) {
              num11 = sum2 - num6;
            }
            num8 = num11;
          }
          tmp19 = sum3;
          tmp20 = sum4;
          num4 = sum3;
          let tmp42 = diff1;
          tmp21 = sum4;
        } while (diff2 >= num8);
      }
      let tmp43 = adapt;
      let sum5 = items.length + 1;
      let tmp46 = floor;
      let result = tmp21 / sum5;
      let tmp45 = adapt(tmp21 - num7, sum5, 0 === num7);
      let tmp48 = c1;
      if (floor(result) > c1 - num2) {
        let tmp49 = error;
        let tmp50 = error("overflow");
      }
      let tmp51 = floor;
      let sum6 = num2 + floor(result);
      let result1 = tmp21 % sum5;
      num7 = result1 + 1;
      let spliceResult = items.splice(result1, 0, sum6);
      num2 = sum6;
      num6 = tmp45;
    }
    return ucs2encode(items);
  }
  function encode(arg0) {
    const items = [];
    let arr1 = ucs2decode(arg0);
    let num = 128;
    let num2 = 0;
    if (0 < arr1.length) {
      do {
        let tmp = arr1[num2];
        if (tmp < num) {
          let tmp2 = fromCharCode;
          let arr = items.push(fromCharCode(tmp));
        }
        num2 = num2 + 1;
        let tmp4 = tmp;
      } while (num2 < length);
    }
    if (items.length) {
      items.push("-");
    }
    let num3 = 72;
    let num4 = 0;
    let tmp6 = length2;
    if (items.length < arr1.length) {
      do {
        let tmp10 = c1;
        let num5 = 0;
        let tmp11 = c1;
        if (0 < length) {
          do {
            let tmp12 = arr1[num5];
            let tmp13 = tmp12 >= num && tmp12 < tmp10;
            if (tmp13) {
              tmp10 = tmp12;
            }
            num5 = num5 + 1;
            tmp11 = tmp10;
            let tmp14 = tmp12;
          } while (num5 < length);
        }
        let tmp16 = floor;
        let tmp17 = c1;
        let sum = tmp6 + 1;
        let diff = tmp11 - num;
        if (diff > floor((c1 - num4) / sum)) {
          let tmp19 = error;
          let tmp20 = error("overflow");
        }
        let sum1 = num4 + (tmp11 - num) * sum;
        let tmp22 = tmp6;
        let tmp23 = num3;
        let num6 = 0;
        let tmp24 = tmp7;
        let tmp25 = tmp8;
        let tmp26 = tmp9;
        let tmp27 = sum1;
        if (0 < length) {
          do {
            let tmp28 = arr1[num6];
            let tmp29 = tmp28 < tmp11;
            let tmp30 = sum1;
            if (tmp29) {
              let sum2 = sum1 + 1;
              let tmp32 = c1;
              tmp29 = sum2 > c1;
              tmp30 = sum2;
            }
            if (tmp29) {
              let tmp33 = error;
              let tmp34 = error("overflow");
            }
            let num7 = tmp30;
            let sum4 = tmp22;
            let tmp36 = tmp23;
            if (tmp28 == tmp11) {
              let tmp58 = c2;
              let num9 = 1;
              if (c2 > tmp23) {
                let num8 = 26;
                if (tmp58 < tmp23 + 26) {
                  num8 = tmp58 - tmp23;
                }
                num9 = num8;
              }
              let tmp37 = num9;
              let tmp38 = tmp30;
              let tmp39 = tmp58;
              let tmp40 = tmp30;
              let tmp41 = tmp58;
              let tmp42 = num9;
              if (tmp30 >= num9) {
                do {
                  let diff1 = tmp38 - tmp37;
                  let tmp44 = c2;
                  let diff2 = c2 - tmp37;
                  let tmp46 = fromCharCode;
                  let tmp47 = digitToBasic;
                  arr1 = items.push(fromCharCode(digitToBasic(tmp37 + diff1 % diff2, 0)));
                  let tmp49 = floor;
                  tmp50 = floor(diff1 / diff2);
                  let tmp51 = c2;
                  let sum3 = tmp39 + c2;
                  num10 = 1;
                  if (sum3 > tmp23) {
                    let num11 = 26;
                    if (sum3 < tmp23 + 26) {
                      num11 = sum3 - tmp23;
                    }
                    num10 = num11;
                  }
                  tmp37 = num10;
                  tmp38 = tmp50;
                  tmp39 = sum3;
                  tmp41 = sum3;
                  tmp40 = tmp50;
                  tmp42 = num10;
                } while (tmp50 >= num10);
              }
              let tmp53 = fromCharCode;
              let tmp54 = digitToBasic;
              let arr2 = items.push(fromCharCode(digitToBasic(tmp40, 0)));
              let tmp56 = adapt;
              tmp36 = adapt(tmp30, sum, tmp22 == length2);
              sum4 = tmp22 + 1;
              tmp24 = tmp40;
              tmp25 = tmp41;
              tmp26 = tmp42;
              num7 = 0;
            }
            num6 = num6 + 1;
            sum1 = num7;
            tmp22 = sum4;
            tmp23 = tmp36;
            tmp27 = num7;
            tmp6 = sum4;
            num3 = tmp36;
            tmp7 = tmp24;
            tmp8 = tmp25;
            tmp9 = tmp26;
            let tmp57 = tmp28;
          } while (num6 < length);
        }
        num4 = tmp27 + 1;
        num = tmp11 + 1;
      } while (tmp6 < length);
    }
    return items.join("");
  }
  let tmp2 = "object" === typeof _exports && _exports;
  if (tmp2) {
    tmp2 = !_exports.nodeType;
  }
  if (tmp2) {
    tmp2 = _exports;
  }
  let tmp4 = "object" === typeof dependencyMap && dependencyMap;
  if (tmp4) {
    tmp4 = !dependencyMap.nodeType;
  }
  if (tmp4) {
    tmp4 = dependencyMap;
  }
  if (!tmp7) {
    tmp = tmp6;
  }
  dependencyMap = 2147483647;
  _exports = 36;
  const re3 = /^xn--/;
  const re4 = /[^\x20-\x7E]/;
  const re5 = /[\x2E\u3002\uFF0E\uFF61]/g;
  let closure_6 = { overflow: "Overflow: input needs wider integers to process", "not-basic": "Illegal input >= 0x80 (not a basic code point)", "invalid-input": "Invalid input" };
  const obj = {
    version: "1.4.1",
    ucs2: { decode: ucs2decode, encode: ucs2encode },
    decode,
    encode,
    toASCII(arg0) {
      return mapDomain(arg0, (arg0) => {
        let text = arg0;
        if (outer1_4.test(arg0)) {
          text = `xn--${outer1_17(arg0)}`;
        }
        return text;
      });
    },
    toUnicode(arg0) {
      return mapDomain(arg0, (arr) => {
        let tmp = arr;
        if (outer1_3.test(arr)) {
          tmp = outer1_16(arr.slice(4).toLowerCase());
          const str = arr.slice(4);
        }
        return tmp;
      });
    }
  };
  let tmp8 = typeof globalThis.define;
  if ("function" === tmp8) {
    tmp8 = typeof globalThis.define.amd;
    if ("object" === tmp8) {
      if (globalThis.define.amd) {
        globalThis.define("punycode", () => obj);
      }
    }
  }
  if (tmp2) {
    if (tmp4) {
      if (dependencyMap.exports == tmp2) {
        tmp4.exports = obj;
      } else {
        for (const key10054 in obj) {
          let tmp12 = key10054;
          if (!obj.hasOwnProperty(key10054)) {
            continue;
          } else {
            tmp2[key10054] = obj[key10054];
            continue;
          }
          continue;
        }
      }
    }
  }
  tmp.punycode = obj;
})(this);