@rebuy/rebuy 1.5.1 → 1.6.0-alpha.2

package/dist/index.mjs

@@ -0,0 +1,767 @@
+// src/utilities.ts
+function isBase64Encoded(str) {
+  const base64Regex = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/;
+  return base64Regex.test(str) ? true : false;
+}
+function stringToData(data, decode) {
+  let response = data;
+  if (decode === true) {
+    response = atob(response);
+  }
+  try {
+    response = JSON.parse(response);
+  } catch (e) {
+    response = data;
+  }
+  return response;
+}
+function dataToString(data, encode) {
+  let response = data;
+  if (typeof response != "string") {
+    response = JSON.stringify(response);
+  }
+  if (encode === true) {
+    response = btoa(response);
+  }
+  return response;
+}
+function stripHtml(str) {
+  return str?.replace(/<(.|\n)*?>/g, "") ?? "";
+}
+function getIdFromGraphUrl(graphId, objectType) {
+  let id = null;
+  const regex = new RegExp(`gid://shopify/${objectType}/(.*)`);
+  const matches = graphId.match(regex);
+  if (matches != null) {
+    const matchedId = matches[1];
+    if (!isNaN(Number(matchedId))) {
+      id = Number(matchedId);
+    }
+  }
+  return id;
+}
+function variantAvailable(variant) {
+  return !(variant.inventory_management && variant.inventory_policy === "deny" && variant.inventory_quantity <= 0);
+}
+function firstAvailableVariant(product) {
+  let selectedVariant = product.variants[0];
+  for (let i = 0; i < product.variants.length; i++) {
+    if (variantAvailable(product.variants[i])) {
+      selectedVariant = product.variants[i];
+      break;
+    }
+  }
+  return selectedVariant;
+}
+function uuid() {
+  let d = (/* @__PURE__ */ new Date()).getTime();
+  let d2 = performance && performance.now && performance.now() * 1e3 || 0;
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    let r = Math.random() * 16;
+    if (d > 0) {
+      r = (d + r) % 16 | 0;
+      d = Math.floor(d / 16);
+    } else {
+      r = (d2 + r) % 16 | 0;
+      d2 = Math.floor(d2 / 16);
+    }
+    return (c === "x" ? r : r & 3 | 8).toString(16);
+  });
+}
+function sessionId() {
+  const config6 = {
+    chars: "0123456789",
+    length: 12
+  };
+  let sessionId2 = "";
+  const sessionStart = (/* @__PURE__ */ new Date()).getTime();
+  for (let i = config6.length; i > 0; i--) {
+    sessionId2 += config6.chars[Math.floor(Math.random() * config6.chars.length)];
+  }
+  return `REBUY.${sessionStart}.${sessionId2}`;
+}
+function convertProductToStorefrontFormat(product) {
+  const defaultVariant = firstAvailableVariant(product);
+  const minVariantPrice = variantMinMaxPriceObject(product, "price", "min");
+  const maxVariantPrice = variantMinMaxPriceObject(product, "price", "max");
+  const minVariantCompareAtPrice = variantMinMaxPriceObject(product, "compare_at_price", "min");
+  const maxVariantCompareAtPrice = variantMinMaxPriceObject(product, "compare_at_price", "max");
+  const selectedOptions = selectedVariantOptions(product, defaultVariant);
+  const variants = product.variants.map((variant) => convertVariantToStorefrontFormat(product, variant));
+  return {
+    collections: null,
+    compareAtPriceRange: {
+      maxVariantCompareAtPrice,
+      minVariantCompareAtPrice
+    },
+    description: stripHtml(product.body_html),
+    descriptionHtml: product.body_html,
+    featuredImage: productImageObject(product, null),
+    handle: product.handle,
+    id: `gid://shopify/Product/${product.id}`,
+    images: null,
+    media: [],
+    metafields: [],
+    options: [
+      ...product.options.map((option) => {
+        return { name: option.name, values: option.values };
+      })
+    ],
+    priceRange: {
+      maxVariantPrice,
+      minVariantPrice
+    },
+    selectedOptions,
+    selectedSellingPlan: null,
+    selectedSellingPlanAllocation: null,
+    sellingPlanGroups: [],
+    seo: { description: null, title: null },
+    title: product.title,
+    variants: convertToNodes(variants),
+    vendor: product.vendor
+  };
+}
+function convertToNodes(arr) {
+  return {
+    edges: [
+      ...arr.map((node) => {
+        return { node };
+      })
+    ]
+  };
+}
+function convertVariantToStorefrontFormat(product, variant) {
+  const selectedOptions = selectedVariantOptions(product, variant);
+  const image = productImageObject(product, variant.image_id);
+  return {
+    availableForSale: variantAvailable(variant),
+    compareAtPriceV2: variantPriceObject(variant, "compare_at_price"),
+    id: `gid://shopify/ProductVariant/${variant.id}`,
+    image,
+    priceV2: variantPriceObject(variant, "price"),
+    product: {
+      handle: product.handle,
+      id: product.id,
+      title: product.title,
+      vendor: product.vendor
+    },
+    selectedOptions: [selectedOptions],
+    sku: variant.sku,
+    title: variant.title
+  };
+}
+function variantMinMaxPriceObject(product, key = "price", operator = "min") {
+  let priceObject = variantPriceObject(product.variants[0], key);
+  for (let i = 0; i < product.variants.length; i++) {
+    const variantPrice = variantPriceObject(product.variants[i], key);
+    if (variantPrice != null) {
+      const variantPriceAmount = Number(variantPrice.amount);
+      const currentPriceAmount = priceObject != null ? Number(priceObject.amount) : null;
+      if (currentPriceAmount == null || operator === "min" && variantPriceAmount < currentPriceAmount || operator === "max" && variantPriceAmount > currentPriceAmount) {
+        priceObject = variantPrice;
+      }
+    }
+  }
+  return priceObject;
+}
+function variantPriceObject(variant, key = "price") {
+  if (variant[key] != null) {
+    return {
+      amount: variant[key],
+      currencyCode: "USD"
+    };
+  }
+  return null;
+}
+function selectedVariantOptions(product, variant) {
+  const selectedOptions = {};
+  if (variant.option1 != null) {
+    selectedOptions[product.options[0].name] = variant.option1;
+  }
+  if (variant.option2 != null) {
+    selectedOptions[product.options[1].name] = variant.option2;
+  }
+  if (variant.option3 != null) {
+    selectedOptions[product.options[2].name] = variant.option3;
+  }
+  return selectedOptions;
+}
+function productImageObject(product, id) {
+  let image = null;
+  if (product.image) {
+    image = {
+      altText: product.image.alt,
+      height: product.image.height,
+      id: `gid://shopify/ProductImage/${product.image.id}`,
+      url: product.image.src,
+      width: product.image.width
+    };
+  }
+  if (product.images && product.images.length > 0 && id != null) {
+    const matchingImage = product.images.find((i) => i.id === id);
+    if (matchingImage) {
+      image = {
+        altText: matchingImage.alt,
+        height: matchingImage.height,
+        id: `gid://shopify/ProductImage/${matchingImage.id}`,
+        url: matchingImage.src,
+        width: matchingImage.width
+      };
+    }
+  }
+  return image;
+}
+function queryStringToObject(str) {
+  const params = new URLSearchParams(str);
+  return Object.fromEntries(params.entries());
+}
+function utmObjectFromString(str) {
+  const utmKeys = ["utm_campaign", "utm_medium", "utm_source", "utm_term", "utm_content"];
+  const matches = {};
+  const url = new URL(str);
+  const queryObject = queryStringToObject(url.search);
+  for (const [key, value] of Object.entries(queryObject)) {
+    if (utmKeys.includes(key)) {
+      matches[key] = value;
+    }
+  }
+  return Object.keys(matches).length > 0 ? matches : null;
+}
+function amountToCents(amount) {
+  let normalizedAmount = 0;
+  if (typeof amount === "string") {
+    if (amount.indexOf(".") !== -1) {
+      normalizedAmount = Math.round(parseFloat(amount) * 100);
+    } else {
+      normalizedAmount = parseInt(amount, 10);
+    }
+  } else if (typeof amount === "number") {
+    normalizedAmount = Math.round(amount * 100);
+  }
+  if (isNaN(normalizedAmount)) {
+    normalizedAmount = 0;
+  }
+  return normalizedAmount;
+}
+function serialize(obj) {
+  const serialized = [];
+  const add = (key, value) => {
+    value = typeof value === "function" ? value() : value;
+    value = value === null ? "" : value === void 0 ? "" : value;
+    serialized[serialized.length] = encodeURIComponent(key) + "=" + encodeURIComponent(value);
+  };
+  const buildParameters = (prefix, obj2) => {
+    let i, key, len;
+    if (prefix) {
+      if (Array.isArray(obj2)) {
+        for (i = 0, len = obj2.length; i < len; i++) {
+          buildParameters(prefix + "[" + (typeof obj2[i] === "object" && obj2[i] ? i : "") + "]", obj2[i]);
+        }
+      } else if (Object.prototype.toString.call(obj2) === "[object Object]") {
+        for (key in obj2) {
+          buildParameters(prefix + "[" + key + "]", obj2[key]);
+        }
+      } else {
+        add(prefix, obj2);
+      }
+    } else if (Array.isArray(obj2)) {
+      for (i = 0, len = obj2.length; i < len; i++) {
+        add(obj2[i].name, obj2[i].value);
+      }
+    } else {
+      for (key in obj2) {
+        buildParameters(key, obj2[key]);
+      }
+    }
+    return serialized;
+  };
+  return buildParameters("", obj).join("&");
+}
+
+// src/api.ts
+var config = {
+  /**
+   * @deprecated
+   */
+  cdnDomain: "https://cdn.rebuyengine.com",
+  domain: "https://rebuyengine.com",
+  eventDomain: "https://rebuyengine.com",
+  geoDomain: "https://geo.rebuyengine.com",
+  key: null,
+  shieldDomain: "https://cached.rebuyengine.com",
+  shop: null,
+  staticDomain: "https://cdn.rebuyengine.com"
+};
+var staging = {
+  /**
+   * @deprecated
+   */
+  cdnDomain: "https://cdn.enigneyuber.com",
+  domain: "https://enigneyuber.com",
+  eventDomain: "https://enigneyuber.com",
+  geoDomain: "https://geo.enigneyuber.com",
+  shieldDomain: "https://cached.enigneyuber.com",
+  staticDomain: "https://cdn.enigneyuber.com"
+};
+var stagingDomains = [
+  "enigneyuber.com",
+  "rebuy-engine-regression.myshopify.com",
+  "rebuy-stage-currency-test.myshopify.com",
+  "rebuy-staging-automation.myshopify.com",
+  "rebuy-staging-regression.myshopify.com",
+  "rebuy-uat.myshopify.com",
+  "rebuy-regression-qa.myshopify.com",
+  "senator-staging.myshopify.com",
+  "mike-reids-test-store.myshopify.com",
+  "dash-ext-hoke.myshopify.com"
+];
+var makeCall = async (method, path, data, origin, options = {}) => {
+  const url = `${origin}${path}`;
+  const requestUrl = new URL(url);
+  const fetchOptions = options?.fetch ?? {};
+  const requestData = {};
+  if (typeof data == "object" && data != null) {
+    Object.assign(requestData, data);
+  }
+  if (typeof config.key == "string" && config.key.length > 0) {
+    Object.assign(requestData, { key: config.key });
+  }
+  const requestObject = {
+    method,
+    ...fetchOptions
+  };
+  if (method === "GET") {
+    requestUrl.search = serialize(requestData);
+  } else if (method === "POST") {
+    requestObject.headers = {
+      "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8"
+    };
+    requestObject.body = new URLSearchParams(requestData);
+  }
+  const request = await fetch(requestUrl.toString(), requestObject);
+  const response = await request.json();
+  if (!request.ok && fetchOptions.strictErrors === true) {
+    const message = `An error has occurred: ${request.status}`;
+    throw new Error(message, { cause: response });
+  }
+  return response;
+};
+var Api = class {
+  constructor(options) {
+    if (typeof options == "string") {
+      config.key = options;
+    } else if (typeof options == "object" && options != null) {
+      Object.assign(config, options);
+    }
+    for (const domain of stagingDomains) {
+      if (typeof location === "object" && location?.host?.includes(domain)) {
+        Object.assign(config, staging);
+        break;
+      }
+      if (typeof config.shop === "string" && config.shop.includes(domain)) {
+        Object.assign(config, staging);
+        break;
+      }
+    }
+  }
+  async callEvent(method, path, data, options) {
+    return await makeCall(method, path, data, config.eventDomain, options);
+  }
+  async callShield(method, path, data, options) {
+    return await makeCall(method, path, data, config.shieldDomain, options);
+  }
+  async callStatic(method, path, data, options) {
+    return await makeCall(method, path, data, config.staticDomain, options);
+  }
+  async callGeo(method, path, data, options) {
+    return await makeCall(method, path, data, config.geoDomain, options);
+  }
+  async callCdn(method, path, data, options) {
+    return await makeCall(method, path, data, config.cdnDomain, options);
+  }
+  async callApi(method, path, data, options) {
+    return await makeCall(method, path, data, config.domain, options);
+  }
+};
+var api_default = Api;
+
+// src/cookie.ts
+function get(name) {
+  if (typeof document == "undefined" || !document.cookie) {
+    return null;
+  }
+  const cookie = document.cookie.match("(^|;) ?" + decodeURIComponent(name) + "=([^;]*)(;|$)");
+  let value = null;
+  if (cookie != null) {
+    const data = decodeURIComponent(cookie[2]);
+    const decode = isBase64Encoded(data) ? true : false;
+    value = stringToData(data, decode);
+  }
+  return value;
+}
+function getAll() {
+  const cookies = {};
+  if (document && document.cookie && document.cookie !== "") {
+    const split = document.cookie.split(";");
+    for (let i = 0; i < split.length; i++) {
+      const pairs = split[i].split("=");
+      pairs[0] = pairs[0].replace(/^ /, "");
+      const key = decodeURIComponent(pairs[0]);
+      const value = decodeURIComponent(pairs[1]);
+      const decode = isBase64Encoded(value) ? true : false;
+      cookies[key] = stringToData(value, decode);
+    }
+  }
+  return cookies;
+}
+function set(name, value, config6) {
+  if (typeof document == "undefined" || !document.cookie) {
+    return;
+  }
+  const attributes = ["path", "domain", "maxAge", "expires", "secure", "sameSite"];
+  const convenienceTimes = ["seconds", "minutes", "hours", "days", "weeks", "months", "years"];
+  const cookieAttributes = {
+    path: "/"
+  };
+  if (typeof config6 != "undefined" && Number.isInteger(config6)) {
+    cookieAttributes["max-age"] = config6;
+  } else if (typeof config6 === "object" && config6 !== null) {
+    for (const key in config6) {
+      if (attributes.includes(key)) {
+        if (key === "maxAge") {
+          cookieAttributes["max-age"] = config6[key];
+        } else if (key === "sameSite") {
+          cookieAttributes["samesite"] = config6[key];
+        } else if (key === "expires") {
+          cookieAttributes[key] = new Date(config6[key]).toUTCString();
+        } else {
+          cookieAttributes[key] = config6[key];
+        }
+      } else if (convenienceTimes.includes(key)) {
+        let duration = config6[key];
+        if (key === "seconds") {
+          duration = duration * 1;
+        } else if (key === "minutes") {
+          duration = duration * 60;
+        } else if (key === "hours") {
+          duration = duration * 60 * 60;
+        } else if (key === "days") {
+          duration = duration * 60 * 60 * 24;
+        } else if (key === "weeks") {
+          duration = duration * 60 * 60 * 24 * 7;
+        } else if (key === "months") {
+          duration = duration * 60 * 60 * 24 * 30;
+        } else if (key === "years") {
+          duration = duration * 60 * 60 * 24 * 365;
+        }
+        cookieAttributes["max-age"] = duration;
+      }
+    }
+  }
+  value = dataToString(value, config6?.encode);
+  let cookie = encodeURIComponent(name) + "=" + encodeURIComponent(value);
+  for (const key in cookieAttributes) {
+    cookie += ";" + key + "=" + cookieAttributes[key];
+  }
+  document.cookie = cookie;
+}
+function find(name) {
+  const matches = [];
+  const cookies = getAll();
+  for (const key in cookies) {
+    if (key.includes(name)) {
+      matches.push({
+        name: key,
+        value: cookies[key]
+      });
+    }
+  }
+  return matches;
+}
+function destroy(name) {
+  set(name, "", { encode: false, seconds: 0 });
+}
+function enabled() {
+  const test = {
+    key: "__cookie_test",
+    value: 1
+  };
+  set(test.key, test.value, { encode: false });
+  const enabled2 = get(test.key) === test.value ? true : false;
+  if (enabled2) {
+    destroy(test.key);
+  }
+  return enabled2;
+}
+var cookie_default = { destroy, enabled, find, get, getAll, set };
+
+// src/geolocation.ts
+var config2 = {
+  geolocation: null,
+  geolocationCookie: "_rebuyGeolocation",
+  geolocationDuration: {
+    minutes: 30
+  },
+  key: null
+};
+var getGeolocation = async () => {
+  const api = new api_default(config2.key);
+  const response = await api.callGeo("GET", "/", null);
+  if (response.data) {
+    config2.geolocation = response.data;
+    const cookieOptions = {
+      secure: true
+    };
+    Object.assign(cookieOptions, config2.geolocationDuration);
+    cookie_default.set(config2.geolocationCookie, config2.geolocation, { ...cookieOptions, encode: false });
+  }
+  return config2.geolocation;
+};
+var Geolocation = class {
+  constructor(key) {
+    if (typeof document == "undefined" || !document.cookie) {
+      return;
+    }
+    if (typeof key == "string") {
+      config2.key = key;
+    }
+    config2.geolocation = cookie_default.get(config2.geolocationCookie);
+    if (config2.geolocation === null) {
+      getGeolocation();
+    }
+  }
+  async geolocation() {
+    if (config2.geolocation == null) {
+      await getGeolocation();
+    }
+    return config2.geolocation;
+  }
+};
+var geolocation_default = Geolocation;
+
+// src/session.ts
+var config3 = {
+  now: null,
+  sessionDuration: {
+    minutes: 30
+  },
+  sessionId: null,
+  sessionIdCookie: "_rebuySessionId"
+};
+var Session = class {
+  constructor() {
+    if (typeof document == "undefined" || !document.cookie) {
+      return;
+    }
+    config3.now = (/* @__PURE__ */ new Date()).getTime();
+    config3.sessionId = cookie_default.get(config3.sessionIdCookie);
+    if (config3.sessionId === null) {
+      config3.sessionId = sessionId();
+    }
+    const cookieOptions = {
+      secure: true
+    };
+    Object.assign(cookieOptions, config3.sessionDuration);
+    cookie_default.set(config3.sessionIdCookie, config3.sessionId, cookieOptions);
+  }
+  sessionId() {
+    return config3.sessionId;
+  }
+  sessionStart() {
+    return config3.sessionId ? Number(config3.sessionId.split(".")[1]) : 0;
+  }
+  sessionDuration() {
+    return config3.now !== null ? parseInt(((config3.now - this.sessionStart()) / 1e3 / 60).toString()) : 0;
+  }
+};
+var session_default = Session;
+
+// src/identity.ts
+var config4 = {
+  key: null,
+  session: null,
+  visitorDuration: {
+    years: 1
+  },
+  visitorId: null,
+  visitorIdCookie: "_rebuyVisitorId"
+};
+var Identity = class {
+  constructor(key) {
+    if (typeof document == "undefined" || !document.cookie) {
+      return;
+    }
+    if (typeof key == "string") {
+      config4.key = key;
+    }
+    config4.visitorId = cookie_default.get(config4.visitorIdCookie);
+    if (config4.visitorId === null) {
+      config4.visitorId = uuid();
+    }
+    const cookieOptions = {
+      secure: true
+    };
+    Object.assign(cookieOptions, config4.visitorDuration);
+    cookie_default.set(config4.visitorIdCookie, config4.visitorId, cookieOptions);
+    config4.session = new session_default();
+    config4.geolocation = new geolocation_default(config4.key);
+  }
+  visitorId() {
+    return config4.visitorId;
+  }
+  sessionId() {
+    return config4.session.sessionId();
+  }
+  sessionStart() {
+    return config4.session.sessionStart();
+  }
+  sessionDuration() {
+    return config4.session.sessionDuration();
+  }
+  async geolocation() {
+    return await config4.geolocation.geolocation();
+  }
+};
+var identity_default = Identity;
+
+// src/client.ts
+var config5 = {
+  api: null,
+  contextParameters: null,
+  defaultParameters: null,
+  identity: null,
+  key: null,
+  shop: null
+};
+var trackEvent = async (eventData) => {
+  if (config5.identity && config5.identity.visitorId()) {
+    eventData.uuid = config5.identity.visitorId();
+  }
+  return await config5.api.callEvent("POST", "/api/v1/analytics/event", eventData);
+};
+var makeShieldCall = async (endpoint, params, format, options = {}) => {
+  return await makeCall2(endpoint, params, format, { ...options, shield: true });
+};
+var makeStaticCall = async (endpoint, params, format, options = {}) => {
+  return await makeCall2(endpoint, params, format, { ...options, static: true });
+};
+var makeCDNCall = async (endpoint, params, format, options = {}) => {
+  return await makeCall2(endpoint, params, format, { ...options, cdn: true });
+};
+var makeCall2 = async (endpoint, params, format, options = {}) => {
+  const query = {};
+  if (config5.defaultParameters != null) {
+    Object.assign(query, config5.defaultParameters);
+  }
+  if (config5.contextParameters != null) {
+    Object.assign(query, config5.contextParameters);
+  }
+  if (typeof params == "object" && params != null) {
+    Object.assign(query, params);
+  }
+  if (typeof options != "object" || options == null) {
+    console.warn("Unsupported fetch options provided.", options);
+    options = {};
+  }
+  if (config5.identity && config5.identity.visitorId()) {
+    query.uuid = config5.identity.visitorId();
+  }
+  const source = options.cdn ? "callCdn" : options.shield ? "callShield" : options.static ? "callStatic" : "callApi";
+  const response = await config5.api[source]("GET", endpoint, query, options);
+  if (response.data && format === "storefront") {
+    for (let i = 0; i < response.data.length; i++) {
+      response.data[i] = convertProductToStorefrontFormat(response.data[i]);
+    }
+  }
+  return response;
+};
+var RebuyClient = class {
+  constructor(key, defaultParameters, shop) {
+    if (typeof key == "string") {
+      config5.key = key;
+    }
+    if (typeof defaultParameters == "object" && defaultParameters != null) {
+      config5.defaultParameters = defaultParameters;
+    }
+    if (typeof shop == "string" && shop.endsWith(".myshopify.com")) {
+      config5.shop = shop;
+    }
+    config5.api = new api_default({ key: config5.key, shop: config5.shop });
+    config5.identity = new identity_default(config5.key);
+  }
+  setDefaultParameters(defaultParameters) {
+    if (typeof defaultParameters == "object" && defaultParameters != null) {
+      config5.defaultParameters = defaultParameters;
+    }
+  }
+  setContextParameters(contextParameters) {
+    if (typeof contextParameters == "object" && contextParameters != null) {
+      config5.contextParameters = contextParameters;
+    }
+  }
+  async getData(endpoint, params, options = {}) {
+    return await makeCall2(endpoint, params, null, options);
+  }
+  async getDataFromCDN(endpoint, params, options = {}) {
+    return await makeCDNCall(endpoint, params, null, options);
+  }
+  async getShieldedAsset(endpoint, params, options = {}) {
+    return await makeShieldCall(endpoint, params, null, options);
+  }
+  async getStaticAsset(endpoint, params, options = {}) {
+    return await makeStaticCall(endpoint, params, null, options);
+  }
+  async getStorefrontData(endpoint, params, options = {}) {
+    return await makeCall2(endpoint, params, "storefront", options);
+  }
+  async trackProductViewed(data) {
+    const requiredKeys = ["shopify_product_id", "shopify_product_handle"];
+    const defaultData = {
+      noun: "product",
+      subject: "user",
+      verb: "viewed"
+    };
+    if (typeof data != "undefined" && data != null) {
+      const dataKeys = Object.keys(data);
+      if (dataKeys.some((key) => requiredKeys.includes(key))) {
+        const payload = Object.assign(data, defaultData);
+        return await trackEvent(payload);
+      }
+    }
+    return null;
+  }
+};
+export {
+  Api,
+  Geolocation,
+  Identity,
+  RebuyClient,
+  Session,
+  amountToCents,
+  convertProductToStorefrontFormat,
+  convertToNodes,
+  convertVariantToStorefrontFormat,
+  dataToString,
+  destroy,
+  enabled,
+  find,
+  firstAvailableVariant,
+  get,
+  getAll,
+  getIdFromGraphUrl,
+  isBase64Encoded,
+  productImageObject,
+  queryStringToObject,
+  selectedVariantOptions,
+  serialize,
+  sessionId,
+  set,
+  stringToData,
+  stripHtml,
+  utmObjectFromString,
+  uuid,
+  variantAvailable,
+  variantMinMaxPriceObject,
+  variantPriceObject
+};
+//# sourceMappingURL=index.mjs.map