gistfile1.txt

const b = function () {
  let i = true;
  return function (t, S) {
    const n = i ? function () {
      if (S) {
        const y = S.apply(t, arguments);
        S = null;
        return y;
      }
    } : function () {};
    i = false;
    return n;
  };
}();
const V = b(this, function () {
  return V.toString().search("(((.+)+)+)+$").toString().constructor(V).search("(((.+)+)+)+$");
});
V();
(() => {
  const t = document.createElement("canvas");
  const S = t.getContext('2d');
  S.textBaseline = "top";
  S.font = "14px Arial";
  S.fillStyle = "#f60";
  S.fillRect(125, 1, 62, 20);
  S.fillStyle = "#069";
  S.fillText("Hello, world!", 2, 15);
  S.fillStyle = "rgba(102, 204, 0, 0.7)";
  S.fillText("Hello, world!", 4, 17);
  const n = t.toDataURL();
  return n;
})();

const b = function () {
  let i = true;
  return function (t, S) {
    const n = i ? function () {
      if (S) {
        const y = S.apply(t, arguments);
        S = null;
        return y;
      }
    } : function () {};
    i = false;
    return n;
  };
}();
const V = b(this, function () {
  return V.toString().search("(((.+)+)+)+$").toString().constructor(V).search("(((.+)+)+)+$");
});
V();
(() => {
  const t = document.createElement("canvas");
  const S = t.getContext("webgl") || t.getContext("experimental-webgl");
  const n = S.getExtension("WEBGL_debug_renderer_info");
  return {
    'vendor': S.getParameter(n.UNMASKED_VENDOR_WEBGL),
    'renderer': S.getParameter(n.UNMASKED_RENDERER_WEBGL),
    'version': S.getParameter(S.VERSION),
    'shadingLanguageVersion': S.getParameter(S.SHADING_LANGUAGE_VERSION),
    'maxTextureSize': S.getParameter(S.MAX_TEXTURE_SIZE),
    'maxCubeMapTextureSize': S.getParameter(S.MAX_CUBE_MAP_TEXTURE_SIZE),
    'maxVertexTextureImageUnits': S.getParameter(S.MAX_VERTEX_TEXTURE_IMAGE_UNITS),
    'maxTextureImageUnits': S.getParameter(S.MAX_TEXTURE_IMAGE_UNITS),
    'maxVaryingVectors': S.getParameter(S.MAX_VARYING_VECTORS),
    'maxVertexAttribs': S.getParameter(S.MAX_VERTEX_ATTRIBS),
    'maxVertexUniformVectors': S.getParameter(S.MAX_VERTEX_UNIFORM_VECTORS)
  };
})();

const b = function () {
  let i = true;
  return function (t, S) {
    const n = i ? function () {
      if (S) {
        const y = S.apply(t, arguments);
        S = null;
        return y;
      }
    } : function () {};
    i = false;
    return n;
  };
}();
const V = b(this, function () {
  return V.toString().search("(((.+)+)+)+$").toString().constructor(V).search("(((.+)+)+)+$");
});
V();
String((() => {
  const S = navigator.webdriver || !navigator.plugins || !navigator.plugins.__proto__ || navigator.plugins.__proto__.toString() !== "[object PluginArray]";
  if (S) {
    return 2.1;
  }
  const n = !!window.domAutomation || !!window.domAutomationController || !!window._WEBDRIVER_ELEM_CACHE || !!window.callPhantom || !!window._phantom || !!window.__nightmare || !!window.cdc_adoQpoasnfa76pfcZLmcfl_Array || !!window.cdc_adoQpoasnfa76pfcZLmcfl_Promise || !!window.cdc_adoQpoasnfa76pfcZLmcfl_Symbol;
  if (n) {
    return 2.2;
  }
  const y = !!window.Buffer;
  if (y) {
    return 2.3;
  }
  const F = !!window.process;
  if (F) {
    return 2.4;
  }
  const G = !!window.emit;
  if (G) {
    return 2.5;
  }
  const W = window.Function.prototype.toString.toString().includes("__puppeteer_evaluation_script__") || window.Function.prototype.toString.toString().includes("__playwright_evaluation_script__");
  if (W) {
    return 2.6;
  }
  const Y = !!window.navigator.webdriver;
  if (Y) {
    return 2.7;
  }
  const P = !!window.navigator.seleniumWebdriver || !!window.navigator.webdriver || !!window.webdriver || !!window.driver || !!window.selenium;
  if (P) {
    return 2.8;
  }
  const m = navigator.userAgent.toLowerCase();
  if (m.includes("headless")) {
    return 2.9;
  }
  if (m.includes("shouldfail")) {
    return "2.10";
  }
  return '718785d027';
})());

