swell-js 5.8.2 → 5.9.1

package/dist/swell.cjs

@@ -1,9 +1,128 @@
 'use strict';
 
-const qs = require('qs');
 const deepmerge = require('deepmerge');
 const fastCase = require('fast-case');
 
+/*!
+ * The UTF-8/RFC 3986 encoder in this file is adapted from qs 6.16.0 (lib/utils.js).
+ * That code was originally written by Brian White (mscdex) for the io.js core
+ * querystring library and adapted by qs for stricter adherence to RFC 3986.
+ *
+ * @license BSD-3-Clause
+ *
+ * Copyright (c) 2014, Nathan LaFreniere and other contributors
+ * (https://github.com/ljharb/qs/graphs/contributors)
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its
+ *    contributors may be used to endorse or promote products derived from
+ *    this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+const hex = Array.from({ length: 256 }, (_, c) =>
+  `%${c.toString(16).padStart(2, '0')}`.toUpperCase(),
+);
+const toISO = Date.prototype.toISOString;
+
+function encode(value) {
+  if (value.length === 0) return value;
+  const string =
+    typeof value === 'symbol'
+      ? Symbol.prototype.toString.call(value)
+      : String(value);
+  let out = '';
+  for (let j = 0; j < string.length; j += 1024) {
+    let segment = string.slice(j, j + 1024);
+    if (j + 1024 < string.length) {
+      const last = segment.charCodeAt(segment.length - 1);
+      if (last >= 0xd800 && last <= 0xdbff) {
+        segment = segment.slice(0, -1);
+        j -= 1;
+      }
+    }
+    for (let i = 0; i < segment.length; ++i) {
+      let c = segment.charCodeAt(i);
+      if (
+        c === 0x2d ||
+        c === 0x2e ||
+        c === 0x5f ||
+        c === 0x7e ||
+        (c >= 0x30 && c <= 0x39) ||
+        (c >= 0x41 && c <= 0x5a) ||
+        (c >= 0x61 && c <= 0x7a)
+      ) {
+        out += segment.charAt(i);
+      } else if (c < 0x80) {
+        out += hex[c];
+      } else if (c < 0x800) {
+        out += hex[0xc0 | (c >> 6)] + hex[0x80 | (c & 0x3f)];
+      } else if (c < 0xd800 || c >= 0xe000) {
+        out +=
+          hex[0xe0 | (c >> 12)] +
+          hex[0x80 | ((c >> 6) & 0x3f)] +
+          hex[0x80 | (c & 0x3f)];
+      } else {
+        i += 1;
+        c = 0x10000 + (((c & 0x3ff) << 10) | (segment.charCodeAt(i) & 0x3ff));
+        out +=
+          hex[0xf0 | (c >> 18)] +
+          hex[0x80 | ((c >> 12) & 0x3f)] +
+          hex[0x80 | ((c >> 6) & 0x3f)] +
+          hex[0x80 | (c & 0x3f)];
+      }
+    }
+  }
+  return out;
+}
+
+function stringifyQuery(obj) {
+  if (typeof obj !== 'object' || obj === null) return '';
+  const parts = [];
+  const ancestors = new Set();
+  function walk(value, prefix) {
+    if (value === undefined) return;
+    if (value instanceof Date) value = toISO.call(value);
+    if (value === null) value = '';
+    const isObject = typeof value === 'object';
+    const isBuffer =
+      isObject &&
+      value.constructor &&
+      value.constructor.isBuffer &&
+      value.constructor.isBuffer(value);
+    if ((!isObject && typeof value !== 'function') || isBuffer) {
+      parts.push(`${encode(prefix)}=${encode(value)}`);
+      return;
+    }
+    if (ancestors.has(value)) throw new RangeError('Cyclic object value');
+    ancestors.add(value);
+    for (const key of Object.keys(value)) walk(value[key], `${prefix}[${key}]`);
+    ancestors.delete(value);
+  }
+  for (const key of Object.keys(obj)) walk(obj[key], key);
+  return parts.join('&');
+}
+
 /** Detect free variable `global` from Node.js. */
 var freeGlobal = typeof global == 'object' && global && global.Object === Object && global;
 
