@dodopayments/convex 0.2.7 → 0.2.8

package/dist/index.cjs

@@ -417,8 +417,8 @@ function convexOrUndefinedToJson(value) {
   return convexOrUndefinedToJsonInternal(value, value, "");
 }
 
-var __defProp$3 = Object.defineProperty;
-var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defProp$4 = Object.defineProperty;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField$3 = (obj, key, value) => __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
 var _a, _b;
 const IDENTIFYING_FIELD = Symbol.for("ConvexError");
@@ -533,8 +533,8 @@ function setupActionCalls(requestId) {
   };
 }
 
-var __defProp$2 = Object.defineProperty;
-var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defProp$3 = Object.defineProperty;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField$2 = (obj, key, value) => __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
 class FilterExpression {
   /**
@@ -556,8 +556,8 @@ function validateArg(arg, idx, method, argName) {
   }
 }
 
-var __defProp$1 = Object.defineProperty;
-var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defProp$2 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
 function setupActionVectorSearch(requestId) {
   return async (tableName, indexName, query) => {
@@ -834,8 +834,8 @@ const httpActionGeneric = (func) => {
   return q;
 };
 
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 class InstalledComponent {
   constructor(definition, name) {
@@ -5308,857 +5308,824 @@ var WebhookPayloadSchema = discriminatedUnionType("type", [
   LicenseKeyCreatedPayloadSchema
 ]);
 
-var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
-var dist = {};
-
-var timing_safe_equal = {};
-
-Object.defineProperty(timing_safe_equal, "__esModule", { value: true });
-timing_safe_equal.timingSafeEqual = void 0;
+// src/webhook/vendor/timing_safe_equal.ts
 function assert(expr, msg = "") {
-    if (!expr) {
-        throw new Error(msg);
-    }
+  if (!expr) {
+    throw new Error(msg);
+  }
 }
 function timingSafeEqual(a, b) {
-    if (a.byteLength !== b.byteLength) {
-        return false;
-    }
-    if (!(a instanceof DataView)) {
-        a = new DataView(ArrayBuffer.isView(a) ? a.buffer : a);
-    }
-    if (!(b instanceof DataView)) {
-        b = new DataView(ArrayBuffer.isView(b) ? b.buffer : b);
-    }
-    assert(a instanceof DataView);
-    assert(b instanceof DataView);
-    const length = a.byteLength;
-    let out = 0;
-    let i = -1;
-    while (++i < length) {
-        out |= a.getUint8(i) ^ b.getUint8(i);
-    }
-    return out === 0;
+  if (a.byteLength !== b.byteLength) {
+    return false;
+  }
+  if (!(a instanceof DataView)) {
+    a = new DataView(ArrayBuffer.isView(a) ? a.buffer : a);
+  }
+  if (!(b instanceof DataView)) {
+    b = new DataView(ArrayBuffer.isView(b) ? b.buffer : b);
+  }
+  assert(a instanceof DataView);
+  assert(b instanceof DataView);
+  const length = a.byteLength;
+  let out = 0;
+  let i = -1;
+  while (++i < length) {
+    out |= a.getUint8(i) ^ b.getUint8(i);
+  }
+  return out === 0;
 }
-timing_safe_equal.timingSafeEqual = timingSafeEqual;
 
-var base64$1 = {};
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  __defProp(target, "default", { value: mod, enumerable: true }) ,
+  mod
+));
 
-// Copyright (C) 2016 Dmitry Chestnykh
-// MIT License. See LICENSE file for details.
-var __extends = (commonjsGlobal && commonjsGlobal.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+// ../../node_modules/@stablelib/base64/lib/base64.js
+var require_base64 = __commonJS({
+  "../../node_modules/@stablelib/base64/lib/base64.js"(exports) {
+    var __extends = exports && exports.__extends || /* @__PURE__ */ function() {
+      var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+          d2.__proto__ = b2;
+        } || function(d2, b2) {
+          for (var p in b2) if (b2.hasOwnProperty(p)) d2[p] = b2[p];
+        };
         return extendStatics(d, b);
-    };
-    return function (d, b) {
+      };
+      return function(d, b) {
         extendStatics(d, b);
-        function __() { this.constructor = d; }
+        function __() {
+          this.constructor = d;
+        }
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-Object.defineProperty(base64$1, "__esModule", { value: true });
-/**
- * Package base64 implements Base64 encoding and decoding.
- */
-// Invalid character used in decoding to indicate
-// that the character to decode is out of range of
-// alphabet and cannot be decoded.
-var INVALID_BYTE = 256;
-/**
- * Implements standard Base64 encoding.
- *
- * Operates in constant time.
- */
-var Coder = /** @class */ (function () {
-    // TODO(dchest): methods to encode chunk-by-chunk.
-    function Coder(_paddingCharacter) {
-        if (_paddingCharacter === void 0) { _paddingCharacter = "="; }
-        this._paddingCharacter = _paddingCharacter;
-    }
-    Coder.prototype.encodedLength = function (length) {
-        if (!this._paddingCharacter) {
+      };
+    }();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var INVALID_BYTE = 256;
+    var Coder = (
+      /** @class */
+      function() {
+        function Coder2(_paddingCharacter) {
+          if (_paddingCharacter === void 0) {
+            _paddingCharacter = "=";
+          }
+          this._paddingCharacter = _paddingCharacter;
+        }
+        Coder2.prototype.encodedLength = function(length) {
+          if (!this._paddingCharacter) {
             return (length * 8 + 5) / 6 | 0;
-        }
-        return (length + 2) / 3 * 4 | 0;
-    };
-    Coder.prototype.encode = function (data) {
-        var out = "";
-        var i = 0;
-        for (; i < data.length - 2; i += 3) {
-            var c = (data[i] << 16) | (data[i + 1] << 8) | (data[i + 2]);
-            out += this._encodeByte((c >>> 3 * 6) & 63);
-            out += this._encodeByte((c >>> 2 * 6) & 63);
-            out += this._encodeByte((c >>> 1 * 6) & 63);
-            out += this._encodeByte((c >>> 0 * 6) & 63);
-        }
-        var left = data.length - i;
-        if (left > 0) {
-            var c = (data[i] << 16) | (left === 2 ? data[i + 1] << 8 : 0);
-            out += this._encodeByte((c >>> 3 * 6) & 63);
-            out += this._encodeByte((c >>> 2 * 6) & 63);
+          }
+          return (length + 2) / 3 * 4 | 0;
+        };
+        Coder2.prototype.encode = function(data) {
+          var out = "";
+          var i = 0;
+          for (; i < data.length - 2; i += 3) {
+            var c = data[i] << 16 | data[i + 1] << 8 | data[i + 2];
+            out += this._encodeByte(c >>> 3 * 6 & 63);
+            out += this._encodeByte(c >>> 2 * 6 & 63);
+            out += this._encodeByte(c >>> 1 * 6 & 63);
+            out += this._encodeByte(c >>> 0 * 6 & 63);
+          }
+          var left = data.length - i;
+          if (left > 0) {
+            var c = data[i] << 16 | (left === 2 ? data[i + 1] << 8 : 0);
+            out += this._encodeByte(c >>> 3 * 6 & 63);
+            out += this._encodeByte(c >>> 2 * 6 & 63);
             if (left === 2) {
-                out += this._encodeByte((c >>> 1 * 6) & 63);
-            }
-            else {
-                out += this._paddingCharacter || "";
+              out += this._encodeByte(c >>> 1 * 6 & 63);
+            } else {
+              out += this._paddingCharacter || "";
             }
             out += this._paddingCharacter || "";
-        }
-        return out;
-    };
-    Coder.prototype.maxDecodedLength = function (length) {
-        if (!this._paddingCharacter) {
+          }
+          return out;
+        };
+        Coder2.prototype.maxDecodedLength = function(length) {
+          if (!this._paddingCharacter) {
             return (length * 6 + 7) / 8 | 0;
-        }
-        return length / 4 * 3 | 0;
-    };
-    Coder.prototype.decodedLength = function (s) {
-        return this.maxDecodedLength(s.length - this._getPaddingLength(s));
-    };
-    Coder.prototype.decode = function (s) {
-        if (s.length === 0) {
+          }
+          return length / 4 * 3 | 0;
+        };
+        Coder2.prototype.decodedLength = function(s) {
+          return this.maxDecodedLength(s.length - this._getPaddingLength(s));
+        };
+        Coder2.prototype.decode = function(s) {
+          if (s.length === 0) {
             return new Uint8Array(0);
-        }
-        var paddingLength = this._getPaddingLength(s);
-        var length = s.length - paddingLength;
-        var out = new Uint8Array(this.maxDecodedLength(length));
-        var op = 0;
-        var i = 0;
-        var haveBad = 0;
-        var v0 = 0, v1 = 0, v2 = 0, v3 = 0;
-        for (; i < length - 4; i += 4) {
+          }
+          var paddingLength = this._getPaddingLength(s);
+          var length = s.length - paddingLength;
+          var out = new Uint8Array(this.maxDecodedLength(length));
+          var op = 0;
+          var i = 0;
+          var haveBad = 0;
+          var v0 = 0, v1 = 0, v2 = 0, v3 = 0;
+          for (; i < length - 4; i += 4) {
             v0 = this._decodeChar(s.charCodeAt(i + 0));
             v1 = this._decodeChar(s.charCodeAt(i + 1));
             v2 = this._decodeChar(s.charCodeAt(i + 2));
             v3 = this._decodeChar(s.charCodeAt(i + 3));
-            out[op++] = (v0 << 2) | (v1 >>> 4);
-            out[op++] = (v1 << 4) | (v2 >>> 2);
-            out[op++] = (v2 << 6) | v3;
+            out[op++] = v0 << 2 | v1 >>> 4;
+            out[op++] = v1 << 4 | v2 >>> 2;
+            out[op++] = v2 << 6 | v3;
             haveBad |= v0 & INVALID_BYTE;
             haveBad |= v1 & INVALID_BYTE;
             haveBad |= v2 & INVALID_BYTE;
             haveBad |= v3 & INVALID_BYTE;
-        }
-        if (i < length - 1) {
+          }
+          if (i < length - 1) {
             v0 = this._decodeChar(s.charCodeAt(i));
             v1 = this._decodeChar(s.charCodeAt(i + 1));
-            out[op++] = (v0 << 2) | (v1 >>> 4);
+            out[op++] = v0 << 2 | v1 >>> 4;
             haveBad |= v0 & INVALID_BYTE;
             haveBad |= v1 & INVALID_BYTE;
-        }
-        if (i < length - 2) {
+          }
+          if (i < length - 2) {
             v2 = this._decodeChar(s.charCodeAt(i + 2));
-            out[op++] = (v1 << 4) | (v2 >>> 2);
+            out[op++] = v1 << 4 | v2 >>> 2;
             haveBad |= v2 & INVALID_BYTE;
-        }
-        if (i < length - 3) {
+          }
+          if (i < length - 3) {
             v3 = this._decodeChar(s.charCodeAt(i + 3));
-            out[op++] = (v2 << 6) | v3;
+            out[op++] = v2 << 6 | v3;
             haveBad |= v3 & INVALID_BYTE;
-        }
-        if (haveBad !== 0) {
+          }
+          if (haveBad !== 0) {
             throw new Error("Base64Coder: incorrect characters for decoding");
-        }
-        return out;
-    };
-    // Standard encoding have the following encoded/decoded ranges,
-    // which we need to convert between.
-    //
-    // ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 0123456789  +   /
-    // Index:   0 - 25                    26 - 51              52 - 61   62  63
-    // ASCII:  65 - 90                    97 - 122             48 - 57   43  47
-    //
-    // Encode 6 bits in b into a new character.
-    Coder.prototype._encodeByte = function (b) {
-        // Encoding uses constant time operations as follows:
-        //
-        // 1. Define comparison of A with B using (A - B) >>> 8:
-        //          if A > B, then result is positive integer
-        //          if A <= B, then result is 0
-        //
-        // 2. Define selection of C or 0 using bitwise AND: X & C:
-        //          if X == 0, then result is 0
-        //          if X != 0, then result is C
-        //
-        // 3. Start with the smallest comparison (b >= 0), which is always
-        //    true, so set the result to the starting ASCII value (65).
-        //
-        // 4. Continue comparing b to higher ASCII values, and selecting
-        //    zero if comparison isn't true, otherwise selecting a value
-        //    to add to result, which:
-        //
-        //          a) undoes the previous addition
-        //          b) provides new value to add
-        //
-        var result = b;
-        // b >= 0
-        result += 65;
-        // b > 25
-        result += ((25 - b) >>> 8) & ((0 - 65) - 26 + 97);
-        // b > 51
-        result += ((51 - b) >>> 8) & ((26 - 97) - 52 + 48);
-        // b > 61
-        result += ((61 - b) >>> 8) & ((52 - 48) - 62 + 43);
-        // b > 62
-        result += ((62 - b) >>> 8) & ((62 - 43) - 63 + 47);
-        return String.fromCharCode(result);
-    };
-    // Decode a character code into a byte.
-    // Must return 256 if character is out of alphabet range.
-    Coder.prototype._decodeChar = function (c) {
-        // Decoding works similar to encoding: using the same comparison
-        // function, but now it works on ranges: result is always incremented
-        // by value, but this value becomes zero if the range is not
-        // satisfied.
-        //
-        // Decoding starts with invalid value, 256, which is then
-        // subtracted when the range is satisfied. If none of the ranges
-        // apply, the function returns 256, which is then checked by
-        // the caller to throw error.
-        var result = INVALID_BYTE; // start with invalid character
-        // c == 43 (c > 42 and c < 44)
-        result += (((42 - c) & (c - 44)) >>> 8) & (-INVALID_BYTE + c - 43 + 62);
-        // c == 47 (c > 46 and c < 48)
-        result += (((46 - c) & (c - 48)) >>> 8) & (-INVALID_BYTE + c - 47 + 63);
-        // c > 47 and c < 58
-        result += (((47 - c) & (c - 58)) >>> 8) & (-INVALID_BYTE + c - 48 + 52);
-        // c > 64 and c < 91
-        result += (((64 - c) & (c - 91)) >>> 8) & (-INVALID_BYTE + c - 65 + 0);
-        // c > 96 and c < 123
-        result += (((96 - c) & (c - 123)) >>> 8) & (-INVALID_BYTE + c - 97 + 26);
-        return result;
-    };
-    Coder.prototype._getPaddingLength = function (s) {
-        var paddingLength = 0;
-        if (this._paddingCharacter) {
+          }
+          return out;
+        };
+        Coder2.prototype._encodeByte = function(b) {
+          var result = b;
+          result += 65;
+          result += 25 - b >>> 8 & 0 - 65 - 26 + 97;
+          result += 51 - b >>> 8 & 26 - 97 - 52 + 48;
+          result += 61 - b >>> 8 & 52 - 48 - 62 + 43;
+          result += 62 - b >>> 8 & 62 - 43 - 63 + 47;
+          return String.fromCharCode(result);
+        };
+        Coder2.prototype._decodeChar = function(c) {
+          var result = INVALID_BYTE;
+          result += (42 - c & c - 44) >>> 8 & -INVALID_BYTE + c - 43 + 62;
+          result += (46 - c & c - 48) >>> 8 & -INVALID_BYTE + c - 47 + 63;
+          result += (47 - c & c - 58) >>> 8 & -INVALID_BYTE + c - 48 + 52;
+          result += (64 - c & c - 91) >>> 8 & -INVALID_BYTE + c - 65 + 0;
+          result += (96 - c & c - 123) >>> 8 & -INVALID_BYTE + c - 97 + 26;
+          return result;
+        };
+        Coder2.prototype._getPaddingLength = function(s) {
+          var paddingLength = 0;
+          if (this._paddingCharacter) {
             for (var i = s.length - 1; i >= 0; i--) {
-                if (s[i] !== this._paddingCharacter) {
-                    break;
-                }
-                paddingLength++;
+              if (s[i] !== this._paddingCharacter) {
+                break;
+              }
+              paddingLength++;
             }
             if (s.length < 4 || paddingLength > 2) {
-                throw new Error("Base64Coder: incorrect padding");
+              throw new Error("Base64Coder: incorrect padding");
             }
-        }
-        return paddingLength;
+          }
+          return paddingLength;
+        };
+        return Coder2;
+      }()
+    );
+    exports.Coder = Coder;
+    var stdCoder = new Coder();
+    function encode2(data) {
+      return stdCoder.encode(data);
+    }
+    exports.encode = encode2;
+    function decode2(s) {
+      return stdCoder.decode(s);
+    }
+    exports.decode = decode2;
+    var URLSafeCoder = (
+      /** @class */
+      function(_super) {
+        __extends(URLSafeCoder2, _super);
+        function URLSafeCoder2() {
+          return _super !== null && _super.apply(this, arguments) || this;
+        }
+        URLSafeCoder2.prototype._encodeByte = function(b) {
+          var result = b;
+          result += 65;
+          result += 25 - b >>> 8 & 0 - 65 - 26 + 97;
+          result += 51 - b >>> 8 & 26 - 97 - 52 + 48;
+          result += 61 - b >>> 8 & 52 - 48 - 62 + 45;
+          result += 62 - b >>> 8 & 62 - 45 - 63 + 95;
+          return String.fromCharCode(result);
+        };
+        URLSafeCoder2.prototype._decodeChar = function(c) {
+          var result = INVALID_BYTE;
+          result += (44 - c & c - 46) >>> 8 & -INVALID_BYTE + c - 45 + 62;
+          result += (94 - c & c - 96) >>> 8 & -INVALID_BYTE + c - 95 + 63;
+          result += (47 - c & c - 58) >>> 8 & -INVALID_BYTE + c - 48 + 52;
+          result += (64 - c & c - 91) >>> 8 & -INVALID_BYTE + c - 65 + 0;
+          result += (96 - c & c - 123) >>> 8 & -INVALID_BYTE + c - 97 + 26;
+          return result;
+        };
+        return URLSafeCoder2;
+      }(Coder)
+    );
+    exports.URLSafeCoder = URLSafeCoder;
+    var urlSafeCoder = new URLSafeCoder();
+    function encodeURLSafe(data) {
+      return urlSafeCoder.encode(data);
+    }
+    exports.encodeURLSafe = encodeURLSafe;
+    function decodeURLSafe(s) {
+      return urlSafeCoder.decode(s);
+    }
+    exports.decodeURLSafe = decodeURLSafe;
+    exports.encodedLength = function(length) {
+      return stdCoder.encodedLength(length);
     };
-    return Coder;
-}());
-base64$1.Coder = Coder;
-var stdCoder = new Coder();
-function encode(data) {
-    return stdCoder.encode(data);
-}
-base64$1.encode = encode;
-function decode(s) {
-    return stdCoder.decode(s);
-}
-base64$1.decode = decode;
-/**
- * Implements URL-safe Base64 encoding.
- * (Same as Base64, but '+' is replaced with '-', and '/' with '_').
- *
- * Operates in constant time.
- */
-var URLSafeCoder = /** @class */ (function (_super) {
-    __extends(URLSafeCoder, _super);
-    function URLSafeCoder() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    // URL-safe encoding have the following encoded/decoded ranges:
-    //
-    // ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz 0123456789  -   _
-    // Index:   0 - 25                    26 - 51              52 - 61   62  63
-    // ASCII:  65 - 90                    97 - 122             48 - 57   45  95
-    //
-    URLSafeCoder.prototype._encodeByte = function (b) {
-        var result = b;
-        // b >= 0
-        result += 65;
-        // b > 25
-        result += ((25 - b) >>> 8) & ((0 - 65) - 26 + 97);
-        // b > 51
-        result += ((51 - b) >>> 8) & ((26 - 97) - 52 + 48);
-        // b > 61
-        result += ((61 - b) >>> 8) & ((52 - 48) - 62 + 45);
-        // b > 62
-        result += ((62 - b) >>> 8) & ((62 - 45) - 63 + 95);
-        return String.fromCharCode(result);
+    exports.maxDecodedLength = function(length) {
+      return stdCoder.maxDecodedLength(length);
     };
-    URLSafeCoder.prototype._decodeChar = function (c) {
-        var result = INVALID_BYTE;
-        // c == 45 (c > 44 and c < 46)
-        result += (((44 - c) & (c - 46)) >>> 8) & (-INVALID_BYTE + c - 45 + 62);
-        // c == 95 (c > 94 and c < 96)
-        result += (((94 - c) & (c - 96)) >>> 8) & (-INVALID_BYTE + c - 95 + 63);
-        // c > 47 and c < 58
-        result += (((47 - c) & (c - 58)) >>> 8) & (-INVALID_BYTE + c - 48 + 52);
-        // c > 64 and c < 91
-        result += (((64 - c) & (c - 91)) >>> 8) & (-INVALID_BYTE + c - 65 + 0);
-        // c > 96 and c < 123
-        result += (((96 - c) & (c - 123)) >>> 8) & (-INVALID_BYTE + c - 97 + 26);
-        return result;
+    exports.decodedLength = function(s) {
+      return stdCoder.decodedLength(s);
     };
-    return URLSafeCoder;
-}(Coder));
-base64$1.URLSafeCoder = URLSafeCoder;
-var urlSafeCoder = new URLSafeCoder();
-function encodeURLSafe(data) {
-    return urlSafeCoder.encode(data);
-}
-base64$1.encodeURLSafe = encodeURLSafe;
-function decodeURLSafe(s) {
-    return urlSafeCoder.decode(s);
-}
-base64$1.decodeURLSafe = decodeURLSafe;
-base64$1.encodedLength = function (length) {
-    return stdCoder.encodedLength(length);
-};
-base64$1.maxDecodedLength = function (length) {
-    return stdCoder.maxDecodedLength(length);
-};
-base64$1.decodedLength = function (s) {
-    return stdCoder.decodedLength(s);
-};
-
-var sha256$1 = {exports: {}};
-
-(function (module) {
-	(function (root, factory) {
-	    // Hack to make all exports of this module sha256 function object properties.
-	    var exports = {};
-	    factory(exports);
-	    var sha256 = exports["default"];
-	    for (var k in exports) {
-	        sha256[k] = exports[k];
-	    }
-	        
-	    {
-	        module.exports = sha256;
-	    }
-	})(commonjsGlobal, function(exports) {
-	exports.__esModule = true;
-	// SHA-256 (+ HMAC and PBKDF2) for JavaScript.
-	//
-	// Written in 2014-2016 by Dmitry Chestnykh.
-	// Public domain, no warranty.
-	//
-	// Functions (accept and return Uint8Arrays):
-	//
-	//   sha256(message) -> hash
-	//   sha256.hmac(key, message) -> mac
-	//   sha256.pbkdf2(password, salt, rounds, dkLen) -> dk
-	//
-	//  Classes:
-	//
-	//   new sha256.Hash()
-	//   new sha256.HMAC(key)
-	//
-	exports.digestLength = 32;
-	exports.blockSize = 64;
-	// SHA-256 constants
-	var K = new Uint32Array([
-	    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b,
-	    0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01,
-	    0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7,
-	    0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
-	    0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152,
-	    0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,
-	    0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc,
-	    0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
-	    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819,
-	    0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08,
-	    0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f,
-	    0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
-	    0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
-	]);
-	function hashBlocks(w, v, p, pos, len) {
-	    var a, b, c, d, e, f, g, h, u, i, j, t1, t2;
-	    while (len >= 64) {
-	        a = v[0];
-	        b = v[1];
-	        c = v[2];
-	        d = v[3];
-	        e = v[4];
-	        f = v[5];
-	        g = v[6];
-	        h = v[7];
-	        for (i = 0; i < 16; i++) {
-	            j = pos + i * 4;
-	            w[i] = (((p[j] & 0xff) << 24) | ((p[j + 1] & 0xff) << 16) |
-	                ((p[j + 2] & 0xff) << 8) | (p[j + 3] & 0xff));
-	        }
-	        for (i = 16; i < 64; i++) {
-	            u = w[i - 2];
-	            t1 = (u >>> 17 | u << (32 - 17)) ^ (u >>> 19 | u << (32 - 19)) ^ (u >>> 10);
-	            u = w[i - 15];
-	            t2 = (u >>> 7 | u << (32 - 7)) ^ (u >>> 18 | u << (32 - 18)) ^ (u >>> 3);
-	            w[i] = (t1 + w[i - 7] | 0) + (t2 + w[i - 16] | 0);
-	        }
-	        for (i = 0; i < 64; i++) {
-	            t1 = (((((e >>> 6 | e << (32 - 6)) ^ (e >>> 11 | e << (32 - 11)) ^
-	                (e >>> 25 | e << (32 - 25))) + ((e & f) ^ (~e & g))) | 0) +
-	                ((h + ((K[i] + w[i]) | 0)) | 0)) | 0;
-	            t2 = (((a >>> 2 | a << (32 - 2)) ^ (a >>> 13 | a << (32 - 13)) ^
-	                (a >>> 22 | a << (32 - 22))) + ((a & b) ^ (a & c) ^ (b & c))) | 0;
-	            h = g;
-	            g = f;
-	            f = e;
-	            e = (d + t1) | 0;
-	            d = c;
-	            c = b;
-	            b = a;
-	            a = (t1 + t2) | 0;
-	        }
-	        v[0] += a;
-	        v[1] += b;
-	        v[2] += c;
-	        v[3] += d;
-	        v[4] += e;
-	        v[5] += f;
-	        v[6] += g;
-	        v[7] += h;
-	        pos += 64;
-	        len -= 64;
-	    }
-	    return pos;
-	}
-	// Hash implements SHA256 hash algorithm.
-	var Hash = /** @class */ (function () {
-	    function Hash() {
-	        this.digestLength = exports.digestLength;
-	        this.blockSize = exports.blockSize;
-	        // Note: Int32Array is used instead of Uint32Array for performance reasons.
-	        this.state = new Int32Array(8); // hash state
-	        this.temp = new Int32Array(64); // temporary state
-	        this.buffer = new Uint8Array(128); // buffer for data to hash
-	        this.bufferLength = 0; // number of bytes in buffer
-	        this.bytesHashed = 0; // number of total bytes hashed
-	        this.finished = false; // indicates whether the hash was finalized
-	        this.reset();
-	    }
-	    // Resets hash state making it possible
-	    // to re-use this instance to hash other data.
-	    Hash.prototype.reset = function () {
-	        this.state[0] = 0x6a09e667;
-	        this.state[1] = 0xbb67ae85;
-	        this.state[2] = 0x3c6ef372;
-	        this.state[3] = 0xa54ff53a;
-	        this.state[4] = 0x510e527f;
-	        this.state[5] = 0x9b05688c;
-	        this.state[6] = 0x1f83d9ab;
-	        this.state[7] = 0x5be0cd19;
-	        this.bufferLength = 0;
-	        this.bytesHashed = 0;
-	        this.finished = false;
-	        return this;
-	    };
-	    // Cleans internal buffers and re-initializes hash state.
-	    Hash.prototype.clean = function () {
-	        for (var i = 0; i < this.buffer.length; i++) {
-	            this.buffer[i] = 0;
-	        }
-	        for (var i = 0; i < this.temp.length; i++) {
-	            this.temp[i] = 0;
-	        }
-	        this.reset();
-	    };
-	    // Updates hash state with the given data.
-	    //
-	    // Optionally, length of the data can be specified to hash
-	    // fewer bytes than data.length.
-	    //
-	    // Throws error when trying to update already finalized hash:
-	    // instance must be reset to use it again.
-	    Hash.prototype.update = function (data, dataLength) {
-	        if (dataLength === void 0) { dataLength = data.length; }
-	        if (this.finished) {
-	            throw new Error("SHA256: can't update because hash was finished.");
-	        }
-	        var dataPos = 0;
-	        this.bytesHashed += dataLength;
-	        if (this.bufferLength > 0) {
-	            while (this.bufferLength < 64 && dataLength > 0) {
-	                this.buffer[this.bufferLength++] = data[dataPos++];
-	                dataLength--;
-	            }
-	            if (this.bufferLength === 64) {
-	                hashBlocks(this.temp, this.state, this.buffer, 0, 64);
-	                this.bufferLength = 0;
-	            }
-	        }
-	        if (dataLength >= 64) {
-	            dataPos = hashBlocks(this.temp, this.state, data, dataPos, dataLength);
-	            dataLength %= 64;
-	        }
-	        while (dataLength > 0) {
-	            this.buffer[this.bufferLength++] = data[dataPos++];
-	            dataLength--;
-	        }
-	        return this;
-	    };
-	    // Finalizes hash state and puts hash into out.
-	    //
-	    // If hash was already finalized, puts the same value.
-	    Hash.prototype.finish = function (out) {
-	        if (!this.finished) {
-	            var bytesHashed = this.bytesHashed;
-	            var left = this.bufferLength;
-	            var bitLenHi = (bytesHashed / 0x20000000) | 0;
-	            var bitLenLo = bytesHashed << 3;
-	            var padLength = (bytesHashed % 64 < 56) ? 64 : 128;
-	            this.buffer[left] = 0x80;
-	            for (var i = left + 1; i < padLength - 8; i++) {
-	                this.buffer[i] = 0;
-	            }
-	            this.buffer[padLength - 8] = (bitLenHi >>> 24) & 0xff;
-	            this.buffer[padLength - 7] = (bitLenHi >>> 16) & 0xff;
-	            this.buffer[padLength - 6] = (bitLenHi >>> 8) & 0xff;
-	            this.buffer[padLength - 5] = (bitLenHi >>> 0) & 0xff;
-	            this.buffer[padLength - 4] = (bitLenLo >>> 24) & 0xff;
-	            this.buffer[padLength - 3] = (bitLenLo >>> 16) & 0xff;
-	            this.buffer[padLength - 2] = (bitLenLo >>> 8) & 0xff;
-	            this.buffer[padLength - 1] = (bitLenLo >>> 0) & 0xff;
-	            hashBlocks(this.temp, this.state, this.buffer, 0, padLength);
-	            this.finished = true;
-	        }
-	        for (var i = 0; i < 8; i++) {
-	            out[i * 4 + 0] = (this.state[i] >>> 24) & 0xff;
-	            out[i * 4 + 1] = (this.state[i] >>> 16) & 0xff;
-	            out[i * 4 + 2] = (this.state[i] >>> 8) & 0xff;
-	            out[i * 4 + 3] = (this.state[i] >>> 0) & 0xff;
-	        }
-	        return this;
-	    };
-	    // Returns the final hash digest.
-	    Hash.prototype.digest = function () {
-	        var out = new Uint8Array(this.digestLength);
-	        this.finish(out);
-	        return out;
-	    };
-	    // Internal function for use in HMAC for optimization.
-	    Hash.prototype._saveState = function (out) {
-	        for (var i = 0; i < this.state.length; i++) {
-	            out[i] = this.state[i];
-	        }
-	    };
-	    // Internal function for use in HMAC for optimization.
-	    Hash.prototype._restoreState = function (from, bytesHashed) {
-	        for (var i = 0; i < this.state.length; i++) {
-	            this.state[i] = from[i];
-	        }
-	        this.bytesHashed = bytesHashed;
-	        this.finished = false;
-	        this.bufferLength = 0;
-	    };
-	    return Hash;
-	}());
-	exports.Hash = Hash;
-	// HMAC implements HMAC-SHA256 message authentication algorithm.
-	var HMAC = /** @class */ (function () {
-	    function HMAC(key) {
-	        this.inner = new Hash();
-	        this.outer = new Hash();
-	        this.blockSize = this.inner.blockSize;
-	        this.digestLength = this.inner.digestLength;
-	        var pad = new Uint8Array(this.blockSize);
-	        if (key.length > this.blockSize) {
-	            (new Hash()).update(key).finish(pad).clean();
-	        }
-	        else {
-	            for (var i = 0; i < key.length; i++) {
-	                pad[i] = key[i];
-	            }
-	        }
-	        for (var i = 0; i < pad.length; i++) {
-	            pad[i] ^= 0x36;
-	        }
-	        this.inner.update(pad);
-	        for (var i = 0; i < pad.length; i++) {
-	            pad[i] ^= 0x36 ^ 0x5c;
-	        }
-	        this.outer.update(pad);
-	        this.istate = new Uint32Array(8);
-	        this.ostate = new Uint32Array(8);
-	        this.inner._saveState(this.istate);
-	        this.outer._saveState(this.ostate);
-	        for (var i = 0; i < pad.length; i++) {
-	            pad[i] = 0;
-	        }
-	    }
-	    // Returns HMAC state to the state initialized with key
-	    // to make it possible to run HMAC over the other data with the same
-	    // key without creating a new instance.
-	    HMAC.prototype.reset = function () {
-	        this.inner._restoreState(this.istate, this.inner.blockSize);
-	        this.outer._restoreState(this.ostate, this.outer.blockSize);
-	        return this;
-	    };
-	    // Cleans HMAC state.
-	    HMAC.prototype.clean = function () {
-	        for (var i = 0; i < this.istate.length; i++) {
-	            this.ostate[i] = this.istate[i] = 0;
-	        }
-	        this.inner.clean();
-	        this.outer.clean();
-	    };
-	    // Updates state with provided data.
-	    HMAC.prototype.update = function (data) {
-	        this.inner.update(data);
-	        return this;
-	    };
-	    // Finalizes HMAC and puts the result in out.
-	    HMAC.prototype.finish = function (out) {
-	        if (this.outer.finished) {
-	            this.outer.finish(out);
-	        }
-	        else {
-	            this.inner.finish(out);
-	            this.outer.update(out, this.digestLength).finish(out);
-	        }
-	        return this;
-	    };
-	    // Returns message authentication code.
-	    HMAC.prototype.digest = function () {
-	        var out = new Uint8Array(this.digestLength);
-	        this.finish(out);
-	        return out;
-	    };
-	    return HMAC;
-	}());
-	exports.HMAC = HMAC;
-	// Returns SHA256 hash of data.
-	function hash(data) {
-	    var h = (new Hash()).update(data);
-	    var digest = h.digest();
-	    h.clean();
-	    return digest;
-	}
-	exports.hash = hash;
-	// Function hash is both available as module.hash and as default export.
-	exports["default"] = hash;
-	// Returns HMAC-SHA256 of data under the key.
-	function hmac(key, data) {
-	    var h = (new HMAC(key)).update(data);
-	    var digest = h.digest();
-	    h.clean();
-	    return digest;
-	}
-	exports.hmac = hmac;
-	// Fills hkdf buffer like this:
-	// T(1) = HMAC-Hash(PRK, T(0) | info | 0x01)
-	function fillBuffer(buffer, hmac, info, counter) {
-	    // Counter is a byte value: check if it overflowed.
-	    var num = counter[0];
-	    if (num === 0) {
-	        throw new Error("hkdf: cannot expand more");
-	    }
-	    // Prepare HMAC instance for new data with old key.
-	    hmac.reset();
-	    // Hash in previous output if it was generated
-	    // (i.e. counter is greater than 1).
-	    if (num > 1) {
-	        hmac.update(buffer);
-	    }
-	    // Hash in info if it exists.
-	    if (info) {
-	        hmac.update(info);
-	    }
-	    // Hash in the counter.
-	    hmac.update(counter);
-	    // Output result to buffer and clean HMAC instance.
-	    hmac.finish(buffer);
-	    // Increment counter inside typed array, this works properly.
-	    counter[0]++;
-	}
-	var hkdfSalt = new Uint8Array(exports.digestLength); // Filled with zeroes.
-	function hkdf(key, salt, info, length) {
-	    if (salt === void 0) { salt = hkdfSalt; }
-	    if (length === void 0) { length = 32; }
-	    var counter = new Uint8Array([1]);
-	    // HKDF-Extract uses salt as HMAC key, and key as data.
-	    var okm = hmac(salt, key);
-	    // Initialize HMAC for expanding with extracted key.
-	    // Ensure no collisions with `hmac` function.
-	    var hmac_ = new HMAC(okm);
-	    // Allocate buffer.
-	    var buffer = new Uint8Array(hmac_.digestLength);
-	    var bufpos = buffer.length;
-	    var out = new Uint8Array(length);
-	    for (var i = 0; i < length; i++) {
-	        if (bufpos === buffer.length) {
-	            fillBuffer(buffer, hmac_, info, counter);
-	            bufpos = 0;
-	        }
-	        out[i] = buffer[bufpos++];
-	    }
-	    hmac_.clean();
-	    buffer.fill(0);
-	    counter.fill(0);
-	    return out;
-	}
-	exports.hkdf = hkdf;
-	// Derives a key from password and salt using PBKDF2-HMAC-SHA256
-	// with the given number of iterations.
-	//
-	// The number of bytes returned is equal to dkLen.
-	//
-	// (For better security, avoid dkLen greater than hash length - 32 bytes).
-	function pbkdf2(password, salt, iterations, dkLen) {
-	    var prf = new HMAC(password);
-	    var len = prf.digestLength;
-	    var ctr = new Uint8Array(4);
-	    var t = new Uint8Array(len);
-	    var u = new Uint8Array(len);
-	    var dk = new Uint8Array(dkLen);
-	    for (var i = 0; i * len < dkLen; i++) {
-	        var c = i + 1;
-	        ctr[0] = (c >>> 24) & 0xff;
-	        ctr[1] = (c >>> 16) & 0xff;
-	        ctr[2] = (c >>> 8) & 0xff;
-	        ctr[3] = (c >>> 0) & 0xff;
-	        prf.reset();
-	        prf.update(salt);
-	        prf.update(ctr);
-	        prf.finish(u);
-	        for (var j = 0; j < len; j++) {
-	            t[j] = u[j];
-	        }
-	        for (var j = 2; j <= iterations; j++) {
-	            prf.reset();
-	            prf.update(u).finish(u);
-	            for (var k = 0; k < len; k++) {
-	                t[k] ^= u[k];
-	            }
-	        }
-	        for (var j = 0; j < len && i * len + j < dkLen; j++) {
-	            dk[i * len + j] = t[j];
-	        }
-	    }
-	    for (var i = 0; i < len; i++) {
-	        t[i] = u[i] = 0;
-	    }
-	    for (var i = 0; i < 4; i++) {
-	        ctr[i] = 0;
-	    }
-	    prf.clean();
-	    return dk;
-	}
-	exports.pbkdf2 = pbkdf2;
-	}); 
-} (sha256$1));
+  }
+});
 