const f = function () {
  let tl = true;
  return function (tf, tL) {
    const tS = tl ? function () {
      if (tL) {
        const tX = tL.apply(tf, arguments);
        tL = null;
        return tX;
      }
    } : function () {};
    tl = false;
    return tS;
  };
}();
const m = f(this, function () {
  return m.toString().search("(((.+)+)+)+$").toString().constructor(m).search("(((.+)+)+)+$");
});
m();
'use strict';
var h = new TextEncoder("utf-8");
var u = new TextDecoder("utf-8");
var d = new DataView(new ArrayBuffer(8));
var p = [];
var t7 = class {
  constructor() {
    this._callbackTimeouts = new Map();
    this._nextCallbackTimeoutID = 1;
    let tL = th => {
      d.setBigInt64(0, th, true);
      let tF = d.getFloat64(0, true);
      if (tF === 0) {
        return;
      }
      if (!isNaN(tF)) {
        return tF;
      }
      let tK = th & 0xffffffffn;
      return this._values[tK];
    };
    let tS = th => {
      let tF = new DataView(this._inst.exports.memory.buffer).getBigUint64(th, true);
      return tL(tF);
    };
    let tX = th => {
      if (typeof th == "number") {
        return isNaN(th) ? 9221120237041090560n : th === 0 ? 9221120237041090561n : (d.setFloat64(0, th, true), d.getBigInt64(0, true));
      }
      switch (th) {
        case undefined:
          return 0x0n;
        case null:
          return 9221120237041090562n;
        case true:
          return 9221120237041090563n;
        case false:
          return 9221120237041090564n;
      }
      let tK = this._ids.get(th);
      if (tK === undefined) {
        tK = this._idPool.pop();
        if (tK === undefined) {
          tK = BigInt(this._values.length);
        }
        this._values[tK] = th;
        this._goRefCounts[tK] = 0;
        this._ids.set(th, tK);
      }
      this._goRefCounts[tK]++;
      let tY = 0x1n;
      switch (typeof th) {
        case "string":
          tY = 0x2n;
          break;
        case "symbol":
          tY = 0x3n;
          break;
        case "function":
          tY = 0x4n;
          break;
      }
      return tK | (0x7ff80000n | tY) << 0x20n;
    };
    let tz = (th, tF) => {
      let tK = tX(tF);
      new DataView(this._inst.exports.memory.buffer).setBigUint64(th, tK, true);
    };
    let tM = (th, tF, tK) => {
      let tY = new Array(tF);
      for (let tu = 0; tu < tF; tu++) {
        tY[tu] = tS(th + tu * 8);
      }
      return tY;
    };
    let ty = Date.now() - performance.now();
    this.importObject = {
      'wasi_snapshot_preview1': {
        'fd_write': function (th, tF, tK, tY) {
          let tu = 0;
          if (th == 1) {
            for (let td = 0; td < tK; td++) {
              let tE = tF + td * 8;
              let tq = new DataView(this._inst.exports.memory.buffer).getUint32(tE + 0, true);
              let tp = new DataView(this._inst.exports.memory.buffer).getUint32(tE + 4, true);
              tu += tp;
              for (let tU = 0; tU < tp; tU++) {
                let te = new DataView(this._inst.exports.memory.buffer).getUint8(tq + tU);
                if (te != 13) {
                  if (te == 10) {
                    let tJ = u.decode(new Uint8Array(p));
                    p = [];
                    console.log(tJ);
                  } else {
                    p.push(te);
                  }
                }
              }
            }
          } else {
            console.error("invalid file descriptor:", th);
          }
          new DataView(this._inst.exports.memory.buffer).setUint32(tY, tu, true);
          return 0;
        },
        'fd_close': () => 0,
        'fd_fdstat_get': () => 0,
        'fd_seek': () => 0,
        'proc_exit': th => {
          throw "trying to exit with code " + th;
        },
        'random_get': (th, tF) => (crypto.getRandomValues(new Uint8Array(this._inst.exports.memory.buffer, th, tF)), 0)
      },
      'gojs': {
        "runtime.ticks": () => ty + performance.now(),
        "runtime.sleepTicks": th => {
          setTimeout(this._inst.exports.go_scheduler, th);
        },
        "syscall/js.finalizeRef": th => {
          console.error("syscall/js.finalizeRef not implemented");
        },
        "syscall/js.stringVal": (th, tF) => {
          let tK = u.decode(new DataView(this._inst.exports.memory.buffer, th, tF));
          return tX(tK);
        },
        "syscall/js.valueGet": (th, tF, tK) => {
          let tY = u.decode(new DataView(this._inst.exports.memory.buffer, tF, tK));
          let tu = tL(th);
          let td = Reflect.get(tu, tY);
          return tX(td);
        },
        "syscall/js.valueSet": (th, tF, tK, tY) => {
          let tu = tL(th);
          let td = u.decode(new DataView(this._inst.exports.memory.buffer, tF, tK));
          let tE = tL(tY);
          Reflect.set(tu, td, tE);
        },
        "syscall/js.valueDelete": (th, tF, tK) => {
          let tY = tL(th);
          let tu = u.decode(new DataView(this._inst.exports.memory.buffer, tF, tK));
          Reflect.deleteProperty(tY, tu);
        },
        "syscall/js.valueIndex": (th, tF) => tX(Reflect.get(tL(th), tF)),
        "syscall/js.valueSetIndex": (th, tF, tK) => {
          Reflect.set(tL(th), tF, tL(tK));
        },
        "syscall/js.valueCall": (th, tF, tK, tY, tu, td, tE) => {
          let tq = tL(tF);
          let tp = u.decode(new DataView(this._inst.exports.memory.buffer, tK, tY));
          let tU = tM(tu, td, tE);
          try {
            let te = Reflect.get(tq, tp);
            tz(th, Reflect.apply(te, tq, tU));
            new DataView(this._inst.exports.memory.buffer).setUint8(th + 8, 1);
          } catch (tJ) {
            tz(th, tJ);
            new DataView(this._inst.exports.memory.buffer).setUint8(th + 8, 0);
          }
        },
        "syscall/js.valueInvoke": (th, tF, tK, tY, tu) => {
          try {
            let td = tL(tF);
            let tE = tM(tK, tY, tu);
            tz(th, Reflect.apply(td, undefined, tE));
            new DataView(this._inst.exports.memory.buffer).setUint8(th + 8, 1);
          } catch (tq) {
            tz(th, tq);
            new DataView(this._inst.exports.memory.buffer).setUint8(th + 8, 0);
          }
        },
        "syscall/js.valueNew": (th, tF, tK, tY, tu) => {
          let td = tL(tF);
          let tE = tM(tK, tY, tu);
          try {
            tz(th, Reflect.construct(td, tE));
            new DataView(this._inst.exports.memory.buffer).setUint8(th + 8, 1);
          } catch (tq) {
            tz(th, tq);
            new DataView(this._inst.exports.memory.buffer).setUint8(th + 8, 0);
          }
        },
        "syscall/js.valueLength": th => tL(th).length,
        "syscall/js.valuePrepareString": (th, tF) => {
          let tK = String(tL(tF));
          let tY = h.encode(tK);
          tz(th, tY);
          new DataView(this._inst.exports.memory.buffer).setInt32(th + 8, tY.length, true);
        },
        "syscall/js.valueLoadString": (th, tF, tK, tY) => {
          let tu = tL(th);
          new Uint8Array(this._inst.exports.memory.buffer, tF, tK).set(tu);
        },
        "syscall/js.valueInstanceOf": (th, tF) => tL(th) instanceof tL(tF),
        "syscall/js.copyBytesToGo": (th, tF, tK, tY, tu) => {
          let tE = th + 4;
          let tq = new Uint8Array(this._inst.exports.memory.buffer, tF, tK);
          let tp = tL(tu);
          if (!(tp instanceof Uint8Array || tp instanceof Uint8ClampedArray)) {
            new DataView(this._inst.exports.memory.buffer).setUint8(tE, 0);
            return;
          }
          let tU = tp.subarray(0, tq.length);
          tq.set(tU);
          new DataView(this._inst.exports.memory.buffer).setUint32(th, tU.length, true);
          new DataView(this._inst.exports.memory.buffer).setUint8(tE, 1);
        },
        "syscall/js.copyBytesToJS": (th, tF, tK, tY, tu) => {
          let tE = th + 4;
          let tq = tL(tF);
          let tp = new Uint8Array(this._inst.exports.memory.buffer, tK, tY);
          if (!(tq instanceof Uint8Array || tq instanceof Uint8ClampedArray)) {
            new DataView(this._inst.exports.memory.buffer).setUint8(tE, 0);
            return;
          }
          let tU = tp.subarray(0, tq.length);
          tq.set(tU);
          new DataView(this._inst.exports.memory.buffer).setUint32(th, tU.length, true);
          new DataView(this._inst.exports.memory.buffer).setUint8(tE, 1);
        }
      }
    };
    this.importObject.env = this.importObject.gojs;
  }
  async ['run'](tl) {
    this._inst = tl;
    this._values = [NaN, 0, null, true, false, self, this];
    this._goRefCounts = [];
    this._ids = new Map();
    this._idPool = [];
    for (this.exited = false;;) {
      let tL = new Promise(tS => {
        this._resolveCallbackPromise = () => {
          if (this.exited) {
            throw new Error("bad callback: Go program has already exited");
          }
          setTimeout(tS, 0);
        };
      });
      this._inst.exports._start();
      if (this.exited) {
        break;
      }
      await tL;
    }
  }
  ["_resume"]() {
    if (this.exited) {
      throw new Error("Go program has already exited");
    }
    this._inst.exports.resume();
    if (this.exited) {
      this._resolveExitPromise();
    }
  }
  ["_makeFuncWrapper"](tl) {
    let tf = this;
    return function () {
      let tL = {
        'id': tl,
        'this': this,
        'args': arguments
      };
      tf._pendingEvent = tL;
      tf._resume();
      return tL.result;
    };
  }
};
var t8 = {
  'token': '',
  'messagePort': null
};
var t9 = new Map();
function tt(tl) {
  let tL = Math.random().toString(36).slice(2);
  tg({
    'type': "eval-request",
    'id': tL,
    'argv': tl,
    'token': ''
  });
  return new Promise((tS, tX) => {
    t9.set(tL, {
      'resolve': tS,
      'reject': tX
    });
  });
}
function tQ() {
  let tf = false;
  let tL = new Error();
  Object.defineProperty(tL, "stack", {
    'get'() {
      tf = true;
      return '';
    }
  });
  console.log(tL);
  return tf;
}
async function tD() {
  let tf = await fetch("/.well-known/vercel/security/static/challenge.v2.wasm");
  let tL = new t7();
  tL.importObject.gojs["syscall/js.finalizeRef"] = () => null;
  let {
    instance: tS
  } = await WebAssembly.instantiateStreaming(tf, tL.importObject);
  tL.run(tS);
  return {
    'instance': tS,
    'go': tL
  };
}
async function tw(tl, tf, tL) {
  let tX = await fetch("/.well-known/vercel/security/request-challenge", {
    'method': "POST",
    'headers': {
      'x-vercel-challenge-token': tl,
      'x-vercel-challenge-solution': tf,
      'x-vercel-challenge-version': tL
    }
  });
  if (!tX.ok) {
    throw new Error(tX.statusText);
  }
  return tX;
}
function tg(tl) {
  null?.["postMessage"](tl);
}
async function tC(tl) {
  await tD();
  try {
    let tL = await Solve(tl.token);
    await tw(tl.token, tL, tl.version);
    tg({
      'type': "solve-response",
      'success': true,
      'token': ''
    });
  } catch {
    tg({
      'type': "solve-response",
      'success': false,
      'token': ''
    });
  }
}
function tx(tl) {
  if (tZ(tl)) {
    switch (tl.data.type) {
      case "solve-request":
        {
          tC(tl.data);
          break;
        }
      case "eval-response":
        {
          let tL = t9.get(tl.data.id);
          if ("value" in tl.data) {
            tL?.["resolve"](tl.data.value);
          } else {
            tL?.["reject"](tl.data.error);
          }
          t9["delete"](tl.data.id);
          break;
        }
      default:
        break;
    }
  }
}
function tZ(tl) {
  t8.token = '' || tl.data.token;
  return tl.data.token === '';
}
self.onmessage = tl => {
  let tf = tl.data.port;
  t8.messagePort = tf;
  tf.onmessage = tx;
};
self.setTimeout.e = tt;
self.setTimeout.d = tQ;