@@ -4493,8 +4612,6 @@ function isEmpty(value) {
 
 const LOADING_SCRIPTS = {};
 
-let options = {};
-
 function arrayMerge(target, source, options) {
   const destination = target.slice();
   source.forEach((item, index) => {
@@ -4532,14 +4649,6 @@ function merge(x, y, opt) {
   return deepmerge(x, y, opt);
 }
 
-function setOptions(optns) {
-  options = optns;
-}
-
-function getOptions() {
-  return options;
-}
-
 function isObject(val) {
   return val && typeof val === 'object' && !(val instanceof Array);
 }
@@ -4583,10 +4692,6 @@ function trimEnd(str) {
   return typeof str === 'string' ? str.replace(/[/]+$/, '') : '';
 }
 
-function stringifyQuery(str) {
-  return qs.stringify(str);
-}
-
 function map(arr, cb) {
   return arr instanceof Array ? arr.map(cb) : [];
 }
@@ -4621,7 +4726,7 @@ function defaultMethods(api, uri, methods) {
   };
 }
 
-async function vaultRequest(method, url, data) {
+async function vaultRequest(method, url, data, options) {
   const { vaultUrl, timeout, key } = options;
   const requestData = {
     $jsonp: {
@@ -4805,7 +4910,6 @@ const utils = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
   findIndex,
   get,
   getLocationParams,
-  getOptions,
   isEmpty,
   isEqual,
   isFunction,
@@ -4820,7 +4924,6 @@ const utils = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
   removeUrlParams,
   round: round$1,
   set,
-  setOptions,
   snakeCase,
   stringifyQuery,
   toCamel,
@@ -4835,171 +4938,173 @@ const utils = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
   vaultRequest
 }, Symbol.toStringTag, { value: 'Module' }));
 
-const cardApi = {
-  async createToken(data) {
-    let error = null;
-    let code = null;
-    let param = null;
-    if (!data) {
-      error = 'Card details are missing in `swell.card.createToken(card)`';
-      param = '';
-    }
-    const card = toSnake(data);
-    if (!card.nonce) {
-      if (!this.validateNumber(card.number)) {
-        error = 'Card number appears to be invalid';
-        code = 'invalid_card_number';
-        param = 'number';
+function methods$e(options) {
+  return {
+    async createToken(data) {
+      let error = null;
+      let code = null;
+      let param = null;
+      if (!data) {
+        error = 'Card details are missing in `swell.card.createToken(card)`';
+        param = '';
+      }
+      const card = toSnake(data);
+      if (!card.nonce) {
+        if (!this.validateNumber(card.number)) {
+          error = 'Card number appears to be invalid';
+          code = 'invalid_card_number';
+          param = 'number';
+        }
+        if (card.exp) {
+          const exp = this.expiry(card.exp);
+          card.exp_month = exp.month;
+          card.exp_year = exp.year;
+        }
+        if (!this.validateExpiry(card.exp_month, card.exp_year)) {
+          error = 'Card expiry appears to be invalid';
+          code = 'invalid_card_expiry';
+          param = 'exp_month';
+        }
+        if (!this.validateCVC(card.cvc)) {
+          error = 'Card CVC code appears to be invalid';
+          code = 'invalid_card_cvc';
+          param = 'exp_cvc';
+        }
       }
-      if (card.exp) {
-        const exp = this.expiry(card.exp);
-        card.exp_month = exp.month;
-        card.exp_year = exp.year;
+
+      if (error) {
+        const err = new Error(error);
+        err.code = code || 'invalid_card';
+        err.status = 402;
+        err.param = param;
+        throw err;
       }
-      if (!this.validateExpiry(card.exp_month, card.exp_year)) {
-        error = 'Card expiry appears to be invalid';
-        code = 'invalid_card_expiry';
-        param = 'exp_month';
+
+      // Get a token from the vault
+      const result = await vaultRequest('post', '/tokens', card, options);
+      if (result.errors) {
+        const param = Object.keys(result.errors)[0];
+        const err = new Error(result.errors[param].message || 'Unknown error');
+        err.code = 'vault_error';
+        err.status = 402;
+        err.param = param;
+        throw err;
       }
-      if (!this.validateCVC(card.cvc)) {
-        error = 'Card CVC code appears to be invalid';
-        code = 'invalid_card_cvc';
-        param = 'exp_cvc';
+      return result;
+    },
+
+    expiry(value) {
+      if (value && value.month && value.year) {
+        return value;
       }
-    }
 
-    if (error) {
-      const err = new Error(error);
-      err.code = code || 'invalid_card';
-      err.status = 402;
-      err.param = param;
-      throw err;
-    }
+      const parts = new String(value).split(/[\s/-]+/, 2);
+      const month = parts[0];
 
-    // Get a token from the vault
-    const result = await vaultRequest('post', '/tokens', card);
-    if (result.errors) {
-      const param = Object.keys(result.errors)[0];
-      const err = new Error(result.errors[param].message || 'Unknown error');
-      err.code = 'vault_error';
-      err.status = 402;
-      err.param = param;
-      throw err;
-    }
-    return result;
-  },
+      const currentYear = new Date().getUTCFullYear().toString();
+      let strYear = parts[1];
 
-  expiry(value) {
-    if (value && value.month && value.year) {
-      return value;
-    }
+      if (strYear.length < currentYear.length) {
+        let fullYear =
+          currentYear.slice(0, currentYear.length - strYear.length) + strYear;
+
+        // If the expiration year is less than the current year,
+        // then the expiration year is in the next century.
+        if (fullYear < currentYear) {
+          let year = Number(fullYear);
+          year += 10 ** strYear.length;
+          fullYear = year.toString();
+        }
+
+        strYear = fullYear;
+      }
 
-    const parts = new String(value).split(/[\s/-]+/, 2);
-    const month = parts[0];
+      return {
+        month: Number.parseInt(month, 10),
+        year: Number.parseInt(strYear, 10),
+      };
+    },
+
+    types() {
+      let t = {};
+      for (let e = 40; e <= 49; ++e) t[e] = 'Visa';
+      for (let e = 50; e <= 59; ++e) t[e] = 'MasterCard';
+      t[34] = t[37] = 'American Express';
+      t[60] = t[62] = t[64] = t[65] = 'Discover';
+      t[35] = 'JCB';
+      t[30] = t[36] = t[38] = t[39] = 'Diners Club';
+      return t;
+    },
 
-    const currentYear = new Date().getUTCFullYear().toString();
-    let strYear = parts[1];
+    type(num) {
+      return this.types()[num.slice(0, 2)] || 'Unknown';
+    },
 
-    if (strYear.length < currentYear.length) {
-      let fullYear =
-        currentYear.slice(0, currentYear.length - strYear.length) + strYear;
+    luhnCheck(num) {
+      const numbers = String(num);
+      let odd = false;
+      let sum = 0;
 
-      // If the expiration year is less than the current year,
-      // then the expiration year is in the next century.
-      if (fullYear < currentYear) {
-        let year = Number(fullYear);
-        year += 10 ** strYear.length;
-        fullYear = year.toString();
-      }
+      for (let i = numbers.length - 1; i >= 0; --i) {
+        let digit = Number.parseInt(numbers[i], 10);
 
-      strYear = fullYear;
-    }
+        if (odd) {
+          digit *= 2;
 
-    return {
-      month: Number.parseInt(month, 10),
-      year: Number.parseInt(strYear, 10),
-    };
-  },
-
-  types() {
-    let t = {};
-    for (let e = 40; e <= 49; ++e) t[e] = 'Visa';
-    for (let e = 50; e <= 59; ++e) t[e] = 'MasterCard';
-    t[34] = t[37] = 'American Express';
-    t[60] = t[62] = t[64] = t[65] = 'Discover';
-    t[35] = 'JCB';
-    t[30] = t[36] = t[38] = t[39] = 'Diners Club';
-    return t;
-  },
-
-  type(num) {
-    return this.types()[num.slice(0, 2)] || 'Unknown';
-  },
-
-  luhnCheck(num) {
-    const numbers = String(num);
-    let odd = false;
-    let sum = 0;
-
-    for (let i = numbers.length - 1; i >= 0; --i) {
-      let digit = Number.parseInt(numbers[i], 10);
-
-      if (odd) {
-        digit *= 2;
-
-        if (digit > 9) {
-          digit -= 9;
+          if (digit > 9) {
+            digit -= 9;
+          }
         }
-      }
 
-      sum += digit;
-      odd = !odd;
-    }
+        sum += digit;
+        odd = !odd;
+      }
 
-    return sum % 10 === 0;
-  },
+      return sum % 10 === 0;
+    },
 
-  validateNumber(num) {
-    num = String(num).replace(/\s+|-/g, '');
+    validateNumber(num) {
+      num = String(num).replace(/\s+|-/g, '');
 
-    return num.length >= 10 && num.length <= 16 && this.luhnCheck(num);
-  },
+      return num.length >= 10 && num.length <= 16 && this.luhnCheck(num);
+    },
 
-  validateExpiry(month, year) {
-    month = String(month).trim();
-    year = String(year).trim();
+    validateExpiry(month, year) {
+      month = String(month).trim();
+      year = String(year).trim();
 
-    if (!/^\d+$/.test(month) || !/^\d+$/.test(year)) {
-      return false;
-    }
+      if (!/^\d+$/.test(month) || !/^\d+$/.test(year)) {
+        return false;
+      }
 
-    const numMonth = Number.parseInt(month, 10);
+      const numMonth = Number.parseInt(month, 10);
 
-    if (numMonth <= 0 || numMonth > 12) {
-      return false;
-    }
+      if (numMonth <= 0 || numMonth > 12) {
+        return false;
+      }
 
-    const date = new Date(year, month);
-    date.setMonth(date.getMonth() - 1);
-    date.setMonth(date.getMonth() + 1, 1);
+      const date = new Date(year, month);
+      date.setMonth(date.getMonth() - 1);
+      date.setMonth(date.getMonth() + 1, 1);
 
-    const diff = date.getTime() - Date.now();
+      const diff = date.getTime() - Date.now();
 
-    // The card has expired
-    if (diff < 0) {
-      return false;
-    }
+      // The card has expired
+      if (diff < 0) {
+        return false;
+      }
 
-    // The card's validity period must not exceed 50 years from the current time.
-    return Math.round(diff / 31_557_600_000) < 50;
-  },
+      // The card's validity period must not exceed 50 years from the current time.
+      return Math.round(diff / 31_557_600_000) < 50;
+    },
 
-  validateCVC(val) {
-    val = String(val).trim();
+    validateCVC(val) {
+      val = String(val).trim();
 
-    return /^\d+$/.test(val) && val.length >= 3 && val.length <= 4;
-  },
-};
+      return /^\d+$/.test(val) && val.length >= 3 && val.length <= 4;
+    },
+  };
+}
 
 const COOKIE_MAX_AGE = 604800; // 1 week
 
@@ -5050,191 +5155,191 @@ function setCookie(name, value, options = {}) {
 
 const RECORD_TIMEOUT = 5000;
 
-let VALUES = {
-  /*
-  [model]: {
-    [id]: {
-      data,
-      record,
-      recordTimer,
-      presets,
+function methods$d(opt) {
+  let VALUES = {
+    /*
+    [model]: {
+      [id]: {
+        data,
+        record,
+        recordTimer,
+        presets,
+      }
     }
-  }
-*/
-};
+  */
+  };
 
-const cacheApi = {
-  options: {
-    enabled: true,
-    debug: false,
-  },
+  return {
+    options: {
+      enabled: true,
+      debug: false,
+    },
 
-  debug(...args) {
-    if (this.options.debug) {
-      console.log(...args);
-    }
-  },
+    debug(...args) {
+      if (this.options.debug) {
+        console.log(...args);
+      }
+    },
 
-  values({ model, id }, setValues = undefined) {
-    this.debug('cache.values', ...arguments);
-    if (setValues !== undefined) {
-      for (let key in setValues) {
-        set(VALUES, `${model}.${id}.${key}`, setValues[key]);
+    values({ model, id }, setValues = undefined) {
+      this.debug('cache.values', ...arguments);
+      if (setValues !== undefined) {
+        for (let key in setValues) {
+          set(VALUES, `${model}.${id}.${key}`, setValues[key]);
+        }
+        return;
       }
-      return;
-    }
-    return get(VALUES, `${model}.${id}`, {});
-  },
+      return get(VALUES, `${model}.${id}`, {});
+    },
 
-  preset(details) {
-    this.debug('cache.preset', ...arguments);
-    const { presets = [] } = this.values(details);
-    presets.push(details);
-    this.values(details, { presets });
-  },
+    preset(details) {
+      this.debug('cache.preset', ...arguments);
+      const { presets = [] } = this.values(details);
+      presets.push(details);
+      this.values(details, { presets });
+    },
 
-  set(details) {
-    this.debug('cache.set', ...arguments);
-    let { model, id, path, value } = details;
-    let { data = {}, record } = this.values(details);
+    set(details) {
+      this.debug('cache.set', ...arguments);
+      let { model, id, path, value } = details;
+      let { data = {}, record } = this.values(details);
 
-    if (id === null) {
-      return;
-    }
-
-    if (record === undefined) {
-      return this.preset(details);
-    }
+      if (id === null) {
+        return;
+      }
 
-    data = merge(record || {}, data);
+      if (record === undefined) {
+        return this.preset(details);
+      }
 
-    const { useCamelCase } = getOptions();
-    if (useCamelCase && value && typeof value === 'object') {
-      value = toCamel(value);
-    }
+      data = merge(record || {}, data);
 
-    if (path || value instanceof Array) {
-      let upData = { ...(data || {}) };
-      let upPath = useCamelCase ? toCamelPath(path) : path;
-      set(upData, upPath || '', value);
-      data = upData;
-    } else if (value && typeof value === 'object') {
-      data = data || {};
-      data = merge(data, value);
-    } else {
-      data = value;
-    }
+      const { useCamelCase } = opt;
+      if (useCamelCase && value && typeof value === 'object') {
+        value = toCamel(value);
+      }
+
+      if (path || value instanceof Array) {
+        let upData = { ...(data || {}) };
+        let upPath = useCamelCase ? toCamelPath(path) : path;
+        set(upData, upPath || '', value);
+        data = upData;
+      } else if (value && typeof value === 'object') {
+        data = data || {};
+        data = merge(data, value);
+      } else {
+        data = value;
+      }
 
-    this.values(details, { data });
+      this.values(details, { data });
 
-    try {
-      // Make sure values have clean refs
-      const cache = VALUES[model][id];
-      if (cache !== undefined) {
-        if (cache.data !== undefined) {
-          cache.data = JSON.parse(JSON.stringify(cache.data));
-        }
-        if (cache.record !== undefined) {
-          cache.record = JSON.parse(JSON.stringify(cache.record));
+      try {
+        // Make sure values have clean refs
+        const cache = VALUES[model][id];
+        if (cache !== undefined) {
+          if (cache.data !== undefined) {
+            cache.data = JSON.parse(JSON.stringify(cache.data));
+          }
+          if (cache.record !== undefined) {
+            cache.record = JSON.parse(JSON.stringify(cache.record));
+          }
         }
+      } catch (err) {
+        // noop
       }
-    } catch (err) {
-      // noop
-    }
-  },
+    },
 
-  get(model, id) {
-    this.debug('cache.get', ...arguments);
-    const { data, recordTimer } = this.values({ model, id });
-    this.debug('cache.get:data+recordTimer', ...arguments);
-    if (recordTimer) {
-      return data;
-    }
-  },
+    get(model, id) {
+      this.debug('cache.get', ...arguments);
+      const { data, recordTimer } = this.values({ model, id });
+      this.debug('cache.get:data+recordTimer', ...arguments);
+      if (recordTimer) {
+        return data;
+      }
+    },
 
-  setRecord(record, details) {
-    this.debug('cache.setRecord', ...arguments);
-    let { recordTimer, presets } = this.values(details);
+    setRecord(record, details) {
+      this.debug('cache.setRecord', ...arguments);
+      let { recordTimer, presets } = this.values(details);
 
-    if (recordTimer) {
-      clearTimeout(recordTimer);
-    }
+      if (recordTimer) {
+        clearTimeout(recordTimer);
+      }
 
-    recordTimer = setTimeout(() => {
-      this.values(details, { record: undefined, recordTimer: undefined });
-    }, RECORD_TIMEOUT);
+      recordTimer = setTimeout(() => {
+        this.values(details, { record: undefined, recordTimer: undefined });
+      }, RECORD_TIMEOUT);
 
-    // Record has to be null at minimum, not undefined
-    this.values(details, {
-      record: record !== undefined ? record : null,
-      recordTimer,
-    });
+      // Record has to be null at minimum, not undefined
+      this.values(details, {
+        record: record !== undefined ? record : null,
+        recordTimer,
+      });
 
-    if (presets) {
-      for (let preset of presets) {
-        this.set(preset);
+      if (presets) {
+        for (let preset of presets) {
+          this.set(preset);
+        }
+        this.values(details, { presets: undefined });
       }
-      this.values(details, { presets: undefined });
-    }
 
-    const result = this.get(details.model, details.id);
+      const result = this.get(details.model, details.id);
 
-    return result !== undefined ? result : record;
-  },
+      return result !== undefined ? result : record;
+    },
 
-  async getFetch(model, id, fetch) {
-    if (this.options.enabled) {
-      this.debug('cache.getFetch', ...arguments);
-      const value = this.get(model, id);
+    async getFetch(model, id, fetch) {
+      if (this.options.enabled) {
+        this.debug('cache.getFetch', ...arguments);
+        const value = this.get(model, id);
 
-      if (value !== undefined) {
-        return value;
+        if (value !== undefined) {
+          return value;
+        }
       }
-    }
 
-    const record = await fetch();
-    return this.setRecord(record, { model, id });
-  },
+      const record = await fetch();
+      return this.setRecord(record, { model, id });
+    },
 
-  clear(model = undefined, id = undefined) {
-    this.debug('cache.clear', ...arguments);
-    if (model) {
-      if (id) {
-        set(VALUES, `${model}.${id}`, undefined);
+    clear(model = undefined, id = undefined) {
+      this.debug('cache.clear', ...arguments);
+      if (model) {
+        if (id) {
+          set(VALUES, `${model}.${id}`, undefined);
+        } else {
+          set(VALUES, model, undefined);
+        }
       } else {
-        set(VALUES, model, undefined);
+        VALUES = {};
       }
-    } else {
-      VALUES = {};
-    }
-  },
-};
+    },
+  };
+}
 
 function methods$c(api) {
   const { get, list } = defaultMethods(api, '/attributes', ['list', 'get']);
 
   return {
     get: (id, ...args) => {
-      return cacheApi.getFetch('attributes', id, () => get(id, ...args));
+      return api.cache.getFetch('attributes', id, () => get(id, ...args));
     },
 
     list,
   };
 }
 
-let OPTIONS;
-
 function methods$b(api, opt) {
-  OPTIONS = opt;
   const { get, list } = defaultMethods(api, '/products', ['list', 'get']);
   return {
     get: (id, ...args) => {
-      return cacheApi.getFetch('products', id, () => get(id, ...args));
+      return api.cache.getFetch('products', id, () => get(id, ...args));
     },
 
     list,
 
-    variation: calculateVariation,
+    variation: (input, options, purchaseOption) =>
+      calculateVariation(input, options, purchaseOption, opt),
 
     categories: getCategories,
 
@@ -5314,8 +5419,8 @@ function findVariantWithOptionValueIds(product, ids) {
   return null;
 }
 
-function calculateVariation(input, options, purchaseOption) {
-  const product = OPTIONS.useCamelCase ? toSnake(input) : input;
+function calculateVariation(input, options, purchaseOption, opt) {
+  const product = opt.useCamelCase ? toSnake(input) : input;
   const purchaseOp = findPurchaseOption(product, purchaseOption);
   const variation = {
     ...product,
@@ -5378,7 +5483,7 @@ function calculateVariation(input, options, purchaseOption) {
   if (variation.orig_price === undefined) {
     delete variation.orig_price;
   }
-  return OPTIONS.useCamelCase ? toCamel(variation) : variation;
+  return opt.useCamelCase ? toCamel(variation) : variation;
 }
 
 function findPurchaseOption(product, purchaseOption) {
@@ -5433,8 +5538,7 @@ function findPurchaseOption(product, purchaseOption) {
 }
 
 async function getFilterableAttributeFilters(api, products, options) {
-  const { results: filterableAttributes } = await methods$c(
-    api).list({
+  const { results: filterableAttributes } = await methods$c(api).list({
     filterable: true,
   });
 
@@ -6041,19 +6145,29 @@ class AppPaymentComponent extends AppComponent {
   }
 
   #getIntent(data) {
-    return vaultRequest('GET', '/intent', {
-      gateway: this.#gateway,
-      account_id: this.#accountId,
-      intent: data,
-    });
+    return vaultRequest(
+      'GET',
+      '/intent',
+      {
+        gateway: this.#gateway,
+        account_id: this.#accountId,
+        intent: data,
+      },
+      this.options,
+    );
   }
 
   #createIntent(data) {
-    return vaultRequest('POST', '/intent', {
-      gateway: this.#gateway,
-      account_id: this.#accountId,
-      intent: data,
-    });
+    return vaultRequest(
+      'POST',
+      '/intent',
+      {
+        gateway: this.#gateway,
+        account_id: this.#accountId,
+        intent: data,
+      },
+      this.options,
+    );
   }
 }
 
@@ -6208,7 +6322,7 @@ function methods$8(api) {
 
   return {
     get: (id, ...args) => {
-      return cacheApi.getFetch('categories', id, () => get(id, ...args));
+      return api.cache.getFetch('categories', id, () => get(id, ...args));
     },
 
     list,
@@ -6219,7 +6333,7 @@ function methods$7(api) {
   const { get, list } = defaultMethods(api, '/subscriptions', ['list', 'get']);
   return {
     get: (id, ...args) => {
-      return cacheApi.getFetch('subscriptions', id, () => get(id, ...args));
+      return api.cache.getFetch('subscriptions', id, () => get(id, ...args));
     },
 
     list,
@@ -6284,7 +6398,7 @@ function methods$6(api) {
   const { get, list } = defaultMethods(api, '/invoices', ['list', 'get']);
   return {
     get: (id, ...args) => {
-      return cacheApi.getFetch('invoices', id, () => get(id, ...args));
+      return api.cache.getFetch('invoices', id, () => get(id, ...args));
     },
 
     list,
@@ -6294,7 +6408,7 @@ function methods$6(api) {
 function methods$5(api, opt) {
   return {
     get: (type, id, query) => {
-      return cacheApi.getFetch(`content_${type}`, id, () =>
+      return api.cache.getFetch(`content_${type}`, id, () =>
         api.request('get', `/content/${type}`, id, {
           $preview: opt.previewContent,
           ...(query || {}),
@@ -7041,7 +7155,7 @@ class Payment {
    * @returns {Promise<object>}
    */
   async createIntent(data) {
-    return vaultRequest('post', '/intent', data);
+    return vaultRequest('post', '/intent', data, this.options);
   }
 
   /**
@@ -7051,7 +7165,7 @@ class Payment {
    * @returns {Promise<object>}
    */
   async updateIntent(data) {
-    return vaultRequest('put', '/intent', data);
+    return vaultRequest('put', '/intent', data, this.options);
   }
 
   /**
@@ -7061,7 +7175,7 @@ class Payment {
    * @returns {Promise<object>}
    */
   async authorizeGateway(data) {
-    return vaultRequest('post', '/authorization', data);
+    return vaultRequest('post', '/authorization', data, this.options);
   }
 
   /**
@@ -9345,7 +9459,7 @@ class BraintreeGooglePayment extends Payment {
 
     if (cart.subscription_delivery) {
       try {
-        const card = await cardApi.createToken({
+        const card = await this.api.card.createToken({
           gateway: 'braintree',
           account_id: cart.account_id,
           nonce,
@@ -10022,7 +10136,7 @@ class BraintreeApplePayment extends Payment {
 
       if (cart.subscription_delivery) {
         try {
-          const card = await cardApi.createToken({
+          const card = await this.api.card.createToken({
             gateway: 'braintree',
             account_id: cart.account_id,
             nonce: payload.nonce,
@@ -10928,7 +11042,7 @@ class ConvesioCardPayment extends Payment {
       ''
     ).replace(/[^0-9]+/g, '');
 
-    const cardExpiry = cardApi.expiry(
+    const cardExpiry = this.api.card.expiry(
       this.params.exp ||
         document.getElementById(
           this.params.cardExpiry?.elementId || 'cardExpiry-element',
@@ -10952,7 +11066,7 @@ class ConvesioCardPayment extends Payment {
       ''
     ).trim();
 
-    const cardBrand = cardApi.type(cardNumber).toLowerCase();
+    const cardBrand = this.api.card.type(cardNumber).toLowerCase();
 
     const payment = await createConvesioCardPaymentToken(this.method, {
       paymentMethod: {
@@ -12657,7 +12771,7 @@ class PaymentController {
   }
 
   async _vaultRequest(method, url, data) {
-    const response = await vaultRequest(method, url, data);
+    const response = await vaultRequest(method, url, data, this.options);
 
     if (this.options.useCamelCase) {
       return toCamel(response);
@@ -13211,7 +13325,7 @@ function swell(initStore = undefined, initKey, initOptions = {}) {
   const api = {};
 
   Object.assign(api, {
-    version: '5.8.2',
+    version: '5.9.1',
     options,
     request,
 
@@ -13241,8 +13355,6 @@ function swell(initStore = undefined, initKey, initOptions = {}) {
       options.getCart = opt.getCart;
       options.updateCart = opt.updateCart;
       options.headers = opt.headers || {};
-
-      setOptions(options);
     },
 
     // Backward compatibility
@@ -13266,9 +13378,9 @@ function swell(initStore = undefined, initKey, initOptions = {}) {
       return api.request('delete', url, data);
     },
 
-    cache: cacheApi,
+    cache: methods$d(options),
 
-    card: cardApi,
+    card: methods$e(options),
 
     cart: methods$a(api, options),
 
@@ -13302,9 +13414,13 @@ function swell(initStore = undefined, initKey, initOptions = {}) {
 
     utils,
 
-    getCookie,
+    getCookie(name) {
+      return (options.getCookie || getCookie)(name);
+    },
 
-    setCookie,
+    setCookie(name, value, cookieOptions) {
+      return (options.setCookie || setCookie)(name, value, cookieOptions);
+    },
   });
 
   async function request(