-var sha256Exports = sha256$1.exports;
+// ../../node_modules/fast-sha256/sha256.js
+var require_sha256 = __commonJS({
+  "../../node_modules/fast-sha256/sha256.js"(exports, module) {
+    (function(root, factory) {
+      var exports2 = {};
+      factory(exports2);
+      var sha2562 = exports2["default"];
+      for (var k in exports2) {
+        sha2562[k] = exports2[k];
+      }
+      if (typeof module === "object" && typeof module.exports === "object") {
+        module.exports = sha2562;
+      } else if (typeof define === "function" && define.amd) {
+        define(function() {
+          return sha2562;
+        });
+      } else {
+        root.sha256 = sha2562;
+      }
+    })(exports, function(exports2) {
+      exports2.__esModule = true;
+      exports2.digestLength = 32;
+      exports2.blockSize = 64;
+      var K = new Uint32Array([
+        1116352408,
+        1899447441,
+        3049323471,
+        3921009573,
+        961987163,
+        1508970993,
+        2453635748,
+        2870763221,
+        3624381080,
+        310598401,
+        607225278,
+        1426881987,
+        1925078388,
+        2162078206,
+        2614888103,
+        3248222580,
+        3835390401,
+        4022224774,
+        264347078,
+        604807628,
+        770255983,
+        1249150122,
+        1555081692,
+        1996064986,
+        2554220882,
+        2821834349,
+        2952996808,
+        3210313671,
+        3336571891,
+        3584528711,
+        113926993,
+        338241895,
+        666307205,
+        773529912,
+        1294757372,
+        1396182291,
+        1695183700,
+        1986661051,
+        2177026350,
+        2456956037,
+        2730485921,
+        2820302411,
+        3259730800,
+        3345764771,
+        3516065817,
+        3600352804,
+        4094571909,
+        275423344,
+        430227734,
+        506948616,
+        659060556,
+        883997877,
+        958139571,
+        1322822218,
+        1537002063,
+        1747873779,
+        1955562222,
+        2024104815,
+        2227730452,
+        2361852424,
+        2428436474,
+        2756734187,
+        3204031479,
+        3329325298
+      ]);
+      function hashBlocks(w, v, p, pos, len) {
+        var a, b, c, d, e, f, g, h, u, i, j, t1, t2;
+        while (len >= 64) {
+          a = v[0];
+          b = v[1];
+          c = v[2];
+          d = v[3];
+          e = v[4];
+          f = v[5];
+          g = v[6];
+          h = v[7];
+          for (i = 0; i < 16; i++) {
+            j = pos + i * 4;
+            w[i] = (p[j] & 255) << 24 | (p[j + 1] & 255) << 16 | (p[j + 2] & 255) << 8 | p[j + 3] & 255;
+          }
+          for (i = 16; i < 64; i++) {
+            u = w[i - 2];
+            t1 = (u >>> 17 | u << 32 - 17) ^ (u >>> 19 | u << 32 - 19) ^ u >>> 10;
+            u = w[i - 15];
+            t2 = (u >>> 7 | u << 32 - 7) ^ (u >>> 18 | u << 32 - 18) ^ u >>> 3;
+            w[i] = (t1 + w[i - 7] | 0) + (t2 + w[i - 16] | 0);
+          }
+          for (i = 0; i < 64; i++) {
+            t1 = (((e >>> 6 | e << 32 - 6) ^ (e >>> 11 | e << 32 - 11) ^ (e >>> 25 | e << 32 - 25)) + (e & f ^ ~e & g) | 0) + (h + (K[i] + w[i] | 0) | 0) | 0;
+            t2 = ((a >>> 2 | a << 32 - 2) ^ (a >>> 13 | a << 32 - 13) ^ (a >>> 22 | a << 32 - 22)) + (a & b ^ a & c ^ b & c) | 0;
+            h = g;
+            g = f;
+            f = e;
+            e = d + t1 | 0;
+            d = c;
+            c = b;
+            b = a;
+            a = t1 + t2 | 0;
+          }
+          v[0] += a;
+          v[1] += b;
+          v[2] += c;
+          v[3] += d;
+          v[4] += e;
+          v[5] += f;
+          v[6] += g;
+          v[7] += h;
+          pos += 64;
+          len -= 64;
+        }
+        return pos;
+      }
+      var Hash = (
+        /** @class */
+        function() {
+          function Hash2() {
+            this.digestLength = exports2.digestLength;
+            this.blockSize = exports2.blockSize;
+            this.state = new Int32Array(8);
+            this.temp = new Int32Array(64);
+            this.buffer = new Uint8Array(128);
+            this.bufferLength = 0;
+            this.bytesHashed = 0;
+            this.finished = false;
+            this.reset();
+          }
+          Hash2.prototype.reset = function() {
+            this.state[0] = 1779033703;
+            this.state[1] = 3144134277;
+            this.state[2] = 1013904242;
+            this.state[3] = 2773480762;
+            this.state[4] = 1359893119;
+            this.state[5] = 2600822924;
+            this.state[6] = 528734635;
+            this.state[7] = 1541459225;
+            this.bufferLength = 0;
+            this.bytesHashed = 0;
+            this.finished = false;
+            return this;
+          };
+          Hash2.prototype.clean = function() {
+            for (var i = 0; i < this.buffer.length; i++) {
+              this.buffer[i] = 0;
+            }
+            for (var i = 0; i < this.temp.length; i++) {
+              this.temp[i] = 0;
+            }
+            this.reset();
+          };
+          Hash2.prototype.update = function(data, dataLength) {
+            if (dataLength === void 0) {
+              dataLength = data.length;
+            }
+            if (this.finished) {
+              throw new Error("SHA256: can't update because hash was finished.");
+            }
+            var dataPos = 0;
+            this.bytesHashed += dataLength;
+            if (this.bufferLength > 0) {
+              while (this.bufferLength < 64 && dataLength > 0) {
+                this.buffer[this.bufferLength++] = data[dataPos++];
+                dataLength--;
+              }
+              if (this.bufferLength === 64) {
+                hashBlocks(this.temp, this.state, this.buffer, 0, 64);
+                this.bufferLength = 0;
+              }
+            }
+            if (dataLength >= 64) {
+              dataPos = hashBlocks(this.temp, this.state, data, dataPos, dataLength);
+              dataLength %= 64;
+            }
+            while (dataLength > 0) {
+              this.buffer[this.bufferLength++] = data[dataPos++];
+              dataLength--;
+            }
+            return this;
+          };
+          Hash2.prototype.finish = function(out) {
+            if (!this.finished) {
+              var bytesHashed = this.bytesHashed;
+              var left = this.bufferLength;
+              var bitLenHi = bytesHashed / 536870912 | 0;
+              var bitLenLo = bytesHashed << 3;
+              var padLength = bytesHashed % 64 < 56 ? 64 : 128;
+              this.buffer[left] = 128;
+              for (var i = left + 1; i < padLength - 8; i++) {
+                this.buffer[i] = 0;
+              }
+              this.buffer[padLength - 8] = bitLenHi >>> 24 & 255;
+              this.buffer[padLength - 7] = bitLenHi >>> 16 & 255;
+              this.buffer[padLength - 6] = bitLenHi >>> 8 & 255;
+              this.buffer[padLength - 5] = bitLenHi >>> 0 & 255;
+              this.buffer[padLength - 4] = bitLenLo >>> 24 & 255;
+              this.buffer[padLength - 3] = bitLenLo >>> 16 & 255;
+              this.buffer[padLength - 2] = bitLenLo >>> 8 & 255;
+              this.buffer[padLength - 1] = bitLenLo >>> 0 & 255;
+              hashBlocks(this.temp, this.state, this.buffer, 0, padLength);
+              this.finished = true;
+            }
+            for (var i = 0; i < 8; i++) {
+              out[i * 4 + 0] = this.state[i] >>> 24 & 255;
+              out[i * 4 + 1] = this.state[i] >>> 16 & 255;
+              out[i * 4 + 2] = this.state[i] >>> 8 & 255;
+              out[i * 4 + 3] = this.state[i] >>> 0 & 255;
+            }
+            return this;
+          };
+          Hash2.prototype.digest = function() {
+            var out = new Uint8Array(this.digestLength);
+            this.finish(out);
+            return out;
+          };
+          Hash2.prototype._saveState = function(out) {
+            for (var i = 0; i < this.state.length; i++) {
+              out[i] = this.state[i];
+            }
+          };
+          Hash2.prototype._restoreState = function(from, bytesHashed) {
+            for (var i = 0; i < this.state.length; i++) {
+              this.state[i] = from[i];
+            }
+            this.bytesHashed = bytesHashed;
+            this.finished = false;
+            this.bufferLength = 0;
+          };
+          return Hash2;
+        }()
+      );
+      exports2.Hash = Hash;
+      var HMAC = (
+        /** @class */
+        function() {
+          function HMAC2(key) {
+            this.inner = new Hash();
+            this.outer = new Hash();
+            this.blockSize = this.inner.blockSize;
+            this.digestLength = this.inner.digestLength;
+            var pad = new Uint8Array(this.blockSize);
+            if (key.length > this.blockSize) {
+              new Hash().update(key).finish(pad).clean();
+            } else {
+              for (var i = 0; i < key.length; i++) {
+                pad[i] = key[i];
+              }
+            }
+            for (var i = 0; i < pad.length; i++) {
+              pad[i] ^= 54;
+            }
+            this.inner.update(pad);
+            for (var i = 0; i < pad.length; i++) {
+              pad[i] ^= 54 ^ 92;
+            }
+            this.outer.update(pad);
+            this.istate = new Uint32Array(8);
+            this.ostate = new Uint32Array(8);
+            this.inner._saveState(this.istate);
+            this.outer._saveState(this.ostate);
+            for (var i = 0; i < pad.length; i++) {
+              pad[i] = 0;
+            }
+          }
+          HMAC2.prototype.reset = function() {
+            this.inner._restoreState(this.istate, this.inner.blockSize);
+            this.outer._restoreState(this.ostate, this.outer.blockSize);
+            return this;
+          };
+          HMAC2.prototype.clean = function() {
+            for (var i = 0; i < this.istate.length; i++) {
+              this.ostate[i] = this.istate[i] = 0;
+            }
+            this.inner.clean();
+            this.outer.clean();
+          };
+          HMAC2.prototype.update = function(data) {
+            this.inner.update(data);
+            return this;
+          };
+          HMAC2.prototype.finish = function(out) {
+            if (this.outer.finished) {
+              this.outer.finish(out);
+            } else {
+              this.inner.finish(out);
+              this.outer.update(out, this.digestLength).finish(out);
+            }
+            return this;
+          };
+          HMAC2.prototype.digest = function() {
+            var out = new Uint8Array(this.digestLength);
+            this.finish(out);
+            return out;
+          };
+          return HMAC2;
+        }()
+      );
+      exports2.HMAC = HMAC;
+      function hash(data) {
+        var h = new Hash().update(data);
+        var digest = h.digest();
+        h.clean();
+        return digest;
+      }
+      exports2.hash = hash;
+      exports2["default"] = hash;
+      function hmac2(key, data) {
+        var h = new HMAC(key).update(data);
+        var digest = h.digest();
+        h.clean();
+        return digest;
+      }
+      exports2.hmac = hmac2;
+      function fillBuffer(buffer, hmac3, info, counter) {
+        var num = counter[0];
+        if (num === 0) {
+          throw new Error("hkdf: cannot expand more");
+        }
+        hmac3.reset();
+        if (num > 1) {
+          hmac3.update(buffer);
+        }
+        if (info) {
+          hmac3.update(info);
+        }
+        hmac3.update(counter);
+        hmac3.finish(buffer);
+        counter[0]++;
+      }
+      var hkdfSalt = new Uint8Array(exports2.digestLength);
+      function hkdf(key, salt, info, length) {
+        if (salt === void 0) {
+          salt = hkdfSalt;
+        }
+        if (length === void 0) {
+          length = 32;
+        }
+        var counter = new Uint8Array([1]);
+        var okm = hmac2(salt, key);
+        var hmac_ = new HMAC(okm);
+        var buffer = new Uint8Array(hmac_.digestLength);
+        var bufpos = buffer.length;
+        var out = new Uint8Array(length);
+        for (var i = 0; i < length; i++) {
+          if (bufpos === buffer.length) {
+            fillBuffer(buffer, hmac_, info, counter);
+            bufpos = 0;
+          }
+          out[i] = buffer[bufpos++];
+        }
+        hmac_.clean();
+        buffer.fill(0);
+        counter.fill(0);
+        return out;
+      }
+      exports2.hkdf = hkdf;
+      function pbkdf2(password, salt, iterations, dkLen) {
+        var prf = new HMAC(password);
+        var len = prf.digestLength;
+        var ctr = new Uint8Array(4);
+        var t = new Uint8Array(len);
+        var u = new Uint8Array(len);
+        var dk = new Uint8Array(dkLen);
+        for (var i = 0; i * len < dkLen; i++) {
+          var c = i + 1;
+          ctr[0] = c >>> 24 & 255;
+          ctr[1] = c >>> 16 & 255;
+          ctr[2] = c >>> 8 & 255;
+          ctr[3] = c >>> 0 & 255;
+          prf.reset();
+          prf.update(salt);
+          prf.update(ctr);
+          prf.finish(u);
+          for (var j = 0; j < len; j++) {
+            t[j] = u[j];
+          }
+          for (var j = 2; j <= iterations; j++) {
+            prf.reset();
+            prf.update(u).finish(u);
+            for (var k = 0; k < len; k++) {
+              t[k] ^= u[k];
+            }
+          }
+          for (var j = 0; j < len && i * len + j < dkLen; j++) {
+            dk[i * len + j] = t[j];
+          }
+        }
+        for (var i = 0; i < len; i++) {
+          t[i] = u[i] = 0;
+        }
+        for (var i = 0; i < 4; i++) {
+          ctr[i] = 0;
+        }
+        prf.clean();
+        return dk;
+      }
+      exports2.pbkdf2 = pbkdf2;
+    });
+  }
+});
 
