@wix/astro 0.0.1-experimental-react-component → 0.0.1-experimental

package/build-runtime/chunk-HDTWPOIV.js

@@ -0,0 +1,811 @@
+import {
+  authAsyncLocalStorage
+} from "./chunk-NVTQFGTR.js";
+import {
+  resolveContext
+} from "./chunk-PSHIUVP2.js";
+import {
+  __commonJS,
+  __esm,
+  __export,
+  __toCommonJS,
+  __toESM
+} from "./chunk-QRPWKJ4C.js";
+
+// ../../node_modules/@wix/monitoring/build/index.cjs
+var require_build = __commonJS({
+  "../../node_modules/@wix/monitoring/build/index.cjs"(exports, module) {
+    "use strict";
+    var __defProp = Object.defineProperty;
+    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames = Object.getOwnPropertyNames;
+    var __hasOwnProp = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames(from))
+          if (!__hasOwnProp.call(to, key) && key !== except)
+            __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toCommonJS2 = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+    var index_exports = {};
+    __export2(index_exports, {
+      createFallbackMonitoringClient: () => createFallbackMonitoringClient,
+      generateTagsAndContext: () => generateTagsAndContext
+    });
+    module.exports = __toCommonJS2(index_exports);
+    var validValue = (value) => value !== void 0 && value !== null && value !== "";
+    var pickByValidValues = (obj) => pickBy(obj, validValue);
+    function pickBy(object, predicate = (value) => !!value) {
+      if (!object) {
+        return {};
+      }
+      const result = {};
+      for (const key in object) {
+        if (predicate(object[key], key)) {
+          result[key] = object[key];
+        }
+      }
+      return result;
+    }
+    var generateTagsAndContext = (context) => {
+      const tags = pickByValidValues({
+        "app.id": context.appId,
+        "app.version": context.appVersion,
+        "app.instanceId": context.appInstanceId,
+        "extension.id": context.extensionId,
+        "extension.name": context.extensionName,
+        "extension.type": context.extensionType,
+        platform: context.platform
+      });
+      const contexts = pickBy(
+        {
+          "extension.data": pickByValidValues({
+            ...context.extensionData
+          }),
+          site: pickByValidValues({
+            url: context.siteUrl,
+            id: context.tenantType === "SITE" ? context.tenantId : void 0
+          }),
+          account: pickByValidValues({
+            id: context.tenantType === "ACCOUNT" ? context.tenantId : void 0
+          })
+        },
+        (value) => !!value && Object.keys(value).length > 0
+      );
+      return {
+        tags,
+        contexts
+      };
+    };
+    var FallbackMonitoringClient = class {
+      constructor(message) {
+        this.message = message;
+        this.captureException = () => {
+          console.error(this.message);
+        };
+        this.captureMessage = () => {
+          console.error(this.message);
+        };
+        this.startSpan = (spanOptions, callback) => {
+          console.error(this.message);
+          return callback(void 0);
+        };
+        this.startSpanManual = () => {
+          console.error(this.message);
+          return {
+            end: () => {
+            },
+            fail: () => {
+            }
+          };
+        };
+        this.endSpanManual = () => {
+          console.error(this.message);
+        };
+        this.addBreadcrumb = () => {
+          console.error(this.message);
+        };
+      }
+    };
+    var createFallbackMonitoringClient = (message) => {
+      return new FallbackMonitoringClient(message);
+    };
+  }
+});
+
+// ../../node_modules/@wix/monitoring-common/build/index.js
+var build_exports = {};
+__export(build_exports, {
+  getCallLocation: () => getCallLocation,
+  getCallStack: () => getCallStack
+});
+var getCallStack, getCallLocation;
+var init_build = __esm({
+  "../../node_modules/@wix/monitoring-common/build/index.js"() {
+    "use strict";
+    getCallStack = (stack) => {
+      try {
+        throw new Error();
+      } catch (e) {
+        return e?.stack;
+      }
+    };
+    getCallLocation = (stack) => {
+      const res = { file: "", line: 0, column: 0 };
+      stack = stack ?? getCallStack();
+      const frame = stack?.trim().split("\n").pop();
+      if (!frame) {
+        return res;
+      }
+      const match = frame.match(/https?:\/\/.+?(\/.+):(\d+):(\d+)/) ?? frame.match(/.*(\/[^/]+):(\d+):(\d+)/);
+      if (match) {
+        res.file = match[1];
+        res.line = parseInt(match[2], 10) ?? 0;
+        res.column = parseInt(match[3], 10) ?? 0;
+      }
+      return res;
+    };
+  }
+});
+
+// ../../node_modules/lodash/isObject.js
+var require_isObject = __commonJS({
+  "../../node_modules/lodash/isObject.js"(exports, module) {
+    "use strict";
+    function isObject(value) {
+      var type = typeof value;
+      return value != null && (type == "object" || type == "function");
+    }
+    module.exports = isObject;
+  }
+});
+
+// ../../node_modules/lodash/_freeGlobal.js
+var require_freeGlobal = __commonJS({
+  "../../node_modules/lodash/_freeGlobal.js"(exports, module) {
+    "use strict";
+    var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
+    module.exports = freeGlobal;
+  }
+});
+
+// ../../node_modules/lodash/_root.js
+var require_root = __commonJS({
+  "../../node_modules/lodash/_root.js"(exports, module) {
+    "use strict";
+    var freeGlobal = require_freeGlobal();
+    var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+    var root = freeGlobal || freeSelf || Function("return this")();
+    module.exports = root;
+  }
+});
+
+// ../../node_modules/lodash/now.js
+var require_now = __commonJS({
+  "../../node_modules/lodash/now.js"(exports, module) {
+    "use strict";
+    var root = require_root();
+    var now = function() {
+      return root.Date.now();
+    };
+    module.exports = now;
+  }
+});
+
+// ../../node_modules/lodash/_trimmedEndIndex.js
+var require_trimmedEndIndex = __commonJS({
+  "../../node_modules/lodash/_trimmedEndIndex.js"(exports, module) {
+    "use strict";
+    var reWhitespace = /\s/;
+    function trimmedEndIndex(string) {
+      var index = string.length;
+      while (index-- && reWhitespace.test(string.charAt(index))) {
+      }
+      return index;
+    }
+    module.exports = trimmedEndIndex;
+  }
+});
+
+// ../../node_modules/lodash/_baseTrim.js
+var require_baseTrim = __commonJS({
+  "../../node_modules/lodash/_baseTrim.js"(exports, module) {
+    "use strict";
+    var trimmedEndIndex = require_trimmedEndIndex();
+    var reTrimStart = /^\s+/;
+    function baseTrim(string) {
+      return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, "") : string;
+    }
+    module.exports = baseTrim;
+  }
+});
+
+// ../../node_modules/lodash/_Symbol.js
+var require_Symbol = __commonJS({
+  "../../node_modules/lodash/_Symbol.js"(exports, module) {
+    "use strict";
+    var root = require_root();
+    var Symbol = root.Symbol;
+    module.exports = Symbol;
+  }
+});
+
+// ../../node_modules/lodash/_getRawTag.js
+var require_getRawTag = __commonJS({
+  "../../node_modules/lodash/_getRawTag.js"(exports, module) {
+    "use strict";
+    var Symbol = require_Symbol();
+    var objectProto = Object.prototype;
+    var hasOwnProperty = objectProto.hasOwnProperty;
+    var nativeObjectToString = objectProto.toString;
+    var symToStringTag = Symbol ? Symbol.toStringTag : void 0;
+    function getRawTag(value) {
+      var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
+      try {
+        value[symToStringTag] = void 0;
+        var unmasked = true;
+      } catch (e) {
+      }
+      var result = nativeObjectToString.call(value);
+      if (unmasked) {
+        if (isOwn) {
+          value[symToStringTag] = tag;
+        } else {
+          delete value[symToStringTag];
+        }
+      }
+      return result;
+    }
+    module.exports = getRawTag;
+  }
+});
+
+// ../../node_modules/lodash/_objectToString.js
+var require_objectToString = __commonJS({
+  "../../node_modules/lodash/_objectToString.js"(exports, module) {
+    "use strict";
+    var objectProto = Object.prototype;
+    var nativeObjectToString = objectProto.toString;
+    function objectToString(value) {
+      return nativeObjectToString.call(value);
+    }
+    module.exports = objectToString;
+  }
+});
+
+// ../../node_modules/lodash/_baseGetTag.js
+var require_baseGetTag = __commonJS({
+  "../../node_modules/lodash/_baseGetTag.js"(exports, module) {
+    "use strict";
+    var Symbol = require_Symbol();
+    var getRawTag = require_getRawTag();
+    var objectToString = require_objectToString();
+    var nullTag = "[object Null]";
+    var undefinedTag = "[object Undefined]";
+    var symToStringTag = Symbol ? Symbol.toStringTag : void 0;
+    function baseGetTag(value) {
+      if (value == null) {
+        return value === void 0 ? undefinedTag : nullTag;
+      }
+      return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+    }
+    module.exports = baseGetTag;
+  }
+});
+
+// ../../node_modules/lodash/isObjectLike.js
+var require_isObjectLike = __commonJS({
+  "../../node_modules/lodash/isObjectLike.js"(exports, module) {
+    "use strict";
+    function isObjectLike(value) {
+      return value != null && typeof value == "object";
+    }
+    module.exports = isObjectLike;
+  }
+});
+
+// ../../node_modules/lodash/isSymbol.js
+var require_isSymbol = __commonJS({
+  "../../node_modules/lodash/isSymbol.js"(exports, module) {
+    "use strict";
+    var baseGetTag = require_baseGetTag();
+    var isObjectLike = require_isObjectLike();
+    var symbolTag = "[object Symbol]";
+    function isSymbol(value) {
+      return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag;
+    }
+    module.exports = isSymbol;
+  }
+});
+
+// ../../node_modules/lodash/toNumber.js
+var require_toNumber = __commonJS({
+  "../../node_modules/lodash/toNumber.js"(exports, module) {
+    "use strict";
+    var baseTrim = require_baseTrim();
+    var isObject = require_isObject();
+    var isSymbol = require_isSymbol();
+    var NAN = 0 / 0;
+    var reIsBadHex = /^[-+]0x[0-9a-f]+$/i;
+    var reIsBinary = /^0b[01]+$/i;
+    var reIsOctal = /^0o[0-7]+$/i;
+    var freeParseInt = parseInt;
+    function toNumber(value) {
+      if (typeof value == "number") {
+        return value;
+      }
+      if (isSymbol(value)) {
+        return NAN;
+      }
+      if (isObject(value)) {
+        var other = typeof value.valueOf == "function" ? value.valueOf() : value;
+        value = isObject(other) ? other + "" : other;
+      }
+      if (typeof value != "string") {
+        return value === 0 ? value : +value;
+      }
+      value = baseTrim(value);
+      var isBinary = reIsBinary.test(value);
+      return isBinary || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
+    }
+    module.exports = toNumber;
+  }
+});
+
+// ../../node_modules/lodash/debounce.js
+var require_debounce = __commonJS({
+  "../../node_modules/lodash/debounce.js"(exports, module) {
+    "use strict";
+    var isObject = require_isObject();
+    var now = require_now();
+    var toNumber = require_toNumber();
+    var FUNC_ERROR_TEXT = "Expected a function";
+    var nativeMax = Math.max;
+    var nativeMin = Math.min;
+    function debounce(func, wait, options) {
+      var lastArgs, lastThis, maxWait, result, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
+      if (typeof func != "function") {
+        throw new TypeError(FUNC_ERROR_TEXT);
+      }
+      wait = toNumber(wait) || 0;
+      if (isObject(options)) {
+        leading = !!options.leading;
+        maxing = "maxWait" in options;
+        maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait;
+        trailing = "trailing" in options ? !!options.trailing : trailing;
+      }
+      function invokeFunc(time) {
+        var args = lastArgs, thisArg = lastThis;
+        lastArgs = lastThis = void 0;
+        lastInvokeTime = time;
+        result = func.apply(thisArg, args);
+        return result;
+      }
+      function leadingEdge(time) {
+        lastInvokeTime = time;
+        timerId = setTimeout(timerExpired, wait);
+        return leading ? invokeFunc(time) : result;
+      }
+      function remainingWait(time) {
+        var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime, timeWaiting = wait - timeSinceLastCall;
+        return maxing ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting;
+      }
+      function shouldInvoke(time) {
+        var timeSinceLastCall = time - lastCallTime, timeSinceLastInvoke = time - lastInvokeTime;
+        return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
+      }
+      function timerExpired() {
+        var time = now();
+        if (shouldInvoke(time)) {
+          return trailingEdge(time);
+        }
+        timerId = setTimeout(timerExpired, remainingWait(time));
+      }
+      function trailingEdge(time) {
+        timerId = void 0;
+        if (trailing && lastArgs) {
+          return invokeFunc(time);
+        }
+        lastArgs = lastThis = void 0;
+        return result;
+      }
+      function cancel() {
+        if (timerId !== void 0) {
+          clearTimeout(timerId);
+        }
+        lastInvokeTime = 0;
+        lastArgs = lastCallTime = lastThis = timerId = void 0;
+      }
+      function flush() {
+        return timerId === void 0 ? result : trailingEdge(now());
+      }
+      function debounced() {
+        var time = now(), isInvoking = shouldInvoke(time);
+        lastArgs = arguments;
+        lastThis = this;
+        lastCallTime = time;
+        if (isInvoking) {
+          if (timerId === void 0) {
+            return leadingEdge(lastCallTime);
+          }
+          if (maxing) {
+            clearTimeout(timerId);
+            timerId = setTimeout(timerExpired, wait);
+            return invokeFunc(lastCallTime);
+          }
+        }
+        if (timerId === void 0) {
+          timerId = setTimeout(timerExpired, wait);
+        }
+        return result;
+      }
+      debounced.cancel = cancel;
+      debounced.flush = flush;
+      return debounced;
+    }
+    module.exports = debounce;
+  }
+});
+
+// ../../node_modules/lodash/throttle.js
+var require_throttle = __commonJS({
+  "../../node_modules/lodash/throttle.js"(exports, module) {
+    "use strict";
+    var debounce = require_debounce();
+    var isObject = require_isObject();
+    var FUNC_ERROR_TEXT = "Expected a function";
+    function throttle(func, wait, options) {
+      var leading = true, trailing = true;
+      if (typeof func != "function") {
+        throw new TypeError(FUNC_ERROR_TEXT);
+      }
+      if (isObject(options)) {
+        leading = "leading" in options ? !!options.leading : leading;
+        trailing = "trailing" in options ? !!options.trailing : trailing;
+      }
+      return debounce(func, wait, {
+        "leading": leading,
+        "maxWait": wait,
+        "trailing": trailing
+      });
+    }
+    module.exports = throttle;
+  }
+});
+
+// ../../node_modules/@wix/monitoring-velo/build/index.cjs
+var require_build2 = __commonJS({
+  "../../node_modules/@wix/monitoring-velo/build/index.cjs"(exports, module) {
+    "use strict";
+    var __create = Object.create;
+    var __defProp = Object.defineProperty;
+    var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames = Object.getOwnPropertyNames;
+    var __getProtoOf = Object.getPrototypeOf;
+    var __hasOwnProp = Object.prototype.hasOwnProperty;
+    var __export2 = (target, all) => {
+      for (var name in all)
+        __defProp(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames(from))
+          if (!__hasOwnProp.call(to, key) && key !== except)
+            __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS2 = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+    var index_exports = {};
+    __export2(index_exports, {
+      createVeloMonitoringClient: () => createVeloMonitoringClient2
+    });
+    module.exports = __toCommonJS2(index_exports);
+    var import_monitoring = require_build();
+    var import_monitoring_common = (init_build(), __toCommonJS(build_exports));
+    var generateId = () => {
+      return typeof crypto !== "undefined" && typeof crypto.randomUUID === "function" ? crypto.randomUUID() : "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(e) {
+        const i = 16 * Math.random() | 0;
+        return ("x" === e ? i : 3 & i | 8).toString(16);
+      });
+    };
+    var stringifySafe = (value) => {
+      try {
+        return JSON.stringify(value);
+      } catch (error) {
+        return `Failed to stringify log value: ${error?.toString()}`;
+      }
+    };
+    var buildTelemetryPayload = (options, params) => {
+      const { namespace, producer, req, requestId } = options;
+      const {
+        message,
+        level = "INFO",
+        timestamp = Date.now(),
+        tags,
+        contexts
+      } = params;
+      const { __sourceLocation, ...restOfContext } = contexts ?? {};
+      let siteUrl = "";
+      if (req) {
+        try {
+          if (req.headers.get("referer")) {
+            siteUrl = new URL(req.headers.get("referer") ?? "").origin;
+          } else {
+            siteUrl = new URL(req.url).origin;
+          }
+        } catch (e) {
+        }
+      }
+      const messageParts = [message];
+      if (tags) {
+        messageParts.push(stringifySafe(tags));
+      }
+      if (Object.keys(restOfContext).length > 0) {
+        messageParts.push(stringifySafe(restOfContext));
+      }
+      const sourceLocation = __sourceLocation ?? (0, import_monitoring_common.getCallLocation)();
+      return {
+        insertId: generateId(),
+        timestamp: new Date(timestamp).toISOString(),
+        severity: level.toUpperCase(),
+        labels: {
+          tenantId: "",
+          namespace,
+          ...siteUrl ? { siteUrl } : {}
+        },
+        operation: {
+          id: requestId ?? generateId(),
+          producer
+        },
+        ...sourceLocation ? { sourceLocation } : {},
+        jsonPayload: {
+          message: messageParts.join(" ")
+        }
+      };
+    };
+    var TELEMETRY_URL = "https://www.wixapis.com/wixcode/v1/telemetry/telemetry-messages";
+    var MAX_BATCH_SIZE = 100;
+    var THROTTLE_DURATION = 300;
+    var report = (messages, authToken = "", fetch = globalThis.fetch) => {
+      fetch(TELEMETRY_URL, {
+        method: "POST",
+        body: JSON.stringify({ messages }),
+        headers: {
+          Authorization: authToken
+        }
+      }).catch(() => {
+      });
+    };
+    var import_throttle = __toESM2(require_throttle(), 1);
+    var BatchQueue = class {
+      constructor(options) {
+        this.options = options;
+        this.queue = [];
+        this.flushThrottled = (0, import_throttle.default)(
+          () => this.flush(),
+          options.throttleDuration,
+          {
+            leading: false
+          }
+        );
+      }
+      flush() {
+        const events = this.queue.splice(0);
+        this.options.flushHandler(events);
+      }
+      enqueue(payload) {
+        this.queue.push(payload);
+        if (this.queue.length === this.options.maxBatchSize) {
+          this.flushThrottled.cancel();
+          this.flush();
+        } else {
+          this.flushThrottled();
+        }
+      }
+    };
+    var isPromise = (value) => typeof value?.then === "function";
+    var import_monitoring_common2 = (init_build(), __toCommonJS(build_exports));
+    var VeloClient = class {
+      constructor(options) {
+        this.options = options;
+        this.reportError = (captureContext = {}, e) => {
+          const { tags, contexts } = captureContext;
+          const messagePayload = buildTelemetryPayload(this.options, {
+            message: e?.toString() ?? "Unknown error",
+            level: "error",
+            tags,
+            contexts: {
+              __sourceLocation: (0, import_monitoring_common2.getCallLocation)(e?.stack),
+              ...contexts
+            }
+          });
+          this.batchQueue.enqueue(messagePayload);
+        };
+        this.captureException = (error, captureContext) => {
+          this.reportError(captureContext, error);
+        };
+        this.captureMessage = (message, captureContext = {}) => {
+          const { level = "info", tags, contexts } = captureContext;
+          const messagePayload = buildTelemetryPayload(this.options, {
+            message,
+            level,
+            tags,
+            contexts
+          });
+          this.batchQueue.enqueue(messagePayload);
+        };
+        this.startSpan = (spanOptions, callback) => {
+          let res;
+          try {
+            res = callback();
+            if (isPromise(res)) {
+              res = res.then((_res) => {
+                return _res;
+              }).catch((e) => {
+                this.reportError(spanOptions, e);
+                throw e;
+              });
+            } else {
+            }
+          } catch (e) {
+            this.reportError(spanOptions, e);
+            throw e;
+          }
+          return res;
+        };
+        this.addBreadcrumb = (breadcrumb) => {
+        };
+        const { getAuthToken, fetch } = options;
+        this.batchQueue = new BatchQueue({
+          maxBatchSize: MAX_BATCH_SIZE,
+          throttleDuration: THROTTLE_DURATION,
+          flushHandler: (messages) => getAuthToken().then((token) => report(messages, token, fetch))
+        });
+      }
+      startSpanManual(spanOptions) {
+        return {
+          end: () => {
+          },
+          fail: (error) => {
+            this.reportError(spanOptions, error);
+          }
+        };
+      }
+      endSpanManual(spanOptions) {
+      }
+    };
+    var createVeloMonitoringClient2 = (options) => {
+      const { getAuthToken } = options;
+      if (!getAuthToken) {
+        return (0, import_monitoring.createFallbackMonitoringClient)("Missing getAuthToken");
+      }
+      return new VeloClient(options);
+    };
+  }
+});
+
+// ../../node_modules/@wix/headless-node/dist/esm/host-module.js
+var import_monitoring_velo = __toESM(require_build2());
+
+// ../../node_modules/@wix/headless-node/dist/esm/headers/common-config-header.js
+var COMMON_CONFIG_HEADER_NAME = "commonConfig";
+var BSI_COOKIE_NAME = "bSession";
+var getCommonConfigHeader = (req) => {
+  let value = req.headers.get(COMMON_CONFIG_HEADER_NAME);
+  if (!value) {
+    const cookies = req.headers.get("cookie");
+    const bsiCookie = cookies == null ? void 0 : cookies.split(";").find((keyValue) => keyValue.trim().startsWith(`${BSI_COOKIE_NAME}=`));
+    value = bsiCookie ? encodeURIComponent(JSON.stringify({
+      BSI: bsiCookie.split("=")[1]
+    })) : "";
+  }
+  return {
+    [COMMON_CONFIG_HEADER_NAME]: value
+  };
+};
+
+// ../../node_modules/@wix/headless-node/dist/esm/headers/index.js
+var getPassThroughHeaders = (req) => {
+  if (!req) {
+    return {};
+  }
+  const headers = [getCommonConfigHeader(req)];
+  return headers.reduce((res, header) => {
+    const entries = Object.entries(header).filter((_ref) => {
+      let [_, value] = _ref;
+      return !!value;
+    });
+    res = {
+      ...res,
+      ...Object.fromEntries(entries)
+    };
+    return res;
+  }, {});
+};
+
+// ../../node_modules/@wix/headless-node/dist/esm/utils/auth-utils.js
+var resolveAuthToken = () => {
+  var _resolveContext;
+  return (_resolveContext = resolveContext()) == null ? void 0 : _resolveContext.getAuth().getTokens().accessToken.value;
+};
+
+// ../../node_modules/@wix/headless-node/dist/esm/host-module.js
+var createHostModule = () => {
+  return {
+    __type: "host",
+    create: () => {
+      return {};
+    },
+    host: function(_temp) {
+      let {
+        req
+      } = _temp === void 0 ? {} : _temp;
+      const passThroughHeaders = getPassThroughHeaders(req);
+      return {
+        essentials: {
+          passThroughHeaders,
+          language: "en",
+          locale: "en-US",
+          timezone: "UTC"
+        },
+        getMonitoringClient: () => {
+          return (0, import_monitoring_velo.createVeloMonitoringClient)({
+            namespace: "Headless",
+            producer: "backend",
+            getAuthToken: async () => resolveAuthToken(),
+            req
+          });
+        }
+      };
+    }
+  };
+};
+
+// ../../node_modules/@wix/headless-node/dist/esm/index.js
+var headlessNode = createHostModule();
+
+// src/context/hostProxy.ts
+var createHostWithCurrentRequest = () => {
+  const store = authAsyncLocalStorage.getStore();
+  return headlessNode.host({ req: store?.request });
+};
+var createHostProxy = () => {
+  return new Proxy(
+    {},
+    {
+      get(target, prop) {
+        const host = createHostWithCurrentRequest();
+        const value = host[prop];
+        if (typeof value !== "function") {
+          return value;
+        }
+        return function(...args) {
+          const anotherHost = createHostWithCurrentRequest();
+          return anotherHost[prop].apply(
+            anotherHost,
+            args
+          );
+        };
+      }
+    }
+  );
+};
+
+export {
+  createHostProxy
+};