@agnostack/next-shopify 1.14.1 → 1.15.0-alpha.1

package/dist/umd/verification/index.js

@@ -0,0 +1,1234 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["@agnostack/next-shopify/verification"] = {}));
+})(this, (function (exports) { 'use strict';
+
+  const COLLECTION_ROOT = 'oauth-data';
+
+  const PAGE_ROUTE_NAMES = {
+    EXIT: 'pageRouteExit',
+    ERROR: 'pageRouteError',
+    SUCCESS: 'pageRouteSuccess',
+  };
+
+  const API_WEBHOOK_TOPICS = {
+    APP_UNINSTALLED: 'APP_UNINSTALLED',
+    APP_PURCHASES_ONE_TIME_UPDATE: 'APP_PURCHASES_ONE_TIME_UPDATE',
+    APP_SUBSCRIPTIONS_APPROACHING_CAPPED_AMOUNT: 'APP_SUBSCRIPTIONS_APPROACHING_CAPPED_AMOUNT',
+    APP_SUBSCRIPTIONS_UPDATE: 'APP_SUBSCRIPTIONS_UPDATE',
+    ATTRIBUTED_SESSIONS_FIRST: 'ATTRIBUTED_SESSIONS_FIRST',
+    ATTRIBUTED_SESSIONS_LAST: 'ATTRIBUTED_SESSIONS_LAST',
+    AUDIT_EVENTS_ADMIN_API_ACTIVITY: 'AUDIT_EVENTS_ADMIN_API_ACTIVITY',
+    BULK_OPERATIONS_FINISH: 'BULK_OPERATIONS_FINISH',
+    CARTS_CREATE: 'CARTS_CREATE',
+    CARTS_UPDATE: 'CARTS_UPDATE',
+    CHANNELS_DELETE: 'CHANNELS_DELETE',
+    CHECKOUTS_CREATE: 'CHECKOUTS_CREATE',
+    CHECKOUTS_DELETE: 'CHECKOUTS_DELETE',
+    CHECKOUTS_UPDATE: 'CHECKOUTS_UPDATE',
+    COLLECTIONS_CREATE: 'COLLECTIONS_CREATE',
+    COLLECTIONS_DELETE: 'COLLECTIONS_DELETE',
+    COLLECTIONS_UPDATE: 'COLLECTIONS_UPDATE',
+    COLLECTION_LISTINGS_ADD: 'COLLECTION_LISTINGS_ADD',
+    COLLECTION_LISTINGS_REMOVE: 'COLLECTION_LISTINGS_REMOVE',
+    COLLECTION_LISTINGS_UPDATE: 'COLLECTION_LISTINGS_UPDATE',
+    COLLECTION_PUBLICATIONS_CREATE: 'COLLECTION_PUBLICATIONS_CREATE',
+    COLLECTION_PUBLICATIONS_DELETE: 'COLLECTION_PUBLICATIONS_DELETE',
+    COLLECTION_PUBLICATIONS_UPDATE: 'COLLECTION_PUBLICATIONS_UPDATE',
+    COMPANIES_CREATE: 'COMPANIES_CREATE',
+    COMPANIES_DELETE: 'COMPANIES_DELETE',
+    COMPANIES_UPDATE: 'COMPANIES_UPDATE',
+    COMPANY_CONTACTS_CREATE: 'COMPANY_CONTACTS_CREATE',
+    COMPANY_CONTACTS_DELETE: 'COMPANY_CONTACTS_DELETE',
+    COMPANY_CONTACTS_UPDATE: 'COMPANY_CONTACTS_UPDATE',
+    COMPANY_LOCATIONS_CREATE: 'COMPANY_LOCATIONS_CREATE',
+    COMPANY_LOCATIONS_DELETE: 'COMPANY_LOCATIONS_DELETE',
+    COMPANY_LOCATIONS_UPDATE: 'COMPANY_LOCATIONS_UPDATE',
+    CUSTOMERS_CREATE: 'CUSTOMERS_CREATE',
+    CUSTOMERS_DELETE: 'CUSTOMERS_DELETE',
+    CUSTOMERS_DISABLE: 'CUSTOMERS_DISABLE',
+    CUSTOMERS_ENABLE: 'CUSTOMERS_ENABLE',
+    CUSTOMERS_MARKETING_CONSENT_UPDATE: 'CUSTOMERS_MARKETING_CONSENT_UPDATE',
+    CUSTOMERS_MERGE: 'CUSTOMERS_MERGE',
+    CUSTOMERS_UPDATE: 'CUSTOMERS_UPDATE',
+    CUSTOMER_GROUPS_CREATE: 'CUSTOMER_GROUPS_CREATE',
+    CUSTOMER_GROUPS_DELETE: 'CUSTOMER_GROUPS_DELETE',
+    CUSTOMER_GROUPS_UPDATE: 'CUSTOMER_GROUPS_UPDATE',
+    CUSTOMER_PAYMENT_METHODS_CREATE: 'CUSTOMER_PAYMENT_METHODS_CREATE',
+    CUSTOMER_PAYMENT_METHODS_REVOKE: 'CUSTOMER_PAYMENT_METHODS_REVOKE',
+    CUSTOMER_PAYMENT_METHODS_UPDATE: 'CUSTOMER_PAYMENT_METHODS_UPDATE',
+    DISPUTES_CREATE: 'DISPUTES_CREATE',
+    DISPUTES_UPDATE: 'DISPUTES_UPDATE',
+    DOMAINS_CREATE: 'DOMAINS_CREATE',
+    DOMAINS_DESTROY: 'DOMAINS_DESTROY',
+    DOMAINS_UPDATE: 'DOMAINS_UPDATE',
+    DRAFT_ORDERS_CREATE: 'DRAFT_ORDERS_CREATE',
+    DRAFT_ORDERS_DELETE: 'DRAFT_ORDERS_DELETE',
+    DRAFT_ORDERS_UPDATE: 'DRAFT_ORDERS_UPDATE',
+    FULFILLMENTS_CREATE: 'FULFILLMENTS_CREATE',
+    FULFILLMENTS_UPDATE: 'FULFILLMENTS_UPDATE',
+    FULFILLMENT_EVENTS_CREATE: 'FULFILLMENT_EVENTS_CREATE',
+    FULFILLMENT_EVENTS_DELETE: 'FULFILLMENT_EVENTS_DELETE',
+    FULFILLMENT_ORDERS_CANCELLATION_REQUEST_ACCEPTED: 'FULFILLMENT_ORDERS_CANCELLATION_REQUEST_ACCEPTED',
+    FULFILLMENT_ORDERS_CANCELLATION_REQUEST_REJECTED: 'FULFILLMENT_ORDERS_CANCELLATION_REQUEST_REJECTED',
+    FULFILLMENT_ORDERS_CANCELLATION_REQUEST_SUBMITTED: 'FULFILLMENT_ORDERS_CANCELLATION_REQUEST_SUBMITTED',
+    FULFILLMENT_ORDERS_CANCELLED: 'FULFILLMENT_ORDERS_CANCELLED',
+    FULFILLMENT_ORDERS_FULFILLMENT_REQUEST_ACCEPTED: 'FULFILLMENT_ORDERS_FULFILLMENT_REQUEST_ACCEPTED',
+    FULFILLMENT_ORDERS_FULFILLMENT_REQUEST_REJECTED: 'FULFILLMENT_ORDERS_FULFILLMENT_REQUEST_REJECTED',
+    FULFILLMENT_ORDERS_FULFILLMENT_REQUEST_SUBMITTED: 'FULFILLMENT_ORDERS_FULFILLMENT_REQUEST_SUBMITTED',
+    FULFILLMENT_ORDERS_FULFILLMENT_SERVICE_FAILED_TO_COMPLETE: 'FULFILLMENT_ORDERS_FULFILLMENT_SERVICE_FAILED_TO_COMPLETE',
+    FULFILLMENT_ORDERS_HOLD_RELEASED: 'FULFILLMENT_ORDERS_HOLD_RELEASED',
+    FULFILLMENT_ORDERS_LINE_ITEMS_PREPARED_FOR_LOCAL_DELIVERY: 'FULFILLMENT_ORDERS_LINE_ITEMS_PREPARED_FOR_LOCAL_DELIVERY',
+    FULFILLMENT_ORDERS_LINE_ITEMS_PREPARED_FOR_PICKUP: 'FULFILLMENT_ORDERS_LINE_ITEMS_PREPARED_FOR_PICKUP',
+    FULFILLMENT_ORDERS_MOVED: 'FULFILLMENT_ORDERS_MOVED',
+    FULFILLMENT_ORDERS_ORDER_ROUTING_COMPLETE: 'FULFILLMENT_ORDERS_ORDER_ROUTING_COMPLETE',
+    FULFILLMENT_ORDERS_PLACED_ON_HOLD: 'FULFILLMENT_ORDERS_PLACED_ON_HOLD',
+    FULFILLMENT_ORDERS_RESCHEDULED: 'FULFILLMENT_ORDERS_RESCHEDULED',
+    FULFILLMENT_ORDERS_SCHEDULED_FULFILLMENT_ORDER_READY: 'FULFILLMENT_ORDERS_SCHEDULED_FULFILLMENT_ORDER_READY',
+    INVENTORY_ITEMS_CREATE: 'INVENTORY_ITEMS_CREATE',
+    INVENTORY_ITEMS_DELETE: 'INVENTORY_ITEMS_DELETE',
+    INVENTORY_ITEMS_UPDATE: 'INVENTORY_ITEMS_UPDATE',
+    INVENTORY_LEVELS_CONNECT: 'INVENTORY_LEVELS_CONNECT',
+    INVENTORY_LEVELS_DISCONNECT: 'INVENTORY_LEVELS_DISCONNECT',
+    INVENTORY_LEVELS_UPDATE: 'INVENTORY_LEVELS_UPDATE',
+    LOCALES_CREATE: 'LOCALES_CREATE',
+    LOCALES_UPDATE: 'LOCALES_UPDATE',
+    LOCATIONS_ACTIVATE: 'LOCATIONS_ACTIVATE',
+    LOCATIONS_CREATE: 'LOCATIONS_CREATE',
+    LOCATIONS_DEACTIVATE: 'LOCATIONS_DEACTIVATE',
+    LOCATIONS_DELETE: 'LOCATIONS_DELETE',
+    LOCATIONS_UPDATE: 'LOCATIONS_UPDATE',
+    MARKETS_CREATE: 'MARKETS_CREATE',
+    MARKETS_DELETE: 'MARKETS_DELETE',
+    MARKETS_UPDATE: 'MARKETS_UPDATE',
+    ORDERS_CANCELLED: 'ORDERS_CANCELLED',
+    ORDERS_CREATE: 'ORDERS_CREATE',
+    ORDERS_DELETE: 'ORDERS_DELETE',
+    ORDERS_EDITED: 'ORDERS_EDITED',
+    ORDERS_FULFILLED: 'ORDERS_FULFILLED',
+    ORDERS_PAID: 'ORDERS_PAID',
+    ORDERS_PARTIALLY_FULFILLED: 'ORDERS_PARTIALLY_FULFILLED',
+    ORDERS_UPDATED: 'ORDERS_UPDATED',
+    ORDER_TRANSACTIONS_CREATE: 'ORDER_TRANSACTIONS_CREATE',
+    PAYMENT_SCHEDULES_DUE: 'PAYMENT_SCHEDULES_DUE',
+    PAYMENT_TERMS_CREATE: 'PAYMENT_TERMS_CREATE',
+    PAYMENT_TERMS_DELETE: 'PAYMENT_TERMS_DELETE',
+    PAYMENT_TERMS_UPDATE: 'PAYMENT_TERMS_UPDATE',
+    PRODUCTS_CREATE: 'PRODUCTS_CREATE',
+    PRODUCTS_DELETE: 'PRODUCTS_DELETE',
+    PRODUCTS_UPDATE: 'PRODUCTS_UPDATE',
+    PRODUCT_LISTINGS_ADD: 'PRODUCT_LISTINGS_ADD',
+    PRODUCT_LISTINGS_REMOVE: 'PRODUCT_LISTINGS_REMOVE',
+    PRODUCT_LISTINGS_UPDATE: 'PRODUCT_LISTINGS_UPDATE',
+    PRODUCT_PUBLICATIONS_CREATE: 'PRODUCT_PUBLICATIONS_CREATE',
+    PRODUCT_PUBLICATIONS_DELETE: 'PRODUCT_PUBLICATIONS_DELETE',
+    PRODUCT_PUBLICATIONS_UPDATE: 'PRODUCT_PUBLICATIONS_UPDATE',
+    PROFILES_CREATE: 'PROFILES_CREATE',
+    PROFILES_DELETE: 'PROFILES_DELETE',
+    PROFILES_UPDATE: 'PROFILES_UPDATE',
+    REFUNDS_CREATE: 'REFUNDS_CREATE',
+    RETURNS_APPROVE: 'RETURNS_APPROVE',
+    RETURNS_CANCEL: 'RETURNS_CANCEL',
+    RETURNS_CLOSE: 'RETURNS_CLOSE',
+    RETURNS_DECLINE: 'RETURNS_DECLINE',
+    RETURNS_REOPEN: 'RETURNS_REOPEN',
+    RETURNS_REQUEST: 'RETURNS_REQUEST',
+    REVERSE_DELIVERIES_ATTACH_DELIVERABLE: 'REVERSE_DELIVERIES_ATTACH_DELIVERABLE',
+    REVERSE_FULFILLMENT_ORDERS_DISPOSE: 'REVERSE_FULFILLMENT_ORDERS_DISPOSE',
+    SCHEDULED_PRODUCT_LISTINGS_ADD: 'SCHEDULED_PRODUCT_LISTINGS_ADD',
+    SCHEDULED_PRODUCT_LISTINGS_REMOVE: 'SCHEDULED_PRODUCT_LISTINGS_REMOVE',
+    SCHEDULED_PRODUCT_LISTINGS_UPDATE: 'SCHEDULED_PRODUCT_LISTINGS_UPDATE',
+    SEGMENTS_CREATE: 'SEGMENTS_CREATE',
+    SEGMENTS_DELETE: 'SEGMENTS_DELETE',
+    SEGMENTS_UPDATE: 'SEGMENTS_UPDATE',
+    SELLING_PLAN_GROUPS_CREATE: 'SELLING_PLAN_GROUPS_CREATE',
+    SELLING_PLAN_GROUPS_DELETE: 'SELLING_PLAN_GROUPS_DELETE',
+    SELLING_PLAN_GROUPS_UPDATE: 'SELLING_PLAN_GROUPS_UPDATE',
+    SHIPPING_ADDRESSES_CREATE: 'SHIPPING_ADDRESSES_CREATE',
+    SHIPPING_ADDRESSES_UPDATE: 'SHIPPING_ADDRESSES_UPDATE',
+    SHOP_UPDATE: 'SHOP_UPDATE',
+    SUBSCRIPTION_BILLING_ATTEMPTS_CHALLENGED: 'SUBSCRIPTION_BILLING_ATTEMPTS_CHALLENGED',
+    SUBSCRIPTION_BILLING_ATTEMPTS_FAILURE: 'SUBSCRIPTION_BILLING_ATTEMPTS_FAILURE',
+    SUBSCRIPTION_BILLING_ATTEMPTS_SUCCESS: 'SUBSCRIPTION_BILLING_ATTEMPTS_SUCCESS',
+    SUBSCRIPTION_BILLING_CYCLE_EDITS_CREATE: 'SUBSCRIPTION_BILLING_CYCLE_EDITS_CREATE',
+    SUBSCRIPTION_BILLING_CYCLE_EDITS_DELETE: 'SUBSCRIPTION_BILLING_CYCLE_EDITS_DELETE',
+    SUBSCRIPTION_BILLING_CYCLE_EDITS_UPDATE: 'SUBSCRIPTION_BILLING_CYCLE_EDITS_UPDATE',
+    SUBSCRIPTION_CONTRACTS_CREATE: 'SUBSCRIPTION_CONTRACTS_CREATE',
+    SUBSCRIPTION_CONTRACTS_UPDATE: 'SUBSCRIPTION_CONTRACTS_UPDATE',
+    TAX_SERVICES_CREATE: 'TAX_SERVICES_CREATE',
+    TAX_SERVICES_UPDATE: 'TAX_SERVICES_UPDATE',
+    TENDER_TRANSACTIONS_CREATE: 'TENDER_TRANSACTIONS_CREATE',
+    THEMES_CREATE: 'THEMES_CREATE',
+    THEMES_DELETE: 'THEMES_DELETE',
+    THEMES_PUBLISH: 'THEMES_PUBLISH',
+    THEMES_UPDATE: 'THEMES_UPDATE',
+    VARIANTS_IN_STOCK: 'VARIANTS_IN_STOCK',
+    VARIANTS_OUT_OF_STOCK: 'VARIANTS_OUT_OF_STOCK',
+    // NOTE: latest webhooks as of 6/3/23 UNSTABLE below (https://shopify.dev/docs/api/admin-graphql/unstable/enums/WebhookSubscriptionTopic)
+    CHECKOUTS_PAID: 'CHECKOUTS_PAID',
+    COMPANY_CONTACT_ROLES_ASSIGN: 'COMPANY_CONTACT_ROLES_ASSIGN',
+    COMPANY_CONTACT_ROLES_REVOKE: 'COMPANY_CONTACT_ROLES_REVOKE',
+    CUSTOMERS_EMAIL_MARKETING_CONSENT_UPDATE: 'CUSTOMERS_EMAIL_MARKETING_CONSENT_UPDATE',
+    FINANCE_KYC_INFORMATION_UPDATE: 'FINANCE_KYC_INFORMATION_UPDATE',
+    FULFILLMENT_ORDERS_HOLD_FULFILLMENT: 'FULFILLMENT_ORDERS_HOLD_FULFILLMENT',
+    FULFILLMENT_ORDERS_READY_FOR_PICKUP: 'FULFILLMENT_ORDERS_READY_FOR_PICKUP',
+    FULFILLMENT_ORDERS_READY_TO_FULFILL: 'FULFILLMENT_ORDERS_READY_TO_FULFILL',
+    INVENTORY_QUANTITIES_CHANGED: 'INVENTORY_QUANTITIES_CHANGED',
+    MARKETPLACE_PAYMENTS_CONFIGURATIONS_UPDATE: 'MARKETPLACE_PAYMENTS_CONFIGURATIONS_UPDATE',
+    PRODUCT_FEEDS_CREATE: 'PRODUCT_FEEDS_CREATE',
+    PRODUCT_FEEDS_FULL_SYNC: 'PRODUCT_FEEDS_FULL_SYNC',
+    PRODUCT_FEEDS_INCREMENTAL_SYNC: 'PRODUCT_FEEDS_INCREMENTAL_SYNC',
+    PRODUCT_FEEDS_UPDATE: 'PRODUCT_FEEDS_UPDATE',
+    PUBLICATIONS_DELETE: 'PUBLICATIONS_DELETE',
+    PURCHASE_ORDERS_CREATE: 'PURCHASE_ORDERS_CREATE',
+    PURCHASE_ORDERS_DELETE: 'PURCHASE_ORDERS_DELETE',
+    PURCHASE_ORDERS_MARK_AS_ORDERED: 'PURCHASE_ORDERS_MARK_AS_ORDERED',
+    PURCHASE_ORDERS_RECEIVE: 'PURCHASE_ORDERS_RECEIVE',
+    PURCHASE_ORDERS_UPDATE: 'PURCHASE_ORDERS_UPDATE',
+    SUPPLIERS_CREATE: 'SUPPLIERS_CREATE',
+    SUPPLIERS_DELETE: 'SUPPLIERS_DELETE',
+    SUPPLIERS_UPDATE: 'SUPPLIERS_UPDATE',
+  };
+
+  // NOTE: this is a duplicate of shopify-api-js/registry.topicForStorage
+  const convertEventTopic = (topic) => (
+    API_WEBHOOK_TOPICS[topic?.toUpperCase().replace(/\/|\./g, '_')]
+  );
+
+  const API_ROUTE_NAMES = {
+    APP_INSTALLATION: 'apiRouteAppInstallation',
+    SESSION_TOKEN: 'apiRouteSessionToken',
+    WEBHOOK_EVENT: 'apiRouteWebhook',
+    AUTH_ONLINE: 'apiRouteAuthOnline',
+    AUTH_OFFLINE: 'apiRouteAuthOffline',
+    AUTH_ONLINE_CALLBACK: 'apiRouteAuthOnlineCallback',
+    AUTH_OFFLINE_CALLBACK: 'apiRouteAuthOfflineCallback',
+    AUTH_ONLINE_CALLBACK_REAUTH: 'apiRouteAuthOnlineCallbackReauth',
+    AUTH_OFFLINE_CALLBACK_REAUTH: 'apiRouteAuthOfflineCallbackReauth',
+    [API_WEBHOOK_TOPICS.APP_UNINSTALLED]: 'apiRouteAppUninstalled',
+    [API_WEBHOOK_TOPICS.APP_PURCHASES_ONE_TIME_UPDATE]: 'apiRouteAppOneTimeBilling',
+    [API_WEBHOOK_TOPICS.APP_SUBSCRIPTIONS_UPDATE]: 'apiRouteAppSubscriptionBilling',
+  };
+
+  const BILLING_INTERVALS = {
+    ONE_TIME: 'ONE_TIME',
+    MONTHLY: 'EVERY_30_DAYS',
+    ANNUAL: 'ANNUAL',
+  };
+
+  const BILLING_EVENT_TYPES = {
+    ONE_TIME: 'app_purchase_one_time',
+    SUBSCRIPTION: 'app_subscription',
+  };
+
+  const AUTH_TYPES = {
+    OFFLINE: 'offline',
+    ONLINE: 'online',
+  };
+
+  class VerificationError extends Error {
+    constructor(message, _data) {
+      super(message);
+      const { code = 500, ...data } = _data ?? {};
+      this.code = code;
+      this.data = data;
+      this.name = 'VerificationError';
+      Object.setPrototypeOf(this, VerificationError.prototype);
+    }
+  }
+
+  const getChunkedRawBody = async (readable) => {
+    if (readable?.rawBody) {
+      return readable.rawBody
+    }
+
+    // TODO: move to req.text() after next 13.5: https://github.com/vercel/next.js/discussions/13405
+    try {
+      const getRawBody = (await Promise.resolve().then(function () { return index; })).default;
+      return getRawBody(readable)
+    } catch (error) {
+      console.error(`Failed to import 'raw-body', please ensure the dependency is installed`);
+      throw error
+    }
+  };
+
+  // TODO: explore returning mutated request object adding on req.rawBody??
+  const ensureRawBody = async (req) => (
+    getChunkedRawBody(req)
+      .then((_rawBody) => _rawBody.toString())
+      .catch((error) => {
+        console.error(`Error getting raw body for '${req?.url}'`, error);
+        throw error
+    })
+  );
+
+  /* eslint-disable no-use-before-define */
+
+  const isType = (value, type) => (
+    // eslint-disable-next-line eqeqeq, valid-typeof
+    (value != undefined) && (typeof value === type)
+  );
+
+  const safeTrim = (value) => {
+    if (isType(value, 'string')) {
+      // eslint-disable-next-line no-param-reassign
+      value = value.trim();
+    }
+
+    return value
+  };
+
+  const safeParse = (value, trim) => {
+    if (isType(value, 'string')) {
+      if (trim) {
+        // eslint-disable-next-line no-param-reassign
+        value = safeTrim(value);
+      }
+
+      if (value.startsWith('{') || value.startsWith('[') || value.startsWith('"')) {
+        // eslint-disable-next-line no-param-reassign
+        value = JSON.parse(value);
+      }
+    }
+
+    // TODO: should this be value ?? {}
+    return value
+  };
+
+  const ensureString = (string) => (
+    string ? `${string}` : ''
+  );
+
+  const ensureArray = (array = []) => (
+    // eslint-disable-next-line no-nested-ternary
+    !array ? [] : Array.isArray(array) ? array : [array]
+  );
+
+  const ensureObject = (object) => (
+    object ?? {}
+  );
+
+  // NOTE: this does not ensure !isType(string)
+  const objectEmpty = (object) => (
+    !object || !Object.keys(object).length
+  );
+
+  const stringNotEmpty = (stringable) => {
+    const string = ensureString(stringable);
+    return ((string.length > 0) && !['null', 'undefined'].includes(string))
+  };
+
+  const stringEmpty = (stringable) => (
+    !stringNotEmpty(stringable)
+  );
+
+  const compareString = (string1, string2) => {
+    if (stringEmpty(string1)) {
+      return 1
+    }
+
+    if (stringEmpty(string2)) {
+      return -1
+    }
+
+    return ensureString(string1).localeCompare(string2)
+  };
+
+  const compareEntryKeys = ([string1], [string2]) => (
+    compareString(string1, string2)
+  );
+
+  const objectToSortedString = (object, separator = '') => (
+    Object.entries(ensureObject(object))
+      .sort(compareEntryKeys)
+      .map(([key, value]) => `${key}=${value}`)
+      .join(separator)
+  );
+
+  const uppercase = (string) => (
+    ensureString(string).toUpperCase()
+  );
+
+  const removeLeadingSlash = (string) => (
+    ensureString(string).replace(/^\//, '')
+  );
+
+  const ensureLeadingSlash = (string) => (
+    `/${removeLeadingSlash(string)}`
+  );
+
+  const isTrue = (value, falsy) => {
+    const string = ensureString(value);
+    return ![...ensureArray(falsy), '', 'false'].includes(string)
+  };
+
+  const TEMP_HOSTNAME = 'xyz.com';
+  const REMOVABLE_KEYS = ['shop', 'host'];
+
+  const getRequestMethod = (body, _method) => {
+    const method = _method ?? (body ? 'POST' : 'GET');
+
+    return uppercase(method)
+  };
+
+  const convertToURL = (uri) => {
+    if (stringEmpty(uri)) {
+      return undefined
+    }
+
+    const protocolRegex = /^(https?:\/\/).+/i;
+
+    if (!protocolRegex.test(uri)) {
+      return new URL(`https://${TEMP_HOSTNAME}${ensureLeadingSlash(uri)}`)
+    }
+
+    return new URL(uri)
+  };
+
+  const normalizeURIParts = (uri) => {
+    const urlObject = convertToURL(uri);
+    if (!urlObject) {
+      return undefined
+    }
+
+    REMOVABLE_KEYS.forEach((key) => urlObject.searchParams.delete(key));
+
+    return {
+      ...(urlObject.hostname !== TEMP_HOSTNAME) && {
+        origin: urlObject.origin,
+      },
+      pathname: urlObject.pathname,
+      search: urlObject.search,
+    }
+  };
+
+  var n,r=((n=function(){return r}).toString=n.toLocaleString=n[Symbol.toPrimitive]=function(){return ""},n.valueOf=function(){return !1},new Proxy(Object.freeze(n),{get:function(n,t){return n.hasOwnProperty(t)?n[t]:r}})),u=function(n){return n===r};
+
+  let win = global.window;
+  let exists = (variable) => !u(variable);
+  let window = typeof win !== "undefined" ? win : r;
+
+  class WebCrypto {
+    constructor({ crypto: _crypto, util: _util } = {}) {
+      this._crypto = _crypto ?? {};
+      this._util = _util ?? {};
+    }
+
+    get subtle() {
+      return this._crypto?.subtle
+    }
+
+    async getWebCrypto() {
+      if (!this._crypto?.subtle) {
+        try {
+          this._crypto = (await import('isomorphic-webcrypto')).default;
+        } catch (_ignore) {
+          console.info('Failed to import isomorphic-webcrypto, retrying w/ node crypto');
+          try {
+            this._crypto = (await import('crypto')).default;
+          } catch (error) {
+            // eslint-disable-next-line max-len
+            console.error(`Failed to import node crypto, ensure 'isomorphic-webcrypto' (or node 'crypto') is installed and/or pass in implementation via 'new WebCrypto({ crypto })'`);
+            throw error
+          }
+        }
+      }
+
+      if (!this._crypto?.subtle) {
+        throw new Error('Invalid crypto, missing subtle')
+      }
+
+      return this._crypto
+    }
+
+    async getTextDecoder() {
+      if (this._util?.TextDecoder) {
+        return this._util.TextDecoder
+      }
+
+      if (exists(window) && typeof window?.TextDecoder === 'function') {
+        return window.TextDecoder
+      }
+
+      try {
+        const TextDecoder = (await import('util')).TextDecoder;
+        this._util.TextDecoder = TextDecoder;
+
+        return TextDecoder
+      } catch (error) {
+        console.error(`Failed to import 'utils.TextDecoder', ensure 'util' is available and/or pass in implementation via 'new WebCrypto({ util })'`);
+        throw error
+      }
+    }
+
+    async getTextEncoder() {
+      if (this._util?.TextEncoder) {
+        return this._util.TextEncoder
+      }
+
+      if (exists(window) && typeof window?.TextEncoder === 'function') {
+        return window.TextEncoder
+      }
+
+      try {
+        const TextEncoder = (await import('util')).TextEncoder;
+        this._util.TextEncoder = TextEncoder;
+
+        return TextEncoder
+      } catch (error) {
+        console.error(`Failed to import 'utils.TextEncoder', ensure 'util' is available and/or pass in implementation via 'new WebCrypto({ util })'`);
+        throw error
+      }
+    }
+
+    timingSafeEqual(value1, value2) {
+      if (
+        (value1 == undefined) ||
+        (value2 == undefined) ||
+        (value1.length !== value2.length)
+      ) {
+        return false
+      }
+
+      let result = 0;
+      // eslint-disable-next-line no-plusplus
+      for (let i = 0; i < value1.length; i++) {
+        // eslint-disable-next-line no-bitwise
+        result |= value1[i] ^ value2[i];
+      }
+
+      return (result === 0)
+    }
+
+    stringToHex(stringValue) {
+      return (
+        Array.from(ensureString(stringValue), (char) => (
+          char.charCodeAt(0).toString(16).padStart(2, '0')
+        )).join('')
+      )
+    }
+
+    hexToString(hexValue) {
+      return (
+        ensureArray(
+          ensureString(hexValue).match(/.{1,2}/g)
+        )
+        .map((byte) => String.fromCharCode(parseInt(byte, 16)))
+        .join('')
+      )
+    }
+
+    async arrayBufferToString(arrayBuffer) {
+      const uint8Array = new Uint8Array(arrayBuffer);
+      const Decoder = await this.getTextDecoder();
+      return new Decoder().decode(uint8Array)
+    }
+
+    arrayToArrayBuffer(array) {
+      return (
+        (ArrayBuffer.from != undefined)
+          ? ArrayBuffer.from(array)
+          : new Uint8Array(array).buffer
+      )
+    }
+
+    ensureArrayBuffer(arrayOrArrayBuffer) {
+      return (
+        (arrayOrArrayBuffer instanceof ArrayBuffer)
+          ? arrayOrArrayBuffer
+          : this.arrayToArrayBuffer(arrayOrArrayBuffer)
+      )
+    }
+
+    async generateKeyPair() {
+      const crypto = await this.getWebCrypto();
+      const keyPair = await crypto.subtle.generateKey(
+        {
+          name: 'ECDH',
+          namedCurve: 'P-256',
+        },
+        true,
+        ['deriveKey']
+      );
+
+      return keyPair
+    }
+
+    getKeyOperations(keyType) {
+      switch (keyType) {
+        case 'private':
+        case 'privateKey': {
+          return ['deriveKey']
+        }
+
+        case 'secret':
+        case 'secretKey':
+        case 'sharedSecret': {
+          return ['encrypt', 'decrypt'] 
+        }
+
+        default: {
+          return []
+        }
+      }
+    }
+
+    getKeyAlgorythm(keyType) {
+      switch (keyType) {
+        case 'derivedKey':
+        case 'derived':
+        case 'secret':
+        case 'secretKey':
+        case 'sharedSecret': {
+          return {
+            name: 'AES-GCM',
+          }
+        }
+
+        default: {
+          return {
+            name: 'ECDH',
+            namedCurve: 'P-256',
+          }
+        }
+      }
+    }
+
+    async generateHMAC(message, derivedKey) {
+      if (!message || !derivedKey) {
+        return undefined
+      } 
+
+      const crypto = await this.getWebCrypto();
+      const Encoder = await this.getTextEncoder();
+
+      const signature = await crypto.subtle.sign(
+        'HMAC',
+        derivedKey,
+        new Encoder().encode(message)
+      );
+
+      return this.stringToHex(
+        this.arrayBufferToString(signature)
+      )
+    }
+
+    async verifyHMAC(message, derivedKey, verifiableHMAC) {
+      const calculatedHMAC = await this.generateHMAC(message, derivedKey);
+
+      return this.timingSafeEqual(calculatedHMAC, verifiableHMAC)
+    }
+
+    async getStorableKey(key) {
+      const crypto = await this.getWebCrypto();
+
+      const exportedJWK = await crypto.subtle.exportKey('jwk', key);
+      return this.stringToHex(JSON.stringify(exportedJWK))
+    }
+
+    async restoreStorableKey(keyType, storableHex) {
+      if (!storableHex) {
+        return undefined
+      }
+      const crypto = await this.getWebCrypto();
+
+      const exportedJWK = JSON.parse(this.hexToString(storableHex) || '{}');
+      if (objectEmpty(exportedJWK)) {
+        return undefined
+      }
+
+      return crypto.subtle.importKey(
+        'jwk',
+        exportedJWK,
+        this.getKeyAlgorythm(keyType),
+        true,
+        this.getKeyOperations(keyType)
+      )
+    }
+
+    async getStorableKeyPair(keyPair) {
+      const storableKeys = {};
+
+      // eslint-disable-next-line no-restricted-syntax
+      for (const [keyType, key] of Object.entries(keyPair)) {
+        // eslint-disable-next-line no-await-in-loop
+        storableKeys[keyType] = await this.getStorableKey(key);
+      }
+
+      return storableKeys
+    }
+
+    async restoreStorableKeyPair(keyPair) {
+      const restoredKeys = {};
+
+      // eslint-disable-next-line no-restricted-syntax
+      for (const [keyType, key] of Object.entries(keyPair)) {
+        // eslint-disable-next-line no-await-in-loop
+        restoredKeys[keyType] = await this.restoreStorableKey(keyType, key);
+      }
+
+      return restoredKeys
+    }
+
+    async deriveSharedKey({ publicKey, privateKey }) {
+      if (!publicKey || !privateKey) {
+        return undefined
+      }
+
+      const crypto = await this.getWebCrypto();
+      const derivedKey = await crypto.subtle.deriveKey(
+        {
+          name: 'ECDH',
+          public: publicKey,
+        },
+        privateKey,
+        {
+          name: 'AES-GCM',
+          length: 256,
+        },
+        true,
+        ['encrypt', 'decrypt']
+      );
+      return derivedKey
+    }
+
+    async deriveHMACKey({ publicKey, privateKey }) {
+      if (!publicKey || !privateKey) {
+        return undefined
+      }
+
+      const crypto = await this.getWebCrypto();
+      const derivedKey = await crypto.subtle.deriveKey(
+        {
+          name: 'ECDH',
+          public: publicKey,
+        },
+        privateKey,
+        {
+          name: 'HMAC',
+          hash: { name: 'SHA-256' },
+          length: 256,  // Adjusted key length, e.g., 128 bits
+        },
+        true,
+        ['sign', 'verify']
+      );
+      return derivedKey
+    }
+
+    async getVerificationKeys({ publicKey, privateKey }) {
+      if (!publicKey || !privateKey) {
+        return {}
+      }
+
+      const sharedKeyPair = await this.restoreStorableKeyPair({ publicKey, privateKey });
+      const derivedHMACKey = await this.deriveHMACKey(sharedKeyPair);
+      const derivedSecretKey = await this.deriveSharedKey(sharedKeyPair);
+
+      return {
+        derivedSecretKey,
+        derivedHMACKey,
+      }
+    }
+
+    async encryptMessage(decryptedMessage, derivedKey) {
+      if (!decryptedMessage || !derivedKey) {
+        return undefined
+      }
+
+      const crypto = await this.getWebCrypto();
+      const iv = crypto.getRandomValues(new Uint8Array(12));
+      const Encoder = await this.getTextEncoder();
+      const encodedMessage = new Encoder().encode(decryptedMessage);
+      const ciphertext = await crypto.subtle.encrypt(
+        {
+          name: 'AES-GCM',
+          iv,
+        },
+        derivedKey,
+        encodedMessage
+      );
+
+      const encryptedMessage = new Uint8Array([
+        ...iv,
+        ...new Uint8Array(ciphertext)
+      ]);
+      return Array.from(encryptedMessage)
+    }
+
+    async decryptMessage(encryptedMessage, derivedKey) {
+      if (!encryptedMessage || !derivedKey) {
+        return undefined
+      }
+
+      const crypto = await this.getWebCrypto();
+      // NOTE: this presumed an array or arrayBuffer coming in as encryptedMessage (will fail w/ IV error if its a string)
+      const encryptedArrayBuffer = this.ensureArrayBuffer(encryptedMessage);
+      const iv = encryptedArrayBuffer.slice(0, 12);
+      const ciphertext = encryptedArrayBuffer.slice(12);
+
+      const decryptedArrayBuffer = await crypto.subtle.decrypt(
+        {
+          name: 'AES-GCM',
+          iv,
+        },
+        derivedKey,
+        ciphertext
+      );
+
+      const Decoder = await this.getTextDecoder();
+      const decryptedMessage = new Decoder().decode(decryptedArrayBuffer);
+      return decryptedMessage
+    }
+  }
+
+  const getVerificationHelpers = ({ keyPairs, crypto: _crypto, util: _util  } = {}) => {
+    const webCrypto = new WebCrypto({ crypto: _crypto, util: _util });
+
+    return async (req, params) => {
+      const {
+        'x-public-key': apiKey,
+        'x-ephemeral-key': ephemeralPublicKey,
+        'x-authorization-timestamp': customAuthTimestamp,
+        'x-authorization': customAuth,
+      } = req.headers ?? {};
+
+      const { uri: _uri, disableRecryption: _disableRecryption } = params ?? {};
+      const uri = _uri ?? req.url;
+      const disableRecryption = isTrue(_disableRecryption);
+
+      let isVerifiable;
+      try {
+        const [authProtocol, authSignature] = ensureString(customAuth).split(' ');
+        isVerifiable = isTrue(
+          apiKey &&
+          ephemeralPublicKey &&
+          keyPairs?.shared &&
+          customAuthTimestamp &&
+          authSignature &&
+          (authProtocol === 'HMAC-SHA256')
+        );
+
+        let verificationKeys;
+        const rawBody = await ensureRawBody(req);
+
+        // NOTE: requestBody should be wind up decrypted when isVerifiable (unless disableRecryption, then will pass through)
+        let requestBody = safeParse(rawBody);
+
+        // TEMP!!! remove isVerifiable check once webwidget moved to react
+        if (isVerifiable) {
+          if (
+            !apiKey ||
+            !ephemeralPublicKey ||
+            !customAuthTimestamp ||
+            !authSignature ||
+            !keyPairs?.shared ||
+            (apiKey !== keyPairs.shared.publicKey) ||
+            (authProtocol !== 'HMAC-SHA256')
+          ) {
+            throw new VerificationError('Invalid or missing authorization', { code: 401 })
+          }
+
+          verificationKeys = await webCrypto.getVerificationKeys({
+            publicKey: ephemeralPublicKey,
+            privateKey: keyPairs.shared.privateKey,
+          });
+
+          if (!verificationKeys) {
+            throw new VerificationError('Invalid or missing verification', { code: 412 })
+          }
+
+          const verificationPayload = objectToSortedString({
+            method: getRequestMethod(rawBody, req.method),
+            timestamp: customAuthTimestamp,
+            body: requestBody, // NOTE: requestBody should be encrypted when isVerifiable
+            ...normalizeURIParts(uri),
+          });
+
+          const isValid = await webCrypto.verifyHMAC(
+            verificationPayload,
+            verificationKeys.derivedHMACKey,
+            authSignature
+          );
+
+          if (!isValid) {
+            throw new VerificationError('Invalid or missing verification', { code: 412 })
+          }
+
+          if (!disableRecryption && requestBody) {
+            const decryptedMessage = await webCrypto.decryptMessage(requestBody, verificationKeys.derivedSecretKey);
+            requestBody = safeParse(decryptedMessage);
+          }
+        }
+
+        const processResponse = async (response) => {
+          if (!response || disableRecryption || !isVerifiable || !verificationKeys?.derivedSecretKey) {
+            return response
+          }
+
+          return webCrypto.encryptMessage(JSON.stringify(response), verificationKeys.derivedSecretKey)
+        };
+
+        return { rawBody, requestBody, processResponse }
+      } catch (error) {
+        console.error(`Error handling request verification for '${uri}'`, { error, isVerifiable, disableRecryption });
+        throw error
+      }
+    }
+  };
+
+  /*!
+   * raw-body
+   * Copyright(c) 2013-2014 Jonathan Ong
+   * Copyright(c) 2014-2022 Douglas Christopher Wilson
+   * MIT Licensed
+   */
+
+  /**
+   * Module dependencies.
+   * @private
+   */
+
+  var asyncHooks = tryRequireAsyncHooks();
+  var bytes = require('bytes');
+  var createError = require('http-errors');
+  var iconv = require('iconv-lite');
+  var unpipe = require('unpipe');
+
+  /**
+   * Module exports.
+   * @public
+   */
+
+  module.exports = getRawBody;
+
+  /**
+   * Module variables.
+   * @private
+   */
+
+  var ICONV_ENCODING_MESSAGE_REGEXP = /^Encoding not recognized: /;
+
+  /**
+   * Get the decoder for a given encoding.
+   *
+   * @param {string} encoding
+   * @private
+   */
+
+  function getDecoder (encoding) {
+    if (!encoding) return null
+
+    try {
+      return iconv.getDecoder(encoding)
+    } catch (e) {
+      // error getting decoder
+      if (!ICONV_ENCODING_MESSAGE_REGEXP.test(e.message)) throw e
+
+      // the encoding was not found
+      throw createError(415, 'specified encoding unsupported', {
+        encoding: encoding,
+        type: 'encoding.unsupported'
+      })
+    }
+  }
+
+  /**
+   * Get the raw body of a stream (typically HTTP).
+   *
+   * @param {object} stream
+   * @param {object|string|function} [options]
+   * @param {function} [callback]
+   * @public
+   */
+
+  function getRawBody (stream, options, callback) {
+    var done = callback;
+    var opts = options || {};
+
+    // light validation
+    if (stream === undefined) {
+      throw new TypeError('argument stream is required')
+    } else if (typeof stream !== 'object' || stream === null || typeof stream.on !== 'function') {
+      throw new TypeError('argument stream must be a stream')
+    }
+
+    if (options === true || typeof options === 'string') {
+      // short cut for encoding
+      opts = {
+        encoding: options
+      };
+    }
+
+    if (typeof options === 'function') {
+      done = options;
+      opts = {};
+    }
+
+    // validate callback is a function, if provided
+    if (done !== undefined && typeof done !== 'function') {
+      throw new TypeError('argument callback must be a function')
+    }
+
+    // require the callback without promises
+    if (!done && !global.Promise) {
+      throw new TypeError('argument callback is required')
+    }
+
+    // get encoding
+    var encoding = opts.encoding !== true
+      ? opts.encoding
+      : 'utf-8';
+
+    // convert the limit to an integer
+    var limit = bytes.parse(opts.limit);
+
+    // convert the expected length to an integer
+    var length = opts.length != null && !isNaN(opts.length)
+      ? parseInt(opts.length, 10)
+      : null;
+
+    if (done) {
+      // classic callback style
+      return readStream(stream, encoding, length, limit, wrap(done))
+    }
+
+    return new Promise(function executor (resolve, reject) {
+      readStream(stream, encoding, length, limit, function onRead (err, buf) {
+        if (err) return reject(err)
+        resolve(buf);
+      });
+    })
+  }
+
+  /**
+   * Halt a stream.
+   *
+   * @param {Object} stream
+   * @private
+   */
+
+  function halt (stream) {
+    // unpipe everything from the stream
+    unpipe(stream);
+
+    // pause stream
+    if (typeof stream.pause === 'function') {
+      stream.pause();
+    }
+  }
+
+  /**
+   * Read the data from the stream.
+   *
+   * @param {object} stream
+   * @param {string} encoding
+   * @param {number} length
+   * @param {number} limit
+   * @param {function} callback
+   * @public
+   */
+
+  function readStream (stream, encoding, length, limit, callback) {
+    var complete = false;
+    var sync = true;
+
+    // check the length and limit options.
+    // note: we intentionally leave the stream paused,
+    // so users should handle the stream themselves.
+    if (limit !== null && length !== null && length > limit) {
+      return done(createError(413, 'request entity too large', {
+        expected: length,
+        length: length,
+        limit: limit,
+        type: 'entity.too.large'
+      }))
+    }
+
+    // streams1: assert request encoding is buffer.
+    // streams2+: assert the stream encoding is buffer.
+    //   stream._decoder: streams1
+    //   state.encoding: streams2
+    //   state.decoder: streams2, specifically < 0.10.6
+    var state = stream._readableState;
+    if (stream._decoder || (state && (state.encoding || state.decoder))) {
+      // developer error
+      return done(createError(500, 'stream encoding should not be set', {
+        type: 'stream.encoding.set'
+      }))
+    }
+
+    if (typeof stream.readable !== 'undefined' && !stream.readable) {
+      return done(createError(500, 'stream is not readable', {
+        type: 'stream.not.readable'
+      }))
+    }
+
+    var received = 0;
+    var decoder;
+
+    try {
+      decoder = getDecoder(encoding);
+    } catch (err) {
+      return done(err)
+    }
+
+    var buffer = decoder
+      ? ''
+      : [];
+
+    // attach listeners
+    stream.on('aborted', onAborted);
+    stream.on('close', cleanup);
+    stream.on('data', onData);
+    stream.on('end', onEnd);
+    stream.on('error', onEnd);
+
+    // mark sync section complete
+    sync = false;
+
+    function done () {
+      var args = new Array(arguments.length);
+
+      // copy arguments
+      for (var i = 0; i < args.length; i++) {
+        args[i] = arguments[i];
+      }
+
+      // mark complete
+      complete = true;
+
+      if (sync) {
+        process.nextTick(invokeCallback);
+      } else {
+        invokeCallback();
+      }
+
+      function invokeCallback () {
+        cleanup();
+
+        if (args[0]) {
+          // halt the stream on error
+          halt(stream);
+        }
+
+        callback.apply(null, args);
+      }
+    }
+
+    function onAborted () {
+      if (complete) return
+
+      done(createError(400, 'request aborted', {
+        code: 'ECONNABORTED',
+        expected: length,
+        length: length,
+        received: received,
+        type: 'request.aborted'
+      }));
+    }
+
+    function onData (chunk) {
+      if (complete) return
+
+      received += chunk.length;
+
+      if (limit !== null && received > limit) {
+        done(createError(413, 'request entity too large', {
+          limit: limit,
+          received: received,
+          type: 'entity.too.large'
+        }));
+      } else if (decoder) {
+        buffer += decoder.write(chunk);
+      } else {
+        buffer.push(chunk);
+      }
+    }
+
+    function onEnd (err) {
+      if (complete) return
+      if (err) return done(err)
+
+      if (length !== null && received !== length) {
+        done(createError(400, 'request size did not match content length', {
+          expected: length,
+          length: length,
+          received: received,
+          type: 'request.size.invalid'
+        }));
+      } else {
+        var string = decoder
+          ? buffer + (decoder.end() || '')
+          : Buffer.concat(buffer);
+        done(null, string);
+      }
+    }
+
+    function cleanup () {
+      buffer = null;
+
+      stream.removeListener('aborted', onAborted);
+      stream.removeListener('data', onData);
+      stream.removeListener('end', onEnd);
+      stream.removeListener('error', onEnd);
+      stream.removeListener('close', cleanup);
+    }
+  }
+
+  /**
+   * Try to require async_hooks
+   * @private
+   */
+
+  function tryRequireAsyncHooks () {
+    try {
+      return require('async_hooks')
+    } catch (e) {
+      return {}
+    }
+  }
+
+  /**
+   * Wrap function with async resource, if possible.
+   * AsyncResource.bind static method backported.
+   * @private
+   */
+
+  function wrap (fn) {
+    var res;
+
+    // create anonymous resource
+    if (asyncHooks.AsyncResource) {
+      res = new asyncHooks.AsyncResource(fn.name || 'bound-anonymous-fn');
+    }
+
+    // incompatible node.js
+    if (!res || !res.runInAsyncScope) {
+      return fn
+    }
+
+    // return bound function
+    return res.runInAsyncScope.bind(res, fn, null)
+  }
+
+  var index = /*#__PURE__*/Object.freeze({
+    __proto__: null
+  });
+
+  exports.API_ROUTE_NAMES = API_ROUTE_NAMES;
+  exports.API_WEBHOOK_TOPICS = API_WEBHOOK_TOPICS;
+  exports.AUTH_TYPES = AUTH_TYPES;
+  exports.BILLING_EVENT_TYPES = BILLING_EVENT_TYPES;
+  exports.BILLING_INTERVALS = BILLING_INTERVALS;
+  exports.COLLECTION_ROOT = COLLECTION_ROOT;
+  exports.PAGE_ROUTE_NAMES = PAGE_ROUTE_NAMES;
+  exports.VerificationError = VerificationError;
+  exports.convertEventTopic = convertEventTopic;
+  exports.ensureRawBody = ensureRawBody;
+  exports.getVerificationHelpers = getVerificationHelpers;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=index.js.map