@dodopayments/convex 0.1.0

package/dist/index.js

@@ -0,0 +1,2441 @@
+import { z } from 'zod';
+
+// This is the public-facing client that developers will use.
+class DodoPayments {
+    constructor(component, config) {
+        this.component = component;
+        this.config = config;
+    }
+    /**
+     * Returns the public API methods for the Dodo Payments client.
+     */
+    api() {
+        return {
+            /**
+             * Creates a Dodo Payments checkout session.
+             * Uses session checkout with full feature support.
+             */
+            checkout: async (ctx, args) => {
+                return await ctx.runAction(this.component.lib.checkout, {
+                    ...args,
+                    apiKey: this.config.apiKey,
+                    environment: this.config.environment,
+                });
+            },
+            /**
+             * Retrieves a URL for the customer portal.
+             * This function is designed to be called from a public Convex query in your app.
+             */
+            customerPortal: async (ctx, args) => {
+                const identity = await this.config.identify(ctx);
+                if (!identity) {
+                    throw new Error("User is not authenticated.");
+                }
+                return await ctx.runAction(this.component.lib.customerPortal, {
+                    dodoCustomerId: identity.dodoCustomerId,
+                    send_email: args?.send_email,
+                    apiKey: this.config.apiKey,
+                    environment: this.config.environment,
+                });
+            },
+        };
+    }
+}
+
+var lookup = [];
+var revLookup = [];
+var Arr = Uint8Array;
+var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+for (var i = 0, len = code.length; i < len; ++i) {
+  lookup[i] = code[i];
+  revLookup[code.charCodeAt(i)] = i;
+}
+revLookup["-".charCodeAt(0)] = 62;
+revLookup["_".charCodeAt(0)] = 63;
+function getLens(b64) {
+  var len = b64.length;
+  if (len % 4 > 0) {
+    throw new Error("Invalid string. Length must be a multiple of 4");
+  }
+  var validLen = b64.indexOf("=");
+  if (validLen === -1) validLen = len;
+  var placeHoldersLen = validLen === len ? 0 : 4 - validLen % 4;
+  return [validLen, placeHoldersLen];
+}
+function _byteLength(_b64, validLen, placeHoldersLen) {
+  return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+}
+function toByteArray(b64) {
+  var tmp;
+  var lens = getLens(b64);
+  var validLen = lens[0];
+  var placeHoldersLen = lens[1];
+  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
+  var curByte = 0;
+  var len = placeHoldersLen > 0 ? validLen - 4 : validLen;
+  var i;
+  for (i = 0; i < len; i += 4) {
+    tmp = revLookup[b64.charCodeAt(i)] << 18 | revLookup[b64.charCodeAt(i + 1)] << 12 | revLookup[b64.charCodeAt(i + 2)] << 6 | revLookup[b64.charCodeAt(i + 3)];
+    arr[curByte++] = tmp >> 16 & 255;
+    arr[curByte++] = tmp >> 8 & 255;
+    arr[curByte++] = tmp & 255;
+  }
+  if (placeHoldersLen === 2) {
+    tmp = revLookup[b64.charCodeAt(i)] << 2 | revLookup[b64.charCodeAt(i + 1)] >> 4;
+    arr[curByte++] = tmp & 255;
+  }
+  if (placeHoldersLen === 1) {
+    tmp = revLookup[b64.charCodeAt(i)] << 10 | revLookup[b64.charCodeAt(i + 1)] << 4 | revLookup[b64.charCodeAt(i + 2)] >> 2;
+    arr[curByte++] = tmp >> 8 & 255;
+    arr[curByte++] = tmp & 255;
+  }
+  return arr;
+}
+function tripletToBase64(num) {
+  return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];
+}
+function encodeChunk(uint8, start, end) {
+  var tmp;
+  var output = [];
+  for (var i = start; i < end; i += 3) {
+    tmp = (uint8[i] << 16 & 16711680) + (uint8[i + 1] << 8 & 65280) + (uint8[i + 2] & 255);
+    output.push(tripletToBase64(tmp));
+  }
+  return output.join("");
+}
+function fromByteArray(uint8) {
+  var tmp;
+  var len = uint8.length;
+  var extraBytes = len % 3;
+  var parts = [];
+  var maxChunkLength = 16383;
+  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
+    parts.push(
+      encodeChunk(
+        uint8,
+        i,
+        i + maxChunkLength > len2 ? len2 : i + maxChunkLength
+      )
+    );
+  }
+  if (extraBytes === 1) {
+    tmp = uint8[len - 1];
+    parts.push(lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "==");
+  } else if (extraBytes === 2) {
+    tmp = (uint8[len - 2] << 8) + uint8[len - 1];
+    parts.push(
+      lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "="
+    );
+  }
+  return parts.join("");
+}
+
+function parseArgs(args) {
+  if (args === void 0) {
+    return {};
+  }
+  if (!isSimpleObject(args)) {
+    throw new Error(
+      `The arguments to a Convex function must be an object. Received: ${args}`
+    );
+  }
+  return args;
+}
+function isSimpleObject(value) {
+  const isObject = typeof value === "object";
+  const prototype = Object.getPrototypeOf(value);
+  const isSimple = prototype === null || prototype === Object.prototype || // Objects generated from other contexts (e.g. across Node.js `vm` modules) will not satisfy the previous
+  // conditions but are still simple objects.
+  prototype?.constructor?.name === "Object";
+  return isObject && isSimple;
+}
+
+const LITTLE_ENDIAN = true;
+const MIN_INT64 = BigInt("-9223372036854775808");
+const MAX_INT64 = BigInt("9223372036854775807");
+const ZERO = BigInt("0");
+const EIGHT = BigInt("8");
+const TWOFIFTYSIX = BigInt("256");
+function isSpecial(n) {
+  return Number.isNaN(n) || !Number.isFinite(n) || Object.is(n, -0);
+}
+function slowBigIntToBase64(value) {
+  if (value < ZERO) {
+    value -= MIN_INT64 + MIN_INT64;
+  }
+  let hex = value.toString(16);
+  if (hex.length % 2 === 1) hex = "0" + hex;
+  const bytes = new Uint8Array(new ArrayBuffer(8));
+  let i = 0;
+  for (const hexByte of hex.match(/.{2}/g).reverse()) {
+    bytes.set([parseInt(hexByte, 16)], i++);
+    value >>= EIGHT;
+  }
+  return fromByteArray(bytes);
+}
+function slowBase64ToBigInt(encoded) {
+  const integerBytes = toByteArray(encoded);
+  if (integerBytes.byteLength !== 8) {
+    throw new Error(
+      `Received ${integerBytes.byteLength} bytes, expected 8 for $integer`
+    );
+  }
+  let value = ZERO;
+  let power = ZERO;
+  for (const byte of integerBytes) {
+    value += BigInt(byte) * TWOFIFTYSIX ** power;
+    power++;
+  }
+  if (value > MAX_INT64) {
+    value += MIN_INT64 + MIN_INT64;
+  }
+  return value;
+}
+function modernBigIntToBase64(value) {
+  if (value < MIN_INT64 || MAX_INT64 < value) {
+    throw new Error(
+      `BigInt ${value} does not fit into a 64-bit signed integer.`
+    );
+  }
+  const buffer = new ArrayBuffer(8);
+  new DataView(buffer).setBigInt64(0, value, true);
+  return fromByteArray(new Uint8Array(buffer));
+}
+function modernBase64ToBigInt(encoded) {
+  const integerBytes = toByteArray(encoded);
+  if (integerBytes.byteLength !== 8) {
+    throw new Error(
+      `Received ${integerBytes.byteLength} bytes, expected 8 for $integer`
+    );
+  }
+  const intBytesView = new DataView(integerBytes.buffer);
+  return intBytesView.getBigInt64(0, true);
+}
+const bigIntToBase64 = DataView.prototype.setBigInt64 ? modernBigIntToBase64 : slowBigIntToBase64;
+const base64ToBigInt = DataView.prototype.getBigInt64 ? modernBase64ToBigInt : slowBase64ToBigInt;
+const MAX_IDENTIFIER_LEN = 1024;
+function validateObjectField(k) {
+  if (k.length > MAX_IDENTIFIER_LEN) {
+    throw new Error(
+      `Field name ${k} exceeds maximum field name length ${MAX_IDENTIFIER_LEN}.`
+    );
+  }
+  if (k.startsWith("$")) {
+    throw new Error(`Field name ${k} starts with a '$', which is reserved.`);
+  }
+  for (let i = 0; i < k.length; i += 1) {
+    const charCode = k.charCodeAt(i);
+    if (charCode < 32 || charCode >= 127) {
+      throw new Error(
+        `Field name ${k} has invalid character '${k[i]}': Field names can only contain non-control ASCII characters`
+      );
+    }
+  }
+}
+function jsonToConvex(value) {
+  if (value === null) {
+    return value;
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (Array.isArray(value)) {
+    return value.map((value2) => jsonToConvex(value2));
+  }
+  if (typeof value !== "object") {
+    throw new Error(`Unexpected type of ${value}`);
+  }
+  const entries = Object.entries(value);
+  if (entries.length === 1) {
+    const key = entries[0][0];
+    if (key === "$bytes") {
+      if (typeof value.$bytes !== "string") {
+        throw new Error(`Malformed $bytes field on ${value}`);
+      }
+      return toByteArray(value.$bytes).buffer;
+    }
+    if (key === "$integer") {
+      if (typeof value.$integer !== "string") {
+        throw new Error(`Malformed $integer field on ${value}`);
+      }
+      return base64ToBigInt(value.$integer);
+    }
+    if (key === "$float") {
+      if (typeof value.$float !== "string") {
+        throw new Error(`Malformed $float field on ${value}`);
+      }
+      const floatBytes = toByteArray(value.$float);
+      if (floatBytes.byteLength !== 8) {
+        throw new Error(
+          `Received ${floatBytes.byteLength} bytes, expected 8 for $float`
+        );
+      }
+      const floatBytesView = new DataView(floatBytes.buffer);
+      const float = floatBytesView.getFloat64(0, LITTLE_ENDIAN);
+      if (!isSpecial(float)) {
+        throw new Error(`Float ${float} should be encoded as a number`);
+      }
+      return float;
+    }
+    if (key === "$set") {
+      throw new Error(
+        `Received a Set which is no longer supported as a Convex type.`
+      );
+    }
+    if (key === "$map") {
+      throw new Error(
+        `Received a Map which is no longer supported as a Convex type.`
+      );
+    }
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(value)) {
+    validateObjectField(k);
+    out[k] = jsonToConvex(v);
+  }
+  return out;
+}
+function stringifyValueForError(value) {
+  return JSON.stringify(value, (_key, value2) => {
+    if (value2 === void 0) {
+      return "undefined";
+    }
+    if (typeof value2 === "bigint") {
+      return `${value2.toString()}n`;
+    }
+    return value2;
+  });
+}
+function convexToJsonInternal(value, originalValue, context, includeTopLevelUndefined) {
+  if (value === void 0) {
+    const contextText = context && ` (present at path ${context} in original object ${stringifyValueForError(
+      originalValue
+    )})`;
+    throw new Error(
+      `undefined is not a valid Convex value${contextText}. To learn about Convex's supported types, see https://docs.convex.dev/using/types.`
+    );
+  }
+  if (value === null) {
+    return value;
+  }
+  if (typeof value === "bigint") {
+    if (value < MIN_INT64 || MAX_INT64 < value) {
+      throw new Error(
+        `BigInt ${value} does not fit into a 64-bit signed integer.`
+      );
+    }
+    return { $integer: bigIntToBase64(value) };
+  }
+  if (typeof value === "number") {
+    if (isSpecial(value)) {
+      const buffer = new ArrayBuffer(8);
+      new DataView(buffer).setFloat64(0, value, LITTLE_ENDIAN);
+      return { $float: fromByteArray(new Uint8Array(buffer)) };
+    } else {
+      return value;
+    }
+  }
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value instanceof ArrayBuffer) {
+    return { $bytes: fromByteArray(new Uint8Array(value)) };
+  }
+  if (Array.isArray(value)) {
+    return value.map(
+      (value2, i) => convexToJsonInternal(value2, originalValue, context + `[${i}]`)
+    );
+  }
+  if (value instanceof Set) {
+    throw new Error(
+      errorMessageForUnsupportedType(context, "Set", [...value], originalValue)
+    );
+  }
+  if (value instanceof Map) {
+    throw new Error(
+      errorMessageForUnsupportedType(context, "Map", [...value], originalValue)
+    );
+  }
+  if (!isSimpleObject(value)) {
+    const theType = value?.constructor?.name;
+    const typeName = theType ? `${theType} ` : "";
+    throw new Error(
+      errorMessageForUnsupportedType(context, typeName, value, originalValue)
+    );
+  }
+  const out = {};
+  const entries = Object.entries(value);
+  entries.sort(([k1, _v1], [k2, _v2]) => k1 === k2 ? 0 : k1 < k2 ? -1 : 1);
+  for (const [k, v] of entries) {
+    if (v !== void 0) {
+      validateObjectField(k);
+      out[k] = convexToJsonInternal(v, originalValue, context + `.${k}`);
+    }
+  }
+  return out;
+}
+function errorMessageForUnsupportedType(context, typeName, value, originalValue) {
+  if (context) {
+    return `${typeName}${stringifyValueForError(
+      value
+    )} is not a supported Convex type (present at path ${context} in original object ${stringifyValueForError(
+      originalValue
+    )}). To learn about Convex's supported types, see https://docs.convex.dev/using/types.`;
+  } else {
+    return `${typeName}${stringifyValueForError(
+      value
+    )} is not a supported Convex type.`;
+  }
+}
+function convexOrUndefinedToJsonInternal(value, originalValue, context) {
+  if (value === void 0) {
+    return { $undefined: null };
+  } else {
+    if (originalValue === void 0) {
+      throw new Error(
+        `Programming error. Current value is ${stringifyValueForError(
+          value
+        )} but original value is undefined`
+      );
+    }
+    return convexToJsonInternal(value, originalValue, context);
+  }
+}
+function convexToJson(value) {
+  return convexToJsonInternal(value, value, "");
+}
+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 __publicField$3 = (obj, key, value) => __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
+var _a, _b;
+const IDENTIFYING_FIELD = Symbol.for("ConvexError");
+class ConvexError extends (_b = Error, _a = IDENTIFYING_FIELD, _b) {
+  constructor(data) {
+    super(typeof data === "string" ? data : stringifyValueForError(data));
+    __publicField$3(this, "name", "ConvexError");
+    __publicField$3(this, "data");
+    __publicField$3(this, _a, true);
+    this.data = data;
+  }
+}
+
+const arr = () => Array.from({ length: 4 }, () => 0);
+arr();
+arr();
+
+const version = "1.27.0";
+
+async function performAsyncSyscall(op, arg) {
+  if (typeof Convex === "undefined" || Convex.asyncSyscall === void 0) {
+    throw new Error(
+      "The Convex database and auth objects are being used outside of a Convex backend. Did you mean to use `useQuery` or `useMutation` to call a Convex function?"
+    );
+  }
+  let resultStr;
+  try {
+    resultStr = await Convex.asyncSyscall(op, JSON.stringify(arg));
+  } catch (e) {
+    if (e.data !== void 0) {
+      const rethrown = new ConvexError(e.message);
+      rethrown.data = jsonToConvex(e.data);
+      throw rethrown;
+    }
+    throw new Error(e.message);
+  }
+  return JSON.parse(resultStr);
+}
+function performJsSyscall(op, arg) {
+  if (typeof Convex === "undefined" || Convex.jsSyscall === void 0) {
+    throw new Error(
+      "The Convex database and auth objects are being used outside of a Convex backend. Did you mean to use `useQuery` or `useMutation` to call a Convex function?"
+    );
+  }
+  return Convex.jsSyscall(op, arg);
+}
+
+const functionName = Symbol.for("functionName");
+
+const toReferencePath = Symbol.for("toReferencePath");
+function setReferencePath(obj, value) {
+  obj[toReferencePath] = value;
+}
+function extractReferencePath(reference) {
+  return reference[toReferencePath] ?? null;
+}
+function isFunctionHandle(s) {
+  return s.startsWith("function://");
+}
+function getFunctionAddress(functionReference) {
+  let functionAddress;
+  if (typeof functionReference === "string") {
+    if (isFunctionHandle(functionReference)) {
+      functionAddress = { functionHandle: functionReference };
+    } else {
+      functionAddress = { name: functionReference };
+    }
+  } else if (functionReference[functionName]) {
+    functionAddress = { name: functionReference[functionName] };
+  } else {
+    const referencePath = extractReferencePath(functionReference);
+    if (!referencePath) {
+      throw new Error(`${functionReference} is not a functionReference`);
+    }
+    functionAddress = { reference: referencePath };
+  }
+  return functionAddress;
+}
+
+function syscallArgs(requestId, functionReference, args) {
+  const address = getFunctionAddress(functionReference);
+  return {
+    ...address,
+    args: convexToJson(parseArgs(args)),
+    version,
+    requestId
+  };
+}
+function setupActionCalls(requestId) {
+  return {
+    runQuery: async (query, args) => {
+      const result = await performAsyncSyscall(
+        "1.0/actions/query",
+        syscallArgs(requestId, query, args)
+      );
+      return jsonToConvex(result);
+    },
+    runMutation: async (mutation, args) => {
+      const result = await performAsyncSyscall(
+        "1.0/actions/mutation",
+        syscallArgs(requestId, mutation, args)
+      );
+      return jsonToConvex(result);
+    },
+    runAction: async (action, args) => {
+      const result = await performAsyncSyscall(
+        "1.0/actions/action",
+        syscallArgs(requestId, action, args)
+      );
+      return jsonToConvex(result);
+    }
+  };
+}
+
+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 __publicField$2 = (obj, key, value) => __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
+class FilterExpression {
+  /**
+   * @internal
+   */
+  constructor() {
+    // Property for nominal type support.
+    __publicField$2(this, "_isExpression");
+    // Property to distinguish expressions by the type they resolve to.
+    __publicField$2(this, "_value");
+  }
+}
+
+function validateArg(arg, idx, method, argName) {
+  if (arg === void 0) {
+    throw new TypeError(
+      `Must provide arg ${idx} \`${argName}\` to \`${method}\``
+    );
+  }
+}
+
+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 __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+function setupActionVectorSearch(requestId) {
+  return async (tableName, indexName, query) => {
+    validateArg(tableName, 1, "vectorSearch", "tableName");
+    validateArg(indexName, 2, "vectorSearch", "indexName");
+    validateArg(query, 3, "vectorSearch", "query");
+    if (!query.vector || !Array.isArray(query.vector) || query.vector.length === 0) {
+      throw Error("`vector` must be a non-empty Array in vectorSearch");
+    }
+    return await new VectorQueryImpl(
+      requestId,
+      tableName + "." + indexName,
+      query
+    ).collect();
+  };
+}
+class VectorQueryImpl {
+  constructor(requestId, indexName, query) {
+    __publicField$1(this, "requestId");
+    __publicField$1(this, "state");
+    this.requestId = requestId;
+    const filters = query.filter ? serializeExpression(query.filter(filterBuilderImpl)) : null;
+    this.state = {
+      type: "preparing",
+      query: {
+        indexName,
+        limit: query.limit,
+        vector: query.vector,
+        expressions: filters
+      }
+    };
+  }
+  async collect() {
+    if (this.state.type === "consumed") {
+      throw new Error("This query is closed and can't emit any more values.");
+    }
+    const query = this.state.query;
+    this.state = { type: "consumed" };
+    const { results } = await performAsyncSyscall("1.0/actions/vectorSearch", {
+      requestId: this.requestId,
+      version,
+      query
+    });
+    return results;
+  }
+}
+class ExpressionImpl extends FilterExpression {
+  constructor(inner) {
+    super();
+    __publicField$1(this, "inner");
+    this.inner = inner;
+  }
+  serialize() {
+    return this.inner;
+  }
+}
+function serializeExpression(expr) {
+  if (expr instanceof ExpressionImpl) {
+    return expr.serialize();
+  } else {
+    return { $literal: convexOrUndefinedToJson(expr) };
+  }
+}
+const filterBuilderImpl = {
+  //  Comparisons  /////////////////////////////////////////////////////////////
+  eq(fieldName, value) {
+    if (typeof fieldName !== "string") {
+      throw new Error("The first argument to `q.eq` must be a field name.");
+    }
+    return new ExpressionImpl({
+      $eq: [
+        serializeExpression(new ExpressionImpl({ $field: fieldName })),
+        serializeExpression(value)
+      ]
+    });
+  },
+  //  Logic  ///////////////////////////////////////////////////////////////////
+  or(...exprs) {
+    return new ExpressionImpl({ $or: exprs.map(serializeExpression) });
+  }
+};
+
+function setupAuth(requestId) {
+  return {
+    getUserIdentity: async () => {
+      return await performAsyncSyscall("1.0/getUserIdentity", {
+        requestId
+      });
+    }
+  };
+}
+
+function setupActionScheduler(requestId) {
+  return {
+    runAfter: async (delayMs, functionReference, args) => {
+      const syscallArgs = {
+        requestId,
+        ...runAfterSyscallArgs(delayMs, functionReference, args)
+      };
+      return await performAsyncSyscall("1.0/actions/schedule", syscallArgs);
+    },
+    runAt: async (ms_since_epoch_or_date, functionReference, args) => {
+      const syscallArgs = {
+        requestId,
+        ...runAtSyscallArgs(ms_since_epoch_or_date, functionReference, args)
+      };
+      return await performAsyncSyscall("1.0/actions/schedule", syscallArgs);
+    },
+    cancel: async (id) => {
+      validateArg(id, 1, "cancel", "id");
+      const syscallArgs = { id: convexToJson(id) };
+      return await performAsyncSyscall("1.0/actions/cancel_job", syscallArgs);
+    }
+  };
+}
+function runAfterSyscallArgs(delayMs, functionReference, args) {
+  if (typeof delayMs !== "number") {
+    throw new Error("`delayMs` must be a number");
+  }
+  if (!isFinite(delayMs)) {
+    throw new Error("`delayMs` must be a finite number");
+  }
+  if (delayMs < 0) {
+    throw new Error("`delayMs` must be non-negative");
+  }
+  const functionArgs = parseArgs(args);
+  const address = getFunctionAddress(functionReference);
+  const ts = (Date.now() + delayMs) / 1e3;
+  return {
+    ...address,
+    ts,
+    args: convexToJson(functionArgs),
+    version
+  };
+}
+function runAtSyscallArgs(ms_since_epoch_or_date, functionReference, args) {
+  let ts;
+  if (ms_since_epoch_or_date instanceof Date) {
+    ts = ms_since_epoch_or_date.valueOf() / 1e3;
+  } else if (typeof ms_since_epoch_or_date === "number") {
+    ts = ms_since_epoch_or_date / 1e3;
+  } else {
+    throw new Error("The invoke time must a Date or a timestamp");
+  }
+  const address = getFunctionAddress(functionReference);
+  const functionArgs = parseArgs(args);
+  return {
+    ...address,
+    ts,
+    args: convexToJson(functionArgs),
+    version
+  };
+}
+
+function setupStorageReader(requestId) {
+  return {
+    getUrl: async (storageId) => {
+      validateArg(storageId, 1, "getUrl", "storageId");
+      return await performAsyncSyscall("1.0/storageGetUrl", {
+        requestId,
+        version,
+        storageId
+      });
+    },
+    getMetadata: async (storageId) => {
+      return await performAsyncSyscall("1.0/storageGetMetadata", {
+        requestId,
+        version,
+        storageId
+      });
+    }
+  };
+}
+function setupStorageWriter(requestId) {
+  const reader = setupStorageReader(requestId);
+  return {
+    generateUploadUrl: async () => {
+      return await performAsyncSyscall("1.0/storageGenerateUploadUrl", {
+        requestId,
+        version
+      });
+    },
+    delete: async (storageId) => {
+      await performAsyncSyscall("1.0/storageDelete", {
+        requestId,
+        version,
+        storageId
+      });
+    },
+    getUrl: reader.getUrl,
+    getMetadata: reader.getMetadata
+  };
+}
+function setupStorageActionWriter(requestId) {
+  const writer = setupStorageWriter(requestId);
+  return {
+    ...writer,
+    store: async (blob, options) => {
+      return await performJsSyscall("storage/storeBlob", {
+        requestId,
+        version,
+        blob,
+        options
+      });
+    },
+    get: async (storageId) => {
+      return await performJsSyscall("storage/getBlob", {
+        requestId,
+        version,
+        storageId
+      });
+    }
+  };
+}
+
+async function invokeFunction(func, ctx, args) {
+  let result;
+  try {
+    result = await Promise.resolve(func(ctx, ...args));
+  } catch (thrown) {
+    throw serializeConvexErrorData(thrown);
+  }
+  return result;
+}
+function dontCallDirectly(funcType, handler) {
+  return (ctx, args) => {
+    globalThis.console.warn(
+      `Convex functions should not directly call other Convex functions. Consider calling a helper function instead. e.g. \`export const foo = ${funcType}(...); await foo(ctx);\` is not supported. See https://docs.convex.dev/production/best-practices/#use-helper-functions-to-write-shared-code`
+    );
+    return handler(ctx, args);
+  };
+}
+function serializeConvexErrorData(thrown) {
+  if (typeof thrown === "object" && thrown !== null && Symbol.for("ConvexError") in thrown) {
+    const error = thrown;
+    error.data = JSON.stringify(
+      convexToJson(error.data === void 0 ? null : error.data)
+    );
+    error.ConvexErrorSymbol = Symbol.for("ConvexError");
+    return error;
+  } else {
+    return thrown;
+  }
+}
+function assertNotBrowser() {
+  if (typeof window === "undefined" || window.__convexAllowFunctionsInBrowser) {
+    return;
+  }
+  const isRealBrowser = Object.getOwnPropertyDescriptor(globalThis, "window")?.get?.toString().includes("[native code]") ?? false;
+  if (isRealBrowser) {
+    console.error(
+      "Convex functions should not be imported in the browser. This will throw an error in future versions of `convex`. If this is a false negative, please report it to Convex support."
+    );
+  }
+}
+async function invokeHttpAction(func, request) {
+  const requestId = "";
+  const calls = setupActionCalls(requestId);
+  const ctx = {
+    ...calls,
+    auth: setupAuth(requestId),
+    storage: setupStorageActionWriter(requestId),
+    scheduler: setupActionScheduler(requestId),
+    vectorSearch: setupActionVectorSearch(requestId)
+  };
+  return await invokeFunction(func, ctx, [request]);
+}
+const httpActionGeneric = (func) => {
+  const q = dontCallDirectly("httpAction", func);
+  assertNotBrowser();
+  q.isHttp = true;
+  q.invokeHttpAction = (request) => invokeHttpAction(func, request);
+  q._handler = 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 __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+class InstalledComponent {
+  constructor(definition, name) {
+    /**
+     * @internal
+     */
+    __publicField(this, "_definition");
+    /**
+     * @internal
+     */
+    __publicField(this, "_name");
+    this._definition = definition;
+    this._name = name;
+    setReferencePath(this, `_reference/childComponent/${name}`);
+  }
+  get exports() {
+    return createExports(this._name, []);
+  }
+}
+function createExports(name, pathParts) {
+  const handler = {
+    get(_, prop) {
+      if (typeof prop === "string") {
+        const newParts = [...pathParts, prop];
+        return createExports(name, newParts);
+      } else if (prop === toReferencePath) {
+        let reference = `_reference/childComponent/${name}`;
+        for (const part of pathParts) {
+          reference += `/${part}`;
+        }
+        return reference;
+      } else {
+        return void 0;
+      }
+    }
+  };
+  return new Proxy({}, handler);
+}
+function use(definition, options) {
+  const importedComponentDefinition = definition;
+  if (typeof importedComponentDefinition.componentDefinitionPath !== "string") {
+    throw new Error(
+      "Component definition does not have the required componentDefinitionPath property. This code only works in Convex runtime."
+    );
+  }
+  const name = options?.name || // added recently
+  importedComponentDefinition.defaultName || // can be removed once backend is out
+  importedComponentDefinition.componentDefinitionPath.split("/").pop();
+  this._childComponents.push([name, importedComponentDefinition, {}]);
+  return new InstalledComponent(definition, name);
+}
+function serializeExportTree(tree) {
+  const branch = [];
+  for (const [key, child] of Object.entries(tree)) {
+    let node;
+    if (typeof child === "string") {
+      node = { type: "leaf", leaf: child };
+    } else {
+      node = serializeExportTree(child);
+    }
+    branch.push([key, node]);
+  }
+  return { type: "branch", branch };
+}
+function serializeChildComponents(childComponents) {
+  return childComponents.map(([name, definition, p]) => {
+    let args = null;
+    if (p !== null) {
+      args = [];
+      for (const [name2, value] of Object.entries(p)) {
+        if (value !== void 0) {
+          args.push([
+            name2,
+            { type: "value", value: JSON.stringify(convexToJson(value)) }
+          ]);
+        }
+      }
+    }
+    const path = definition.componentDefinitionPath;
+    if (!path)
+      throw new Error(
+        "no .componentPath for component definition " + JSON.stringify(definition, null, 2)
+      );
+    return {
+      name,
+      path,
+      args
+    };
+  });
+}
+function exportComponentForAnalysis() {
+  const args = Object.entries(
+    this._args
+  ).map(([name, validator]) => [
+    name,
+    {
+      type: "value",
+      value: JSON.stringify(validator.json)
+    }
+  ]);
+  const definitionType = {
+    type: "childComponent",
+    name: this._name,
+    args
+  };
+  const childComponents = serializeChildComponents(this._childComponents);
+  return {
+    name: this._name,
+    definitionType,
+    childComponents,
+    httpMounts: {},
+    exports: serializeExportTree(this._exportTree)
+  };
+}
+function defineComponent(name) {
+  const ret = {
+    _isRoot: false,
+    _name: name,
+    _args: {},
+    _childComponents: [],
+    _exportTree: {},
+    _onInitCallbacks: {},
+    export: exportComponentForAnalysis,
+    use,
+    // pretend to conform to ComponentDefinition, which temporarily expects __args
+    ...{}
+  };
+  return ret;
+}
+
+var convex_config = defineComponent("dodopayments");
+
+/* eslint-disable */
+/**
+ * Generated utilities for implementing server-side Convex query and mutation functions.
+ *
+ * THIS CODE IS AUTOMATICALLY GENERATED.
+ *
+ * To regenerate, run `npx convex dev`.
+ * @module
+ */
+
+
+/**
+ * Define a Convex HTTP action.
+ *
+ * @param func - The function. It receives an {@link ActionCtx} as its first argument, and a `Request` object
+ * as its second.
+ * @returns The wrapped endpoint function. Route a URL path to this function in `convex/http.js`.
+ */
+const httpAction = httpActionGeneric;
+
+var PaymentSchema = z.object({
+    payload_type: z.literal("Payment"),
+    billing: z.object({
+        city: z.string().nullable(),
+        country: z.string().nullable(),
+        state: z.string().nullable(),
+        street: z.string().nullable(),
+        zipcode: z.string().nullable(),
+    }),
+    brand_id: z.string(),
+    business_id: z.string(),
+    card_issuing_country: z.string().nullable(),
+    card_last_four: z.string().nullable(),
+    card_network: z.string().nullable(),
+    card_type: z.string().nullable(),
+    created_at: z.string().transform(function (d) { return new Date(d); }),
+    currency: z.string(),
+    customer: z.object({
+        customer_id: z.string(),
+        email: z.string(),
+        name: z.string().nullable(),
+    }),
+    digital_products_delivered: z.boolean(),
+    discount_id: z.string().nullable(),
+    disputes: z
+        .array(z.object({
+        amount: z.string(),
+        business_id: z.string(),
+        created_at: z.string().transform(function (d) { return new Date(d); }),
+        currency: z.string(),
+        dispute_id: z.string(),
+        dispute_stage: z.enum([
+            "pre_dispute",
+            "dispute_opened",
+            "dispute_won",
+            "dispute_lost",
+        ]),
+        dispute_status: z.enum([
+            "dispute_opened",
+            "dispute_won",
+            "dispute_lost",
+            "dispute_accepted",
+            "dispute_cancelled",
+            "dispute_challenged",
+        ]),
+        payment_id: z.string(),
+        remarks: z.string().nullable(),
+    }))
+        .nullable(),
+    error_code: z.string().nullable(),
+    error_message: z.string().nullable(),
+    metadata: z.record(z.any()).nullable(),
+    payment_id: z.string(),
+    payment_link: z.string().nullable(),
+    payment_method: z.string().nullable(),
+    payment_method_type: z.string().nullable(),
+    product_cart: z
+        .array(z.object({
+        product_id: z.string(),
+        quantity: z.number(),
+    }))
+        .nullable(),
+    refunds: z
+        .array(z.object({
+        amount: z.number(),
+        business_id: z.string(),
+        created_at: z.string().transform(function (d) { return new Date(d); }),
+        currency: z.string(),
+        is_partial: z.boolean(),
+        payment_id: z.string(),
+        reason: z.string().nullable(),
+        refund_id: z.string(),
+        status: z.enum(["succeeded", "failed", "pending"]),
+    }))
+        .nullable(),
+    settlement_amount: z.number(),
+    settlement_currency: z.string(),
+    settlement_tax: z.number().nullable(),
+    status: z.enum(["succeeded", "failed", "pending", "processing", "cancelled"]),
+    subscription_id: z.string().nullable(),
+    tax: z.number().nullable(),
+    total_amount: z.number(),
+    updated_at: z
+        .string()
+        .transform(function (d) { return new Date(d); })
+        .nullable(),
+});
+var SubscriptionSchema = z.object({
+    payload_type: z.literal("Subscription"),
+    addons: z
+        .array(z.object({
+        addon_id: z.string(),
+        quantity: z.number(),
+    }))
+        .nullable(),
+    billing: z.object({
+        city: z.string().nullable(),
+        country: z.string().nullable(),
+        state: z.string().nullable(),
+        street: z.string().nullable(),
+        zipcode: z.string().nullable(),
+    }),
+    cancel_at_next_billing_date: z.boolean(),
+    cancelled_at: z
+        .string()
+        .transform(function (d) { return new Date(d); })
+        .nullable(),
+    created_at: z.string().transform(function (d) { return new Date(d); }),
+    currency: z.string(),
+    customer: z.object({
+        customer_id: z.string(),
+        email: z.string(),
+        name: z.string().nullable(),
+    }),
+    discount_id: z.string().nullable(),
+    metadata: z.record(z.any()).nullable(),
+    next_billing_date: z
+        .string()
+        .transform(function (d) { return new Date(d); })
+        .nullable(),
+    on_demand: z.boolean(),
+    payment_frequency_count: z.number(),
+    payment_frequency_interval: z.enum(["Day", "Week", "Month", "Year"]),
+    previous_billing_date: z
+        .string()
+        .transform(function (d) { return new Date(d); })
+        .nullable(),
+    product_id: z.string(),
+    quantity: z.number(),
+    recurring_pre_tax_amount: z.number(),
+    status: z.enum([
+        "pending",
+        "active",
+        "on_hold",
+        "paused",
+        "cancelled",
+        "expired",
+        "failed",
+    ]),
+    subscription_id: z.string(),
+    subscription_period_count: z.number(),
+    subscription_period_interval: z.enum(["Day", "Week", "Month", "Year"]),
+    tax_inclusive: z.boolean(),
+    trial_period_days: z.number(),
+});
+var RefundSchema = z.object({
+    payload_type: z.literal("Refund"),
+    amount: z.number(),
+    business_id: z.string(),
+    created_at: z.string().transform(function (d) { return new Date(d); }),
+    currency: z.string(),
+    is_partial: z.boolean(),
+    payment_id: z.string(),
+    reason: z.string().nullable(),
+    refund_id: z.string(),
+    status: z.enum(["succeeded", "failed", "pending"]),
+});
+var DisputeSchema = z.object({
+    payload_type: z.literal("Dispute"),
+    amount: z.string(),
+    business_id: z.string(),
+    created_at: z.string().transform(function (d) { return new Date(d); }),
+    currency: z.string(),
+    dispute_id: z.string(),
+    dispute_stage: z.enum([
+        "pre_dispute",
+        "dispute_opened",
+        "dispute_won",
+        "dispute_lost",
+    ]),
+    dispute_status: z.enum([
+        "dispute_opened",
+        "dispute_won",
+        "dispute_lost",
+        "dispute_accepted",
+        "dispute_cancelled",
+        "dispute_challenged",
+    ]),
+    payment_id: z.string(),
+    remarks: z.string().nullable(),
+});
+var LicenseKeySchema = z.object({
+    payload_type: z.literal("LicenseKey"),
+    activations_limit: z.number(),
+    business_id: z.string(),
+    created_at: z.string().transform(function (d) { return new Date(d); }),
+    customer_id: z.string(),
+    expires_at: z
+        .string()
+        .transform(function (d) { return new Date(d); })
+        .nullable(),
+    id: z.string(),
+    instances_count: z.number(),
+    key: z.string(),
+    payment_id: z.string(),
+    product_id: z.string(),
+    status: z.enum(["active", "inactive", "expired"]),
+    subscription_id: z.string().nullable(),
+});
+var PaymentSucceededPayloadSchema = z.object({
+    business_id: z.string(),
+    type: z.literal("payment.succeeded"),
+    timestamp: z.string().transform(function (d) { return new Date(d); }),
+    data: PaymentSchema,
+});
+var PaymentFailedPayloadSchema = z.object({
+    business_id: z.string(),
+    type: z.literal("payment.failed"),
+    timestamp: z.string().transform(function (d) { return new Date(d); }),
+    data: PaymentSchema,
+});
+var PaymentProcessingPayloadSchema = z.object({
+    business_id: z.string(),
+    type: z.literal("payment.processing"),
+    timestamp: z.string().transform(function (d) { return new Date(d); }),
+    data: PaymentSchema,
+});
+var PaymentCancelledPayloadSchema = z.object({
+    business_id: z.string(),
+    type: z.literal("payment.cancelled"),
+    timestamp: z.string().transform(function (d) { return new Date(d); }),
+    data: PaymentSchema,
+});
+var RefundSucceededPayloadSchema = z.object({
+    business_id: z.string(),
+    type: z.literal("refund.succeeded"),
+    timestamp: z.string().transform(function (d) { return new Date(d); }),
+    data: RefundSchema,
+});
+var RefundFailedPayloadSchema = z.object({
+    business_id: z.string(),
+    type: z.literal("refund.failed"),
+    timestamp: z.string().transform(function (d) { return new Date(d); }),
+    data: RefundSchema,
+});
+var DisputeOpenedPayloadSchema = z.object({
+    business_id: z.string(),
+    type: z.literal("dispute.opened"),
+    timestamp: z.string().transform(function (d) { return new Date(d); }),
+    data: DisputeSchema,
+});
+var DisputeExpiredPayloadSchema = z.object({
+    business_id: z.string(),
+    type: z.literal("dispute.expired"),
+    timestamp: z.string().transform(function (d) { return new Date(d); }),
+    data: DisputeSchema,
+});
+var DisputeAcceptedPayloadSchema = z.object({
+    business_id: z.string(),
+    type: z.literal("dispute.accepted"),
+    timestamp: z.string().transform(function (d) { return new Date(d); }),
+    data: DisputeSchema,
+});
+var DisputeCancelledPayloadSchema = z.object({
+    business_id: z.string(),
+    type: z.literal("dispute.cancelled"),
+    timestamp: z.string().transform(function (d) { return new Date(d); }),
+    data: DisputeSchema,
+});
+var DisputeChallengedPayloadSchema = z.object({
+    business_id: z.string(),
+    type: z.literal("dispute.challenged"),
+    timestamp: z.string().transform(function (d) { return new Date(d); }),
+    data: DisputeSchema,
+});
+var DisputeWonPayloadSchema = z.object({
+    business_id: z.string(),
+    type: z.literal("dispute.won"),
+    timestamp: z.string().transform(function (d) { return new Date(d); }),
+    data: DisputeSchema,
+});
+var DisputeLostPayloadSchema = z.object({
+    business_id: z.string(),
+    type: z.literal("dispute.lost"),
+    timestamp: z.string().transform(function (d) { return new Date(d); }),
+    data: DisputeSchema,
+});
+var SubscriptionActivePayloadSchema = z.object({
+    business_id: z.string(),
+    type: z.literal("subscription.active"),
+    timestamp: z.string().transform(function (d) { return new Date(d); }),
+    data: SubscriptionSchema,
+});
+var SubscriptionOnHoldPayloadSchema = z.object({
+    business_id: z.string(),
+    type: z.literal("subscription.on_hold"),
+    timestamp: z.string().transform(function (d) { return new Date(d); }),
+    data: SubscriptionSchema,
+});
+var SubscriptionRenewedPayloadSchema = z.object({
+    business_id: z.string(),
+    type: z.literal("subscription.renewed"),
+    timestamp: z.string().transform(function (d) { return new Date(d); }),
+    data: SubscriptionSchema,
+});
+var SubscriptionPausedPayloadSchema = z.object({
+    business_id: z.string(),
+    type: z.literal("subscription.paused"),
+    timestamp: z.string().transform(function (d) { return new Date(d); }),
+    data: SubscriptionSchema,
+});
+var SubscriptionPlanChangedPayloadSchema = z.object({
+    business_id: z.string(),
+    type: z.literal("subscription.plan_changed"),
+    timestamp: z.string().transform(function (d) { return new Date(d); }),
+    data: SubscriptionSchema,
+});
+var SubscriptionCancelledPayloadSchema = z.object({
+    business_id: z.string(),
+    type: z.literal("subscription.cancelled"),
+    timestamp: z.string().transform(function (d) { return new Date(d); }),
+    data: SubscriptionSchema,
+});
+var SubscriptionFailedPayloadSchema = z.object({
+    business_id: z.string(),
+    type: z.literal("subscription.failed"),
+    timestamp: z.string().transform(function (d) { return new Date(d); }),
+    data: SubscriptionSchema,
+});
+var SubscriptionExpiredPayloadSchema = z.object({
+    business_id: z.string(),
+    type: z.literal("subscription.expired"),
+    timestamp: z.string().transform(function (d) { return new Date(d); }),
+    data: SubscriptionSchema,
+});
+var LicenseKeyCreatedPayloadSchema = z.object({
+    business_id: z.string(),
+    type: z.literal("license_key.created"),
+    timestamp: z.string().transform(function (d) { return new Date(d); }),
+    data: LicenseKeySchema,
+});
+var WebhookPayloadSchema = z.discriminatedUnion("type", [
+    PaymentSucceededPayloadSchema,
+    PaymentFailedPayloadSchema,
+    PaymentProcessingPayloadSchema,
+    PaymentCancelledPayloadSchema,
+    RefundSucceededPayloadSchema,
+    RefundFailedPayloadSchema,
+    DisputeOpenedPayloadSchema,
+    DisputeExpiredPayloadSchema,
+    DisputeAcceptedPayloadSchema,
+    DisputeCancelledPayloadSchema,
+    DisputeChallengedPayloadSchema,
+    DisputeWonPayloadSchema,
+    DisputeLostPayloadSchema,
+    SubscriptionActivePayloadSchema,
+    SubscriptionOnHoldPayloadSchema,
+    SubscriptionRenewedPayloadSchema,
+    SubscriptionPausedPayloadSchema,
+    SubscriptionPlanChangedPayloadSchema,
+    SubscriptionCancelledPayloadSchema,
+    SubscriptionFailedPayloadSchema,
+    SubscriptionExpiredPayloadSchema,
+    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;
+function assert(expr, 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;
+}
+timing_safe_equal.timingSafeEqual = timingSafeEqual;
+
+var base64$1 = {};
+
+// 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]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        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) {
+            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);
+            if (left === 2) {
+                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 (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 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) {
+            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;
+            haveBad |= v0 & INVALID_BYTE;
+            haveBad |= v1 & INVALID_BYTE;
+            haveBad |= v2 & INVALID_BYTE;
+            haveBad |= v3 & INVALID_BYTE;
+        }
+        if (i < length - 1) {
+            v0 = this._decodeChar(s.charCodeAt(i));
+            v1 = this._decodeChar(s.charCodeAt(i + 1));
+            out[op++] = (v0 << 2) | (v1 >>> 4);
+            haveBad |= v0 & INVALID_BYTE;
+            haveBad |= v1 & INVALID_BYTE;
+        }
+        if (i < length - 2) {
+            v2 = this._decodeChar(s.charCodeAt(i + 2));
+            out[op++] = (v1 << 4) | (v2 >>> 2);
+            haveBad |= v2 & INVALID_BYTE;
+        }
+        if (i < length - 3) {
+            v3 = this._decodeChar(s.charCodeAt(i + 3));
+            out[op++] = (v2 << 6) | v3;
+            haveBad |= v3 & INVALID_BYTE;
+        }
+        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) {
+            for (var i = s.length - 1; i >= 0; i--) {
+                if (s[i] !== this._paddingCharacter) {
+                    break;
+                }
+                paddingLength++;
+            }
+            if (s.length < 4 || paddingLength > 2) {
+                throw new Error("Base64Coder: incorrect padding");
+            }
+        }
+        return paddingLength;
+    };
+    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);
+    };
+    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;
+    };
+    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;
+
+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;
+    }
+}
+class WebhookVerificationError extends ExtendableError {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, WebhookVerificationError.prototype);
+        this.name = "WebhookVerificationError";
+    }
+}
+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);
+        }
+    }
+    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");
+    }
+    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}`;
+    }
+    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);
+    }
+}
+Webhook_1 = dist.Webhook = Webhook;
+Webhook.prefix = "whsec_";
+
+var __awaiter = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (undefined && undefined.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var handleWebhookPayload = function (payload, config) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (!config.onPayload) return [3 /*break*/, 2];
+                return [4 /*yield*/, config.onPayload(payload)];
+            case 1:
+                _a.sent();
+                _a.label = 2;
+            case 2:
+                if (!(payload.type === "payment.succeeded" && config.onPaymentSucceeded)) return [3 /*break*/, 4];
+                return [4 /*yield*/, config.onPaymentSucceeded(payload)];
+            case 3:
+                _a.sent();
+                _a.label = 4;
+            case 4:
+                if (!(payload.type === "payment.failed" && config.onPaymentFailed)) return [3 /*break*/, 6];
+                return [4 /*yield*/, config.onPaymentFailed(payload)];
+            case 5:
+                _a.sent();
+                _a.label = 6;
+            case 6:
+                if (!(payload.type === "payment.processing" && config.onPaymentProcessing)) return [3 /*break*/, 8];
+                return [4 /*yield*/, config.onPaymentProcessing(payload)];
+            case 7:
+                _a.sent();
+                _a.label = 8;
+            case 8:
+                if (!(payload.type === "payment.cancelled" && config.onPaymentCancelled)) return [3 /*break*/, 10];
+                return [4 /*yield*/, config.onPaymentCancelled(payload)];
+            case 9:
+                _a.sent();
+                _a.label = 10;
+            case 10:
+                if (!(payload.type === "refund.succeeded" && config.onRefundSucceeded)) return [3 /*break*/, 12];
+                return [4 /*yield*/, config.onRefundSucceeded(payload)];
+            case 11:
+                _a.sent();
+                _a.label = 12;
+            case 12:
+                if (!(payload.type === "refund.failed" && config.onRefundFailed)) return [3 /*break*/, 14];
+                return [4 /*yield*/, config.onRefundFailed(payload)];
+            case 13:
+                _a.sent();
+                _a.label = 14;
+            case 14:
+                if (!(payload.type === "dispute.opened" && config.onDisputeOpened)) return [3 /*break*/, 16];
+                return [4 /*yield*/, config.onDisputeOpened(payload)];
+            case 15:
+                _a.sent();
+                _a.label = 16;
+            case 16:
+                if (!(payload.type === "dispute.expired" && config.onDisputeExpired)) return [3 /*break*/, 18];
+                return [4 /*yield*/, config.onDisputeExpired(payload)];
+            case 17:
+                _a.sent();
+                _a.label = 18;
+            case 18:
+                if (!(payload.type === "dispute.accepted" && config.onDisputeAccepted)) return [3 /*break*/, 20];
+                return [4 /*yield*/, config.onDisputeAccepted(payload)];
+            case 19:
+                _a.sent();
+                _a.label = 20;
+            case 20:
+                if (!(payload.type === "dispute.cancelled" && config.onDisputeCancelled)) return [3 /*break*/, 22];
+                return [4 /*yield*/, config.onDisputeCancelled(payload)];
+            case 21:
+                _a.sent();
+                _a.label = 22;
+            case 22:
+                if (!(payload.type === "dispute.challenged" && config.onDisputeChallenged)) return [3 /*break*/, 24];
+                return [4 /*yield*/, config.onDisputeChallenged(payload)];
+            case 23:
+                _a.sent();
+                _a.label = 24;
+            case 24:
+                if (!(payload.type === "dispute.won" && config.onDisputeWon)) return [3 /*break*/, 26];
+                return [4 /*yield*/, config.onDisputeWon(payload)];
+            case 25:
+                _a.sent();
+                _a.label = 26;
+            case 26:
+                if (!(payload.type === "dispute.lost" && config.onDisputeLost)) return [3 /*break*/, 28];
+                return [4 /*yield*/, config.onDisputeLost(payload)];
+            case 27:
+                _a.sent();
+                _a.label = 28;
+            case 28:
+                if (!(payload.type === "subscription.active" && config.onSubscriptionActive)) return [3 /*break*/, 30];
+                return [4 /*yield*/, config.onSubscriptionActive(payload)];
+            case 29:
+                _a.sent();
+                _a.label = 30;
+            case 30:
+                if (!(payload.type === "subscription.on_hold" && config.onSubscriptionOnHold)) return [3 /*break*/, 32];
+                return [4 /*yield*/, config.onSubscriptionOnHold(payload)];
+            case 31:
+                _a.sent();
+                _a.label = 32;
+            case 32:
+                if (!(payload.type === "subscription.renewed" && config.onSubscriptionRenewed)) return [3 /*break*/, 34];
+                return [4 /*yield*/, config.onSubscriptionRenewed(payload)];
+            case 33:
+                _a.sent();
+                _a.label = 34;
+            case 34:
+                if (!(payload.type === "subscription.paused" && config.onSubscriptionPaused)) return [3 /*break*/, 36];
+                return [4 /*yield*/, config.onSubscriptionPaused(payload)];
+            case 35:
+                _a.sent();
+                _a.label = 36;
+            case 36:
+                if (!(payload.type === "subscription.plan_changed" &&
+                    config.onSubscriptionPlanChanged)) return [3 /*break*/, 38];
+                return [4 /*yield*/, config.onSubscriptionPlanChanged(payload)];
+            case 37:
+                _a.sent();
+                _a.label = 38;
+            case 38:
+                if (!(payload.type === "subscription.cancelled" &&
+                    config.onSubscriptionCancelled)) return [3 /*break*/, 40];
+                return [4 /*yield*/, config.onSubscriptionCancelled(payload)];
+            case 39:
+                _a.sent();
+                _a.label = 40;
+            case 40:
+                if (!(payload.type === "subscription.failed" && config.onSubscriptionFailed)) return [3 /*break*/, 42];
+                return [4 /*yield*/, config.onSubscriptionFailed(payload)];
+            case 41:
+                _a.sent();
+                _a.label = 42;
+            case 42:
+                if (!(payload.type === "subscription.expired" && config.onSubscriptionExpired)) return [3 /*break*/, 44];
+                return [4 /*yield*/, config.onSubscriptionExpired(payload)];
+            case 43:
+                _a.sent();
+                _a.label = 44;
+            case 44:
+                if (!(payload.type === "license_key.created" && config.onLicenseKeyCreated)) return [3 /*break*/, 46];
+                return [4 /*yield*/, config.onLicenseKeyCreated(payload)];
+            case 45:
+                _a.sent();
+                _a.label = 46;
+            case 46: return [2 /*return*/];
+        }
+    });
+}); };
+var verifyWebhookPayload = function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
+    var standardWebhook, _c, success, payload, error;
+    var webhookKey = _b.webhookKey, headers = _b.headers, body = _b.body;
+    return __generator(this, function (_d) {
+        standardWebhook = new Webhook_1(webhookKey);
+        try {
+            standardWebhook.verify(body, headers);
+        }
+        catch (e) {
+            if (e instanceof WebhookVerificationError_1) {
+                throw new Error(e.message);
+            }
+            throw e;
+        }
+        _c = WebhookPayloadSchema.safeParse(JSON.parse(body)), success = _c.success, payload = _c.data, error = _c.error;
+        if (!success) {
+            throw new Error(error.message);
+        }
+        return [2 /*return*/, payload];
+    });
+}); };
+
+/**
+ * Creates a Convex HTTP action to securely handle Dodo Payments webhooks.
+ *
+ * @param handlers - An object containing your webhook event handlers (e.g., onPaymentSucceeded).
+ * @returns A Convex HTTP action.
+ */
+const createDodoWebhookHandler = (handlers) => {
+    return httpAction(async (_, request) => {
+        const webhookSecret = process.env.DODO_PAYMENTS_WEBHOOK_SECRET;
+        if (!webhookSecret) {
+            throw new Error("DODO_PAYMENTS_WEBHOOK_SECRET environment variable is not set.");
+        }
+        const body = await request.text();
+        const headers = {};
+        request.headers.forEach((value, key) => {
+            headers[key] = value;
+        });
+        try {
+            const payload = await verifyWebhookPayload({
+                webhookKey: webhookSecret,
+                headers,
+                body,
+            });
+            await handleWebhookPayload(payload, {
+                webhookKey: webhookSecret,
+                ...handlers,
+            });
+            return new Response(null, { status: 200 });
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error occurred';
+            console.error("Dodo Payments Webhook Error:", errorMessage);
+            return new Response("Error while processing webhook", { status: 400 });
+        }
+    });
+};
+
+export { DodoPayments, convex_config as component, createDodoWebhookHandler };
+//# sourceMappingURL=index.js.map