@wix/ditto-codegen-public 1.0.276 → 1.0.277

package/dist/out.js

@@ -14764,19 +14764,2655 @@ var require_dist5 = __commonJS({
   }
 });
 
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/http-client/dist/src/constants.js
+var require_constants6 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/http-client/dist/src/constants.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.ORIGINAL_PROTOCOL_HEADER = exports2.ORIGINAL_HOST_HEADER = exports2.ORIGINAL_URL_HEADER = exports2.SSR_PROTOCOL = exports2.SSR_HOST = exports2.NO_SCENARIO_FOUND = void 0;
+    exports2.NO_SCENARIO_FOUND = "NO_SCENARIO_FOUND";
+    exports2.SSR_HOST = "www.wix.com";
+    exports2.SSR_PROTOCOL = "http";
+    exports2.ORIGINAL_URL_HEADER = "x-wix-metro-original-url";
+    exports2.ORIGINAL_HOST_HEADER = "x-wix-metro-original-host";
+    exports2.ORIGINAL_PROTOCOL_HEADER = "x-wix-metro-original-protocol";
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/headers/dist/cjs/globals.js
+var require_globals2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/headers/dist/cjs/globals.js"(exports2) {
+    "use strict";
+    exports2.__esModule = true;
+    exports2.maybeGetDocument = maybeGetDocument;
+    exports2.maybeGetGlobal = maybeGetGlobal;
+    function maybeGetDocument() {
+      if (typeof document === "object") {
+        return document;
+      }
+      return void 0;
+    }
+    function maybeGetGlobal() {
+      if (typeof self === "object") {
+        return self;
+      } else {
+        return global;
+      }
+    }
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/headers/dist/cjs/cookies.js
+var require_cookies3 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/headers/dist/cjs/cookies.js"(exports2) {
+    "use strict";
+    exports2.__esModule = true;
+    exports2.readCookie = readCookie;
+    var _globals = require_globals2();
+    function readCookie(name) {
+      const cookieValue = getCookieByName(name);
+      if (cookieValue) {
+        return cookieValue.split("=")[1];
+      }
+      return "";
+    }
+    function loadCookies() {
+      const documentObj = (0, _globals.maybeGetDocument)();
+      if (documentObj && documentObj.cookie) {
+        return decodeURIComponent(documentObj.cookie).split(";");
+      }
+      return [];
+    }
+    function getCookieByName(name) {
+      return loadCookies().filter((cookie) => name === cookie.split("=")[0].trim())[0];
+    }
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/headers/dist/cjs/headers/csrf.js
+var require_csrf2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/headers/dist/cjs/headers/csrf.js"(exports2) {
+    "use strict";
+    exports2.__esModule = true;
+    exports2.XSRF_TOKEN_COOKIE_NAME = exports2.XSRF_HEADER_NAME = void 0;
+    exports2.csrf = csrf;
+    var _cookies = require_cookies3();
+    var XSRF_TOKEN_COOKIE_NAME = exports2.XSRF_TOKEN_COOKIE_NAME = "XSRF-TOKEN";
+    var XSRF_HEADER_NAME = exports2.XSRF_HEADER_NAME = "x-xsrf-token";
+    function csrf() {
+      const value = (0, _cookies.readCookie)(XSRF_TOKEN_COOKIE_NAME);
+      return {
+        [XSRF_HEADER_NAME]: value
+      };
+    }
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/headers/dist/cjs/headers/x-wix-brand.js
+var require_x_wix_brand2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/headers/dist/cjs/headers/x-wix-brand.js"(exports2) {
+    "use strict";
+    exports2.__esModule = true;
+    exports2.xWixBrand = xWixBrand;
+    var _globals = require_globals2();
+    var X_WIX_BRAND_NAME = "x-wix-brand";
+    function xWixBrand() {
+      const value = extractBrand();
+      return {
+        [X_WIX_BRAND_NAME]: value
+      };
+    }
+    function extractBrand() {
+      const globalObj = (0, _globals.maybeGetGlobal)();
+      if (globalObj && globalObj.commonConfig && typeof globalObj.commonConfig.brand === "string") {
+        return globalObj.commonConfig.brand;
+      }
+      return "";
+    }
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/headers/dist/cjs/headers/consent-policy.js
+var require_consent_policy3 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/headers/dist/cjs/headers/consent-policy.js"(exports2) {
+    "use strict";
+    exports2.__esModule = true;
+    exports2.consentPolicy = consentPolicy;
+    var _globals = require_globals2();
+    function consentPolicy() {
+      return tryResolveNativeAPI() || tryResolveJsSDK() || none();
+    }
+    function tryResolveJsSDK() {
+      const globalObj = (0, _globals.maybeGetGlobal)();
+      if (globalObj && globalObj.Wix && globalObj.Wix.Utils && typeof globalObj.Wix.Utils._getConsentPolicyHeader === "function") {
+        return globalObj.Wix.Utils._getConsentPolicyHeader();
+      }
+      return void 0;
+    }
+    function tryResolveNativeAPI() {
+      const globalObj = (0, _globals.maybeGetGlobal)();
+      if (globalObj && globalObj.consentPolicyManager && typeof globalObj.consentPolicyManager._getConsentPolicyHeader === "function") {
+        return globalObj.consentPolicyManager._getConsentPolicyHeader();
+      }
+      return void 0;
+    }
+    function none() {
+      return {};
+    }
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/headers/dist/cjs/headers/authorization.js
+var require_authorization2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/headers/dist/cjs/headers/authorization.js"(exports2) {
+    "use strict";
+    exports2.__esModule = true;
+    exports2.authorization = authorization;
+    function authorization(signedInstance) {
+      return {
+        authorization: signedInstance
+      };
+    }
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/headers/dist/cjs/utils.js
+var require_utils10 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/headers/dist/cjs/utils.js"(exports2) {
+    "use strict";
+    exports2.__esModule = true;
+    exports2.isCI = isCI;
+    function isCI() {
+      if (isNode()) {
+        return !!process.env.TEAMCITY_VERSION || !!process.env.BUILDKITE;
+      }
+      return false;
+    }
+    function isNode() {
+      var _process$versions;
+      return typeof process !== "undefined" && ((_process$versions = process.versions) == null ? void 0 : _process$versions.node) != null;
+    }
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/headers/dist/cjs/headers/artifact-id.js
+var require_artifact_id2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/headers/dist/cjs/headers/artifact-id.js"(exports2) {
+    "use strict";
+    exports2.__esModule = true;
+    exports2.artifactId = artifactId;
+    var _utils = require_utils10();
+    function artifactId(override) {
+      const artifactIdToUse = process.env.ARTIFACT_ID ?? process.env.APP_NAME ?? "";
+      return {
+        "X-Wix-Client-Artifact-Id": override ?? (!(0, _utils.isCI)() ? artifactIdToUse : "")
+      };
+    }
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/headers/dist/cjs/headers/common-config.js
+var require_common_config2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/headers/dist/cjs/headers/common-config.js"(exports2) {
+    "use strict";
+    exports2.__esModule = true;
+    exports2.commonConfig = void 0;
+    var _globals = require_globals2();
+    var IGNORE_KEYS = ["consentPolicy", "consentPolicyHeader"];
+    var COMMON_CONFIG_NAME = "commonConfig";
+    var MAP_KEYS = {
+      bsi: "BSI"
+    };
+    function extractCommonConfigValues() {
+      const globalObj = (0, _globals.maybeGetGlobal)();
+      const commonConfigObj = globalObj == null ? void 0 : globalObj.commonConfig;
+      if (!commonConfigObj) {
+        return null;
+      }
+      const res = {};
+      let addedKeys = false;
+      Object.keys(commonConfigObj).forEach((key) => {
+        const newKey = MAP_KEYS[key];
+        if (newKey) {
+          res[newKey] = commonConfigObj[key];
+          addedKeys = true;
+        } else if (IGNORE_KEYS.indexOf(key) < 0 && typeof commonConfigObj[key] !== "function") {
+          res[key] = commonConfigObj[key];
+          addedKeys = true;
+        }
+      });
+      return addedKeys ? res : null;
+    }
+    var commonConfig = () => {
+      const commonConfigValues = extractCommonConfigValues();
+      const value = commonConfigValues ? JSON.stringify(commonConfigValues) : "";
+      return {
+        [COMMON_CONFIG_NAME]: encodeURIComponent(value)
+      };
+    };
+    exports2.commonConfig = commonConfig;
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/headers/dist/cjs/headers/linguist.js
+var require_linguist2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/headers/dist/cjs/headers/linguist.js"(exports2) {
+    "use strict";
+    var _interopRequireDefault = require_interopRequireDefault();
+    exports2.__esModule = true;
+    exports2.linguistHeader = linguistHeader;
+    var _base = _interopRequireDefault(require_base64());
+    var LINGUIST_HEADER_KEY = "x-wix-linguist";
+    function linguistHeader({
+      lang,
+      locale,
+      isPrimaryLanguage,
+      signedInstance
+    }) {
+      if (isMultilingualOptionsAreValid({
+        lang,
+        locale,
+        isPrimaryLanguage
+      })) {
+        const instanceId = getInstanceIdFromSignedInstance(signedInstance);
+        if (instanceId !== void 0) {
+          return {
+            [LINGUIST_HEADER_KEY]: [lang, locale, isPrimaryLanguage == null ? void 0 : isPrimaryLanguage.toString(), instanceId].join("|")
+          };
+        }
+      }
+      return {};
+    }
+    function isMultilingualOptionsAreValid({
+      lang,
+      locale,
+      isPrimaryLanguage
+    }) {
+      return lang && locale && /^(true|false)$/.test((isPrimaryLanguage == null ? void 0 : isPrimaryLanguage.toString()) || "");
+    }
+    function getInstanceIdFromSignedInstance(signedInstance) {
+      try {
+        const encodedInstance = signedInstance != null && signedInstance.startsWith("wixcode") ? signedInstance == null ? void 0 : signedInstance.split(".")[2] : signedInstance == null ? void 0 : signedInstance.split(".")[1];
+        if (encodedInstance) {
+          return JSON.parse(_base.default.decode(encodedInstance)).instanceId;
+        }
+      } catch (e) {
+      }
+    }
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/headers/dist/cjs/domain.js
+var require_domain3 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/headers/dist/cjs/domain.js"(exports2) {
+    "use strict";
+    exports2.__esModule = true;
+    exports2.Brand = void 0;
+    var Brand = exports2.Brand = /* @__PURE__ */ (function(Brand2) {
+      Brand2[Brand2["wix"] = 0] = "wix";
+      Brand2[Brand2["editorx"] = 1] = "editorx";
+      Brand2[Brand2["dayful"] = 2] = "dayful";
+      Brand2[Brand2["studio"] = 3] = "studio";
+      return Brand2;
+    })({});
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/headers/dist/cjs/errors.js
+var require_errors3 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/headers/dist/cjs/errors.js"(exports2) {
+    "use strict";
+    exports2.__esModule = true;
+    exports2.WixHeadersValidationError = exports2.WixHeadersParsingError = void 0;
+    var WixHeadersParsingError = class extends Error {
+      constructor(header, value) {
+        super(`WixHeadersParsingError: ${header} evaluated with ${JSON.stringify(value)} but should be a string!`);
+      }
+    };
+    exports2.WixHeadersParsingError = WixHeadersParsingError;
+    var WixHeadersValidationError = class extends Error {
+      constructor(type, key, value) {
+        super(`WixHeadersValidationError: expected ${key} to be ${type} but got ${JSON.stringify(value)}`);
+      }
+    };
+    exports2.WixHeadersValidationError = WixHeadersValidationError;
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/headers/dist/cjs/assert.js
+var require_assert3 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/headers/dist/cjs/assert.js"(exports2) {
+    "use strict";
+    exports2.__esModule = true;
+    exports2.assertBoolean = assertBoolean;
+    exports2.assertString = assertString;
+    var _errors = require_errors3();
+    function assertBoolean(key, value) {
+      if (typeof value !== "boolean") {
+        throw new _errors.WixHeadersValidationError("boolean", key, value);
+      }
+    }
+    function assertString(key, value) {
+      if (typeof value !== "string") {
+        throw new _errors.WixHeadersValidationError("string", key, value);
+      }
+    }
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/headers/dist/cjs/index.js
+var require_cjs4 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/headers/dist/cjs/index.js"(exports2) {
+    "use strict";
+    exports2.__esModule = true;
+    exports2.createHeaders = createHeaders;
+    var _csrf = require_csrf2();
+    var _xWixBrand = require_x_wix_brand2();
+    var _consentPolicy = require_consent_policy3();
+    var _authorization = require_authorization2();
+    var _artifactId = require_artifact_id2();
+    var _commonConfig = require_common_config2();
+    var _linguist = require_linguist2();
+    var _domain = require_domain3();
+    exports2.MultilingualOptions = _domain.MultilingualOptions;
+    var _assert = require_assert3();
+    function createHeaders(opts = {}) {
+      opts = {
+        csrf: true,
+        signedInstance: "",
+        ...opts
+      };
+      verifyOptsOrThrow(opts);
+      const headers = [(0, _xWixBrand.xWixBrand)(), (0, _consentPolicy.consentPolicy)(), (0, _authorization.authorization)(opts.signedInstance), (0, _artifactId.artifactId)(opts.artifactId), (0, _commonConfig.commonConfig)(), (0, _linguist.linguistHeader)({
+        signedInstance: opts.signedInstance,
+        ...opts.multilingualOptions
+      })];
+      if (opts.csrf) {
+        headers.push((0, _csrf.csrf)());
+      }
+      return headers.filter((hdrs) => Object.values(hdrs).every((v) => v)).reduce((result, hdrs) => ({
+        ...result,
+        ...hdrs
+      }), {});
+    }
+    function verifyOptsOrThrow(opts) {
+      (0, _assert.assertBoolean)("opts.csrf", opts.csrf);
+      (0, _assert.assertString)("opts.signedInstance", opts.signedInstance);
+    }
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/http-client/dist/src/env-util.js
+var require_env_util2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/http-client/dist/src/env-util.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.isNode = exports2.isWebWorker = exports2.isBrowser = void 0;
+    function isBrowser() {
+      return typeof window !== "undefined";
+    }
+    exports2.isBrowser = isBrowser;
+    function isWebWorker() {
+      var _a;
+      return typeof self === "object" && ((_a = self === null || self === void 0 ? void 0 : self.constructor) === null || _a === void 0 ? void 0 : _a.name) === "DedicatedWorkerGlobalScope";
+    }
+    exports2.isWebWorker = isWebWorker;
+    function isNode() {
+      var _a;
+      return typeof process !== "undefined" && ((_a = process === null || process === void 0 ? void 0 : process.versions) === null || _a === void 0 ? void 0 : _a.node) != null;
+    }
+    exports2.isNode = isNode;
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/http-client/dist/src/utils.js
+var require_utils11 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/http-client/dist/src/utils.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.toSearchQueryParams = exports2.shouldAllowUnmocked = exports2.isHttpMockServerEnabled = exports2.getGlobalConfig = exports2.changeHost = exports2.extractHost = exports2.extractProtocol = exports2.resolveProtocol = exports2.resolveHost = exports2.extractProp = exports2.silent = exports2.isAbsoluteUrl = void 0;
+    var constants_1 = require_constants6();
+    var env_util_1 = require_env_util2();
+    function isAbsoluteUrl(url) {
+      if (typeof url !== "string") {
+        throw new TypeError(`Expected a \`string\`, got \`${typeof url}\``);
+      }
+      return /(^https?:)|(^\/\/)/.test(url);
+    }
+    exports2.isAbsoluteUrl = isAbsoluteUrl;
+    async function silent(fn) {
+      try {
+        await fn();
+      } catch (_a) {
+      }
+    }
+    exports2.silent = silent;
+    function extractProp(data, path) {
+      return path.split(".").filter((prop) => prop).reduce((result, prop) => result[prop], data);
+    }
+    exports2.extractProp = extractProp;
+    function resolveHost(opts) {
+      if (opts.baseURL) {
+        return extractHost(opts.baseURL);
+      } else if (opts.isSSR) {
+        return constants_1.SSR_HOST;
+      } else if (typeof self !== "undefined" && !!self.location) {
+        return self.location.host;
+      } else {
+        return "";
+      }
+    }
+    exports2.resolveHost = resolveHost;
+    function resolveProtocol(opts) {
+      if (opts.baseURL) {
+        return extractProtocol(opts.baseURL);
+      } else if (opts.isSSR) {
+        return constants_1.SSR_PROTOCOL;
+      } else if (typeof self !== "undefined" && !!self.location) {
+        return self.location.protocol;
+      } else {
+        return "";
+      }
+    }
+    exports2.resolveProtocol = resolveProtocol;
+    function extractProtocol(url) {
+      try {
+        const asUrl = new URL(url);
+        return asUrl.protocol;
+      } catch (_a) {
+        const hostAndProtocol = extractHostAndProtocolUsingRegExp(url);
+        return hostAndProtocol.protocol;
+      }
+    }
+    exports2.extractProtocol = extractProtocol;
+    function extractHost(url) {
+      let asUrl;
+      try {
+        asUrl = new URL(url);
+      } catch (_a) {
+        asUrl = new URL(`http:${url}`);
+      }
+      try {
+        return asUrl.host;
+      } catch (_b) {
+        const hostAndProtocol = extractHostAndProtocolUsingRegExp(url);
+        return hostAndProtocol.host;
+      }
+    }
+    exports2.extractHost = extractHost;
+    function extractHostAndProtocolUsingRegExp(url) {
+      const regExp = new RegExp("^(.*:)//([A-Za-z0-9-.]+)(:[0-9]+)?(.*)$");
+      try {
+        const urlOptions = regExp.exec(url);
+        return { protocol: urlOptions[1], host: urlOptions[2] };
+      } catch (_a) {
+        return { protocol: "http:", host: "" };
+      }
+    }
+    function changeHost(urlOrPath, host) {
+      let url;
+      try {
+        url = new URL(urlOrPath);
+        url.host = host;
+        url.protocol = "http";
+      } catch (_a) {
+        url = new URL(`http://${host}`);
+        url.pathname = urlOrPath;
+      }
+      return url.toString();
+    }
+    exports2.changeHost = changeHost;
+    function getGlobalConfig() {
+      const defaultConfig = { httpMockServer: { enabled: false } };
+      let globalConfig;
+      if ((0, env_util_1.isNode)() && process.env.HTTP_CLIENT_GLOBAL_CONFIG) {
+        try {
+          globalConfig = JSON.parse(process.env.HTTP_CLIENT_GLOBAL_CONFIG);
+        } catch (e) {
+        }
+      }
+      if (!globalConfig) {
+        if ((0, env_util_1.isBrowser)()) {
+          globalConfig = window._httpClientGlobalConfig;
+        } else if ((0, env_util_1.isWebWorker)()) {
+        }
+      }
+      return globalConfig || defaultConfig;
+    }
+    exports2.getGlobalConfig = getGlobalConfig;
+    function isHttpMockServerEnabled() {
+      const globalConfig = getGlobalConfig();
+      return globalConfig.httpMockServer.enabled;
+    }
+    exports2.isHttpMockServerEnabled = isHttpMockServerEnabled;
+    function shouldAllowUnmocked() {
+      const globalConfig = getGlobalConfig();
+      return globalConfig.httpMockServer.allowUnmocked;
+    }
+    exports2.shouldAllowUnmocked = shouldAllowUnmocked;
+    function toSearchQueryParams(params) {
+      return Object.entries(params).map(([key, value]) => `${key}=${encodeURIComponent(value)}`).flat().join("&");
+    }
+    exports2.toSearchQueryParams = toSearchQueryParams;
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/http-client/dist/src/whitelist.json
+var require_whitelist2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/http-client/dist/src/whitelist.json"(exports2, module2) {
+    module2.exports = [
+      "wix.com",
+      "editorx.com",
+      "wix-code.com",
+      "wixapps.net",
+      "wixprod.net"
+    ];
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/http-client/dist/src/headers.js
+var require_headers2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/http-client/dist/src/headers.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.isWixDomain = exports2.composeHeaders = exports2.requestIdOrEmptyString = void 0;
+    var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
+    var headers_1 = require_cjs4();
+    var utils_1 = require_utils11();
+    var whitelist_json_1 = tslib_1.__importDefault(require_whitelist2());
+    function requestIdOrEmptyString(response) {
+      var _a;
+      return ((_a = response === null || response === void 0 ? void 0 : response.headers) === null || _a === void 0 ? void 0 : _a["x-wix-request-id"]) || "";
+    }
+    exports2.requestIdOrEmptyString = requestIdOrEmptyString;
+    var composeHeaders = ({ url, disableWixHeaders, wixHeadersOpts }) => {
+      const shouldAssignWixHeaders = !disableWixHeaders && isWixDomain(url);
+      return shouldAssignWixHeaders ? (0, headers_1.createHeaders)(wixHeadersOpts) : {};
+    };
+    exports2.composeHeaders = composeHeaders;
+    function isWixDomain(url) {
+      const isRelative = !(0, utils_1.isAbsoluteUrl)(url);
+      if (isRelative) {
+        return true;
+      }
+      const host = `.${(0, utils_1.extractHost)(url)}`;
+      const isWhitelisted = whitelist_json_1.default.find((wixHost) => host.endsWith(`.${wixHost}`));
+      return !!isWhitelisted;
+    }
+    exports2.isWixDomain = isWixDomain;
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/http-client/dist/src/error.js
+var require_error2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/http-client/dist/src/error.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.createHttpError = exports2.HttpError = exports2.axiosErrorFields = void 0;
+    var headers_1 = require_headers2();
+    exports2.axiosErrorFields = [
+      "code",
+      "config",
+      "request",
+      "response",
+      "toJSON",
+      "__CANCEL__"
+    ];
+    var HttpError = class _HttpError extends Error {
+      constructor(error) {
+        super(error.message);
+        this.isWixHttpError = true;
+        Object.setPrototypeOf(this, _HttpError.prototype);
+        exports2.axiosErrorFields.forEach((key) => {
+          this[key] = error[key];
+        });
+      }
+      get requestId() {
+        return (0, headers_1.requestIdOrEmptyString)(this.response);
+      }
+    };
+    exports2.HttpError = HttpError;
+    function createHttpError(...args) {
+      return new HttpError(...args);
+    }
+    exports2.createHttpError = createHttpError;
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/helpers/bind.js
+var require_bind2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/helpers/bind.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function bind(fn, thisArg) {
+      return function wrap() {
+        var args = new Array(arguments.length);
+        for (var i = 0; i < args.length; i++) {
+          args[i] = arguments[i];
+        }
+        return fn.apply(thisArg, args);
+      };
+    };
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/utils.js
+var require_utils12 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/utils.js"(exports2, module2) {
+    "use strict";
+    var bind = require_bind2();
+    var toString = Object.prototype.toString;
+    function isArray(val) {
+      return toString.call(val) === "[object Array]";
+    }
+    function isUndefined(val) {
+      return typeof val === "undefined";
+    }
+    function isBuffer(val) {
+      return val !== null && !isUndefined(val) && val.constructor !== null && !isUndefined(val.constructor) && typeof val.constructor.isBuffer === "function" && val.constructor.isBuffer(val);
+    }
+    function isArrayBuffer(val) {
+      return toString.call(val) === "[object ArrayBuffer]";
+    }
+    function isFormData(val) {
+      return typeof FormData !== "undefined" && val instanceof FormData;
+    }
+    function isArrayBufferView(val) {
+      var result;
+      if (typeof ArrayBuffer !== "undefined" && ArrayBuffer.isView) {
+        result = ArrayBuffer.isView(val);
+      } else {
+        result = val && val.buffer && val.buffer instanceof ArrayBuffer;
+      }
+      return result;
+    }
+    function isString(val) {
+      return typeof val === "string";
+    }
+    function isNumber(val) {
+      return typeof val === "number";
+    }
+    function isObject(val) {
+      return val !== null && typeof val === "object";
+    }
+    function isPlainObject(val) {
+      if (toString.call(val) !== "[object Object]") {
+        return false;
+      }
+      var prototype = Object.getPrototypeOf(val);
+      return prototype === null || prototype === Object.prototype;
+    }
+    function isDate(val) {
+      return toString.call(val) === "[object Date]";
+    }
+    function isFile(val) {
+      return toString.call(val) === "[object File]";
+    }
+    function isBlob(val) {
+      return toString.call(val) === "[object Blob]";
+    }
+    function isFunction(val) {
+      return toString.call(val) === "[object Function]";
+    }
+    function isStream(val) {
+      return isObject(val) && isFunction(val.pipe);
+    }
+    function isURLSearchParams(val) {
+      return typeof URLSearchParams !== "undefined" && val instanceof URLSearchParams;
+    }
+    function trim(str) {
+      return str.trim ? str.trim() : str.replace(/^\s+|\s+$/g, "");
+    }
+    function isStandardBrowserEnv() {
+      if (typeof navigator !== "undefined" && (navigator.product === "ReactNative" || navigator.product === "NativeScript" || navigator.product === "NS")) {
+        return false;
+      }
+      return typeof window !== "undefined" && typeof document !== "undefined";
+    }
+    function forEach(obj, fn) {
+      if (obj === null || typeof obj === "undefined") {
+        return;
+      }
+      if (typeof obj !== "object") {
+        obj = [obj];
+      }
+      if (isArray(obj)) {
+        for (var i = 0, l = obj.length; i < l; i++) {
+          fn.call(null, obj[i], i, obj);
+        }
+      } else {
+        for (var key in obj) {
+          if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            fn.call(null, obj[key], key, obj);
+          }
+        }
+      }
+    }
+    function merge() {
+      var result = {};
+      function assignValue(val, key) {
+        if (isPlainObject(result[key]) && isPlainObject(val)) {
+          result[key] = merge(result[key], val);
+        } else if (isPlainObject(val)) {
+          result[key] = merge({}, val);
+        } else if (isArray(val)) {
+          result[key] = val.slice();
+        } else {
+          result[key] = val;
+        }
+      }
+      for (var i = 0, l = arguments.length; i < l; i++) {
+        forEach(arguments[i], assignValue);
+      }
+      return result;
+    }
+    function extend(a, b, thisArg) {
+      forEach(b, function assignValue(val, key) {
+        if (thisArg && typeof val === "function") {
+          a[key] = bind(val, thisArg);
+        } else {
+          a[key] = val;
+        }
+      });
+      return a;
+    }
+    function stripBOM(content) {
+      if (content.charCodeAt(0) === 65279) {
+        content = content.slice(1);
+      }
+      return content;
+    }
+    module2.exports = {
+      isArray,
+      isArrayBuffer,
+      isBuffer,
+      isFormData,
+      isArrayBufferView,
+      isString,
+      isNumber,
+      isObject,
+      isPlainObject,
+      isUndefined,
+      isDate,
+      isFile,
+      isBlob,
+      isFunction,
+      isStream,
+      isURLSearchParams,
+      isStandardBrowserEnv,
+      forEach,
+      merge,
+      extend,
+      trim,
+      stripBOM
+    };
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/core/enhanceError.js
+var require_enhanceError2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/core/enhanceError.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function enhanceError(error, config, code, request, response) {
+      error.config = config;
+      if (code) {
+        error.code = code;
+      }
+      error.request = request;
+      error.response = response;
+      error.isAxiosError = true;
+      error.toJSON = function toJSON() {
+        return {
+          // Standard
+          message: this.message,
+          name: this.name,
+          // Microsoft
+          description: this.description,
+          number: this.number,
+          // Mozilla
+          fileName: this.fileName,
+          lineNumber: this.lineNumber,
+          columnNumber: this.columnNumber,
+          stack: this.stack,
+          // Axios
+          config: this.config,
+          code: this.code
+        };
+      };
+      return error;
+    };
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/core/createError.js
+var require_createError2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/core/createError.js"(exports2, module2) {
+    "use strict";
+    var enhanceError = require_enhanceError2();
+    module2.exports = function createError(message, config, code, request, response) {
+      var error = new Error(message);
+      return enhanceError(error, config, code, request, response);
+    };
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/core/settle.js
+var require_settle2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/core/settle.js"(exports2, module2) {
+    "use strict";
+    var createError = require_createError2();
+    module2.exports = function settle(resolve, reject, response) {
+      var validateStatus = response.config.validateStatus;
+      if (!response.status || !validateStatus || validateStatus(response.status)) {
+        resolve(response);
+      } else {
+        reject(createError(
+          "Request failed with status code " + response.status,
+          response.config,
+          null,
+          response.request,
+          response
+        ));
+      }
+    };
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/helpers/isAbsoluteURL.js
+var require_isAbsoluteURL2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/helpers/isAbsoluteURL.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function isAbsoluteURL(url) {
+      return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url);
+    };
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/helpers/combineURLs.js
+var require_combineURLs2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/helpers/combineURLs.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function combineURLs(baseURL, relativeURL) {
+      return relativeURL ? baseURL.replace(/\/+$/, "") + "/" + relativeURL.replace(/^\/+/, "") : baseURL;
+    };
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/core/buildFullPath.js
+var require_buildFullPath2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/core/buildFullPath.js"(exports2, module2) {
+    "use strict";
+    var isAbsoluteURL = require_isAbsoluteURL2();
+    var combineURLs = require_combineURLs2();
+    module2.exports = function buildFullPath(baseURL, requestedURL) {
+      if (baseURL && !isAbsoluteURL(requestedURL)) {
+        return combineURLs(baseURL, requestedURL);
+      }
+      return requestedURL;
+    };
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/helpers/buildURL.js
+var require_buildURL2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/helpers/buildURL.js"(exports2, module2) {
+    "use strict";
+    var utils = require_utils12();
+    function encode(val) {
+      return encodeURIComponent(val).replace(/%3A/gi, ":").replace(/%24/g, "$").replace(/%2C/gi, ",").replace(/%20/g, "+").replace(/%5B/gi, "[").replace(/%5D/gi, "]");
+    }
+    module2.exports = function buildURL(url, params, paramsSerializer) {
+      if (!params) {
+        return url;
+      }
+      var serializedParams;
+      if (paramsSerializer) {
+        serializedParams = paramsSerializer(params);
+      } else if (utils.isURLSearchParams(params)) {
+        serializedParams = params.toString();
+      } else {
+        var parts = [];
+        utils.forEach(params, function serialize(val, key) {
+          if (val === null || typeof val === "undefined") {
+            return;
+          }
+          if (utils.isArray(val)) {
+            key = key + "[]";
+          } else {
+            val = [val];
+          }
+          utils.forEach(val, function parseValue(v) {
+            if (utils.isDate(v)) {
+              v = v.toISOString();
+            } else if (utils.isObject(v)) {
+              v = JSON.stringify(v);
+            }
+            parts.push(encode(key) + "=" + encode(v));
+          });
+        });
+        serializedParams = parts.join("&");
+      }
+      if (serializedParams) {
+        var hashmarkIndex = url.indexOf("#");
+        if (hashmarkIndex !== -1) {
+          url = url.slice(0, hashmarkIndex);
+        }
+        url += (url.indexOf("?") === -1 ? "?" : "&") + serializedParams;
+      }
+      return url;
+    };
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/package.json
+var require_package3 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/package.json"(exports2, module2) {
+    module2.exports = {
+      name: "axios",
+      version: "0.21.4",
+      description: "Promise based HTTP client for the browser and node.js",
+      main: "index.js",
+      scripts: {
+        test: "grunt test",
+        start: "node ./sandbox/server.js",
+        build: "NODE_ENV=production grunt build",
+        preversion: "npm test",
+        version: "npm run build && grunt version && git add -A dist && git add CHANGELOG.md bower.json package.json",
+        postversion: "git push && git push --tags",
+        examples: "node ./examples/server.js",
+        coveralls: "cat coverage/lcov.info | ./node_modules/coveralls/bin/coveralls.js",
+        fix: "eslint --fix lib/**/*.js"
+      },
+      repository: {
+        type: "git",
+        url: "https://github.com/axios/axios.git"
+      },
+      keywords: [
+        "xhr",
+        "http",
+        "ajax",
+        "promise",
+        "node"
+      ],
+      author: "Matt Zabriskie",
+      license: "MIT",
+      bugs: {
+        url: "https://github.com/axios/axios/issues"
+      },
+      homepage: "https://axios-http.com",
+      devDependencies: {
+        coveralls: "^3.0.0",
+        "es6-promise": "^4.2.4",
+        grunt: "^1.3.0",
+        "grunt-banner": "^0.6.0",
+        "grunt-cli": "^1.2.0",
+        "grunt-contrib-clean": "^1.1.0",
+        "grunt-contrib-watch": "^1.0.0",
+        "grunt-eslint": "^23.0.0",
+        "grunt-karma": "^4.0.0",
+        "grunt-mocha-test": "^0.13.3",
+        "grunt-ts": "^6.0.0-beta.19",
+        "grunt-webpack": "^4.0.2",
+        "istanbul-instrumenter-loader": "^1.0.0",
+        "jasmine-core": "^2.4.1",
+        karma: "^6.3.2",
+        "karma-chrome-launcher": "^3.1.0",
+        "karma-firefox-launcher": "^2.1.0",
+        "karma-jasmine": "^1.1.1",
+        "karma-jasmine-ajax": "^0.1.13",
+        "karma-safari-launcher": "^1.0.0",
+        "karma-sauce-launcher": "^4.3.6",
+        "karma-sinon": "^1.0.5",
+        "karma-sourcemap-loader": "^0.3.8",
+        "karma-webpack": "^4.0.2",
+        "load-grunt-tasks": "^3.5.2",
+        minimist: "^1.2.0",
+        mocha: "^8.2.1",
+        sinon: "^4.5.0",
+        "terser-webpack-plugin": "^4.2.3",
+        typescript: "^4.0.5",
+        "url-search-params": "^0.10.0",
+        webpack: "^4.44.2",
+        "webpack-dev-server": "^3.11.0"
+      },
+      browser: {
+        "./lib/adapters/http.js": "./lib/adapters/xhr.js"
+      },
+      jsdelivr: "dist/axios.min.js",
+      unpkg: "dist/axios.min.js",
+      typings: "./index.d.ts",
+      dependencies: {
+        "follow-redirects": "^1.14.0"
+      },
+      bundlesize: [
+        {
+          path: "./dist/axios.min.js",
+          threshold: "5kB"
+        }
+      ]
+    };
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/adapters/http.js
+var require_http2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/adapters/http.js"(exports2, module2) {
+    "use strict";
+    var utils = require_utils12();
+    var settle = require_settle2();
+    var buildFullPath = require_buildFullPath2();
+    var buildURL = require_buildURL2();
+    var http = require("http");
+    var https = require("https");
+    var httpFollow = require_follow_redirects().http;
+    var httpsFollow = require_follow_redirects().https;
+    var url = require("url");
+    var zlib = require("zlib");
+    var pkg = require_package3();
+    var createError = require_createError2();
+    var enhanceError = require_enhanceError2();
+    var isHttps = /https:?/;
+    function setProxy(options, proxy, location) {
+      options.hostname = proxy.host;
+      options.host = proxy.host;
+      options.port = proxy.port;
+      options.path = location;
+      if (proxy.auth) {
+        var base64 = Buffer.from(proxy.auth.username + ":" + proxy.auth.password, "utf8").toString("base64");
+        options.headers["Proxy-Authorization"] = "Basic " + base64;
+      }
+      options.beforeRedirect = function beforeRedirect(redirection) {
+        redirection.headers.host = redirection.host;
+        setProxy(redirection, proxy, redirection.href);
+      };
+    }
+    module2.exports = function httpAdapter(config) {
+      return new Promise(function dispatchHttpRequest(resolvePromise, rejectPromise) {
+        var resolve = function resolve2(value) {
+          resolvePromise(value);
+        };
+        var reject = function reject2(value) {
+          rejectPromise(value);
+        };
+        var data = config.data;
+        var headers = config.headers;
+        if ("User-Agent" in headers || "user-agent" in headers) {
+          if (!headers["User-Agent"] && !headers["user-agent"]) {
+            delete headers["User-Agent"];
+            delete headers["user-agent"];
+          }
+        } else {
+          headers["User-Agent"] = "axios/" + pkg.version;
+        }
+        if (data && !utils.isStream(data)) {
+          if (Buffer.isBuffer(data)) {
+          } else if (utils.isArrayBuffer(data)) {
+            data = Buffer.from(new Uint8Array(data));
+          } else if (utils.isString(data)) {
+            data = Buffer.from(data, "utf-8");
+          } else {
+            return reject(createError(
+              "Data after transformation must be a string, an ArrayBuffer, a Buffer, or a Stream",
+              config
+            ));
+          }
+          headers["Content-Length"] = data.length;
+        }
+        var auth = void 0;
+        if (config.auth) {
+          var username = config.auth.username || "";
+          var password = config.auth.password || "";
+          auth = username + ":" + password;
+        }
+        var fullPath = buildFullPath(config.baseURL, config.url);
+        var parsed = url.parse(fullPath);
+        var protocol = parsed.protocol || "http:";
+        if (!auth && parsed.auth) {
+          var urlAuth = parsed.auth.split(":");
+          var urlUsername = urlAuth[0] || "";
+          var urlPassword = urlAuth[1] || "";
+          auth = urlUsername + ":" + urlPassword;
+        }
+        if (auth) {
+          delete headers.Authorization;
+        }
+        var isHttpsRequest = isHttps.test(protocol);
+        var agent = isHttpsRequest ? config.httpsAgent : config.httpAgent;
+        var options = {
+          path: buildURL(parsed.path, config.params, config.paramsSerializer).replace(/^\?/, ""),
+          method: config.method.toUpperCase(),
+          headers,
+          agent,
+          agents: { http: config.httpAgent, https: config.httpsAgent },
+          auth
+        };
+        if (config.socketPath) {
+          options.socketPath = config.socketPath;
+        } else {
+          options.hostname = parsed.hostname;
+          options.port = parsed.port;
+        }
+        var proxy = config.proxy;
+        if (!proxy && proxy !== false) {
+          var proxyEnv = protocol.slice(0, -1) + "_proxy";
+          var proxyUrl = process.env[proxyEnv] || process.env[proxyEnv.toUpperCase()];
+          if (proxyUrl) {
+            var parsedProxyUrl = url.parse(proxyUrl);
+            var noProxyEnv = process.env.no_proxy || process.env.NO_PROXY;
+            var shouldProxy = true;
+            if (noProxyEnv) {
+              var noProxy = noProxyEnv.split(",").map(function trim(s) {
+                return s.trim();
+              });
+              shouldProxy = !noProxy.some(function proxyMatch(proxyElement) {
+                if (!proxyElement) {
+                  return false;
+                }
+                if (proxyElement === "*") {
+                  return true;
+                }
+                if (proxyElement[0] === "." && parsed.hostname.substr(parsed.hostname.length - proxyElement.length) === proxyElement) {
+                  return true;
+                }
+                return parsed.hostname === proxyElement;
+              });
+            }
+            if (shouldProxy) {
+              proxy = {
+                host: parsedProxyUrl.hostname,
+                port: parsedProxyUrl.port,
+                protocol: parsedProxyUrl.protocol
+              };
+              if (parsedProxyUrl.auth) {
+                var proxyUrlAuth = parsedProxyUrl.auth.split(":");
+                proxy.auth = {
+                  username: proxyUrlAuth[0],
+                  password: proxyUrlAuth[1]
+                };
+              }
+            }
+          }
+        }
+        if (proxy) {
+          options.headers.host = parsed.hostname + (parsed.port ? ":" + parsed.port : "");
+          setProxy(options, proxy, protocol + "//" + parsed.hostname + (parsed.port ? ":" + parsed.port : "") + options.path);
+        }
+        var transport;
+        var isHttpsProxy = isHttpsRequest && (proxy ? isHttps.test(proxy.protocol) : true);
+        if (config.transport) {
+          transport = config.transport;
+        } else if (config.maxRedirects === 0) {
+          transport = isHttpsProxy ? https : http;
+        } else {
+          if (config.maxRedirects) {
+            options.maxRedirects = config.maxRedirects;
+          }
+          transport = isHttpsProxy ? httpsFollow : httpFollow;
+        }
+        if (config.maxBodyLength > -1) {
+          options.maxBodyLength = config.maxBodyLength;
+        }
+        var req = transport.request(options, function handleResponse(res) {
+          if (req.aborted) return;
+          var stream = res;
+          var lastRequest = res.req || req;
+          if (res.statusCode !== 204 && lastRequest.method !== "HEAD" && config.decompress !== false) {
+            switch (res.headers["content-encoding"]) {
+              /*eslint default-case:0*/
+              case "gzip":
+              case "compress":
+              case "deflate":
+                stream = stream.pipe(zlib.createUnzip());
+                delete res.headers["content-encoding"];
+                break;
+            }
+          }
+          var response = {
+            status: res.statusCode,
+            statusText: res.statusMessage,
+            headers: res.headers,
+            config,
+            request: lastRequest
+          };
+          if (config.responseType === "stream") {
+            response.data = stream;
+            settle(resolve, reject, response);
+          } else {
+            var responseBuffer = [];
+            var totalResponseBytes = 0;
+            stream.on("data", function handleStreamData(chunk) {
+              responseBuffer.push(chunk);
+              totalResponseBytes += chunk.length;
+              if (config.maxContentLength > -1 && totalResponseBytes > config.maxContentLength) {
+                stream.destroy();
+                reject(createError(
+                  "maxContentLength size of " + config.maxContentLength + " exceeded",
+                  config,
+                  null,
+                  lastRequest
+                ));
+              }
+            });
+            stream.on("error", function handleStreamError(err) {
+              if (req.aborted) return;
+              reject(enhanceError(err, config, null, lastRequest));
+            });
+            stream.on("end", function handleStreamEnd() {
+              var responseData = Buffer.concat(responseBuffer);
+              if (config.responseType !== "arraybuffer") {
+                responseData = responseData.toString(config.responseEncoding);
+                if (!config.responseEncoding || config.responseEncoding === "utf8") {
+                  responseData = utils.stripBOM(responseData);
+                }
+              }
+              response.data = responseData;
+              settle(resolve, reject, response);
+            });
+          }
+        });
+        req.on("error", function handleRequestError(err) {
+          if (req.aborted && err.code !== "ERR_FR_TOO_MANY_REDIRECTS") return;
+          reject(enhanceError(err, config, null, req));
+        });
+        if (config.timeout) {
+          var timeout = parseInt(config.timeout, 10);
+          if (isNaN(timeout)) {
+            reject(createError(
+              "error trying to parse `config.timeout` to int",
+              config,
+              "ERR_PARSE_TIMEOUT",
+              req
+            ));
+            return;
+          }
+          req.setTimeout(timeout, function handleRequestTimeout() {
+            req.abort();
+            reject(createError(
+              "timeout of " + timeout + "ms exceeded",
+              config,
+              config.transitional && config.transitional.clarifyTimeoutError ? "ETIMEDOUT" : "ECONNABORTED",
+              req
+            ));
+          });
+        }
+        if (config.cancelToken) {
+          config.cancelToken.promise.then(function onCanceled(cancel) {
+            if (req.aborted) return;
+            req.abort();
+            reject(cancel);
+          });
+        }
+        if (utils.isStream(data)) {
+          data.on("error", function handleStreamError(err) {
+            reject(enhanceError(err, config, null, req));
+          }).pipe(req);
+        } else {
+          req.end(data);
+        }
+      });
+    };
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/core/InterceptorManager.js
+var require_InterceptorManager2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/core/InterceptorManager.js"(exports2, module2) {
+    "use strict";
+    var utils = require_utils12();
+    function InterceptorManager() {
+      this.handlers = [];
+    }
+    InterceptorManager.prototype.use = function use(fulfilled, rejected, options) {
+      this.handlers.push({
+        fulfilled,
+        rejected,
+        synchronous: options ? options.synchronous : false,
+        runWhen: options ? options.runWhen : null
+      });
+      return this.handlers.length - 1;
+    };
+    InterceptorManager.prototype.eject = function eject(id) {
+      if (this.handlers[id]) {
+        this.handlers[id] = null;
+      }
+    };
+    InterceptorManager.prototype.forEach = function forEach(fn) {
+      utils.forEach(this.handlers, function forEachHandler(h) {
+        if (h !== null) {
+          fn(h);
+        }
+      });
+    };
+    module2.exports = InterceptorManager;
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/helpers/normalizeHeaderName.js
+var require_normalizeHeaderName2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/helpers/normalizeHeaderName.js"(exports2, module2) {
+    "use strict";
+    var utils = require_utils12();
+    module2.exports = function normalizeHeaderName(headers, normalizedName) {
+      utils.forEach(headers, function processHeader(value, name) {
+        if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {
+          headers[normalizedName] = value;
+          delete headers[name];
+        }
+      });
+    };
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/helpers/cookies.js
+var require_cookies4 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/helpers/cookies.js"(exports2, module2) {
+    "use strict";
+    var utils = require_utils12();
+    module2.exports = utils.isStandardBrowserEnv() ? (
+      // Standard browser envs support document.cookie
+      /* @__PURE__ */ (function standardBrowserEnv() {
+        return {
+          write: function write(name, value, expires, path, domain, secure) {
+            var cookie = [];
+            cookie.push(name + "=" + encodeURIComponent(value));
+            if (utils.isNumber(expires)) {
+              cookie.push("expires=" + new Date(expires).toGMTString());
+            }
+            if (utils.isString(path)) {
+              cookie.push("path=" + path);
+            }
+            if (utils.isString(domain)) {
+              cookie.push("domain=" + domain);
+            }
+            if (secure === true) {
+              cookie.push("secure");
+            }
+            document.cookie = cookie.join("; ");
+          },
+          read: function read(name) {
+            var match = document.cookie.match(new RegExp("(^|;\\s*)(" + name + ")=([^;]*)"));
+            return match ? decodeURIComponent(match[3]) : null;
+          },
+          remove: function remove(name) {
+            this.write(name, "", Date.now() - 864e5);
+          }
+        };
+      })()
+    ) : (
+      // Non standard browser env (web workers, react-native) lack needed support.
+      /* @__PURE__ */ (function nonStandardBrowserEnv() {
+        return {
+          write: function write() {
+          },
+          read: function read() {
+            return null;
+          },
+          remove: function remove() {
+          }
+        };
+      })()
+    );
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/helpers/parseHeaders.js
+var require_parseHeaders2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/helpers/parseHeaders.js"(exports2, module2) {
+    "use strict";
+    var utils = require_utils12();
+    var ignoreDuplicateOf = [
+      "age",
+      "authorization",
+      "content-length",
+      "content-type",
+      "etag",
+      "expires",
+      "from",
+      "host",
+      "if-modified-since",
+      "if-unmodified-since",
+      "last-modified",
+      "location",
+      "max-forwards",
+      "proxy-authorization",
+      "referer",
+      "retry-after",
+      "user-agent"
+    ];
+    module2.exports = function parseHeaders(headers) {
+      var parsed = {};
+      var key;
+      var val;
+      var i;
+      if (!headers) {
+        return parsed;
+      }
+      utils.forEach(headers.split("\n"), function parser(line) {
+        i = line.indexOf(":");
+        key = utils.trim(line.substr(0, i)).toLowerCase();
+        val = utils.trim(line.substr(i + 1));
+        if (key) {
+          if (parsed[key] && ignoreDuplicateOf.indexOf(key) >= 0) {
+            return;
+          }
+          if (key === "set-cookie") {
+            parsed[key] = (parsed[key] ? parsed[key] : []).concat([val]);
+          } else {
+            parsed[key] = parsed[key] ? parsed[key] + ", " + val : val;
+          }
+        }
+      });
+      return parsed;
+    };
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/helpers/isURLSameOrigin.js
+var require_isURLSameOrigin2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/helpers/isURLSameOrigin.js"(exports2, module2) {
+    "use strict";
+    var utils = require_utils12();
+    module2.exports = utils.isStandardBrowserEnv() ? (
+      // Standard browser envs have full support of the APIs needed to test
+      // whether the request URL is of the same origin as current location.
+      (function standardBrowserEnv() {
+        var msie = /(msie|trident)/i.test(navigator.userAgent);
+        var urlParsingNode = document.createElement("a");
+        var originURL;
+        function resolveURL(url) {
+          var href = url;
+          if (msie) {
+            urlParsingNode.setAttribute("href", href);
+            href = urlParsingNode.href;
+          }
+          urlParsingNode.setAttribute("href", href);
+          return {
+            href: urlParsingNode.href,
+            protocol: urlParsingNode.protocol ? urlParsingNode.protocol.replace(/:$/, "") : "",
+            host: urlParsingNode.host,
+            search: urlParsingNode.search ? urlParsingNode.search.replace(/^\?/, "") : "",
+            hash: urlParsingNode.hash ? urlParsingNode.hash.replace(/^#/, "") : "",
+            hostname: urlParsingNode.hostname,
+            port: urlParsingNode.port,
+            pathname: urlParsingNode.pathname.charAt(0) === "/" ? urlParsingNode.pathname : "/" + urlParsingNode.pathname
+          };
+        }
+        originURL = resolveURL(window.location.href);
+        return function isURLSameOrigin(requestURL) {
+          var parsed = utils.isString(requestURL) ? resolveURL(requestURL) : requestURL;
+          return parsed.protocol === originURL.protocol && parsed.host === originURL.host;
+        };
+      })()
+    ) : (
+      // Non standard browser envs (web workers, react-native) lack needed support.
+      /* @__PURE__ */ (function nonStandardBrowserEnv() {
+        return function isURLSameOrigin() {
+          return true;
+        };
+      })()
+    );
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/adapters/xhr.js
+var require_xhr2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/adapters/xhr.js"(exports2, module2) {
+    "use strict";
+    var utils = require_utils12();
+    var settle = require_settle2();
+    var cookies = require_cookies4();
+    var buildURL = require_buildURL2();
+    var buildFullPath = require_buildFullPath2();
+    var parseHeaders = require_parseHeaders2();
+    var isURLSameOrigin = require_isURLSameOrigin2();
+    var createError = require_createError2();
+    module2.exports = function xhrAdapter(config) {
+      return new Promise(function dispatchXhrRequest(resolve, reject) {
+        var requestData = config.data;
+        var requestHeaders = config.headers;
+        var responseType = config.responseType;
+        if (utils.isFormData(requestData)) {
+          delete requestHeaders["Content-Type"];
+        }
+        var request = new XMLHttpRequest();
+        if (config.auth) {
+          var username = config.auth.username || "";
+          var password = config.auth.password ? unescape(encodeURIComponent(config.auth.password)) : "";
+          requestHeaders.Authorization = "Basic " + btoa(username + ":" + password);
+        }
+        var fullPath = buildFullPath(config.baseURL, config.url);
+        request.open(config.method.toUpperCase(), buildURL(fullPath, config.params, config.paramsSerializer), true);
+        request.timeout = config.timeout;
+        function onloadend() {
+          if (!request) {
+            return;
+          }
+          var responseHeaders = "getAllResponseHeaders" in request ? parseHeaders(request.getAllResponseHeaders()) : null;
+          var responseData = !responseType || responseType === "text" || responseType === "json" ? request.responseText : request.response;
+          var response = {
+            data: responseData,
+            status: request.status,
+            statusText: request.statusText,
+            headers: responseHeaders,
+            config,
+            request
+          };
+          settle(resolve, reject, response);
+          request = null;
+        }
+        if ("onloadend" in request) {
+          request.onloadend = onloadend;
+        } else {
+          request.onreadystatechange = function handleLoad() {
+            if (!request || request.readyState !== 4) {
+              return;
+            }
+            if (request.status === 0 && !(request.responseURL && request.responseURL.indexOf("file:") === 0)) {
+              return;
+            }
+            setTimeout(onloadend);
+          };
+        }
+        request.onabort = function handleAbort() {
+          if (!request) {
+            return;
+          }
+          reject(createError("Request aborted", config, "ECONNABORTED", request));
+          request = null;
+        };
+        request.onerror = function handleError() {
+          reject(createError("Network Error", config, null, request));
+          request = null;
+        };
+        request.ontimeout = function handleTimeout() {
+          var timeoutErrorMessage = "timeout of " + config.timeout + "ms exceeded";
+          if (config.timeoutErrorMessage) {
+            timeoutErrorMessage = config.timeoutErrorMessage;
+          }
+          reject(createError(
+            timeoutErrorMessage,
+            config,
+            config.transitional && config.transitional.clarifyTimeoutError ? "ETIMEDOUT" : "ECONNABORTED",
+            request
+          ));
+          request = null;
+        };
+        if (utils.isStandardBrowserEnv()) {
+          var xsrfValue = (config.withCredentials || isURLSameOrigin(fullPath)) && config.xsrfCookieName ? cookies.read(config.xsrfCookieName) : void 0;
+          if (xsrfValue) {
+            requestHeaders[config.xsrfHeaderName] = xsrfValue;
+          }
+        }
+        if ("setRequestHeader" in request) {
+          utils.forEach(requestHeaders, function setRequestHeader(val, key) {
+            if (typeof requestData === "undefined" && key.toLowerCase() === "content-type") {
+              delete requestHeaders[key];
+            } else {
+              request.setRequestHeader(key, val);
+            }
+          });
+        }
+        if (!utils.isUndefined(config.withCredentials)) {
+          request.withCredentials = !!config.withCredentials;
+        }
+        if (responseType && responseType !== "json") {
+          request.responseType = config.responseType;
+        }
+        if (typeof config.onDownloadProgress === "function") {
+          request.addEventListener("progress", config.onDownloadProgress);
+        }
+        if (typeof config.onUploadProgress === "function" && request.upload) {
+          request.upload.addEventListener("progress", config.onUploadProgress);
+        }
+        if (config.cancelToken) {
+          config.cancelToken.promise.then(function onCanceled(cancel) {
+            if (!request) {
+              return;
+            }
+            request.abort();
+            reject(cancel);
+            request = null;
+          });
+        }
+        if (!requestData) {
+          requestData = null;
+        }
+        request.send(requestData);
+      });
+    };
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/defaults.js
+var require_defaults2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/defaults.js"(exports2, module2) {
+    "use strict";
+    var utils = require_utils12();
+    var normalizeHeaderName = require_normalizeHeaderName2();
+    var enhanceError = require_enhanceError2();
+    var DEFAULT_CONTENT_TYPE = {
+      "Content-Type": "application/x-www-form-urlencoded"
+    };
+    function setContentTypeIfUnset(headers, value) {
+      if (!utils.isUndefined(headers) && utils.isUndefined(headers["Content-Type"])) {
+        headers["Content-Type"] = value;
+      }
+    }
+    function getDefaultAdapter() {
+      var adapter;
+      if (typeof XMLHttpRequest !== "undefined") {
+        adapter = require_xhr2();
+      } else if (typeof process !== "undefined" && Object.prototype.toString.call(process) === "[object process]") {
+        adapter = require_http2();
+      }
+      return adapter;
+    }
+    function stringifySafely(rawValue, parser, encoder) {
+      if (utils.isString(rawValue)) {
+        try {
+          (parser || JSON.parse)(rawValue);
+          return utils.trim(rawValue);
+        } catch (e) {
+          if (e.name !== "SyntaxError") {
+            throw e;
+          }
+        }
+      }
+      return (encoder || JSON.stringify)(rawValue);
+    }
+    var defaults = {
+      transitional: {
+        silentJSONParsing: true,
+        forcedJSONParsing: true,
+        clarifyTimeoutError: false
+      },
+      adapter: getDefaultAdapter(),
+      transformRequest: [function transformRequest(data, headers) {
+        normalizeHeaderName(headers, "Accept");
+        normalizeHeaderName(headers, "Content-Type");
+        if (utils.isFormData(data) || utils.isArrayBuffer(data) || utils.isBuffer(data) || utils.isStream(data) || utils.isFile(data) || utils.isBlob(data)) {
+          return data;
+        }
+        if (utils.isArrayBufferView(data)) {
+          return data.buffer;
+        }
+        if (utils.isURLSearchParams(data)) {
+          setContentTypeIfUnset(headers, "application/x-www-form-urlencoded;charset=utf-8");
+          return data.toString();
+        }
+        if (utils.isObject(data) || headers && headers["Content-Type"] === "application/json") {
+          setContentTypeIfUnset(headers, "application/json");
+          return stringifySafely(data);
+        }
+        return data;
+      }],
+      transformResponse: [function transformResponse(data) {
+        var transitional = this.transitional;
+        var silentJSONParsing = transitional && transitional.silentJSONParsing;
+        var forcedJSONParsing = transitional && transitional.forcedJSONParsing;
+        var strictJSONParsing = !silentJSONParsing && this.responseType === "json";
+        if (strictJSONParsing || forcedJSONParsing && utils.isString(data) && data.length) {
+          try {
+            return JSON.parse(data);
+          } catch (e) {
+            if (strictJSONParsing) {
+              if (e.name === "SyntaxError") {
+                throw enhanceError(e, this, "E_JSON_PARSE");
+              }
+              throw e;
+            }
+          }
+        }
+        return data;
+      }],
+      /**
+       * A timeout in milliseconds to abort a request. If set to 0 (default) a
+       * timeout is not created.
+       */
+      timeout: 0,
+      xsrfCookieName: "XSRF-TOKEN",
+      xsrfHeaderName: "X-XSRF-TOKEN",
+      maxContentLength: -1,
+      maxBodyLength: -1,
+      validateStatus: function validateStatus(status) {
+        return status >= 200 && status < 300;
+      }
+    };
+    defaults.headers = {
+      common: {
+        "Accept": "application/json, text/plain, */*"
+      }
+    };
+    utils.forEach(["delete", "get", "head"], function forEachMethodNoData(method) {
+      defaults.headers[method] = {};
+    });
+    utils.forEach(["post", "put", "patch"], function forEachMethodWithData(method) {
+      defaults.headers[method] = utils.merge(DEFAULT_CONTENT_TYPE);
+    });
+    module2.exports = defaults;
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/core/transformData.js
+var require_transformData2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/core/transformData.js"(exports2, module2) {
+    "use strict";
+    var utils = require_utils12();
+    var defaults = require_defaults2();
+    module2.exports = function transformData(data, headers, fns) {
+      var context = this || defaults;
+      utils.forEach(fns, function transform(fn) {
+        data = fn.call(context, data, headers);
+      });
+      return data;
+    };
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/cancel/isCancel.js
+var require_isCancel2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/cancel/isCancel.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function isCancel(value) {
+      return !!(value && value.__CANCEL__);
+    };
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/core/dispatchRequest.js
+var require_dispatchRequest2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/core/dispatchRequest.js"(exports2, module2) {
+    "use strict";
+    var utils = require_utils12();
+    var transformData = require_transformData2();
+    var isCancel = require_isCancel2();
+    var defaults = require_defaults2();
+    function throwIfCancellationRequested(config) {
+      if (config.cancelToken) {
+        config.cancelToken.throwIfRequested();
+      }
+    }
+    module2.exports = function dispatchRequest(config) {
+      throwIfCancellationRequested(config);
+      config.headers = config.headers || {};
+      config.data = transformData.call(
+        config,
+        config.data,
+        config.headers,
+        config.transformRequest
+      );
+      config.headers = utils.merge(
+        config.headers.common || {},
+        config.headers[config.method] || {},
+        config.headers
+      );
+      utils.forEach(
+        ["delete", "get", "head", "post", "put", "patch", "common"],
+        function cleanHeaderConfig(method) {
+          delete config.headers[method];
+        }
+      );
+      var adapter = config.adapter || defaults.adapter;
+      return adapter(config).then(function onAdapterResolution(response) {
+        throwIfCancellationRequested(config);
+        response.data = transformData.call(
+          config,
+          response.data,
+          response.headers,
+          config.transformResponse
+        );
+        return response;
+      }, function onAdapterRejection(reason) {
+        if (!isCancel(reason)) {
+          throwIfCancellationRequested(config);
+          if (reason && reason.response) {
+            reason.response.data = transformData.call(
+              config,
+              reason.response.data,
+              reason.response.headers,
+              config.transformResponse
+            );
+          }
+        }
+        return Promise.reject(reason);
+      });
+    };
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/core/mergeConfig.js
+var require_mergeConfig2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/core/mergeConfig.js"(exports2, module2) {
+    "use strict";
+    var utils = require_utils12();
+    module2.exports = function mergeConfig(config1, config2) {
+      config2 = config2 || {};
+      var config = {};
+      var valueFromConfig2Keys = ["url", "method", "data"];
+      var mergeDeepPropertiesKeys = ["headers", "auth", "proxy", "params"];
+      var defaultToConfig2Keys = [
+        "baseURL",
+        "transformRequest",
+        "transformResponse",
+        "paramsSerializer",
+        "timeout",
+        "timeoutMessage",
+        "withCredentials",
+        "adapter",
+        "responseType",
+        "xsrfCookieName",
+        "xsrfHeaderName",
+        "onUploadProgress",
+        "onDownloadProgress",
+        "decompress",
+        "maxContentLength",
+        "maxBodyLength",
+        "maxRedirects",
+        "transport",
+        "httpAgent",
+        "httpsAgent",
+        "cancelToken",
+        "socketPath",
+        "responseEncoding"
+      ];
+      var directMergeKeys = ["validateStatus"];
+      function getMergedValue(target, source) {
+        if (utils.isPlainObject(target) && utils.isPlainObject(source)) {
+          return utils.merge(target, source);
+        } else if (utils.isPlainObject(source)) {
+          return utils.merge({}, source);
+        } else if (utils.isArray(source)) {
+          return source.slice();
+        }
+        return source;
+      }
+      function mergeDeepProperties(prop) {
+        if (!utils.isUndefined(config2[prop])) {
+          config[prop] = getMergedValue(config1[prop], config2[prop]);
+        } else if (!utils.isUndefined(config1[prop])) {
+          config[prop] = getMergedValue(void 0, config1[prop]);
+        }
+      }
+      utils.forEach(valueFromConfig2Keys, function valueFromConfig2(prop) {
+        if (!utils.isUndefined(config2[prop])) {
+          config[prop] = getMergedValue(void 0, config2[prop]);
+        }
+      });
+      utils.forEach(mergeDeepPropertiesKeys, mergeDeepProperties);
+      utils.forEach(defaultToConfig2Keys, function defaultToConfig2(prop) {
+        if (!utils.isUndefined(config2[prop])) {
+          config[prop] = getMergedValue(void 0, config2[prop]);
+        } else if (!utils.isUndefined(config1[prop])) {
+          config[prop] = getMergedValue(void 0, config1[prop]);
+        }
+      });
+      utils.forEach(directMergeKeys, function merge(prop) {
+        if (prop in config2) {
+          config[prop] = getMergedValue(config1[prop], config2[prop]);
+        } else if (prop in config1) {
+          config[prop] = getMergedValue(void 0, config1[prop]);
+        }
+      });
+      var axiosKeys = valueFromConfig2Keys.concat(mergeDeepPropertiesKeys).concat(defaultToConfig2Keys).concat(directMergeKeys);
+      var otherKeys = Object.keys(config1).concat(Object.keys(config2)).filter(function filterAxiosKeys(key) {
+        return axiosKeys.indexOf(key) === -1;
+      });
+      utils.forEach(otherKeys, mergeDeepProperties);
+      return config;
+    };
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/helpers/validator.js
+var require_validator2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/helpers/validator.js"(exports2, module2) {
+    "use strict";
+    var pkg = require_package3();
+    var validators = {};
+    ["object", "boolean", "number", "function", "string", "symbol"].forEach(function(type, i) {
+      validators[type] = function validator(thing) {
+        return typeof thing === type || "a" + (i < 1 ? "n " : " ") + type;
+      };
+    });
+    var deprecatedWarnings = {};
+    var currentVerArr = pkg.version.split(".");
+    function isOlderVersion(version2, thanVersion) {
+      var pkgVersionArr = thanVersion ? thanVersion.split(".") : currentVerArr;
+      var destVer = version2.split(".");
+      for (var i = 0; i < 3; i++) {
+        if (pkgVersionArr[i] > destVer[i]) {
+          return true;
+        } else if (pkgVersionArr[i] < destVer[i]) {
+          return false;
+        }
+      }
+      return false;
+    }
+    validators.transitional = function transitional(validator, version2, message) {
+      var isDeprecated = version2 && isOlderVersion(version2);
+      function formatMessage(opt, desc) {
+        return "[Axios v" + pkg.version + "] Transitional option '" + opt + "'" + desc + (message ? ". " + message : "");
+      }
+      return function(value, opt, opts) {
+        if (validator === false) {
+          throw new Error(formatMessage(opt, " has been removed in " + version2));
+        }
+        if (isDeprecated && !deprecatedWarnings[opt]) {
+          deprecatedWarnings[opt] = true;
+          console.warn(
+            formatMessage(
+              opt,
+              " has been deprecated since v" + version2 + " and will be removed in the near future"
+            )
+          );
+        }
+        return validator ? validator(value, opt, opts) : true;
+      };
+    };
+    function assertOptions(options, schema, allowUnknown) {
+      if (typeof options !== "object") {
+        throw new TypeError("options must be an object");
+      }
+      var keys = Object.keys(options);
+      var i = keys.length;
+      while (i-- > 0) {
+        var opt = keys[i];
+        var validator = schema[opt];
+        if (validator) {
+          var value = options[opt];
+          var result = value === void 0 || validator(value, opt, options);
+          if (result !== true) {
+            throw new TypeError("option " + opt + " must be " + result);
+          }
+          continue;
+        }
+        if (allowUnknown !== true) {
+          throw Error("Unknown option " + opt);
+        }
+      }
+    }
+    module2.exports = {
+      isOlderVersion,
+      assertOptions,
+      validators
+    };
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/core/Axios.js
+var require_Axios2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/core/Axios.js"(exports2, module2) {
+    "use strict";
+    var utils = require_utils12();
+    var buildURL = require_buildURL2();
+    var InterceptorManager = require_InterceptorManager2();
+    var dispatchRequest = require_dispatchRequest2();
+    var mergeConfig = require_mergeConfig2();
+    var validator = require_validator2();
+    var validators = validator.validators;
+    function Axios(instanceConfig) {
+      this.defaults = instanceConfig;
+      this.interceptors = {
+        request: new InterceptorManager(),
+        response: new InterceptorManager()
+      };
+    }
+    Axios.prototype.request = function request(config) {
+      if (typeof config === "string") {
+        config = arguments[1] || {};
+        config.url = arguments[0];
+      } else {
+        config = config || {};
+      }
+      config = mergeConfig(this.defaults, config);
+      if (config.method) {
+        config.method = config.method.toLowerCase();
+      } else if (this.defaults.method) {
+        config.method = this.defaults.method.toLowerCase();
+      } else {
+        config.method = "get";
+      }
+      var transitional = config.transitional;
+      if (transitional !== void 0) {
+        validator.assertOptions(transitional, {
+          silentJSONParsing: validators.transitional(validators.boolean, "1.0.0"),
+          forcedJSONParsing: validators.transitional(validators.boolean, "1.0.0"),
+          clarifyTimeoutError: validators.transitional(validators.boolean, "1.0.0")
+        }, false);
+      }
+      var requestInterceptorChain = [];
+      var synchronousRequestInterceptors = true;
+      this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
+        if (typeof interceptor.runWhen === "function" && interceptor.runWhen(config) === false) {
+          return;
+        }
+        synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;
+        requestInterceptorChain.unshift(interceptor.fulfilled, interceptor.rejected);
+      });
+      var responseInterceptorChain = [];
+      this.interceptors.response.forEach(function pushResponseInterceptors(interceptor) {
+        responseInterceptorChain.push(interceptor.fulfilled, interceptor.rejected);
+      });
+      var promise;
+      if (!synchronousRequestInterceptors) {
+        var chain = [dispatchRequest, void 0];
+        Array.prototype.unshift.apply(chain, requestInterceptorChain);
+        chain = chain.concat(responseInterceptorChain);
+        promise = Promise.resolve(config);
+        while (chain.length) {
+          promise = promise.then(chain.shift(), chain.shift());
+        }
+        return promise;
+      }
+      var newConfig = config;
+      while (requestInterceptorChain.length) {
+        var onFulfilled = requestInterceptorChain.shift();
+        var onRejected = requestInterceptorChain.shift();
+        try {
+          newConfig = onFulfilled(newConfig);
+        } catch (error) {
+          onRejected(error);
+          break;
+        }
+      }
+      try {
+        promise = dispatchRequest(newConfig);
+      } catch (error) {
+        return Promise.reject(error);
+      }
+      while (responseInterceptorChain.length) {
+        promise = promise.then(responseInterceptorChain.shift(), responseInterceptorChain.shift());
+      }
+      return promise;
+    };
+    Axios.prototype.getUri = function getUri(config) {
+      config = mergeConfig(this.defaults, config);
+      return buildURL(config.url, config.params, config.paramsSerializer).replace(/^\?/, "");
+    };
+    utils.forEach(["delete", "get", "head", "options"], function forEachMethodNoData(method) {
+      Axios.prototype[method] = function(url, config) {
+        return this.request(mergeConfig(config || {}, {
+          method,
+          url,
+          data: (config || {}).data
+        }));
+      };
+    });
+    utils.forEach(["post", "put", "patch"], function forEachMethodWithData(method) {
+      Axios.prototype[method] = function(url, data, config) {
+        return this.request(mergeConfig(config || {}, {
+          method,
+          url,
+          data
+        }));
+      };
+    });
+    module2.exports = Axios;
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/cancel/Cancel.js
+var require_Cancel2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/cancel/Cancel.js"(exports2, module2) {
+    "use strict";
+    function Cancel(message) {
+      this.message = message;
+    }
+    Cancel.prototype.toString = function toString() {
+      return "Cancel" + (this.message ? ": " + this.message : "");
+    };
+    Cancel.prototype.__CANCEL__ = true;
+    module2.exports = Cancel;
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/cancel/CancelToken.js
+var require_CancelToken2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/cancel/CancelToken.js"(exports2, module2) {
+    "use strict";
+    var Cancel = require_Cancel2();
+    function CancelToken(executor) {
+      if (typeof executor !== "function") {
+        throw new TypeError("executor must be a function.");
+      }
+      var resolvePromise;
+      this.promise = new Promise(function promiseExecutor(resolve) {
+        resolvePromise = resolve;
+      });
+      var token = this;
+      executor(function cancel(message) {
+        if (token.reason) {
+          return;
+        }
+        token.reason = new Cancel(message);
+        resolvePromise(token.reason);
+      });
+    }
+    CancelToken.prototype.throwIfRequested = function throwIfRequested() {
+      if (this.reason) {
+        throw this.reason;
+      }
+    };
+    CancelToken.source = function source() {
+      var cancel;
+      var token = new CancelToken(function executor(c) {
+        cancel = c;
+      });
+      return {
+        token,
+        cancel
+      };
+    };
+    module2.exports = CancelToken;
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/helpers/spread.js
+var require_spread2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/helpers/spread.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function spread(callback) {
+      return function wrap(arr) {
+        return callback.apply(null, arr);
+      };
+    };
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/helpers/isAxiosError.js
+var require_isAxiosError2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/helpers/isAxiosError.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function isAxiosError(payload) {
+      return typeof payload === "object" && payload.isAxiosError === true;
+    };
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/axios.js
+var require_axios3 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/lib/axios.js"(exports2, module2) {
+    "use strict";
+    var utils = require_utils12();
+    var bind = require_bind2();
+    var Axios = require_Axios2();
+    var mergeConfig = require_mergeConfig2();
+    var defaults = require_defaults2();
+    function createInstance(defaultConfig) {
+      var context = new Axios(defaultConfig);
+      var instance = bind(Axios.prototype.request, context);
+      utils.extend(instance, Axios.prototype, context);
+      utils.extend(instance, context);
+      return instance;
+    }
+    var axios = createInstance(defaults);
+    axios.Axios = Axios;
+    axios.create = function create(instanceConfig) {
+      return createInstance(mergeConfig(axios.defaults, instanceConfig));
+    };
+    axios.Cancel = require_Cancel2();
+    axios.CancelToken = require_CancelToken2();
+    axios.isCancel = require_isCancel2();
+    axios.all = function all(promises) {
+      return Promise.all(promises);
+    };
+    axios.spread = require_spread2();
+    axios.isAxiosError = require_isAxiosError2();
+    module2.exports = axios;
+    module2.exports.default = axios;
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/index.js
+var require_axios4 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/axios/index.js"(exports2, module2) {
+    module2.exports = require_axios3();
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/http-client/dist/src/options.js
+var require_options2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/http-client/dist/src/options.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.getUrlHeaders = exports2.buildAllHeaders = exports2.buildOptions = void 0;
+    var constants_1 = require_constants6();
+    var headers_1 = require_headers2();
+    var utils_1 = require_utils11();
+    var buildOptions = ({ requestOptions, urlObject, headers, globalConfig = {
+      httpMockServer: {
+        enabled: false
+      }
+    } }) => {
+      const { url, params } = requestOptions;
+      if (params) {
+        if (typeof params !== "object") {
+          throw new Error("Search params must be an object");
+        }
+      }
+      const localConfigOptions = maybeRedirectToMockServer(url, globalConfig);
+      const newOptions = Object.assign(Object.assign(Object.assign({}, requestOptions), localConfigOptions), { headers });
+      return newOptions;
+    };
+    exports2.buildOptions = buildOptions;
+    var buildAllHeaders = (requestOptions, wixHeadersOpts, globalConfig = {
+      httpMockServer: {
+        enabled: false
+      }
+    }, urlObject) => {
+      const { url, disableWixHeaders, headers } = requestOptions;
+      const composedHeaders = (0, headers_1.composeHeaders)({
+        url,
+        disableWixHeaders,
+        wixHeadersOpts
+      });
+      const originalUrlHeader = (0, exports2.getUrlHeaders)(globalConfig, requestOptions, urlObject);
+      return Object.assign(Object.assign(Object.assign({}, composedHeaders), lowerAllJsonKeys(headers)), originalUrlHeader);
+    };
+    exports2.buildAllHeaders = buildAllHeaders;
+    var getUrlHeaders = (globalConfig, requestOptions, urlObject) => {
+      const { url, params } = requestOptions;
+      const { host, protocol } = urlObject;
+      const originalUrlHeader = globalConfig.httpMockServer.enabled ? {
+        [constants_1.ORIGINAL_URL_HEADER]: buildUrlFromRequest(url, params),
+        [constants_1.ORIGINAL_HOST_HEADER]: (0, utils_1.isAbsoluteUrl)(url) ? (0, utils_1.extractHost)(url) : host,
+        [constants_1.ORIGINAL_PROTOCOL_HEADER]: (0, utils_1.isAbsoluteUrl)(url) ? (0, utils_1.extractProtocol)(url) : protocol
+      } : {};
+      return originalUrlHeader;
+    };
+    exports2.getUrlHeaders = getUrlHeaders;
+    function maybeRedirectToMockServer(url, globalConfig) {
+      if (globalConfig.httpMockServer.enabled) {
+        const mockUrl = new URL(globalConfig.httpMockServer.mockServerUrl);
+        return {
+          url: (0, utils_1.changeHost)(url, mockUrl.host)
+        };
+      }
+      return {};
+    }
+    function buildUrlFromRequest(url, requestParams) {
+      const { pathname, searchParams } = new URL(url, "http://unused.com");
+      requestParams = requestParams || searchParams;
+      if (requestParams) {
+        const params = (0, utils_1.toSearchQueryParams)(requestParams) || requestParams.toString();
+        const paramsAsString = params ? `?${params}` : "";
+        return `${pathname}${paramsAsString}`;
+      }
+      return pathname;
+    }
+    function lowerAllJsonKeys(objectToChange) {
+      objectToChange = objectToChange || {};
+      const result = Object.keys(objectToChange).reduce((prev, key) => Object.assign(Object.assign({}, prev), { [key.toLowerCase()]: objectToChange[key] }), {});
+      return result;
+    }
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/http-client/dist/src/http-client.js
+var require_http_client2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/http-client/dist/src/http-client.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.createHttpClient = exports2.HttpClient = void 0;
+    var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
+    var axios_1 = tslib_1.__importDefault(require_axios4());
+    var xhr_1 = tslib_1.__importDefault(require_xhr2());
+    var constants_1 = require_constants6();
+    var env_util_1 = require_env_util2();
+    var error_1 = require_error2();
+    var headers_1 = require_headers2();
+    var options_1 = require_options2();
+    var utils_1 = require_utils11();
+    var HttpClient = class {
+      constructor(opts = {}) {
+        this.opts = opts;
+        this.opts = defaultClientOptions(this.opts);
+        this.client = axios_1.default.create(this.opts);
+        this.flags = {
+          sanitizerPocEnabled: checkSanitizerPocEnabled()
+        };
+      }
+      static isHttpError(payload) {
+        return !!(payload === null || payload === void 0 ? void 0 : payload.isWixHttpError);
+      }
+      async request(requestOptionsOrFactory, overrides) {
+        var _a, _b;
+        const host = (0, utils_1.resolveHost)(this.opts);
+        const protocol = (0, utils_1.resolveProtocol)(this.opts);
+        const urlObject = { protocol, host };
+        const requestOptions = typeof requestOptionsOrFactory === "function" ? requestOptionsOrFactory({ isSSR: this.opts.isSSR, host }) : requestOptionsOrFactory;
+        const signedInstance = (overrides === null || overrides === void 0 ? void 0 : overrides.signedInstance) || await ((_b = (_a = this.opts).getAppToken) === null || _b === void 0 ? void 0 : _b.call(_a)) || "";
+        const headers = this.getHeaders(requestOptions, signedInstance, urlObject);
+        const options = (0, options_1.buildOptions)({
+          requestOptions,
+          urlObject,
+          headers,
+          globalConfig: (0, utils_1.getGlobalConfig)()
+        });
+        if (this.opts.isSSR) {
+          options.baseURL = this.opts.baseURL ? this.opts.baseURL : `${constants_1.SSR_PROTOCOL}://${constants_1.SSR_HOST}`;
+        }
+        try {
+          const res = await this.client.request(options).catch((err) => this.maybeFallbackRequest(err, requestOptions, urlObject, signedInstance));
+          return this.transformResponse(res, requestOptions);
+        } catch (e) {
+          this.handleRequestError(e, options);
+        }
+      }
+      async get(url, requestOptions) {
+        const opts = Object.assign(Object.assign({}, requestOptions), { url, method: "GET" });
+        return this.request(opts);
+      }
+      async delete(url, requestOptions) {
+        const opts = Object.assign(Object.assign({}, requestOptions), { url, method: "DELETE" });
+        return this.request(opts);
+      }
+      async head(url, requestOptions) {
+        const opts = Object.assign(Object.assign({}, requestOptions), { url, method: "HEAD" });
+        return this.request(opts);
+      }
+      async options(url, requestOptions) {
+        const opts = Object.assign(Object.assign({}, requestOptions), { url, method: "OPTIONS" });
+        return this.request(opts);
+      }
+      async post(url, data, requestOptions) {
+        const opts = Object.assign(Object.assign({}, requestOptions), {
+          url,
+          data,
+          method: "POST"
+        });
+        return this.request(opts);
+      }
+      async put(url, data, requestOptions) {
+        const opts = Object.assign(Object.assign({}, requestOptions), {
+          url,
+          data,
+          method: "PUT"
+        });
+        return this.request(opts);
+      }
+      async patch(url, data, requestOptions) {
+        const opts = Object.assign(Object.assign({}, requestOptions), {
+          url,
+          data,
+          method: "PATCH"
+        });
+        return this.request(opts);
+      }
+      get CancelToken() {
+        return axios_1.default.CancelToken;
+      }
+      get isCancel() {
+        return axios_1.default.isCancel;
+      }
+      getHeaders(requestOptions, signedInstance, urlObject) {
+        if (typeof this.opts.createHeaders === "function") {
+          return this.getCustomHeaders(requestOptions, signedInstance, urlObject);
+        }
+        const wixHeadersOpts = {
+          signedInstance,
+          artifactId: this.opts.artifactId,
+          csrf: false,
+          multilingualOptions: this.opts.multilingualOptions
+        };
+        return (0, options_1.buildAllHeaders)(requestOptions, wixHeadersOpts, (0, utils_1.getGlobalConfig)(), urlObject);
+      }
+      getCustomHeaders(requestOptions, signedInstance, urlObject) {
+        const { url } = requestOptions;
+        const authHeader = signedInstance && (0, headers_1.isWixDomain)(url) ? { authorization: signedInstance } : {};
+        const customHeaders = this.opts.createHeaders();
+        const originalUrlHeader = (0, options_1.getUrlHeaders)((0, utils_1.getGlobalConfig)(), requestOptions, urlObject);
+        return Object.assign(Object.assign(Object.assign({}, originalUrlHeader), customHeaders), authHeader);
+      }
+      handleRequestError(error, requestOptions) {
+        const requestError = (0, error_1.createHttpError)(error);
+        (0, utils_1.silent)(() => {
+          var _a;
+          return (_a = requestOptions.onError) === null || _a === void 0 ? void 0 : _a.call(requestOptions, requestError);
+        });
+        throw requestError;
+      }
+      maybeFallbackRequest(err, requestOptions, urlObject, signedInstance) {
+        var _a, _b, _c;
+        const shouldFallbackRequest = (0, utils_1.isHttpMockServerEnabled)() && (0, utils_1.shouldAllowUnmocked)() && ((_a = err.response) === null || _a === void 0 ? void 0 : _a.status) === 404 && ((_c = (_b = err.response) === null || _b === void 0 ? void 0 : _b.data) === null || _c === void 0 ? void 0 : _c.msg) === constants_1.NO_SCENARIO_FOUND;
+        if (shouldFallbackRequest) {
+          const headers = this.getHeaders(requestOptions, signedInstance, urlObject);
+          const prodOptions = (0, options_1.buildOptions)({
+            requestOptions,
+            urlObject,
+            headers
+          });
+          return this.client.request(prodOptions);
+        }
+        throw err;
+      }
+      transformResponse(res, requestOptions) {
+        const requestId = (0, headers_1.requestIdOrEmptyString)(res);
+        const data = transformData(res, requestOptions, this.flags);
+        return Object.assign(Object.assign({}, res), {
+          data,
+          requestId
+        });
+      }
+    };
+    exports2.HttpClient = HttpClient;
+    HttpClient.CancelToken = axios_1.default.CancelToken;
+    HttpClient.isCancel = axios_1.default.isCancel;
+    function defaultClientOptions(opts) {
+      let adapter = opts.adapter;
+      if (!adapter) {
+        adapter = xhr_1.default;
+        if ((0, env_util_1.isNode)()) {
+          adapter = getNodeAdapter();
+        }
+      }
+      return Object.assign({ adapter, isSSR: false }, opts);
+    }
+    function getNodeAdapter() {
+      if (typeof __webpack_require__ === "function") {
+        return __non_webpack_require__("axios/lib/adapters/http");
+      }
+      return require_http2();
+    }
+    function transformData(res, requestOptions, flags) {
+      let resData = sanitizeResponse(res, flags);
+      if (requestOptions._pickResponseBody) {
+        resData = (0, utils_1.extractProp)(res.data, requestOptions._pickResponseBody);
+      }
+      if (requestOptions._logs) {
+        const logs = (0, utils_1.extractProp)(res.data, requestOptions._logs);
+        if (logs === null || logs === void 0 ? void 0 : logs.length) {
+          logs.map((log) => console.log(...log));
+        }
+      }
+      return resData;
+    }
+    function sanitizeResponse(res, flags) {
+      try {
+        if (flags.sanitizerPocEnabled) {
+          const start = performance.now();
+          const sanitizer = new Sanitizer();
+          if (res.headers["content-type"].includes("application/json")) {
+            console.log("[+] JSON Response detected, sanitizing data");
+            const sanitizeStringValue = function(jsonResponse) {
+              try {
+                Object.keys(jsonResponse).forEach((key) => {
+                  if (typeof jsonResponse[key] === "string") {
+                    jsonResponse[key] = sanitizer.sanitizeFor("span", jsonResponse[key]).innerHTML;
+                  } else if (typeof jsonResponse[key] === "object") {
+                    jsonResponse[key] = sanitizeStringValue(jsonResponse[key]);
+                  }
+                });
+                return jsonResponse;
+              } catch (error) {
+                console.log(error);
+              }
+            };
+            const end = performance.now();
+            console.log(`Time taken: ${end - start} milliseconds.`);
+            return sanitizeStringValue(res.data);
+          }
+        }
+      } catch (e) {
+        console.log("[+] Sanitizer API not supported: %o", e);
+      }
+      return res.data;
+    }
+    function checkSanitizerPocEnabled() {
+      var _a;
+      try {
+        return (0, env_util_1.isBrowser)() && new URLSearchParams(((_a = window === null || window === void 0 ? void 0 : window.location) === null || _a === void 0 ? void 0 : _a.hash) || "").get("sanitizerPOC") === "true";
+      } catch (_b) {
+        return false;
+      }
+    }
+    function createHttpClient(...args) {
+      return new HttpClient(...args);
+    }
+    exports2.createHttpClient = createHttpClient;
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/http-client/dist/src/http-client-node.js
+var require_http_client_node2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/http-client/dist/src/http-client-node.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.HttpClient = exports2.createHttpClient = void 0;
+    var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
+    var http_1 = tslib_1.__importDefault(require_http2());
+    var http_client_1 = require_http_client2();
+    var HttpClientNode = class extends http_client_1.HttpClient {
+      constructor(opts = {}) {
+        super(Object.assign({ adapter: http_1.default }, opts));
+      }
+    };
+    exports2.HttpClient = HttpClientNode;
+    function createHttpClientNode(...args) {
+      return new HttpClientNode(...args);
+    }
+    exports2.createHttpClient = createHttpClientNode;
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/http-client/dist/src/types.js
+var require_types5 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/http-client/dist/src/types.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/http-client/dist/src/index-node.js
+var require_index_node2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/node_modules/@wix/http-client/dist/src/index-node.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.HttpClient = exports2.createHttpClient = exports2.HttpError = exports2.createHttpError = exports2.ORIGINAL_URL_HEADER = exports2.ORIGINAL_PROTOCOL_HEADER = exports2.ORIGINAL_HOST_HEADER = void 0;
+    var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
+    var constants_1 = require_constants6();
+    Object.defineProperty(exports2, "ORIGINAL_HOST_HEADER", { enumerable: true, get: function() {
+      return constants_1.ORIGINAL_HOST_HEADER;
+    } });
+    Object.defineProperty(exports2, "ORIGINAL_PROTOCOL_HEADER", { enumerable: true, get: function() {
+      return constants_1.ORIGINAL_PROTOCOL_HEADER;
+    } });
+    Object.defineProperty(exports2, "ORIGINAL_URL_HEADER", { enumerable: true, get: function() {
+      return constants_1.ORIGINAL_URL_HEADER;
+    } });
+    var error_1 = require_error2();
+    Object.defineProperty(exports2, "createHttpError", { enumerable: true, get: function() {
+      return error_1.createHttpError;
+    } });
+    Object.defineProperty(exports2, "HttpError", { enumerable: true, get: function() {
+      return error_1.HttpError;
+    } });
+    var http_client_node_1 = require_http_client_node2();
+    Object.defineProperty(exports2, "createHttpClient", { enumerable: true, get: function() {
+      return http_client_node_1.createHttpClient;
+    } });
+    Object.defineProperty(exports2, "HttpClient", { enumerable: true, get: function() {
+      return http_client_node_1.HttpClient;
+    } });
+    tslib_1.__exportStar(require_types5(), exports2);
+  }
+});
+
+// ../../node_modules/@wix/standalone-node-bi-logger/dist/src/index.js
+var require_src2 = __commonJS({
+  "../../node_modules/@wix/standalone-node-bi-logger/dist/src/index.js"(exports2) {
+    "use strict";
+    Object.defineProperty(exports2, "__esModule", { value: true });
+    exports2.StandaloneNodeLogger = void 0;
+    var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports));
+    var wix_bi_logger_client_1 = tslib_1.__importDefault(require_dist5());
+    var http_client_1 = require_index_node2();
+    var defaultOptions = {
+      baseUrl: process.env.BI_BASE_URL || "https://frog.wix.com",
+      endpoint: "",
+      logError: false
+    };
+    var StandaloneNodeLogger = (
+      /** @class */
+      (function() {
+        function StandaloneNodeLogger2() {
+        }
+        StandaloneNodeLogger2.prototype.factory = function(options) {
+          var _this = this;
+          if (options === void 0) {
+            options = {};
+          }
+          var fullOptions = tslib_1.__assign(tslib_1.__assign({}, defaultOptions), options);
+          var biLoggerFactory = wix_bi_logger_client_1.default.factory();
+          if (fullOptions.onError) {
+            biLoggerFactory.setPublisherFailHandler(fullOptions.onError);
+          }
+          biLoggerFactory.addPublisher(function(eventParams, context) {
+            return tslib_1.__awaiter(_this, void 0, void 0, function() {
+              var endpoint, baseUrl, userAgent, logError, headers;
+              return tslib_1.__generator(this, function(_a) {
+                switch (_a.label) {
+                  case 0:
+                    endpoint = context.endpoint || fullOptions.endpoint;
+                    baseUrl = fullOptions.baseUrl, userAgent = fullOptions.userAgent, logError = fullOptions.logError;
+                    headers = userAgent ? { headers: { "User-Agent": userAgent } } : {};
+                    return [4, new http_client_1.HttpClient({ baseURL: baseUrl }).get(endpoint, {
+                      headers,
+                      params: eventParams,
+                      timeout: 30 * 1e3
+                    }).catch(function(e) {
+                      return logError ? console.error(e.toJSON()) : Promise.reject(e);
+                    })];
+                  case 1:
+                    _a.sent();
+                    return [
+                      2
+                      /*return*/
+                    ];
+                }
+              });
+            });
+          });
+          return biLoggerFactory;
+        };
+        return StandaloneNodeLogger2;
+      })()
+    );
+    exports2.StandaloneNodeLogger = StandaloneNodeLogger;
+    exports2.default = new StandaloneNodeLogger();
+  }
+});
+
 // dist/biLogger.js
 var require_biLogger = __commonJS({
   "dist/biLogger.js"(exports2) {
     "use strict";
+    var __importDefault2 = exports2 && exports2.__importDefault || function(mod) {
+      return mod && mod.__esModule ? mod : { "default": mod };
+    };
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.biLogger = void 0;
-    var wix_bi_logger_client_1 = require_dist5();
-    var biPublisher = async (event) => {
-      const { src, evid, ...params } = event;
-      const queryString = Object.entries({ src, evid, ...params }).filter(([, v]) => v !== void 0 && v !== null).map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`).join("&");
-      await fetch(`https://frog.wix.com/code?${queryString}`);
-    };
-    exports2.biLogger = (0, wix_bi_logger_client_1.factory)().addPublisher(biPublisher).logger();
+    var standalone_node_bi_logger_1 = __importDefault2(require_src2());
+    exports2.biLogger = standalone_node_bi_logger_1.default.factory({ endpoint: "code" }).logger();
   }
 });