@agnostack/verifyd 1.0.0

package/dist/umd/lib/index.js

@@ -0,0 +1,2204 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('luxon')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'luxon'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["@agnostack/verifyd/lib"] = {}, global.luxon));
+})(this, (function (exports, luxon) { 'use strict';
+
+  /* eslint-disable no-use-before-define */
+
+  // #region lib-core
+  // TODO!!!: keep in sync between verifyd and lib-core (and lib-utils-js at bottom)
+  const normalizeShopifyId = (shopifyData) => {
+    const isString = isType(shopifyData, 'string');
+    if (isString && !shopifyData.startsWith('gid:')) {
+      if (!isNumericOnly(shopifyData)) {
+        return {}
+      }
+
+      return {
+        id: `${shopifyData}`,
+      }
+    }
+
+    const { id: _entityId, legacyResourceId } = isString
+      ? { id: shopifyData }
+      : ensureObject(shopifyData);
+
+    if (stringEmpty(_entityId) && stringEmpty(legacyResourceId)) {
+      return {}
+    }
+
+    const entity_id = ensureString(_entityId);
+    const { entity_type, parsedId } = entity_id.match(/^gid:\/\/shopify\/(?<entity_type>.*)\/(?<parsedId>[0-9]+).*$/)?.groups ?? {};
+    const id = ensureString(parsedId || legacyResourceId);
+
+    const hasEntityId = stringNotEmpty(entity_id);
+    const hasEntityType = stringNotEmpty(entity_type);
+
+    return {
+      ...stringNotEmpty(id) && { id },
+      ...hasEntityId && { entity_id },
+      ...hasEntityType && { entity_type },
+      ...(hasEntityId && hasEntityType) && {
+        gid: `gid://shopify/${entity_type}/${entity_id}`,
+      },
+    }
+  };
+
+  const random = (max = 100, min = 1) => {
+    const floor = Math.min(max, min);
+    return Math.floor(Math.random() * (max - floor + 1)) + floor
+  };
+
+  const nextRandom = (max = 100, min = 1) => {
+    const maximum = Math.max(max, 0);
+    const minimum = Math.max(min, 0);
+
+    let randomNumber = maximum;
+
+    if (maximum > minimum) {
+      do {
+        randomNumber = random(maximum, minimum);
+      } while (randomNumber === nextRandom.last)
+
+      nextRandom.last = randomNumber;
+    }
+
+    return randomNumber
+  };
+
+  const arrayRandom = (_values, _max = 1) => {
+    const values = ensureArray(_values);
+    const valuesLength = values.length;
+    const maxLength = Math.min(_max, valuesLength);
+
+    if (valuesLength <= maxLength) {
+      return values
+    }
+
+    const arrayLength = valuesLength - 1;
+    const randomValues = [];
+    do {
+      const newVal = values[nextRandom(arrayLength, 0)];
+      if (!randomValues.includes(newVal)) {
+        randomValues.push(newVal);
+      }
+    } while (randomValues.length < maxLength)
+
+    return randomValues
+  };
+
+  const arrayRandomItem = (_values) => (
+    arrayRandom(_values)[0]
+  );
+
+  const isArray = (value) => (
+    // eslint-disable-next-line eqeqeq
+    (value != undefined) && Array.isArray(value)
+  );
+
+  const isSet = (value) => (
+    // eslint-disable-next-line eqeqeq
+    (value != undefined) && (value instanceof Set)
+  );
+
+  const isType = (value, type) => (
+    // eslint-disable-next-line eqeqeq, valid-typeof
+    (value != undefined) && (typeof value === type)
+  );
+
+  const isTypeEnhanced = (value, type) => {
+    switch (true) {
+      case (type === 'set'): {
+        return isSet(value)
+      }
+
+      case (type === 'array'): {
+        return (
+          isArray(value) &&
+          !isSet(value)
+        )
+      }
+
+      case (type === 'object'): {
+        return (
+          isType(value, type) &&
+          !isArray(value)
+        )
+      }
+
+      default: {
+        return isType(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}` : ''
+  );
+
+  // HMMM: what if 'string' is an object?
+  const ensureStringOnly = (string) => (
+    // eslint-disable-next-line eqeqeq
+    (string != undefined) ? `${string}` : ''
+  );
+
+  const ensureStringAscii = (string) => (
+    // eslint-disable-next-line no-control-regex
+    ensureStringOnly(string).replace(/[^\x00-\x7F]/g, '')
+  );
+
+  const ensureStringClean = (string) => (
+    // eslint-disable-next-line no-control-regex
+    ensureStringOnly(string).replace(/[^a-z0-9_-]/gi, '')
+  );
+
+  const ensureAlphaNumeric = (string) => (
+    // eslint-disable-next-line no-control-regex
+    ensureStringOnly(string).replace(/[^a-z0-9]/gi, '')
+  );
+
+  const isNumericOnly = (value) => {
+    const [matched] = `${value}`.match(/^([0-9]+)$/) ?? [];
+    // eslint-disable-next-line eqeqeq
+    return (matched != undefined)
+  };
+
+  const isNumericNegatable = (value) => {
+    const [matched] = `${value}`.match(/^(-?[0-9]+(\.[0-9]+)?)?$/) ?? [];
+    // eslint-disable-next-line eqeqeq
+    return (matched != undefined)
+  };
+
+  // TODO: explore places using ensureNumeric to move to isNumericNegatable
+  const ensureNumeric = (string) => (
+    Number(ensureString(string).replace(/[^0-9.]/gi, ''))
+  );
+
+  const ensureNumericOnly = (string) => (
+    Number(ensureString(string).replace(/[^0-9]/gi, ''))
+  );
+
+  // TODO: update regex to handle negative number returns negative. Something like (?!\d\.)(-?\d+(\.\d)?)
+  const ensureNumericNegatable = (string) => (
+    Number(ensureString(string).replace(/[^0-9.-]/gi, ''))
+  );
+
+  const ensureNumericConstrained = (value, { min: _min = 0, max: _max = 100 } = {}) => {
+    const min = ensureNumericNegatable(_min);
+    const max = ensureNumericNegatable(_max);
+
+    return Math.max(
+      min,
+      Math.min(ensureNumeric(value), max)
+    )
+  };
+
+  const ensureArray = (array = []) => (
+    // eslint-disable-next-line no-nested-ternary
+    !array ? [] : Array.isArray(array) ? array : [array]
+  );
+
+  const ensureArraySet = (arrayOrSet) => (
+    ensureArray(isSet(arrayOrSet) ? [...arrayOrSet] : arrayOrSet)
+  );
+
+  const arrayEmpty = (array, disableEmptyString = false) => (
+    // eslint-disable-next-line eqeqeq
+    !array || !array.length || (array.length === 1 && (array[0] == undefined || (disableEmptyString && stringEmpty(array[0]))))
+  );
+
+  const arrayNotEmpty = (array, disableEmptyString = false) => (
+    // eslint-disable-next-line eqeqeq
+    !arrayEmpty(array) && array[0] != undefined && (!disableEmptyString || stringNotEmpty(array[0]))
+  );
+
+  const findLastMatch = (array, filterCallback = (value) => (value)) => (
+    ensureArray(array).filter(filterCallback).slice(-1)[0]
+  );
+
+  const ensureObject = (object) => (
+    object ?? {}
+  );
+
+  // NOTE: this does not ensure !isType(string)
+  const objectEmpty = (object) => (
+    !object || !Object.keys(object).length
+  );
+
+  const objectNotEmpty = (object) => (
+    !objectEmpty(object)
+  );
+
+  const nullable = (object) => (
+    (!object || (object === 'null') || (object === undefined) || (object === null))
+      ? null // TODO: explore undefined here??
+      : object
+  );
+
+  const objectContainsAnyValue = (object) => (
+    Object.values(ensureObject(object)).some((value) => nullable(value))
+  );
+
+  const isUndefined = (value) => (
+    // eslint-disable-next-line eqeqeq
+    value == undefined
+  );
+
+  const cleanObject = (object, allowEmptyLeafs, isEmptyCallback) => (
+    Object.entries(ensureObject(object)).reduce((
+      _cleanedObject,
+      [key, _value]
+    ) => {
+      if (!allowEmptyLeafs && (isEmptyCallback?.(_value) ?? isUndefined(_value))) {
+        return _cleanedObject // skip key if null or undefined
+      }
+
+      const value = !Array.isArray(_value)
+        ? cleanObjectValue(_value, allowEmptyLeafs, isEmptyCallback)
+        : _value.reduce((_data, __value) => ([
+          ..._data,
+          cleanObjectValue(__value, allowEmptyLeafs, isEmptyCallback)
+        ]), []);
+
+      return {
+        ..._cleanedObject,
+        [key]: value,
+      }
+    }, {})
+  );
+
+  const cleanObjectValue = (value, allowEmptyLeafs, isEmptyCallback) => (
+    isType(value, 'object') ? cleanObject(value, allowEmptyLeafs, isEmptyCallback) : value
+  );
+
+  const stringNotEmptyOnly = (stringable) => {
+    const string = ensureStringOnly(stringable);
+    return ((string.length > 0) && !['null', 'undefined'].includes(string))
+  };
+
+  const stringEmptyOnly = (stringable) => (
+    !stringNotEmptyOnly(stringable)
+  );
+
+  const stringNotEmpty = (stringable) => {
+    const string = ensureString(stringable);
+    return ((string.length > 0) && !['null', 'undefined'].includes(string))
+  };
+
+  const stringEmpty = (stringable) => (
+    !stringNotEmpty(stringable)
+  );
+
+  const splitString = (splitting, index = splitting.length) => {
+    const string = ensureString(splitting);
+    return [string.slice(0, index), string.slice(index)]
+  };
+
+  const compareNumber = (number1 = 0, number2 = 0) => (
+    number1 - number2
+  );
+
+  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 isHTML = (string) => (
+    (string?.startsWith?.('<') || string?.startsWith?.('\n<')) ?? false
+  );
+
+  const freeze = (logMessage, object, type = 'log') => {
+    console[type](logMessage, !object ? object : JSON.parse(JSON.stringify(ensureObject(object))));
+  };
+
+  const replaceSpaces = (string, replacement = '') => (
+    !isType(string, 'string')
+      ? ''
+      : string.replace(/\s/g, replacement)
+  );
+
+  const recase = (string, replacement = '') => (
+    !isType(string, 'string')
+      ? ''
+      : string
+        .replace(/[^a-zA-Z0-9]+/g, replacement)
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2')
+        .replace(/([a-z])([A-Z])/g, '$1-$2')
+        .replace(/([0-9])([^0-9])/g, '$1-$2')
+        .replace(/([^0-9])([0-9])/g, '$1-$2')
+        .replace(/[-_]+/g, replacement)
+        .replace(new RegExp(`${replacement}$`), '')
+        .toLowerCase()
+  );
+
+  const zencase = (string, replacement = '-') => (
+    !isType(string, 'string')
+      ? ''
+      : replaceSpaces(string, replacement)
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2')
+        .replace(/([a-z])([A-Z])/g, '$1-$2')
+        .replace(new RegExp(`${replacement}$`), '')
+        .toLowerCase()
+  );
+
+  const dashcase = (string) => (
+    recase(string, '-')
+  );
+
+  const undashcase = (string, replacement = ' ') => (
+    ensureString(string).replace(/-/g, replacement).trim()
+  );
+
+  const snakecase = (string) => (
+    recase(string, '_')
+  );
+
+  const unsnakecase = (string, replacement = ' ') => (
+    ensureString(string).replace(/_/g, replacement).trim()
+  );
+
+  const uppercase = (string) => (
+    ensureString(string).toUpperCase()
+  );
+
+  const lowercase = (string, defaultValue = '') => (
+    !stringNotEmpty(string)
+      ? defaultValue
+      : ensureString(string).toLowerCase()
+  );
+
+  const slugify = (string) => (
+    lowercase(dashcase(string))
+  );
+
+  const capitalize = (string) => {
+    const parts = splitString(string, 1);
+    return `${uppercase(parts[0])}${parts[1]}`
+  };
+
+  const camelCase = (string) => (
+    stringNotEmpty(string)
+      ? unsnakecase(undashcase(string)).replace(/\w\S*/g, (word, charIndex) => {
+          if (charIndex === 0) {
+            return lowercase(word)
+          }
+          return `${uppercase(word.charAt(0))}${lowercase(word.substr(1))}`
+        }).split(' ').join('')
+      : ''
+  );
+
+  const titleCase = (string, _overrides) => {
+    if (!stringNotEmpty(string)) {
+      return ''
+    }
+
+    const overrides = {
+      'add-ons': 'Add-Ons',
+      agnostack: 'agnoStack',
+      ai: 'AI',
+      b2b: 'B2B',
+      b2c: 'B2C',
+      cartcollab: 'CartCollab',
+      'cartcollab(sm)': 'CartCollab(SM)',
+      chatgpt: 'ChatGPT',
+      covid: 'COVID',
+      covid19: 'COVID-19',
+      'covid-19': 'COVID-19',
+      crm: 'CRM',
+      elasticpath: 'Elastic Path',
+      ecommerce: 'eCommerce',
+      'e-commerce': 'eCommerce',
+      faqs: 'FAQs',
+      gpt: 'GPT',
+      'smile.io': 'Smile.io',
+      'stamped.io': 'Stamped.io',
+      'judge.me': 'Judge.me',
+      'influence.io': 'Influence.io',
+      keepsmallstrong: 'KeepSmallStrong',
+      loyaltylion: 'LoyaltyLion',
+      openai: 'OpenAI',
+      paypal: 'PayPal',
+      'postscript.io': 'Postscript.io',
+      recharge: 'ReCharge',
+      'stay.ai': 'Stay.ai',
+      'stay ai': 'Stay Ai',
+      shipengine: 'ShipEngine',
+      shipperhq: 'ShipperHQ',
+      shipstation: 'ShipStation',
+      taxjar: 'TaxJar',
+      yotpo: 'YotPo',
+      ..._overrides,
+    };
+
+    const stringParts = lowercase(string)
+      .split(' ')
+      .reduce((
+        _stringParts,
+        _stringPart
+      ) => {
+        const stringPart = overrides[_stringPart] ?? _stringPart
+          .replace(/([A-Z]+)/g, ' $1')
+          .replace(/\s\s+/g, ' ')
+          .replace(/(\b[a-z](?!\s)*)/g, (firstChar) => uppercase(firstChar));
+
+        return [
+          ..._stringParts,
+          ...stringNotEmpty(stringPart) ? [stringPart] : []
+        ]
+      }, []);
+
+    return stringParts.join(' ')
+  };
+
+  const removeLeadingSlash = (string) => (
+    ensureString(string).replace(/^\//, '')
+  );
+
+  const removeLeadingTrailingQuotes = (string) => (
+    ensureString(string).replace(/^"|"$/g, '')
+  );
+
+  // TODO: not sure if this should remove multipel at end or just one (as it does now)?
+  const removeTrailingSlash = (string) => (
+    ensureString(string).replace(/\/$/, '')
+  );
+
+  const removeLeadingTrailingSlash = (string) => (
+    removeTrailingSlash(removeLeadingSlash(string))
+  );
+
+  const ensureLeadingSlash = (string) => (
+    `/${removeLeadingSlash(string)}`
+  );
+
+  const ensureTrailingSlash = (string) => (
+    `${removeTrailingSlash(string)}/`
+  );
+
+  const ensureExtension = (string, extension) => {
+    if (stringEmpty(extension)) {
+      return string
+    }
+
+    const filePath = string.match(/(.*)\..+$/)?.[1] ?? string;
+
+    return `${filePath}.${extension}`
+  };
+
+  const wrappedEncode = (basePath, _wrappingPath) => {
+    const wrappingPath = ensureString(_wrappingPath);
+    if (stringEmpty(basePath)) {
+      return wrappingPath
+    }
+
+    return `${basePath}${encodeURIComponent(wrappingPath)}`
+  };
+
+  const splitCommas = (value) => (
+    ensureString(value)
+      .replace(/, /g, ',')
+      .split(',')
+      .reduce((_values, _value) => {
+        const __value = safeTrim(_value);
+        return [
+          ..._values,
+          ...stringNotEmpty(__value) ? [__value] : [] // TODO: explore stringEmptyOnly?
+        ]
+      }, [])
+  );
+
+  const combineCommas = (values) => (
+    [...new Set(
+      ensureArray(values).reduce((
+        _combined,
+        value
+      ) => ([
+        ..._combined,
+        ...splitCommas(value)
+      ]), [])
+    )]
+  );
+
+  const normalizeArray = (input, separator = ' ') => {
+    const inputArray = ensureArray(input);
+
+    return inputArray.reduce((normalized, _ignore, index) => ([
+      ...normalized,
+      inputArray.slice(0, index + 1).join(separator)
+    ]), []).reverse()
+  };
+
+  const arrayToObject = (arrayable, key) => (
+    ensureArray(arrayable).reduce((_object, item) => ({
+      ..._object,
+      [item?.[key]]: item,
+    }), {})
+  );
+
+  const isTrue = (value, falsy) => {
+    const string = ensureString(value);
+    return ![...ensureArray(falsy), '', 'false'].includes(string)
+  };
+
+  // TODO: move all uses of parseKeywords to parseKeywordGroups
+  const parseKeywords = (keywordGroup, previous) => (
+    [...new Set(ensureArray(keywordGroup).reduce((_parsedKeywords, keyword) => {
+      const keywords = splitCommas(keyword);
+
+      return [
+        ..._parsedKeywords,
+        ...keywords.filter((_keyword) => stringNotEmpty(_keyword))
+      ]
+    }, ensureArray(previous)))].join(', ')
+  );
+
+  const parseKeywordGroups = (keywordGroups) => {
+    const parsedKeywords = ensureArray(keywordGroups).reduce((_parsedKeywords, keywordGroup) => ([
+      ..._parsedKeywords,
+      ...ensureArray(keywordGroup).reduce((_parsedGroupKeywords, keyword) => {
+        const keywords = splitCommas(keyword);
+
+        return [
+          ..._parsedGroupKeywords,
+          ...keywords.filter((_keyword) => stringNotEmpty(_keyword))
+        ]
+      }, [])
+    ]), []);
+
+    return [...new Set(parsedKeywords)].join(', ')
+  };
+
+  const parseProjectName = (_name) => {
+    const name = ensureString(_name);
+    const [, organization, ...parts] = /(@.*)([\\]+|\/)+(.*)/.exec(name) ?? [];
+    const projectName = organization ? name.replace(organization, '').replace('/', '') : name;
+
+    return {
+      name,
+      parts,
+      organization,
+      projectName,
+    }
+  };
+
+  const parseProject = (packageInfo) => {
+    const { shortName, owner: _appOwner, name: _name, appName: _appName, keywords, siteName: _siteName } = packageInfo ?? {};
+    const { name, organization, projectName } = parseProjectName(_name);
+
+    const appName = _appName ?? projectName?.slice(projectName?.indexOf('-') + 1);
+    const siteName = _siteName ?? projectName?.slice(projectName?.indexOf('-') + 1);
+    const companyName = titleCase(organization?.replace('@', ''));
+    const appOwner = _appOwner ?? companyName;
+
+    return [{
+      keywords,
+      appOwner,
+      appName,
+      siteName,
+      shortName,
+      companyName,
+      projectName,
+    }, organization, name]
+  };
+
+  // #endregion lib-core
+
+  // #region lib-utils-js
+
+  const querystringToObject = (queryString) => {
+    if (stringEmpty(queryString)) {
+      return {}
+    }
+
+    const urlParams = new URLSearchParams(queryString);
+    return Object.fromEntries(urlParams)
+  };
+
+  const arrayIncludesAll = (_values, comparison) => {
+    const values = ensureArray(_values);
+    return ensureArray(comparison).every((value) => (
+      stringNotEmpty(value) && values.includes(value)
+    ))
+  };
+
+  const arraysMatch = (array1, array2) => (
+    arrayIncludesAll(array1, array2) && arrayIncludesAll(array2, array1)
+  );
+
+  const appendQuery = (_basePath, queryString) => {
+    const basePath = ensureString(_basePath);
+    if (stringEmpty(queryString)) {
+      return basePath
+    }
+    return `${basePath}${basePath.includes('?') ? '&' : '?'}${queryString}`
+  };
+
+  /* eslint-disable no-use-before-define */
+
+  // TODO!!!: keep in sync between verifyd and lib-core
+  // TODO: consolidate these to export as COMMON_FORMATS
+  const TIME_FORMAT_LONG = 'HH:mm';
+  const TIME_FORMAT_AMPM = 'h:mm a';
+
+  const DATE_FORMAT_MED = 'M/d/yyyy';
+  const DATE_FORMAT_LONG = 'MM/dd/yyyy';
+  const DATE_FORMAT_TRACKING = 'MMddyyyy';
+  const DATE_FORMAT_ORGANIZED = 'yyyy-MM-dd';
+
+  const {
+    DATE_SHORT,
+    DATE_MED,
+    DATE_FULL,
+    DATE_HUGE,
+    DATETIME_SHORT,
+    DATETIME_MED,
+    DATETIME_MED_WITH_SECONDS,
+    DATETIME_FULL,
+    DATETIME_HUGE,
+    TIME_SIMPLE,
+  } = luxon.DateTime;
+
+  const DATE_MINI = {
+    ...DATE_SHORT,
+    year: '2-digit',
+  };
+
+  const DATETIME_MINI = {
+    ...DATETIME_SHORT,
+    year: '2-digit',
+  };
+
+  const {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    timeZoneName: _timeZoneNameF,
+    ...DATETIME_FULL_NO_ZONE
+  } = DATETIME_FULL;
+
+  const {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    timeZoneName: _timeZoneNameH,
+    ...DATETIME_HUGE_NO_ZONE
+  } = DATETIME_HUGE;
+
+  const CUSTOM_FORMATS = {
+    UTC: 'UTC',
+    ISO: 'ISO',
+    UNIX: 'UNIX',
+  };
+
+  const LOCALE_FORMATS = {
+    DATE_MINI,
+    DATE_SHORT,
+    DATE_MED,
+    DATE_FULL,
+    DATE_HUGE,
+    DATETIME_MINI,
+    DATETIME_SHORT,
+    DATETIME_MED,
+    DATETIME_MED_WITH_SECONDS,
+    DATETIME_FULL_NO_ZONE,
+    DATETIME_HUGE_NO_ZONE,
+    TIME_SIMPLE,
+  };
+
+  const DATE_PARTS = {
+    day: 'dd',
+    month: 'MM',
+    year: 'yyyy',
+  };
+
+  const validLocaleFormats = Object.values(LOCALE_FORMATS);
+
+  const hasSomeNumbers = (value) => /\d/.test(value);
+  const hasOnlyValidCharacters = (value) => /^[\w-+:,\\/\s.]+$/.test(value); // TODO: confirm if these are all needed?
+
+  const getDaysInMonth = (year, month) => (
+    new Date(year, month, 0).getDate()
+  );
+
+  const setDateTimeLocale = (locale) => {
+    if (stringNotEmpty(locale)) {
+      luxon.Settings.defaultLocale = locale;
+    }
+  };
+
+  const setDateTimeZone = (zone) => {
+    if (stringNotEmpty(zone)) {
+      luxon.Settings.defaultZone = zone;
+    }
+  };
+
+  const getDateTimeFormat = ({ locale, mappings = DATE_PARTS } = {}) => {
+    const localeParts = getCurrentDateTime().toLocaleParts({ locale });
+
+    return localeParts.map(({ type, value }) => {
+      if (type === 'literal') {
+        return value
+      }
+
+      return mappings[type]
+    }).filter(stringNotEmpty).join('')
+  };
+
+  const getDateTimeFromString = ({ format, value, ...options } = {}) => {
+    if (
+      !hasSomeNumbers(value) ||
+      !hasOnlyValidCharacters(value) ||
+      (isType(value, 'string') && stringEmpty(value))
+    ) {
+      return undefined
+    }
+
+    if (stringNotEmpty(format)) {
+      return luxon.DateTime.fromFormat(value, format, options)
+    }
+
+    if (isNumericNegatable(value)) {
+      return luxon.DateTime.fromSeconds(ensureNumericNegatable(value))
+    }
+
+    let dateTime = luxon.DateTime.fromISO(value, options);
+
+    if (!dateTime?.isValid) {
+      dateTime = luxon.DateTime.fromSQL(value, options);
+    }
+
+    if (!dateTime?.isValid) {
+      dateTime = luxon.DateTime.fromRFC2822(value, options);
+    }
+
+    return dateTime
+  };
+
+  const convertDateTime = (value, { shouldThrow = true, shouldLog = shouldThrow, ...options } = {}) => {
+    let dateTime;
+    try {
+      switch (true) {
+        // eslint-disable-next-line eqeqeq
+        case (value == undefined): {
+          break
+        }
+
+        case luxon.DateTime.isDateTime(value): {
+          dateTime = value;
+          break
+        }
+
+        case (value instanceof Date): {
+          dateTime = luxon.DateTime.fromJSDate(value, options);
+          break
+        }
+
+        case isType(value, 'object'): {
+          dateTime = luxon.DateTime.fromObject(value, options);
+          break
+        }
+
+        default: {
+          dateTime = getDateTimeFromString({ value, ...options });
+          break
+        }
+      }
+
+      if (dateTime && !dateTime.isValid) {
+        if (shouldLog) {
+          console.info('Issue converting timestamp', { value, dateTime });
+        }
+        throw new Error(['Error converting timestamp', dateTime?.invalidExplanation].filter(stringNotEmpty).join('. '))
+      }
+    } catch (error) {
+      if (shouldThrow) {
+        throw error
+      }
+      dateTime = undefined;
+    }
+
+    return dateTime
+  };
+
+  const convertDuration = (value, { shouldThrow = true, ...options } = {}) => {
+    let duration;
+    try {
+      switch (true) {
+        // eslint-disable-next-line eqeqeq
+        case (value == undefined): {
+          break
+        }
+
+        case luxon.Duration.isDuration(value): {
+          duration = value;
+          break
+        }
+
+        case isType(value, 'object'): {
+          duration = luxon.Duration.fromObject(value, options);
+          break
+        }
+
+        case isNumericNegatable(value): {
+          duration = luxon.Duration.fromMillis(value, options);
+          break
+        }
+
+        case (
+          isType(value, 'string') &&
+          stringNotEmpty(value) &&
+          hasSomeNumbers(value) &&
+          hasOnlyValidCharacters(value)
+        ): {
+          duration = luxon.Duration.fromISOTime(value, options);
+
+          if (!duration?.isValid) {
+            duration = luxon.Duration.fromISO(value, options);
+          }
+
+          break
+        }
+
+        default: {
+          break
+        }
+      }
+
+      if (duration && !duration.isValid) {
+        console.error('Error converting duration', { value, duration });
+        throw new Error(['Error converting duration', duration?.invalidExplanation].filter(stringNotEmpty).join('. '))
+      }
+    } catch (error) {
+      if (shouldThrow) {
+        throw error
+      }
+      duration = undefined;
+    }
+
+    return duration
+  };
+
+  const getDuration = (dt1, dt2) => (
+    luxon.Interval.fromDateTimes(convertDateTime(dt1), convertDateTime(dt2)).toDuration()
+  );
+
+  const getCurrentDateTime = () => (
+    luxon.DateTime.now()
+  );
+
+  const getDateTimeDifference = (dt1, dt2 = getCurrentDateTime(), unit) => (
+    dt2.diff(ensureDateTime(dt1), unit)?.[unit]
+  );
+
+  const getDaysBetween = (dt1, dt2) => (
+    Math.abs(getDateTimeDifference(dt1, dt2, 'days'))
+  );
+
+  const getWeeksBetween = (dt1, dt2) => (
+    Math.abs(getDateTimeDifference(dt1, dt2, 'weeks'))
+  );
+
+  const isSameDateTime = (dt1, dt2 = getCurrentDateTime(), unit) => (
+    // eslint-disable-next-line eqeqeq
+    dt1.startOf(unit).ts == dt2.startOf(unit).ts
+  );
+
+  const isSameHour = (dt1, dt2) => (
+    isSameDateTime(dt1, dt2, 'hour')
+  );
+
+  const isSameDay = (dt1, dt2) => (
+    isSameDateTime(dt1, dt2, 'day')
+  );
+
+  const ensureDateTime = (value, options) => (
+    convertDateTime(value, options) ?? getCurrentDateTime()
+  );
+
+  const formatTimestamps = (timestamps, defaultValue) => (
+    Object.entries(ensureObject(timestamps)).reduce((_timestamps, [name, value]) => ({
+      ..._timestamps,
+      [name]: value ? toUnixString(value) : defaultValue,
+    }), {})
+  );
+
+  const formatRequiredTimestamps = ({ created_at, updated_at, ...timestamps } = {}) => {
+    const _createdTimestamp = toUnixString(created_at);
+    const updatedTimestamp = updated_at ? toUnixString(updated_at) : _createdTimestamp;
+    const createdTimestamp = `${Math.min(_createdTimestamp, updatedTimestamp)}`; // HMMM: why doing math on strings??
+
+    const otherTimestamps = formatTimestamps(timestamps, createdTimestamp);
+    return { created_at: createdTimestamp, updated_at: updatedTimestamp, ...otherTimestamps }
+  };
+
+  const toJSDate = (value, options) => (
+    ensureDateTime(value, options).toJSDate()
+  );
+
+  const toUnixInteger = (value, options) => (
+    ensureDateTime(value, options).toUnixInteger()
+  );
+
+  // consolidate w/ toFormatted({ value, CUSTOM_FORMATS.UNIX })
+  const toUnixString = (value, options) => (
+    `${toUnixInteger(convertDateTime(value, options), options)}`
+  );
+
+  // consolidate w/ toFormatted({ value, format: CUSTOM_FORMATS.ISO })
+  const toISOString = (value, options) => (
+    ensureDateTime(value, options).toISO()
+  );
+
+  // consolidate w/ toFormatted({ value, format: CUSTOM_FORMATS.UTC })
+  const toUTCString = (value, options) => (
+    ensureDateTime(value, options).toUTC().toString()
+  );
+
+  // HMMM: return toString if no format (or similar)??
+  const toFormatted = ({ format, value, zone, ...options } = {}) => {
+    // eslint-disable-next-line eqeqeq
+    if (format == undefined) {
+      throw new Error('Please supply a format')
+    }
+
+    let datetime = ensureDateTime(value, options);
+
+    if (stringNotEmpty(zone)) {
+      datetime = datetime.setZone(zone);
+    }
+
+    switch (true) {
+      case (format === CUSTOM_FORMATS.UTC): {
+        return datetime.toUTC().toString()
+      }
+
+      case (format === CUSTOM_FORMATS.ISO): {
+        return datetime.toISO()
+      }
+
+      case (format === CUSTOM_FORMATS.UNIX): {
+        return `${toUnixInteger(datetime)}`
+      }
+
+      case (isType(format, 'string')): {
+        return datetime.toFormat(format, options)
+      }
+
+      default: {
+        if (!validLocaleFormats.includes(format)) {
+          console.warn('Please consider using a format from LOCALE_FORMATS');
+        }
+
+        return datetime.toLocaleString(format, options)
+      }
+    }
+  };
+
+  const convertFormatted = ({
+    value,
+    to: { format: toFormat, ...toOptions } = {},
+    from: { format: fromFormat, ...fromOptions } = {},
+  } = {}) => {
+    if (stringEmpty(toFormat) || stringEmpty(fromFormat)) {
+      throw new Error('Please supply to/from formats')
+    }
+
+    if (stringEmpty(value)) {
+      return undefined
+    }
+
+    return toFormatted({
+      format: toFormat,
+      value: getDateTimeFromString({ value, format: fromFormat, ...fromOptions }),
+      ...toOptions,
+    })
+  };
+
+  const compareDate = (date1, date2) => (
+    -convertDateTime(date1).diff(convertDateTime(date2)).as('milliseconds')
+  );
+
+  const TEMP_HOSTNAME = 'xyz.com';
+  const REMOVABLE_KEYS = ['shop', 'host'];
+
+  const HEADER_CONTENT_TYPE = 'Content-Type';
+  const CONTENT_TYPES = {
+    APPLICATION_JSON: 'application/json',
+  };
+
+  const getRequestMethod = (body, _method) => {
+    const method = _method ?? (body ? 'POST' : 'GET');
+
+    return uppercase(method)
+  };
+
+  const prepareRequestOptions = ({ method: _method, body: _body, headers: _header, ...requestOptions } = {}) => {
+    const method = getRequestMethod(_body, _method);
+
+    const headers = {
+      [HEADER_CONTENT_TYPE]: CONTENT_TYPES.APPLICATION_JSON,
+      ..._header,
+    };
+
+    let body = _body;
+    if (body && headers[HEADER_CONTENT_TYPE].startsWith(CONTENT_TYPES.APPLICATION_JSON)) {
+      body = JSON.stringify(safeParse(body));
+    }
+
+    return {
+      method,
+      headers,
+      ...(body && (method !== 'GET')) && { body },
+      ...requestOptions,
+    }
+  };
+
+  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 getKeysData = async (publicKey, { crypto: _crypto, util: _util } = {}) => {
+    const webCrypto = new WebCrypto({ crypto: _crypto, util: _util });
+
+    const _ephemeralStoreableKeyPair = await webCrypto.getStorableKeyPair(
+      await webCrypto.generateKeyPair(publicKey)
+    );
+
+    const _verificationKeyPair = await webCrypto.getVerificationKeys({
+      publicKey,
+      privateKey: _ephemeralStoreableKeyPair.privateKey,
+    });
+
+    return {
+      publicKey,
+      ephemeral: _ephemeralStoreableKeyPair,
+      verification: _verificationKeyPair,
+    }
+  };
+
+  // eslint-disable-next-line arrow-body-style
+  const prepareVerificationRequest = ({ keysData: _keysData, disableRecryption: _disableRecryption, crypto: _crypto, util: _util } = {}) => {
+    const webCrypto = new WebCrypto({ crypto: _crypto, util: _util });
+    const disableRecryption = isTrue(_disableRecryption);
+
+    return async (requestPath, { method: rawMethod, body: rawBody, headers: rawHeaders,  ...requestOptions } = {}) => {
+      let parsedBody = safeParse(rawBody);
+      const method = getRequestMethod(parsedBody, rawMethod);
+
+      if (disableRecryption || stringEmpty(_keysData?.publicKey)) {
+        return [
+          requestPath,
+          prepareRequestOptions({
+            method,
+            body: parsedBody,
+            headers: rawHeaders,
+            ...requestOptions,
+          })
+        ]
+      }
+
+      const {
+        verification: {
+          derivedHMACKey,
+          derivedSecretKey,
+        } = {},
+        ephemeral: {
+          publicKey: ephemeralPublicKey,
+        } = {},
+      } = _keysData ?? {};
+
+      if (!derivedHMACKey || !ephemeralPublicKey) {
+        return undefined
+      }
+
+      if (parsedBody && derivedSecretKey) {
+        parsedBody = await webCrypto.encryptMessage(JSON.stringify(parsedBody), derivedSecretKey);
+      }
+
+      const timestamp = toUnixString();
+      const computedHMAC = await webCrypto.generateHMAC(
+        objectToSortedString({
+          body: parsedBody,
+          method,
+          timestamp,
+          ...normalizeURIParts(requestPath),
+        }),
+        derivedHMACKey
+      );
+
+      return [
+        requestPath,
+        prepareRequestOptions({
+          method,
+          body: parsedBody,
+          headers: {
+            'X-Authorization': `HMAC-SHA256 ${computedHMAC}`,
+            'X-Authorization-Timestamp': timestamp,
+            'X-Ephemeral-Key': ephemeralPublicKey,
+            'X-Public-Key': _keysData.publicKey,
+            ...rawHeaders,
+          },
+          ...requestOptions,
+        }),
+        derivedSecretKey
+      ]
+    }
+  };
+
+  const processVerificationResponse = ({ keysData, disableRecryption: _disableRecryption, crypto: _crypto, util: _util } = {}) => {
+    const webCrypto = new WebCrypto({ crypto: _crypto, util: _util });
+    const disableRecryption = isTrue(_disableRecryption);
+
+    return async (encryptedResponse, _derivedSecretKey) => {
+      const derivedSecretKey = _derivedSecretKey ?? keysData.verification?.derivedSecretKey;
+      if (disableRecryption || !encryptedResponse || !derivedSecretKey) {
+        return encryptedResponse
+      }
+    
+      const decryptedMessage = await webCrypto.decryptMessage(encryptedResponse, derivedSecretKey);
+      return safeParse(decryptedMessage)
+    }
+  };
+
+  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
+    })
+  );
+
+  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.CONTENT_TYPES = CONTENT_TYPES;
+  exports.CUSTOM_FORMATS = CUSTOM_FORMATS;
+  exports.DATE_FORMAT_LONG = DATE_FORMAT_LONG;
+  exports.DATE_FORMAT_MED = DATE_FORMAT_MED;
+  exports.DATE_FORMAT_ORGANIZED = DATE_FORMAT_ORGANIZED;
+  exports.DATE_FORMAT_TRACKING = DATE_FORMAT_TRACKING;
+  exports.HEADER_CONTENT_TYPE = HEADER_CONTENT_TYPE;
+  exports.LOCALE_FORMATS = LOCALE_FORMATS;
+  exports.TIME_FORMAT_AMPM = TIME_FORMAT_AMPM;
+  exports.TIME_FORMAT_LONG = TIME_FORMAT_LONG;
+  exports.VerificationError = VerificationError;
+  exports.WebCrypto = WebCrypto;
+  exports.appendQuery = appendQuery;
+  exports.arrayEmpty = arrayEmpty;
+  exports.arrayIncludesAll = arrayIncludesAll;
+  exports.arrayNotEmpty = arrayNotEmpty;
+  exports.arrayRandom = arrayRandom;
+  exports.arrayRandomItem = arrayRandomItem;
+  exports.arrayToObject = arrayToObject;
+  exports.arraysMatch = arraysMatch;
+  exports.camelCase = camelCase;
+  exports.capitalize = capitalize;
+  exports.cleanObject = cleanObject;
+  exports.combineCommas = combineCommas;
+  exports.compareDate = compareDate;
+  exports.compareEntryKeys = compareEntryKeys;
+  exports.compareNumber = compareNumber;
+  exports.compareString = compareString;
+  exports.convertDateTime = convertDateTime;
+  exports.convertDuration = convertDuration;
+  exports.convertFormatted = convertFormatted;
+  exports.dashcase = dashcase;
+  exports.ensureAlphaNumeric = ensureAlphaNumeric;
+  exports.ensureArray = ensureArray;
+  exports.ensureArraySet = ensureArraySet;
+  exports.ensureDateTime = ensureDateTime;
+  exports.ensureExtension = ensureExtension;
+  exports.ensureLeadingSlash = ensureLeadingSlash;
+  exports.ensureNumeric = ensureNumeric;
+  exports.ensureNumericConstrained = ensureNumericConstrained;
+  exports.ensureNumericNegatable = ensureNumericNegatable;
+  exports.ensureNumericOnly = ensureNumericOnly;
+  exports.ensureObject = ensureObject;
+  exports.ensureRawBody = ensureRawBody;
+  exports.ensureString = ensureString;
+  exports.ensureStringAscii = ensureStringAscii;
+  exports.ensureStringClean = ensureStringClean;
+  exports.ensureStringOnly = ensureStringOnly;
+  exports.ensureTrailingSlash = ensureTrailingSlash;
+  exports.findLastMatch = findLastMatch;
+  exports.formatRequiredTimestamps = formatRequiredTimestamps;
+  exports.formatTimestamps = formatTimestamps;
+  exports.freeze = freeze;
+  exports.getCurrentDateTime = getCurrentDateTime;
+  exports.getDateTimeFormat = getDateTimeFormat;
+  exports.getDateTimeFromString = getDateTimeFromString;
+  exports.getDaysBetween = getDaysBetween;
+  exports.getDaysInMonth = getDaysInMonth;
+  exports.getDuration = getDuration;
+  exports.getKeysData = getKeysData;
+  exports.getRequestMethod = getRequestMethod;
+  exports.getVerificationHelpers = getVerificationHelpers;
+  exports.getWeeksBetween = getWeeksBetween;
+  exports.isArray = isArray;
+  exports.isHTML = isHTML;
+  exports.isNumericNegatable = isNumericNegatable;
+  exports.isNumericOnly = isNumericOnly;
+  exports.isSameDay = isSameDay;
+  exports.isSameHour = isSameHour;
+  exports.isSet = isSet;
+  exports.isTrue = isTrue;
+  exports.isType = isType;
+  exports.isTypeEnhanced = isTypeEnhanced;
+  exports.lowercase = lowercase;
+  exports.nextRandom = nextRandom;
+  exports.normalizeArray = normalizeArray;
+  exports.normalizeShopifyId = normalizeShopifyId;
+  exports.normalizeURIParts = normalizeURIParts;
+  exports.nullable = nullable;
+  exports.objectContainsAnyValue = objectContainsAnyValue;
+  exports.objectEmpty = objectEmpty;
+  exports.objectNotEmpty = objectNotEmpty;
+  exports.objectToSortedString = objectToSortedString;
+  exports.parseKeywordGroups = parseKeywordGroups;
+  exports.parseKeywords = parseKeywords;
+  exports.parseProject = parseProject;
+  exports.parseProjectName = parseProjectName;
+  exports.prepareRequestOptions = prepareRequestOptions;
+  exports.prepareVerificationRequest = prepareVerificationRequest;
+  exports.processVerificationResponse = processVerificationResponse;
+  exports.querystringToObject = querystringToObject;
+  exports.random = random;
+  exports.removeLeadingSlash = removeLeadingSlash;
+  exports.removeLeadingTrailingQuotes = removeLeadingTrailingQuotes;
+  exports.removeLeadingTrailingSlash = removeLeadingTrailingSlash;
+  exports.removeTrailingSlash = removeTrailingSlash;
+  exports.replaceSpaces = replaceSpaces;
+  exports.safeParse = safeParse;
+  exports.safeTrim = safeTrim;
+  exports.setDateTimeLocale = setDateTimeLocale;
+  exports.setDateTimeZone = setDateTimeZone;
+  exports.slugify = slugify;
+  exports.snakecase = snakecase;
+  exports.splitCommas = splitCommas;
+  exports.stringEmpty = stringEmpty;
+  exports.stringEmptyOnly = stringEmptyOnly;
+  exports.stringNotEmpty = stringNotEmpty;
+  exports.stringNotEmptyOnly = stringNotEmptyOnly;
+  exports.titleCase = titleCase;
+  exports.toFormatted = toFormatted;
+  exports.toISOString = toISOString;
+  exports.toJSDate = toJSDate;
+  exports.toUTCString = toUTCString;
+  exports.toUnixInteger = toUnixInteger;
+  exports.toUnixString = toUnixString;
+  exports.undashcase = undashcase;
+  exports.unsnakecase = unsnakecase;
+  exports.uppercase = uppercase;
+  exports.wrappedEncode = wrappedEncode;
+  exports.zencase = zencase;
+
+  Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=index.js.map