@agnostack/verifyd 2.4.1-alpha.1 → 2.5.0-alpha.2

package/dist/esm/shared/display.js

@@ -0,0 +1,429 @@
+/* eslint-disable no-use-before-define */
+// #region lib-core
+// TODO!!!: keep in sync between next-shopify and lib-core (AND lib-utils-js at bottom)
+const REACT_SYMBOL = Symbol.for('react.element');
+export const random = (max = 100, min = 1) => {
+    const floor = Math.min(max, min);
+    return Math.floor(Math.random() * (max - floor + 1)) + floor;
+};
+export 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;
+};
+export 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;
+};
+export const arrayRandomItem = (_values) => (arrayRandom(_values)[0]);
+export const isArray = (value) => (
+// eslint-disable-next-line eqeqeq
+(value != undefined) && Array.isArray(value));
+export const isSet = (value) => (
+// eslint-disable-next-line eqeqeq
+(value != undefined) && (value instanceof Set));
+export const isType = (value, type) => (
+// eslint-disable-next-line eqeqeq, valid-typeof
+(value != undefined) && (typeof value === type));
+export const isString = (value) => (isType(value, 'string') ||
+    (value instanceof String));
+const isReact = (value) => (isType(value, 'object') &&
+    ((value === null || value === void 0 ? void 0 : value.$$typeof) === REACT_SYMBOL));
+const isClass = (value) => (isType(value, 'object') &&
+    (Object.getPrototypeOf(value) !== Object.prototype) &&
+    !isReact(value));
+export const isTypeEnhanced = (value, type) => {
+    switch (true) {
+        case (type === 'boolean'): {
+            return isType(value, type) || ['true', 'false'].includes(value);
+        }
+        case (type === 'string'): {
+            return isString(value);
+        }
+        case (type === 'set'): {
+            return isSet(value);
+        }
+        case (type === 'react'): {
+            return isReact(value);
+        }
+        case (type === 'class'): {
+            return isClass(value);
+        }
+        case (type === 'array'): {
+            return (isArray(value) &&
+                !isSet(value));
+        }
+        case (type === 'object'): {
+            return (isType(value, type) &&
+                !isArray(value) &&
+                !isClass(value) &&
+                !isString(value) &&
+                !isReact(value));
+        }
+        default: {
+            return isType(value, type);
+        }
+    }
+};
+export const safeTrim = (value) => {
+    if (isTypeEnhanced(value, 'string')) {
+        // eslint-disable-next-line no-param-reassign
+        value = value.trim();
+    }
+    return value;
+};
+export const isParseable = (value, trim, matchQuoted) => {
+    if (!isTypeEnhanced(value, 'string')) {
+        return false;
+    }
+    if (trim) {
+        // eslint-disable-next-line no-param-reassign
+        value = safeTrim(value);
+    }
+    return isTrue(value.startsWith('{') || value.startsWith('[') || (matchQuoted && value.startsWith('"')));
+};
+export const safeParse = (value, trim) => {
+    switch (true) {
+        case isTypeEnhanced(value, 'object'):
+        case isTypeEnhanced(value, 'array'): {
+            return value;
+        }
+        case isParseable(value, trim, true): {
+            if (trim) {
+                // eslint-disable-next-line no-param-reassign
+                value = safeTrim(value);
+            }
+            try {
+                return JSON.parse(value);
+            }
+            catch (_ignore) {
+                console.info('Ignoring error parsing', _ignore);
+                // TODO: should this be value ?? {}
+                return value;
+            }
+        }
+        default: {
+            // TODO: should this be value ?? {}
+            return value;
+        }
+    }
+};
+export const ensureString = (string) => (string ? `${string}` : '');
+// HMMM: what if 'string' is an object?
+export const ensureStringOnly = (string) => (
+// eslint-disable-next-line eqeqeq
+(string != undefined) ? `${string}` : '');
+export const ensureStringAscii = (string) => (
+// eslint-disable-next-line no-control-regex
+ensureStringOnly(string).replace(/[^\x00-\x7F]/g, ''));
+export const ensureStringClean = (string) => (
+// eslint-disable-next-line no-control-regex
+ensureStringOnly(string).replace(/[^a-z0-9_-]/gi, ''));
+export const ensureAlphaNumeric = (string) => (
+// eslint-disable-next-line no-control-regex
+ensureStringOnly(string).replace(/[^a-z0-9]/gi, ''));
+export const isNumericOnly = (value) => {
+    var _a;
+    const [matched] = (_a = `${value}`.match(/^([0-9]+)$/)) !== null && _a !== void 0 ? _a : [];
+    // eslint-disable-next-line eqeqeq
+    return (matched != undefined);
+};
+export const isNumericNegatable = (value) => {
+    var _a;
+    const [matched] = (_a = `${value}`.match(/^(-?[0-9]+(\.[0-9]+)?)?$/)) !== null && _a !== void 0 ? _a : [];
+    // eslint-disable-next-line eqeqeq
+    return (matched != undefined);
+};
+// TODO: explore places using ensureNumeric to move to isNumericNegatable
+export const ensureNumeric = (string) => (Number(ensureString(string).replace(/[^0-9.]/gi, '')));
+export const ensureNumericOnly = (string) => (Number(ensureString(string).replace(/[^0-9]/gi, '')));
+// TODO: update regex to handle negative number returns negative. Something like (?!\d\.)(-?\d+(\.\d)?)
+export const ensureNumericNegatable = (string) => (Number(ensureString(string).replace(/[^0-9.-]/gi, '')));
+export 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));
+};
+export const ensureArray = (array = []) => (
+// eslint-disable-next-line no-nested-ternary
+!array ? [] : Array.isArray(array) ? array : [array]);
+export const ensureArraySet = (arrayOrSet) => (ensureArray(isSet(arrayOrSet) ? [...arrayOrSet] : arrayOrSet));
+export const arrayEmpty = (array, disableEmptyString = false) => (
+// eslint-disable-next-line eqeqeq
+!array || !array.length || (array.length === 1 && (array[0] == undefined || (disableEmptyString && stringEmpty(array[0])))));
+export const arrayNotEmpty = (array, disableEmptyString = false) => (
+// eslint-disable-next-line eqeqeq
+!arrayEmpty(array) && array[0] != undefined && (!disableEmptyString || stringNotEmpty(array[0])));
+export const findLastMatch = (array, filterCallback = (value) => (value)) => (ensureArray(array).filter(filterCallback).slice(-1)[0]);
+export const ensureObject = (object) => (object !== null && object !== void 0 ? object : {});
+// NOTE: this does not ensure !isType(string)
+export const objectEmpty = (object) => (!object || !Object.keys(object).length);
+export const objectNotEmpty = (object) => (!objectEmpty(object));
+export const nullable = (object) => ((!object || (object === 'null') || (object === undefined) || (object === null))
+    ? null // TODO: explore undefined here??
+    : object);
+export const objectContainsAnyValue = (object) => (Object.values(ensureObject(object)).some((value) => nullable(value)));
+const isUndefined = (value) => (
+// eslint-disable-next-line eqeqeq
+value == undefined);
+export const cleanObjectKeys = (object, _removeKeyNames) => {
+    const removeKeyNames = ensureArray(_removeKeyNames);
+    return Object.fromEntries(Object.entries(ensureObject(object)).filter(([key]) => !removeKeyNames.includes(key)));
+};
+export const cleanObject = (object, allowEmptyLeafs, isEmptyCallback) => (Object.entries(ensureObject(object)).reduce((_cleanedObject, [key, _value]) => {
+    var _a, _b;
+    if (!allowEmptyLeafs && ((_a = isEmptyCallback === null || isEmptyCallback === void 0 ? void 0 : isEmptyCallback(_value)) !== null && _a !== void 0 ? _a : 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)
+        ]), []);
+    if (!allowEmptyLeafs && ((_b = isEmptyCallback === null || isEmptyCallback === void 0 ? void 0 : isEmptyCallback(value)) !== null && _b !== void 0 ? _b : isUndefined(value))) {
+        return _cleanedObject; // skip key if null or undefined
+    }
+    return Object.assign(Object.assign({}, _cleanedObject), { [key]: value });
+}, {}));
+const cleanObjectValue = (value, allowEmptyLeafs, isEmptyCallback) => {
+    switch (true) {
+        case isClass(value): {
+            return undefined;
+        }
+        case isTypeEnhanced(value, 'object'): {
+            return cleanObject(value, allowEmptyLeafs, isEmptyCallback);
+        }
+        default: {
+            return value;
+        }
+    }
+};
+export const stringNotEmptyOnly = (stringable) => {
+    const string = ensureStringOnly(stringable);
+    return ((string.length > 0) && !['null', 'undefined'].includes(string));
+};
+export const stringEmptyOnly = (stringable) => (!stringNotEmptyOnly(stringable));
+export const stringNotEmpty = (stringable) => {
+    const string = ensureString(stringable);
+    return ((string.length > 0) && !['null', 'undefined'].includes(string));
+};
+export const stringEmpty = (stringable) => (!stringNotEmpty(stringable));
+const splitString = (splitting, index = splitting.length) => {
+    const string = ensureString(splitting);
+    return [string.slice(0, index), string.slice(index)];
+};
+export const compareNumber = (number1 = 0, number2 = 0) => (number1 - number2);
+export const compareString = (string1, string2) => {
+    if (stringEmpty(string1)) {
+        return 1;
+    }
+    if (stringEmpty(string2)) {
+        return -1;
+    }
+    return ensureString(string1).localeCompare(string2);
+};
+export const compareEntryKeys = ([string1], [string2]) => (compareString(string1, string2));
+export const objectToSortedString = (object, separator = '') => (Object.entries(ensureObject(object))
+    .sort(compareEntryKeys)
+    .map(([key, value]) => `${key}=${value}`)
+    .join(separator));
+export const isHTML = (string) => {
+    var _a, _b, _c;
+    return ((_c = (((_a = string === null || string === void 0 ? void 0 : string.startsWith) === null || _a === void 0 ? void 0 : _a.call(string, '<')) || ((_b = string === null || string === void 0 ? void 0 : string.startsWith) === null || _b === void 0 ? void 0 : _b.call(string, '\n<')))) !== null && _c !== void 0 ? _c : false);
+};
+export const freeze = (logMessage, object, type = 'log') => {
+    console[type](logMessage, !object ? object : JSON.parse(JSON.stringify(ensureObject(object))));
+};
+export 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());
+export 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());
+export const dashcase = (string) => (recase(string, '-'));
+export const undashcase = (string, replacement = ' ') => (ensureString(string).replace(/-/g, replacement).trim());
+export const snakecase = (string) => (recase(string, '_'));
+export const unsnakecase = (string, replacement = ' ') => (ensureString(string).replace(/_/g, replacement).trim());
+export const uppercase = (string) => (ensureString(string).toUpperCase());
+export const lowercase = (string, defaultValue = '') => (!stringNotEmpty(string)
+    ? defaultValue
+    : ensureString(string).toLowerCase());
+export const isLowercase = (string) => (stringNotEmpty(string) && /^[^A-Z]*$/.test(string));
+export const slugify = (string) => (lowercase(dashcase(string)));
+export const capitalize = (string) => {
+    const parts = splitString(string, 1);
+    return `${uppercase(parts[0])}${parts[1]}`;
+};
+export const camelCase = (string) => (stringEmpty(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(''));
+export const titleCase = (_string, _overrides) => {
+    if (stringEmpty(_string)) {
+        return '';
+    }
+    const overrides = Object.assign({ ach: 'ACH', 'add-ons': 'Add-Ons', agnostack: 'agnoStack', ai: 'AI', 'ai for commerce': 'AI for Commerce', "'ai for commerce'": "'AI For Commerce'", 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', ipaas: 'iPaaS', 'ltv.ai': 'LTV.ai', 'smile.io': 'Smile.io', 'stamped.io': 'Stamped.io', 'judge.me': 'Judge.me', 'influence.io': 'Influence.io', keepsmallstrong: 'KeepSmallStrong', loyaltylion: 'LoyaltyLion', 'mach alliance': 'MACH Alliance', 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', vs: 'vs', 'vs.': 'vs.', yotpo: 'YotPo', "zendesk 'ai for commerce'": "Zendesk 'AI For Commerce'" }, _overrides);
+    const string = lowercase(_string);
+    if (overrides[string]) {
+        return overrides[string];
+    }
+    const stringParts = string
+        .split(' ')
+        .reduce((_stringParts, _stringPart) => {
+        var _a;
+        const stringPart = (_a = overrides[_stringPart]) !== null && _a !== void 0 ? _a : _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(' ');
+};
+export const removeLeadingSlash = (string) => (ensureString(string).replace(/^\//, ''));
+export const removeLeadingTrailingQuotes = (string) => (ensureString(string).replace(/^"|"$/g, ''));
+// TODO: not sure if this should remove multipel at end or just one (as it does now)?
+export const removeTrailingSlash = (string) => (ensureString(string).replace(/\/$/, ''));
+export const removeLeadingTrailingSlash = (string) => (removeTrailingSlash(removeLeadingSlash(string)));
+export const ensureLeadingSlash = (string) => (`/${removeLeadingSlash(string)}`);
+export const ensureTrailingSlash = (string) => (`${removeTrailingSlash(string)}/`);
+export const ensureTrailingQuestion = (string) => {
+    if (!isString(string)) {
+        return string;
+    }
+    return string.endsWith('?') ? string : `${string}?`;
+};
+export const ensureExtension = (string, extension) => {
+    var _a, _b;
+    if (stringEmpty(extension)) {
+        return string;
+    }
+    const filePath = (_b = (_a = string.match(/(.*)\..+$/)) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : string;
+    return `${filePath}.${extension}`;
+};
+export const wrappedEncode = (basePath, _wrappingPath) => {
+    const wrappingPath = ensureString(_wrappingPath);
+    if (stringEmpty(basePath)) {
+        return wrappingPath;
+    }
+    return `${basePath}${encodeURIComponent(wrappingPath)}`;
+};
+export const splitCommas = (value) => (ensureString(value)
+    .replace(/, /g, ',')
+    .split(',')
+    .reduce((_values, _value) => {
+    const __value = safeTrim(_value);
+    return [
+        ..._values,
+        ...stringNotEmpty(__value) ? [__value] : [] // TODO: explore stringEmptyOnly?
+    ];
+}, []));
+export const combineCommas = (values) => ([...new Set(ensureArray(values).reduce((_combined, value) => ([
+        ..._combined,
+        ...splitCommas(value)
+    ]), []))]);
+export const normalizeArray = (input, separator = ' ') => {
+    const inputArray = ensureArray(input);
+    return inputArray.reduce((normalized, _ignore, index) => ([
+        ...normalized,
+        inputArray.slice(0, index + 1).join(separator)
+    ]), []).reverse();
+};
+export const arrayToObject = (arrayable, key) => (ensureArray(arrayable).reduce((_object, item) => (Object.assign(Object.assign({}, _object), { [item === null || item === void 0 ? void 0 : item[key]]: item })), {}));
+export const isTrue = (value, falsy) => {
+    if ((value === false) ||
+        isUndefined(value) ||
+        ensureArray(falsy).includes(value)) {
+        return false;
+    }
+    return ![...ensureArray(falsy), '', 'false'].includes(lowercase(value));
+};
+export const isUndefinedOrTrue = (value, falsy) => (isUndefined(value) || isTrue(value, falsy));
+export const isBoolean = (value) => ([true, false].includes(value) ||
+    ['true', 'false'].includes(lowercase(value)));
+export const getBaseDomain = (baseUrl) => ((baseUrl === null || baseUrl === void 0 ? void 0 : baseUrl.match(/^(?:https?:\/\/)?([^/:]+)(?::(\d+))?/).slice(1, 3).filter(stringNotEmpty).join(':')) || undefined);
+// TODO: move all uses of parseKeywords to parseKeywordGroups
+export 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(', '));
+export const parseCommaGroups = (commaGroups) => {
+    const parsedGroups = ensureArray(commaGroups).reduce((_parsedGroups, commaGroup) => ([
+        ..._parsedGroups,
+        ...ensureArray(commaGroup).reduce((_parsedCommaKeywords, keyword) => {
+            const keywords = splitCommas(keyword);
+            return [
+                ..._parsedCommaKeywords,
+                ...keywords.filter((_keyword) => stringNotEmpty(_keyword))
+            ];
+        }, [])
+    ]), []);
+    return [...new Set(parsedGroups)];
+};
+export const parseKeywordGroups = (keywordGroups) => (parseCommaGroups(keywordGroups).join(', '));
+// #endregion lib-core
+// #region lib-utils-js
+export const querystringToParams = (queryString) => {
+    const urlParams = new URLSearchParams(ensureString(queryString));
+    return [Object.fromEntries(urlParams), urlParams];
+};
+export const querystringToObject = (queryString) => (querystringToParams(queryString)[0]);
+export const arrayIncludesAll = (_values, comparison) => {
+    const values = ensureArray(_values);
+    return ensureArray(comparison).every((value) => (stringNotEmpty(value) && values.includes(value)));
+};
+export const arraysMatch = (array1, array2) => (arrayIncludesAll(array1, array2) && arrayIncludesAll(array2, array1));
+export const appendQuery = (_basePath, queryString) => {
+    const basePath = ensureString(_basePath);
+    if (stringEmpty(queryString)) {
+        return basePath;
+    }
+    return `${basePath}${basePath.includes('?') ? '&' : '?'}${queryString}`;
+};
+export const appendParams = (basePath, params) => (appendQuery(basePath, ensureArray(params).join('&')));
+// #endregion lib-utils-js

package/dist/esm/shared/errors.js

@@ -0,0 +1,37 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+export class PreconditionError extends Error {
+    constructor(message, _data) {
+        super(message);
+        const _a = _data !== null && _data !== void 0 ? _data : {}, { code = 412 } = _a, data = __rest(_a, ["code"]);
+        this.code = code;
+        this.data = data;
+        this.name = 'PreconditionError';
+        Object.setPrototypeOf(this, PreconditionError.prototype);
+    }
+}
+export class CryptoError extends PreconditionError {
+    constructor(message, _data) {
+        const _a = _data !== null && _data !== void 0 ? _data : {}, { code = 500 } = _a, data = __rest(_a, ["code"]);
+        super(message, Object.assign({ code }, data));
+        this.name = 'CryptoError';
+        Object.setPrototypeOf(this, CryptoError.prototype);
+    }
+}
+export class VerificationError extends PreconditionError {
+    constructor(message, _data) {
+        const _a = _data !== null && _data !== void 0 ? _data : {}, { code = 500 } = _a, data = __rest(_a, ["code"]);
+        super(message, Object.assign({ code }, data));
+        this.name = 'VerificationError';
+        Object.setPrototypeOf(this, VerificationError.prototype);
+    }
+}

package/dist/esm/shared/index.js

@@ -0,0 +1,6 @@
+// export * from './constants' // HMMMM???
+export * from './errors';
+export * from './authorization';
+export * from './request';
+export * from './verification';
+export * from './WebCrypto';

package/dist/esm/shared/request.js

@@ -0,0 +1,60 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { ensureLeadingSlash, stringEmpty, uppercase, safeParse, } from './display';
+const TEMP_HOSTNAME = 'xyz.com';
+const REMOVABLE_KEYS = ['shop', 'host'];
+export const VERIFYD_HEADERS = {
+    PUBLIC_KEY: 'X-Public-Key',
+    EPHEMERAL_KEY: 'X-Ephemeral-Key',
+    AUTHORIZATION: 'X-Authorization',
+    AUTHORIZATION_TIMESTAMP: 'X-Authorization-Timestamp',
+};
+const CONTENT_TYPE_HEADER = 'Content-Type';
+export const CONTENT_TYPES = {
+    APPLICATION_JSON: 'application/json',
+};
+export const getRequestMethod = (body, _method) => {
+    const method = _method !== null && _method !== void 0 ? _method : (body ? 'POST' : 'GET');
+    return uppercase(method);
+};
+export const prepareRequestOptions = (_a = {}) => {
+    var { method: _method, body: _body, headers: _headers } = _a, requestOptions = __rest(_a, ["method", "body", "headers"]);
+    const method = getRequestMethod(_body, _method);
+    const _contentType = _headers === null || _headers === void 0 ? void 0 : _headers[CONTENT_TYPE_HEADER.toLowerCase()];
+    const headers = Object.assign({ [CONTENT_TYPE_HEADER]: _contentType || CONTENT_TYPES.APPLICATION_JSON }, _headers);
+    let body = _body;
+    if (body && headers[CONTENT_TYPE_HEADER].startsWith(CONTENT_TYPES.APPLICATION_JSON)) {
+        body = JSON.stringify(safeParse(body));
+    }
+    return Object.assign(Object.assign({ 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);
+};
+export const normalizeURIParts = (uri) => {
+    const urlObject = convertToURL(uri);
+    if (!urlObject) {
+        return undefined;
+    }
+    REMOVABLE_KEYS.forEach((key) => urlObject.searchParams.delete(key));
+    return Object.assign(Object.assign({}, (urlObject.hostname !== TEMP_HOSTNAME) && {
+        origin: urlObject.origin,
+    }), { pathname: urlObject.pathname, search: urlObject.search });
+};

package/dist/esm/shared/verification.js

@@ -0,0 +1,94 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { VerificationError } from './errors';
+import { normalizeURIParts, prepareRequestOptions, getRequestMethod, } from './request';
+import { isTrue, safeParse, stringEmpty, objectToSortedString, } from './display';
+import { WebCrypto } from './WebCrypto';
+const getUnixString = () => {
+    const currentDate = new Date();
+    const unixTimestamp = currentDate.getTime();
+    return Math.floor(unixTimestamp / 1000).toString();
+};
+export const getVerificationKeysData = (publicKey_1, ...args_1) => __awaiter(void 0, [publicKey_1, ...args_1], void 0, function* (publicKey, { crypto: _crypto, util: _util } = {}) {
+    if (stringEmpty(publicKey)) {
+        return {};
+    }
+    const webCrypto = new WebCrypto({ crypto: _crypto, util: _util });
+    const _ephemeralStoreableKeyPair = yield webCrypto.getStorableKeyPair(yield webCrypto.generateKeyPair());
+    const _verificationKeyPair = yield webCrypto.getVerificationKeys({
+        publicKey,
+        privateKey: _ephemeralStoreableKeyPair.privateKey,
+    });
+    return {
+        publicKey,
+        ephemeral: _ephemeralStoreableKeyPair,
+        verification: _verificationKeyPair,
+    };
+});
+// eslint-disable-next-line arrow-body-style
+export const prepareVerificationRequest = ({ keysData: _keysData, disableRecryption: _disableRecryption, crypto: _crypto, util: _util } = {}) => {
+    const webCrypto = new WebCrypto({ crypto: _crypto, util: _util });
+    const disableRecryption = isTrue(_disableRecryption);
+    return (requestPath_1, ...args_1) => __awaiter(void 0, [requestPath_1, ...args_1], void 0, function* (requestPath, _a = {}) {
+        var { method: rawMethod, body: rawBody, headers: rawHeaders } = _a, requestOptions = __rest(_a, ["method", "body", "headers"]);
+        let parsedBody = safeParse(rawBody);
+        const method = getRequestMethod(parsedBody, rawMethod);
+        if (disableRecryption || stringEmpty(_keysData === null || _keysData === void 0 ? void 0 : _keysData.publicKey)) {
+            return [
+                requestPath,
+                prepareRequestOptions(Object.assign({ method, body: parsedBody, headers: rawHeaders }, requestOptions), requestPath)
+            ];
+        }
+        const { verification: { derivedHMACKey, derivedSecretKey, } = {}, ephemeral: { publicKey: ephemeralPublicKey, } = {}, } = _keysData !== null && _keysData !== void 0 ? _keysData : {};
+        if (!derivedHMACKey || !ephemeralPublicKey) {
+            return undefined;
+        }
+        if (parsedBody && derivedSecretKey) {
+            parsedBody = yield webCrypto.encryptMessage(JSON.stringify(parsedBody), derivedSecretKey);
+        }
+        const timestamp = getUnixString();
+        const computedHMAC = yield webCrypto.generateHMAC(objectToSortedString(Object.assign({ body: parsedBody, method,
+            timestamp }, normalizeURIParts(requestPath))), derivedHMACKey);
+        return [
+            requestPath,
+            prepareRequestOptions(Object.assign({ method, body: parsedBody, headers: Object.assign({ 'X-Authorization': `HMAC-SHA256 ${computedHMAC}`, 'X-Authorization-Timestamp': timestamp, 'X-Ephemeral-Key': ephemeralPublicKey, 'X-Public-Key': _keysData.publicKey }, rawHeaders) }, requestOptions), requestPath),
+            derivedSecretKey
+        ];
+    });
+};
+export const processVerificationResponse = ({ keysData, disableRecryption: _disableRecryption, crypto: _crypto, util: _util } = {}) => {
+    const webCrypto = new WebCrypto({ crypto: _crypto, util: _util });
+    const disableRecryption = isTrue(_disableRecryption);
+    return (encryptedResponse, _derivedSecretKey) => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const derivedSecretKey = _derivedSecretKey !== null && _derivedSecretKey !== void 0 ? _derivedSecretKey : (_a = keysData.verification) === null || _a === void 0 ? void 0 : _a.derivedSecretKey;
+        if (disableRecryption || !encryptedResponse || !derivedSecretKey) {
+            return encryptedResponse;
+        }
+        try {
+            const decryptedMessage = yield webCrypto.decryptMessage(encryptedResponse, derivedSecretKey);
+            return safeParse(decryptedMessage);
+        }
+        catch (_b) {
+            throw new VerificationError('Error decrypting response', { code: 400 });
+        }
+    });
+};