@rebuy/rebuy 2.14.0 → 2.15.0-rc.2

package/dist/client.js

@@ -0,0 +1,720 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/client.ts
+var client_exports = {};
+__export(client_exports, {
+  RebuyClient: () => RebuyClient,
+  default: () => client_default
+});
+module.exports = __toCommonJS(client_exports);
+
+// 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 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 config2 = {
+    chars: "0123456789",
+    length: 12
+  };
+  let sessionId2 = "";
+  const sessionStart = (/* @__PURE__ */ new Date()).getTime();
+  for (let i = config2.length; i > 0; i--) {
+    sessionId2 += config2.chars[Math.floor(Math.random() * config2.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 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 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 = [
+  "cab-staging.myshopify.com",
+  "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 (key, 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 key == "string" && key.length > 0) {
+    Object.assign(requestData, { 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) {
+    this.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"
+    };
+    if (typeof options == "string") {
+      this.config.key = options;
+    } else if (typeof options == "object" && options != null) {
+      Object.assign(this.config, options);
+    }
+    for (const domain of stagingDomains) {
+      if (typeof location === "object" && location?.host?.includes(domain)) {
+        Object.assign(this.config, staging);
+        break;
+      }
+      if (typeof this.config.shop === "string" && this.config.shop.includes(domain)) {
+        Object.assign(this.config, staging);
+        break;
+      }
+    }
+  }
+  async callEvent(method, path, data, options) {
+    return await makeCall(this.config.key, method, path, data, this.config.eventDomain, options);
+  }
+  async callShield(method, path, data, options) {
+    return await makeCall(this.config.key, method, path, data, this.config.shieldDomain, options);
+  }
+  async callStatic(method, path, data, options) {
+    return await makeCall(this.config.key, method, path, data, this.config.staticDomain, options);
+  }
+  async callGeo(method, path, data, options) {
+    return await makeCall(this.config.key, method, path, data, this.config.geoDomain, options);
+  }
+  async callCdn(method, path, data, options) {
+    return await makeCall(this.config.key, method, path, data, this.config.cdnDomain, options);
+  }
+  async callApi(method, path, data, options) {
+    return await makeCall(this.config.key, method, path, data, this.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, config2) {
+  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 config2 != "undefined" && Number.isInteger(config2)) {
+    cookieAttributes["max-age"] = config2;
+  } else if (typeof config2 === "object" && config2 !== null) {
+    for (const key in config2) {
+      if (attributes.includes(key)) {
+        if (key === "maxAge") {
+          cookieAttributes["max-age"] = config2[key];
+        } else if (key === "sameSite") {
+          cookieAttributes["samesite"] = config2[key];
+        } else if (key === "expires") {
+          cookieAttributes[key] = new Date(config2[key]).toUTCString();
+        } else {
+          cookieAttributes[key] = config2[key];
+        }
+      } else if (convenienceTimes.includes(key)) {
+        let duration = config2[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, config2?.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 Geolocation = class {
+  constructor(key) {
+    this.config = {
+      geolocation: null,
+      geolocationCookie: "_rebuyGeolocation",
+      geolocationDuration: {
+        minutes: 30
+      },
+      key: null
+    };
+    if (typeof document == "undefined" || !document.cookie) {
+      return;
+    }
+    if (typeof key == "string") {
+      this.config.key = key;
+    }
+    this.config.geolocation = cookie_default.get(this.config.geolocationCookie);
+    if (this.config.geolocation === null) {
+      this._fetchGeolocation();
+    }
+  }
+  async _fetchGeolocation() {
+    const api = new api_default({ key: this.config.key });
+    const response = await api.callGeo("GET", "/", null);
+    if (response.data) {
+      this.config.geolocation = response.data;
+      const cookieOptions = {
+        secure: true
+      };
+      Object.assign(cookieOptions, this.config.geolocationDuration);
+      cookie_default.set(this.config.geolocationCookie, this.config.geolocation, { ...cookieOptions, encode: false });
+    }
+    return this.config.geolocation;
+  }
+  async geolocation() {
+    if (this.config.geolocation == null) {
+      await this._fetchGeolocation();
+    }
+    return this.config.geolocation;
+  }
+};
+var geolocation_default = Geolocation;
+
+// src/session.ts
+var config = {
+  now: null,
+  sessionDuration: {
+    minutes: 30
+  },
+  sessionId: null,
+  sessionIdCookie: "_rebuySessionId"
+};
+var Session = class {
+  constructor() {
+    if (typeof document == "undefined" || !document.cookie) {
+      return;
+    }
+    config.now = (/* @__PURE__ */ new Date()).getTime();
+    config.sessionId = cookie_default.get(config.sessionIdCookie);
+    if (config.sessionId === null) {
+      config.sessionId = sessionId();
+    }
+    const cookieOptions = {
+      secure: true
+    };
+    Object.assign(cookieOptions, config.sessionDuration);
+    cookie_default.set(config.sessionIdCookie, config.sessionId, cookieOptions);
+  }
+  sessionId() {
+    return config.sessionId;
+  }
+  sessionStart() {
+    return config.sessionId ? Number(config.sessionId.split(".")[1]) : 0;
+  }
+  sessionDuration() {
+    return config.now !== null ? parseInt(((config.now - this.sessionStart()) / 1e3 / 60).toString()) : 0;
+  }
+};
+var session_default = Session;
+
+// src/identity.ts
+var Identity = class {
+  constructor(key) {
+    this.config = {
+      geolocation: null,
+      key: null,
+      session: null,
+      visitorDuration: {
+        years: 1
+      },
+      visitorId: null,
+      visitorIdCookie: "_rebuyVisitorId"
+    };
+    if (typeof document == "undefined" || !document.cookie) {
+      return;
+    }
+    if (typeof key == "string") {
+      this.config.key = key;
+    }
+    this.config.visitorId = cookie_default.get(this.config.visitorIdCookie);
+    if (this.config.visitorId === null) {
+      this.config.visitorId = uuid();
+    }
+    const cookieOptions = {
+      secure: true
+    };
+    Object.assign(cookieOptions, this.config.visitorDuration);
+    cookie_default.set(this.config.visitorIdCookie, this.config.visitorId, cookieOptions);
+    this.config.session = new session_default();
+    this.config.geolocation = new geolocation_default(this.config.key);
+  }
+  visitorId() {
+    return this.config.visitorId;
+  }
+  sessionId() {
+    return this.config.session ? this.config.session.sessionId() : null;
+  }
+  sessionStart() {
+    return this.config.session ? this.config.session.sessionStart() : null;
+  }
+  sessionDuration() {
+    return this.config.session ? this.config.session.sessionDuration() : null;
+  }
+  async geolocation() {
+    return this.config.geolocation ? await this.config.geolocation.geolocation() : null;
+  }
+};
+var identity_default = Identity;
+
+// src/client.ts
+var trackEvent = async (config2, eventData) => {
+  if (config2.identity && config2.identity.visitorId()) {
+    eventData.uuid = config2.identity.visitorId();
+  }
+  return await config2.api.callEvent("POST", "/api/v1/analytics/event", eventData);
+};
+var makeShieldCall = async (config2, endpoint, params, format, options = {}) => {
+  return await makeCall2(config2, endpoint, params, format, { ...options, shield: true });
+};
+var makeStaticCall = async (config2, endpoint, params, format, options = {}) => {
+  return await makeCall2(config2, endpoint, params, format, { ...options, static: true });
+};
+var makeCDNCall = async (config2, endpoint, params, format, options = {}) => {
+  return await makeCall2(config2, endpoint, params, format, { ...options, cdn: true });
+};
+var makeCall2 = async (config2, endpoint, params, format, options = {}) => {
+  const query = {};
+  if (config2.defaultParameters != null) {
+    Object.assign(query, config2.defaultParameters);
+  }
+  if (config2.contextParameters != null) {
+    Object.assign(query, config2.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 (config2.identity && config2.identity.visitorId()) {
+    query.uuid = config2.identity.visitorId();
+  }
+  const source = options.cdn ? "callCdn" : options.shield ? "callShield" : options.static ? "callStatic" : "callApi";
+  const response = await config2.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) {
+    this.config = {
+      api: null,
+      contextParameters: null,
+      defaultParameters: null,
+      identity: null,
+      key: null,
+      shop: null
+    };
+    if (typeof key == "string") {
+      this.config.key = key;
+    }
+    if (typeof defaultParameters == "object" && defaultParameters != null) {
+      this.config.defaultParameters = defaultParameters;
+    }
+    if (typeof shop == "string" && shop.endsWith(".myshopify.com")) {
+      this.config.shop = shop;
+    }
+    this.config.api = new api_default({ key: this.config.key, shop: this.config.shop });
+    this.config.identity = new identity_default(this.config.key);
+  }
+  setDefaultParameters(defaultParameters) {
+    if (typeof defaultParameters == "object" && defaultParameters != null) {
+      this.config.defaultParameters = defaultParameters;
+    }
+  }
+  setContextParameters(contextParameters) {
+    if (typeof contextParameters == "object" && contextParameters != null) {
+      this.config.contextParameters = contextParameters;
+    }
+  }
+  async getData(endpoint, params, options = {}) {
+    return await makeCall2(this.config, endpoint, params, null, options);
+  }
+  async getDataFromCDN(endpoint, params, options = {}) {
+    return await makeCDNCall(this.config, endpoint, params, null, options);
+  }
+  async getShieldedAsset(endpoint, params, options = {}) {
+    return await makeShieldCall(this.config, endpoint, params, null, options);
+  }
+  async getStaticAsset(endpoint, params, options = {}) {
+    return await makeStaticCall(this.config, endpoint, params, null, options);
+  }
+  async getStorefrontData(endpoint, params, options = {}) {
+    return await makeCall2(this.config, 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(this.config, payload);
+      }
+    }
+    return null;
+  }
+};
+var client_default = RebuyClient;
+//# sourceMappingURL=client.js.map