@agnostack/next-shopify 1.15.0-beta.2 → 1.15.0-beta.21

package/dist/umd/verification.js

@@ -0,0 +1,901 @@
+(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/umd-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);
+    }
+  }
+
+  // import getRawBody from 'raw-body'
+  // import * as getRawBody from 'raw-body'
+
+  const getChunkedRawBody = async (readable) => {
+    if (readable?.rawBody) {
+      return readable.rawBody
+    }
+
+    const chunks = [];
+    const chunkedBody = readable?.body ?? [];
+
+    for await (const chunk of chunkedBody) {
+      chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+    }
+
+    return Buffer.concat(chunks)
+  };
+
+  // TODO: explore returning mutated request object adding on req.rawBody??
+  // TODO: move to req.text() after next 13.5: https://github.com/vercel/next.js/discussions/13405
+  const ensureRawBody = async (req) => (
+    getChunkedRawBody(req)
+    // getRawBody(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) {
+        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) {
+            console.error('Failed to import node crypto');
+            throw error
+          }
+        }
+      }
+
+      if (!this._crypto?.subtle) {
+        throw new Error('Invalid crypto, missing subtle')
+      }
+
+      return this._crypto
+    }
+
+    async getTextDecoder() {
+      if (this._util?.TextDecoder) {
+        console.info('Using this._util.TextDecoder');
+        return this._util.TextDecoder
+      }
+
+      if (exists(window) && typeof window?.TextDecoder === 'function') {
+        console.info('Using window.TextDecoder');
+        return window.TextDecoder
+      }
+
+      try {
+        const TextDecoder = (await import('util')).TextDecoder;
+        console.info('Using imported util.TextDecoder');
+        return TextDecoder
+      } catch (error) {
+        console.error('Failed to import utils.TextDecoder', error);
+        throw error
+      }
+    }
+
+    async getTextEncoder() {
+      if (this._util?.TextEncoder) {
+        console.info('Using this._util.TextEncoder');
+        return this._util.TextEncoder
+      }
+
+      if (exists(window) && typeof window?.TextEncoder === 'function') {
+        console.info('Using window.TextEncoder');
+        return window.TextEncoder
+      }
+
+      try {
+        const TextEncoder = (await import('util')).TextEncoder;
+        console.info('Using imported util.TextEncoder');
+        return TextEncoder
+      } catch (error) {
+        console.error('Failed to import utils.TextEncoder', error);
+        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
+      }
+    }
+  };
+
+  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=verification.js.map