-Object.defineProperty(dist, "__esModule", { value: true });
-var Webhook_1 = dist.Webhook = WebhookVerificationError_1 = dist.WebhookVerificationError = void 0;
-const timing_safe_equal_1 = timing_safe_equal;
-const base64 = base64$1;
-const sha256 = sha256Exports;
-const WEBHOOK_TOLERANCE_IN_SECONDS = 5 * 60;
-class ExtendableError extends Error {
-    constructor(message) {
-        super(message);
-        Object.setPrototypeOf(this, ExtendableError.prototype);
-        this.name = "ExtendableError";
-        this.stack = new Error(message).stack;
+// src/webhook/vendor/standardwebhook.ts
+var base64 = __toESM(require_base64());
+var sha256 = __toESM(require_sha256());
+var WEBHOOK_TOLERANCE_IN_SECONDS = 5 * 60;
+var ExtendableError = class _ExtendableError extends Error {
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, _ExtendableError.prototype);
+    this.name = "ExtendableError";
+    this.stack = new Error(message).stack;
+  }
+};
+var WebhookVerificationError = class _WebhookVerificationError extends ExtendableError {
+  constructor(message) {
+    super(message);
+    Object.setPrototypeOf(this, _WebhookVerificationError.prototype);
+    this.name = "WebhookVerificationError";
+  }
+};
+var Webhook = class _Webhook {
+  static prefix = "whsec_";
+  key;
+  constructor(secret, options) {
+    if (!secret) {
+      throw new Error("Secret can't be empty.");
+    }
+    if ((options == null ? void 0 : options.format) === "raw") {
+      if (secret instanceof Uint8Array) {
+        this.key = secret;
+      } else {
+        this.key = Uint8Array.from(secret, (c) => c.charCodeAt(0));
+      }
+    } else {
+      if (typeof secret !== "string") {
+        throw new Error("Expected secret to be of type string");
+      }
+      if (secret.startsWith(_Webhook.prefix)) {
+        secret = secret.substring(_Webhook.prefix.length);
+      }
+      this.key = base64.decode(secret);
     }
-}
-class WebhookVerificationError extends ExtendableError {
-    constructor(message) {
-        super(message);
-        Object.setPrototypeOf(this, WebhookVerificationError.prototype);
-        this.name = "WebhookVerificationError";
+  }
+  verify(payload, headers_) {
+    const headers = {};
+    for (const key of Object.keys(headers_)) {
+      headers[key.toLowerCase()] = headers_[key];
+    }
+    const msgId = headers["webhook-id"];
+    const msgSignature = headers["webhook-signature"];
+    const msgTimestamp = headers["webhook-timestamp"];
+    if (!msgSignature || !msgId || !msgTimestamp) {
+      throw new WebhookVerificationError("Missing required headers");
+    }
+    const timestamp = this.verifyTimestamp(msgTimestamp);
+    const computedSignature = this.sign(msgId, timestamp, payload);
+    const expectedSignature = computedSignature.split(",")[1];
+    const passedSignatures = msgSignature.split(" ");
+    const encoder = new globalThis.TextEncoder();
+    for (const versionedSignature of passedSignatures) {
+      const [version, signature] = versionedSignature.split(",");
+      if (version !== "v1") {
+        continue;
+      }
+      if (timingSafeEqual(
+        encoder.encode(signature),
+        encoder.encode(expectedSignature)
+      )) {
+        return JSON.parse(payload.toString());
+      }
     }
-}
-var WebhookVerificationError_1 = dist.WebhookVerificationError = WebhookVerificationError;
-class Webhook {
-    constructor(secret, options) {
-        if (!secret) {
-            throw new Error("Secret can't be empty.");
-        }
-        if ((options === null || options === void 0 ? void 0 : options.format) === "raw") {
-            if (secret instanceof Uint8Array) {
-                this.key = secret;
-            }
-            else {
-                this.key = Uint8Array.from(secret, (c) => c.charCodeAt(0));
-            }
-        }
-        else {
-            if (typeof secret !== "string") {
-                throw new Error("Expected secret to be of type string");
-            }
-            if (secret.startsWith(Webhook.prefix)) {
-                secret = secret.substring(Webhook.prefix.length);
-            }
-            this.key = base64.decode(secret);
-        }
+    throw new WebhookVerificationError("No matching signature found");
+  }
+  sign(msgId, timestamp, payload) {
+    if (typeof payload === "string") ; else if (payload.constructor.name === "Buffer") {
+      payload = payload.toString();
+    } else {
+      throw new Error("Expected payload to be of type string or Buffer.");
     }
-    verify(payload, headers_) {
-        const headers = {};
-        for (const key of Object.keys(headers_)) {
-            headers[key.toLowerCase()] = headers_[key];
-        }
-        const msgId = headers["webhook-id"];
-        const msgSignature = headers["webhook-signature"];
-        const msgTimestamp = headers["webhook-timestamp"];
-        if (!msgSignature || !msgId || !msgTimestamp) {
-            throw new WebhookVerificationError("Missing required headers");
-        }
-        const timestamp = this.verifyTimestamp(msgTimestamp);
-        const computedSignature = this.sign(msgId, timestamp, payload);
-        const expectedSignature = computedSignature.split(",")[1];
-        const passedSignatures = msgSignature.split(" ");
-        const encoder = new globalThis.TextEncoder();
-        for (const versionedSignature of passedSignatures) {
-            const [version, signature] = versionedSignature.split(",");
-            if (version !== "v1") {
-                continue;
-            }
-            if ((0, timing_safe_equal_1.timingSafeEqual)(encoder.encode(signature), encoder.encode(expectedSignature))) {
-                return JSON.parse(payload.toString());
-            }
-        }
-        throw new WebhookVerificationError("No matching signature found");
+    const encoder = new TextEncoder();
+    const timestampNumber = Math.floor(timestamp.getTime() / 1e3);
+    const toSign = encoder.encode(`${msgId}.${timestampNumber}.${payload}`);
+    const expectedSignature = base64.encode(sha256.hmac(this.key, toSign));
+    return `v1,${expectedSignature}`;
+  }
+  verifyTimestamp(timestampHeader) {
+    const now = Math.floor(Date.now() / 1e3);
+    const timestamp = parseInt(timestampHeader, 10);
+    if (isNaN(timestamp)) {
+      throw new WebhookVerificationError("Invalid Signature Headers");
     }
-    sign(msgId, timestamp, payload) {
-        if (typeof payload === "string") ;
-        else if (payload.constructor.name === "Buffer") {
-            payload = payload.toString();
-        }
-        else {
-            throw new Error("Expected payload to be of type string or Buffer.");
-        }
-        const encoder = new TextEncoder();
-        const timestampNumber = Math.floor(timestamp.getTime() / 1000);
-        const toSign = encoder.encode(`${msgId}.${timestampNumber}.${payload}`);
-        const expectedSignature = base64.encode(sha256.hmac(this.key, toSign));
-        return `v1,${expectedSignature}`;
+    if (now - timestamp > WEBHOOK_TOLERANCE_IN_SECONDS) {
+      throw new WebhookVerificationError("Message timestamp too old");
     }
-    verifyTimestamp(timestampHeader) {
-        const now = Math.floor(Date.now() / 1000);
-        const timestamp = parseInt(timestampHeader, 10);
-        if (isNaN(timestamp)) {
-            throw new WebhookVerificationError("Invalid Signature Headers");
-        }
-        if (now - timestamp > WEBHOOK_TOLERANCE_IN_SECONDS) {
-            throw new WebhookVerificationError("Message timestamp too old");
-        }
-        if (timestamp > now + WEBHOOK_TOLERANCE_IN_SECONDS) {
-            throw new WebhookVerificationError("Message timestamp too new");
-        }
-        return new Date(timestamp * 1000);
+    if (timestamp > now + WEBHOOK_TOLERANCE_IN_SECONDS) {
+      throw new WebhookVerificationError("Message timestamp too new");
     }
-}
-Webhook_1 = dist.Webhook = Webhook;
-Webhook.prefix = "whsec_";
+    return new Date(timestamp * 1e3);
+  }
+};
+/**
+ * The MIT License
+ *
+ * Copyright (c) 2023 Svix (https://www.svix.com)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ *
+ * @fileoverview Server-only webhook verification implementation.
+ * @description Vendored from standardwebhooks package to avoid bundling issues.
+ * Uses Node.js crypto module - DO NOT import in client/browser code.
+ * @license MIT
+ * @internal
+ */
 
+// src/webhook/webhook.ts
 async function handleWebhookPayload(payload, config, context) {
   const callHandler = (handler, payload2) => {
     if (!handler) return;
@@ -6245,11 +6212,11 @@ var verifyWebhookPayload = async ({
   headers,
   body
 }) => {
-  const standardWebhook = new Webhook_1(webhookKey);
+  const standardWebhook = new Webhook(webhookKey);
   try {
     standardWebhook.verify(body, headers);
   } catch (e) {
-    if (e instanceof WebhookVerificationError_1) {
+    if (e instanceof WebhookVerificationError) {
       throw new Error(e.message);
     }
     throw e;