@adhese/sdk 0.6.1 → 0.6.3

package/dist/index.cjs

@@ -0,0 +1,2311 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const sdkDevtools = require("@adhese/sdk-devtools");
+const runtimeCore = require("@vue/runtime-core");
+const zod = require("zod");
+async function waitForDomLoad() {
+  return new Promise((resolve) => {
+    function onDomLoad() {
+      resolve();
+      window.removeEventListener("DOMContentLoaded", onDomLoad);
+    }
+    if (document.readyState === "loading")
+      document.addEventListener("DOMContentLoaded", onDomLoad);
+    else
+      resolve();
+  });
+}
+function createEventManager() {
+  const disposables = /* @__PURE__ */ new Set();
+  function dispose() {
+    for (const disposable of disposables)
+      disposable();
+  }
+  return new Proxy({
+    dispose
+  }, {
+    // eslint-disable-next-line ts/explicit-function-return-type
+    get(target, key, receiver) {
+      if (!(key in target) && typeof key === "string") {
+        const event = createEvent();
+        disposables.add(() => {
+          event.listeners.clear();
+        });
+        Reflect.set(target, key, event, receiver);
+      }
+      return Reflect.get(target, key, receiver);
+    }
+  });
+}
+function createEvent() {
+  const listeners = /* @__PURE__ */ new Set();
+  function dispatch(data) {
+    for (const listener of listeners)
+      void listener(data);
+  }
+  async function dispatchAsync(data) {
+    await Promise.allSettled(
+      Array.from(listeners).map((listener) => listener(data))
+    );
+  }
+  function addListener(listener) {
+    listeners.add(listener);
+  }
+  function removeListener(listener) {
+    listeners.delete(listener);
+  }
+  return {
+    listeners,
+    dispatch,
+    dispatchAsync,
+    addListener,
+    removeListener
+  };
+}
+var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var freeGlobal$1 = typeof commonjsGlobal == "object" && commonjsGlobal && commonjsGlobal.Object === Object && commonjsGlobal;
+var _freeGlobal = freeGlobal$1;
+var freeGlobal = _freeGlobal;
+var freeSelf = typeof self == "object" && self && self.Object === Object && self;
+var root$a = freeGlobal || freeSelf || Function("return this")();
+var _root = root$a;
+var root$9 = _root;
+var Symbol$5 = root$9.Symbol;
+var _Symbol = Symbol$5;
+function arrayMap$1(array, iteratee) {
+  var index = -1, length = array == null ? 0 : array.length, result = Array(length);
+  while (++index < length) {
+    result[index] = iteratee(array[index], index, array);
+  }
+  return result;
+}
+var _arrayMap = arrayMap$1;
+var isArray$4 = Array.isArray;
+var isArray_1 = isArray$4;
+var Symbol$4 = _Symbol;
+var objectProto$b = Object.prototype;
+var hasOwnProperty$8 = objectProto$b.hasOwnProperty;
+var nativeObjectToString$1 = objectProto$b.toString;
+var symToStringTag$1 = Symbol$4 ? Symbol$4.toStringTag : void 0;
+function getRawTag$1(value) {
+  var isOwn = hasOwnProperty$8.call(value, symToStringTag$1), tag = value[symToStringTag$1];
+  try {
+    value[symToStringTag$1] = void 0;
+    var unmasked = true;
+  } catch (e) {
+  }
+  var result = nativeObjectToString$1.call(value);
+  if (unmasked) {
+    if (isOwn) {
+      value[symToStringTag$1] = tag;
+    } else {
+      delete value[symToStringTag$1];
+    }
+  }
+  return result;
+}
+var _getRawTag = getRawTag$1;
+var objectProto$a = Object.prototype;
+var nativeObjectToString = objectProto$a.toString;
+function objectToString$1(value) {
+  return nativeObjectToString.call(value);
+}
+var _objectToString = objectToString$1;
+var Symbol$3 = _Symbol, getRawTag = _getRawTag, objectToString = _objectToString;
+var nullTag = "[object Null]", undefinedTag = "[object Undefined]";
+var symToStringTag = Symbol$3 ? Symbol$3.toStringTag : void 0;
+function baseGetTag$5(value) {
+  if (value == null) {
+    return value === void 0 ? undefinedTag : nullTag;
+  }
+  return symToStringTag && symToStringTag in Object(value) ? getRawTag(value) : objectToString(value);
+}
+var _baseGetTag = baseGetTag$5;
+function isObjectLike$5(value) {
+  return value != null && typeof value == "object";
+}
+var isObjectLike_1 = isObjectLike$5;
+var baseGetTag$4 = _baseGetTag, isObjectLike$4 = isObjectLike_1;
+var symbolTag$1 = "[object Symbol]";
+function isSymbol$2(value) {
+  return typeof value == "symbol" || isObjectLike$4(value) && baseGetTag$4(value) == symbolTag$1;
+}
+var isSymbol_1 = isSymbol$2;
+var Symbol$2 = _Symbol, arrayMap = _arrayMap, isArray$3 = isArray_1, isSymbol$1 = isSymbol_1;
+var INFINITY$1 = 1 / 0;
+var symbolProto$1 = Symbol$2 ? Symbol$2.prototype : void 0, symbolToString = symbolProto$1 ? symbolProto$1.toString : void 0;
+function baseToString$1(value) {
+  if (typeof value == "string") {
+    return value;
+  }
+  if (isArray$3(value)) {
+    return arrayMap(value, baseToString$1) + "";
+  }
+  if (isSymbol$1(value)) {
+    return symbolToString ? symbolToString.call(value) : "";
+  }
+  var result = value + "";
+  return result == "0" && 1 / value == -INFINITY$1 ? "-0" : result;
+}
+var _baseToString = baseToString$1;
+var baseToString = _baseToString;
+function toString$2(value) {
+  return value == null ? "" : baseToString(value);
+}
+var toString_1 = toString$2;
+var toString$1 = toString_1;
+var idCounter = 0;
+function uniqueId(prefix) {
+  var id = ++idCounter;
+  return toString$1(prefix) + id;
+}
+var uniqueId_1 = uniqueId;
+const uniqueId$1 = /* @__PURE__ */ getDefaultExportFromCjs(uniqueId_1);
+function createSafeFrame({
+  renderFile,
+  context
+}) {
+  const safeFrame = window.$sf;
+  if (!safeFrame)
+    throw new Error("SafeFrame not found");
+  const adhesePositions = /* @__PURE__ */ new Set();
+  const config = new safeFrame.host.Config({
+    auto: false,
+    debug: context.debug,
+    renderFile
+  });
+  function addPosition(ad, element) {
+    var _a;
+    if (!safeFrame)
+      throw new Error("SafeFrame not found");
+    const html = ad.ext === "js" && ad.body ? ad.body : ad.tag;
+    if (typeof html !== "string")
+      throw new Error("Ad tag is not a string");
+    const elementId = element.id || `ad-${ad.id}-${uniqueId$1()}`;
+    element.id = elementId;
+    const position = new safeFrame.host.Position({
+      id: elementId,
+      html,
+      src: ad.ext === "js" ? (_a = ad.swfSrc) == null ? void 0 : _a.href : void 0,
+      config: new safeFrame.host.PosConfig({
+        id: elementId,
+        w: Number(ad.width),
+        h: Number(ad.height),
+        size: `${Number(ad.width)}x${Number(ad.height)}`,
+        tgt: html.includes('target="_self"') ? "_self" : "_blank",
+        dest: elementId
+      })
+    });
+    adhesePositions.add(position);
+    return position;
+  }
+  async function render(position) {
+    if (!safeFrame)
+      throw new Error("SafeFrame not found");
+    safeFrame.host.render(position);
+  }
+  function dispose() {
+  }
+  return {
+    config,
+    addPosition,
+    render,
+    dispose
+  };
+}
+function renderIframe(ad, element) {
+  const iframe = document.createElement("iframe");
+  iframe.srcdoc = `
+      <!DOCTYPE html>
+      <html>
+        <head>
+          <style>
+            body {
+              margin: 0;
+              padding: 0;
+              overflow: hidden;
+            }
+          </style>
+        </head>
+        <body>
+          ${String(ad.tag)}
+        </body>
+      `.replaceAll(/\s+/g, " ").trim();
+  iframe.style.border = "none";
+  iframe.style.width = ad.width ? `${ad.width}px` : "auto";
+  iframe.style.height = ad.height ? `${ad.height}px` : "auto";
+  element.replaceChildren(iframe);
+}
+function renderInline(ad, element) {
+  element.innerHTML = String(ad.tag);
+}
+function generateName(location, format, slot) {
+  return `${location}${slot ? `${slot}` : ""}-${format}`;
+}
+async function findDomSlots(context) {
+  await waitForDomLoad();
+  return Array.from(document.querySelectorAll(".adunit")).filter((element) => {
+    var _a;
+    if (!element.dataset.format)
+      return false;
+    const name = generateName(
+      context.location,
+      element.dataset.format,
+      element.dataset.slot
+    );
+    return !((_a = context.getAll) == null ? void 0 : _a.call(context).some((activeSlot) => activeSlot.name.value === name));
+  }).map((element) => createSlot({
+    format: element.dataset.format,
+    containingElement: element,
+    slot: element.dataset.slot,
+    context
+  })).filter((slot) => {
+    var _a;
+    return !((_a = context.getAll) == null ? void 0 : _a.call(context).some((activeSlot) => activeSlot.name.value === slot.name.value));
+  });
+}
+function createSlotManager({
+  initialSlots = [],
+  context
+}) {
+  const scope = runtimeCore.effectScope();
+  return scope.run(() => {
+    const slots = runtimeCore.shallowReactive(/* @__PURE__ */ new Map());
+    runtimeCore.watchEffect(() => {
+      var _a;
+      (_a = context.events) == null ? void 0 : _a.changeSlots.dispatch(Array.from(slots.values()));
+    });
+    function getAll() {
+      return Array.from(slots).map(([, slot]) => slot);
+    }
+    function add(options) {
+      var _a;
+      const slot = createSlot({
+        ...options,
+        onDispose,
+        context
+      });
+      function onDispose() {
+        var _a2;
+        slots.delete(slot.name.value);
+        logger.debug("Slot removed", {
+          slot,
+          slots: Array.from(slots)
+        });
+        (_a2 = context.events) == null ? void 0 : _a2.removeSlot.dispatch(slot);
+      }
+      slots.set(slot.name.value, slot);
+      runtimeCore.watch(slot.name, (newName, previousName) => {
+        slots.set(newName, slot);
+        slots.delete(previousName);
+      });
+      logger.debug("Slot added", {
+        slot,
+        slots: Array.from(slots.values())
+      });
+      (_a = context.events) == null ? void 0 : _a.addSlot.dispatch(slot);
+      return slot;
+    }
+    async function findDomSlots$1() {
+      const domSlots = await findDomSlots(
+        context
+      );
+      for (const slot of domSlots)
+        slots.set(slot.name.value, slot);
+      return domSlots;
+    }
+    function get(name) {
+      return slots.get(name);
+    }
+    function dispose() {
+      for (const slot of slots.values())
+        slot.dispose();
+      slots.clear();
+      scope.stop();
+    }
+    for (const options of initialSlots) {
+      add({
+        ...options,
+        lazyLoading: false
+      });
+    }
+    return {
+      getAll,
+      add,
+      findDomSlots: findDomSlots$1,
+      get,
+      dispose
+    };
+  });
+}
+function onTcfConsentChange(callback) {
+  var _a;
+  (_a = window.__tcfapi) == null ? void 0 : _a.call(window, "addEventListener", 2, callback);
+  return () => {
+    var _a2;
+    return (_a2 = window.__tcfapi) == null ? void 0 : _a2.call(window, "removeEventListener", 2, callback);
+  };
+}
+function isObject$5(value) {
+  var type = typeof value;
+  return value != null && (type == "object" || type == "function");
+}
+var isObject_1 = isObject$5;
+var root$8 = _root;
+var now$1 = function() {
+  return root$8.Date.now();
+};
+var now_1 = now$1;
+var reWhitespace = /\s/;
+function trimmedEndIndex$1(string) {
+  var index = string.length;
+  while (index-- && reWhitespace.test(string.charAt(index))) {
+  }
+  return index;
+}
+var _trimmedEndIndex = trimmedEndIndex$1;
+var trimmedEndIndex = _trimmedEndIndex;
+var reTrimStart = /^\s+/;
+function baseTrim$1(string) {
+  return string ? string.slice(0, trimmedEndIndex(string) + 1).replace(reTrimStart, "") : string;
+}
+var _baseTrim = baseTrim$1;
+var baseTrim = _baseTrim, isObject$4 = isObject_1, isSymbol = isSymbol_1;
+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$3(value) {
+  if (typeof value == "number") {
+    return value;
+  }
+  if (isSymbol(value)) {
+    return NAN;
+  }
+  if (isObject$4(value)) {
+    var other = typeof value.valueOf == "function" ? value.valueOf() : value;
+    value = isObject$4(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;
+}
+var toNumber_1 = toNumber$3;
+var isObject$3 = isObject_1, now = now_1, toNumber$2 = toNumber_1;
+var FUNC_ERROR_TEXT = "Expected a function";
+var nativeMax = Math.max, nativeMin$2 = 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$2(wait) || 0;
+  if (isObject$3(options)) {
+    leading = !!options.leading;
+    maxing = "maxWait" in options;
+    maxWait = maxing ? nativeMax(toNumber$2(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$2(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;
+}
+var debounce_1 = debounce;
+const debounce$1 = /* @__PURE__ */ getDefaultExportFromCjs(debounce_1);
+function createQueryDetector({
+  onChange,
+  queries = {
+    mobile: "(max-width: 768px) and (pointer: coarse)",
+    tablet: "(min-width: 769px) and (max-width: 1024px) and (pointer: coarse)",
+    desktop: "(min-width: 1025px) and (pointer: fine)"
+  }
+} = {}) {
+  const mediaMap = new Map(
+    Object.entries(queries).map(([key, query]) => [key, window.matchMedia(query)])
+  );
+  function getQuery() {
+    for (const [device, query] of Object.entries(queries)) {
+      if (window.matchMedia(query).matches)
+        return device;
+    }
+    return "unknown";
+  }
+  const handleOnChange = debounce$1(() => {
+    void (onChange == null ? void 0 : onChange(getQuery()));
+    logger.debug(`Change device ${getQuery()}`);
+  }, 50);
+  if (onChange) {
+    for (const query of mediaMap.values())
+      query.addEventListener("change", handleOnChange);
+  }
+  function dispose() {
+    for (const query of mediaMap.values())
+      query.removeEventListener("change", handleOnChange);
+  }
+  return {
+    queries: mediaMap,
+    getQuery,
+    dispose
+  };
+}
+var nativeFloor = Math.floor, nativeRandom$1 = Math.random;
+function baseRandom$1(lower, upper) {
+  return lower + nativeFloor(nativeRandom$1() * (upper - lower + 1));
+}
+var _baseRandom = baseRandom$1;
+function eq$3(value, other) {
+  return value === other || value !== value && other !== other;
+}
+var eq_1 = eq$3;
+var baseGetTag$3 = _baseGetTag, isObject$2 = isObject_1;
+var asyncTag = "[object AsyncFunction]", funcTag$1 = "[object Function]", genTag = "[object GeneratorFunction]", proxyTag = "[object Proxy]";
+function isFunction$2(value) {
+  if (!isObject$2(value)) {
+    return false;
+  }
+  var tag = baseGetTag$3(value);
+  return tag == funcTag$1 || tag == genTag || tag == asyncTag || tag == proxyTag;
+}
+var isFunction_1 = isFunction$2;
+var MAX_SAFE_INTEGER$1 = 9007199254740991;
+function isLength$2(value) {
+  return typeof value == "number" && value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER$1;
+}
+var isLength_1 = isLength$2;
+var isFunction$1 = isFunction_1, isLength$1 = isLength_1;
+function isArrayLike$2(value) {
+  return value != null && isLength$1(value.length) && !isFunction$1(value);
+}
+var isArrayLike_1 = isArrayLike$2;
+var MAX_SAFE_INTEGER = 9007199254740991;
+var reIsUint = /^(?:0|[1-9]\d*)$/;
+function isIndex$2(value, length) {
+  var type = typeof value;
+  length = length == null ? MAX_SAFE_INTEGER : length;
+  return !!length && (type == "number" || type != "symbol" && reIsUint.test(value)) && (value > -1 && value % 1 == 0 && value < length);
+}
+var _isIndex = isIndex$2;
+var eq$2 = eq_1, isArrayLike$1 = isArrayLike_1, isIndex$1 = _isIndex, isObject$1 = isObject_1;
+function isIterateeCall$1(value, index, object) {
+  if (!isObject$1(object)) {
+    return false;
+  }
+  var type = typeof index;
+  if (type == "number" ? isArrayLike$1(object) && isIndex$1(index, object.length) : type == "string" && index in object) {
+    return eq$2(object[index], value);
+  }
+  return false;
+}
+var _isIterateeCall = isIterateeCall$1;
+var toNumber$1 = toNumber_1;
+var INFINITY = 1 / 0, MAX_INTEGER = 17976931348623157e292;
+function toFinite$2(value) {
+  if (!value) {
+    return value === 0 ? value : 0;
+  }
+  value = toNumber$1(value);
+  if (value === INFINITY || value === -INFINITY) {
+    var sign = value < 0 ? -1 : 1;
+    return sign * MAX_INTEGER;
+  }
+  return value === value ? value : 0;
+}
+var toFinite_1 = toFinite$2;
+var baseRandom = _baseRandom, isIterateeCall = _isIterateeCall, toFinite$1 = toFinite_1;
+var freeParseFloat = parseFloat;
+var nativeMin$1 = Math.min, nativeRandom = Math.random;
+function random(lower, upper, floating) {
+  if (floating && typeof floating != "boolean" && isIterateeCall(lower, upper, floating)) {
+    upper = floating = void 0;
+  }
+  if (floating === void 0) {
+    if (typeof upper == "boolean") {
+      floating = upper;
+      upper = void 0;
+    } else if (typeof lower == "boolean") {
+      floating = lower;
+      lower = void 0;
+    }
+  }
+  if (lower === void 0 && upper === void 0) {
+    lower = 0;
+    upper = 1;
+  } else {
+    lower = toFinite$1(lower);
+    if (upper === void 0) {
+      upper = lower;
+      lower = 0;
+    } else {
+      upper = toFinite$1(upper);
+    }
+  }
+  if (lower > upper) {
+    var temp = lower;
+    lower = upper;
+    upper = temp;
+  }
+  if (floating || lower % 1 || upper % 1) {
+    var rand = nativeRandom();
+    return nativeMin$1(lower + rand * (upper - lower + freeParseFloat("1e-" + ((rand + "").length - 1))), upper);
+  }
+  return baseRandom(lower, upper);
+}
+var random_1 = random;
+const random$1 = /* @__PURE__ */ getDefaultExportFromCjs(random_1);
+const defaultLogLevels = ["trace", "debug", "info", "warn", "error"];
+function createLogger({
+  scope,
+  logLevels = defaultLogLevels,
+  minLogLevelThreshold = logLevels[2]
+}) {
+  const logs = /* @__PURE__ */ new Set();
+  let currentMinLogLevelThreshold = minLogLevelThreshold;
+  const events = createEventManager();
+  const logFunctions = Object.fromEntries(logLevels.map((level, index) => {
+    const logFunction = (message, attributes) => {
+      logs.add({
+        scope,
+        level,
+        message,
+        attributes,
+        timestamp: Date.now(),
+        id: uniqueId$1()
+      });
+      events.log.dispatch({
+        scope,
+        level,
+        message,
+        attributes,
+        timestamp: Date.now(),
+        id: uniqueId$1()
+      });
+      if (index >= logLevels.indexOf(currentMinLogLevelThreshold)) {
+        if (["warn", "error", "trace"].includes(level)) {
+          console[level](...[
+            `%c${scope}`,
+            "color: red; font-weight: bold;",
+            message,
+            attributes
+          ].filter(Boolean));
+        } else {
+          console.log(...[
+            `%c${scope} %c${level.toUpperCase()}`,
+            "color: red; font-weight: bold;",
+            "font-weight: bold;",
+            message,
+            attributes
+          ].filter(Boolean));
+        }
+      }
+    };
+    return [level, logFunction];
+  }));
+  return {
+    ...logFunctions,
+    scope,
+    events,
+    setMinLogLevelThreshold(level) {
+      currentMinLogLevelThreshold = level;
+    },
+    resetMinLogLevelThreshold() {
+      currentMinLogLevelThreshold = minLogLevelThreshold;
+    },
+    getMinLogLevelThreshold() {
+      return currentMinLogLevelThreshold;
+    },
+    getLogs() {
+      return Array.from(logs);
+    },
+    resetLogs() {
+      events.reset.dispatch();
+      logs.clear();
+    }
+  };
+}
+const logger = createLogger({
+  scope: "Adhese SDK"
+});
+function createParameters(options, queryDetector) {
+  const parameters = /* @__PURE__ */ new Map();
+  if (options.logReferrer)
+    parameters.set("re", btoa(document.referrer));
+  if (options.logUrl)
+    parameters.set("ur", btoa(window.location.href));
+  for (const [key, value] of Object.entries({
+    ...options.parameters ?? {},
+    tl: options.consent ? "all" : "none",
+    dt: queryDetector.getQuery(),
+    br: queryDetector.getQuery(),
+    rn: random$1(1e4).toString()
+  }))
+    parameters.set(key, value);
+  return parameters;
+}
+function setupLogging(mergedOptions) {
+  if (mergedOptions.debug || window.location.search.includes("adhese_debug=true")) {
+    logger.setMinLogLevelThreshold("debug");
+    logger.debug("Debug logging enabled");
+  }
+  logger.debug("Created Adhese SDK instance", {
+    mergedOptions
+  });
+}
+function isPreviewMode() {
+  return window.location.search.includes("adhesePreviewCreativeId");
+}
+function createHook({
+  onRun,
+  onAdd
+}) {
+  const callbacks = /* @__PURE__ */ new Set();
+  function run() {
+    for (const callback of callbacks)
+      callback();
+    onRun == null ? void 0 : onRun(callbacks);
+  }
+  function add(callback) {
+    callbacks.add(callback);
+    onAdd == null ? void 0 : onAdd(callbacks);
+  }
+  return [run, add];
+}
+let resolveOnInitPromise = () => {
+};
+let isInit = false;
+const waitOnInit = new Promise((resolve) => {
+  resolveOnInitPromise = resolve;
+});
+const [runOnInit, onInit] = createHook({
+  onRun(callbacks) {
+    isInit = true;
+    resolveOnInitPromise();
+    logger.debug("Initialization completed");
+    callbacks.clear();
+  },
+  onAdd() {
+    if (isInit)
+      runOnInit();
+  }
+});
+function createAdhese(options) {
+  const scope = runtimeCore.effectScope();
+  return scope.run(() => {
+    const mergedOptions = {
+      host: `https://ads-${options.account}.adhese.com`,
+      poolHost: `https://pool-${options.account}.adhese.com`,
+      location: "homepage",
+      requestType: "POST",
+      debug: false,
+      initialSlots: [],
+      findDomSlotsOnLoad: false,
+      consent: false,
+      logReferrer: true,
+      logUrl: true,
+      safeFrame: false,
+      eagerRendering: false,
+      viewabilityTracking: true,
+      ...options
+    };
+    setupLogging(mergedOptions);
+    const context = runtimeCore.reactive({
+      location: mergedOptions.location,
+      consent: mergedOptions.consent,
+      debug: mergedOptions.debug,
+      getAll,
+      get,
+      options: mergedOptions,
+      logger
+    });
+    context.events = createEventManager();
+    context.safeFrame = options.safeFrame ? createSafeFrame({
+      renderFile: `${mergedOptions.poolHost}/sf/r.html`,
+      context
+    }) : void 0;
+    function getLocation() {
+      return context.location;
+    }
+    function setLocation(newLocation) {
+      var _a;
+      context.location = newLocation;
+      (_a = context.events) == null ? void 0 : _a.locationChange.dispatch(newLocation);
+    }
+    const queryDetector = createQueryDetector({
+      onChange: onQueryChange,
+      queries: mergedOptions.queries
+    });
+    context.parameters = createParameters(mergedOptions, queryDetector);
+    runtimeCore.watch(
+      context.parameters,
+      onParametersChange,
+      {
+        deep: true,
+        immediate: true
+      }
+    );
+    function onParametersChange() {
+      var _a;
+      if (context.parameters)
+        (_a = context.events) == null ? void 0 : _a.parametersChange.dispatch(context.parameters);
+    }
+    async function onQueryChange() {
+      var _a, _b;
+      const query = queryDetector.getQuery();
+      (_a = context.parameters) == null ? void 0 : _a.set("dt", query);
+      (_b = context.parameters) == null ? void 0 : _b.set("br", query);
+      await fetchAndRenderAllSlots();
+    }
+    function getConsent() {
+      return context.consent;
+    }
+    function setConsent(newConsent) {
+      var _a, _b;
+      (_a = context.parameters) == null ? void 0 : _a.set("tl", newConsent ? "all" : "none");
+      context.consent = newConsent;
+      (_b = context.events) == null ? void 0 : _b.consentChange.dispatch(newConsent);
+    }
+    const slotManager = createSlotManager({
+      initialSlots: mergedOptions.initialSlots,
+      context
+    });
+    function getAll() {
+      return slotManager.getAll() ?? [];
+    }
+    function get(name) {
+      return slotManager.get(name);
+    }
+    async function addSlot(slotOptions) {
+      if (!slotManager)
+        throw new Error("Slot manager not initialized");
+      const slot = slotManager.add(slotOptions);
+      if (!slot.lazyLoading) {
+        slot.ad.value = await requestAd({
+          slot,
+          context
+        });
+      }
+      return slot;
+    }
+    async function findDomSlots2() {
+      const domSlots = (await slotManager.findDomSlots() ?? []).filter((slot) => !slot.lazyLoading);
+      if (domSlots.length <= 0)
+        return [];
+      const ads = await requestAds({
+        slots: domSlots,
+        context
+      });
+      for (const ad of ads) {
+        const slot = slotManager.get(ad.slotName);
+        if (slot)
+          slot.ad.value = ad;
+      }
+      return domSlots;
+    }
+    let unmountDevtools;
+    async function toggleDebug() {
+      var _a, _b;
+      context.debug = !context.debug;
+      if (context.debug && !unmountDevtools) {
+        unmountDevtools = await sdkDevtools.createDevtools(context);
+        logger.setMinLogLevelThreshold("debug");
+        logger.debug("Debug mode enabled");
+        (_a = context.events) == null ? void 0 : _a.debugChange.dispatch(true);
+      } else {
+        logger.debug("Debug mode disabled");
+        unmountDevtools == null ? void 0 : unmountDevtools();
+        unmountDevtools = void 0;
+        logger.setMinLogLevelThreshold("info");
+        (_b = context.events) == null ? void 0 : _b.debugChange.dispatch(false);
+      }
+      return context.debug;
+    }
+    async function fetchAndRenderAllSlots() {
+      const slots = (slotManager.getAll() ?? []).filter((slot) => !slot.lazyLoading);
+      if (slots.length === 0)
+        return;
+      const ads = await requestAds({
+        slots,
+        context
+      });
+      for (const ad of ads) {
+        const slot = slotManager.get(ad.slotName);
+        if (slot)
+          slot.ad.value = ad;
+      }
+    }
+    const disposeOnTcfConsentChange = onTcfConsentChange(async (data) => {
+      var _a, _b;
+      if (!data.tcString)
+        return;
+      logger.debug("TCF v2 consent data received", {
+        data
+      });
+      (_a = context.parameters) == null ? void 0 : _a.set("xt", data.tcString);
+      (_b = context.parameters) == null ? void 0 : _b.delete("tl");
+      await fetchAndRenderAllSlots();
+    });
+    function dispose() {
+      var _a, _b;
+      unmountDevtools == null ? void 0 : unmountDevtools();
+      queryDetector.dispose();
+      slotManager.dispose();
+      queryDetector.dispose();
+      disposeOnTcfConsentChange();
+      (_a = context.parameters) == null ? void 0 : _a.clear();
+      logger.resetLogs();
+      (_b = context.events) == null ? void 0 : _b.dispose();
+      logger.info("Adhese instance disposed");
+      scope.stop();
+    }
+    onInit(async () => {
+      var _a;
+      if ((slotManager.getAll().length ?? 0) > 0)
+        await fetchAndRenderAllSlots().catch(logger.error);
+      if (mergedOptions.findDomSlotsOnLoad)
+        await findDomSlots2();
+      if (mergedOptions.debug || window.location.search.includes("adhese_debug=true") || isPreviewMode()) {
+        unmountDevtools = await sdkDevtools.createDevtools(context);
+        (_a = context.events) == null ? void 0 : _a.debugChange.dispatch(true);
+      }
+      if (!scope.active)
+        dispose();
+    });
+    runOnInit();
+    return {
+      ...mergedOptions,
+      ...slotManager,
+      parameters: context.parameters,
+      events: context.events,
+      getLocation,
+      setLocation,
+      getConsent,
+      setConsent,
+      addSlot,
+      findDomSlots: findDomSlots2,
+      dispose,
+      toggleDebug,
+      context
+    };
+  });
+}
+function listCacheClear$1() {
+  this.__data__ = [];
+  this.size = 0;
+}
+var _listCacheClear = listCacheClear$1;
+var eq$1 = eq_1;
+function assocIndexOf$4(array, key) {
+  var length = array.length;
+  while (length--) {
+    if (eq$1(array[length][0], key)) {
+      return length;
+    }
+  }
+  return -1;
+}
+var _assocIndexOf = assocIndexOf$4;
+var assocIndexOf$3 = _assocIndexOf;
+var arrayProto = Array.prototype;
+var splice = arrayProto.splice;
+function listCacheDelete$1(key) {
+  var data = this.__data__, index = assocIndexOf$3(data, key);
+  if (index < 0) {
+    return false;
+  }
+  var lastIndex = data.length - 1;
+  if (index == lastIndex) {
+    data.pop();
+  } else {
+    splice.call(data, index, 1);
+  }
+  --this.size;
+  return true;
+}
+var _listCacheDelete = listCacheDelete$1;
+var assocIndexOf$2 = _assocIndexOf;
+function listCacheGet$1(key) {
+  var data = this.__data__, index = assocIndexOf$2(data, key);
+  return index < 0 ? void 0 : data[index][1];
+}
+var _listCacheGet = listCacheGet$1;
+var assocIndexOf$1 = _assocIndexOf;
+function listCacheHas$1(key) {
+  return assocIndexOf$1(this.__data__, key) > -1;
+}
+var _listCacheHas = listCacheHas$1;
+var assocIndexOf = _assocIndexOf;
+function listCacheSet$1(key, value) {
+  var data = this.__data__, index = assocIndexOf(data, key);
+  if (index < 0) {
+    ++this.size;
+    data.push([key, value]);
+  } else {
+    data[index][1] = value;
+  }
+  return this;
+}
+var _listCacheSet = listCacheSet$1;
+var listCacheClear = _listCacheClear, listCacheDelete = _listCacheDelete, listCacheGet = _listCacheGet, listCacheHas = _listCacheHas, listCacheSet = _listCacheSet;
+function ListCache$4(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+ListCache$4.prototype.clear = listCacheClear;
+ListCache$4.prototype["delete"] = listCacheDelete;
+ListCache$4.prototype.get = listCacheGet;
+ListCache$4.prototype.has = listCacheHas;
+ListCache$4.prototype.set = listCacheSet;
+var _ListCache = ListCache$4;
+var ListCache$3 = _ListCache;
+function stackClear$1() {
+  this.__data__ = new ListCache$3();
+  this.size = 0;
+}
+var _stackClear = stackClear$1;
+function stackDelete$1(key) {
+  var data = this.__data__, result = data["delete"](key);
+  this.size = data.size;
+  return result;
+}
+var _stackDelete = stackDelete$1;
+function stackGet$1(key) {
+  return this.__data__.get(key);
+}
+var _stackGet = stackGet$1;
+function stackHas$1(key) {
+  return this.__data__.has(key);
+}
+var _stackHas = stackHas$1;
+var root$7 = _root;
+var coreJsData$1 = root$7["__core-js_shared__"];
+var _coreJsData = coreJsData$1;
+var coreJsData = _coreJsData;
+var maskSrcKey = function() {
+  var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || "");
+  return uid ? "Symbol(src)_1." + uid : "";
+}();
+function isMasked$1(func) {
+  return !!maskSrcKey && maskSrcKey in func;
+}
+var _isMasked = isMasked$1;
+var funcProto$1 = Function.prototype;
+var funcToString$1 = funcProto$1.toString;
+function toSource$2(func) {
+  if (func != null) {
+    try {
+      return funcToString$1.call(func);
+    } catch (e) {
+    }
+    try {
+      return func + "";
+    } catch (e) {
+    }
+  }
+  return "";
+}
+var _toSource = toSource$2;
+var isFunction = isFunction_1, isMasked = _isMasked, isObject = isObject_1, toSource$1 = _toSource;
+var reRegExpChar = /[\\^$.*+?()[\]{}|]/g;
+var reIsHostCtor = /^\[object .+?Constructor\]$/;
+var funcProto = Function.prototype, objectProto$9 = Object.prototype;
+var funcToString = funcProto.toString;
+var hasOwnProperty$7 = objectProto$9.hasOwnProperty;
+var reIsNative = RegExp(
+  "^" + funcToString.call(hasOwnProperty$7).replace(reRegExpChar, "\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, "$1.*?") + "$"
+);
+function baseIsNative$1(value) {
+  if (!isObject(value) || isMasked(value)) {
+    return false;
+  }
+  var pattern = isFunction(value) ? reIsNative : reIsHostCtor;
+  return pattern.test(toSource$1(value));
+}
+var _baseIsNative = baseIsNative$1;
+function getValue$1(object, key) {
+  return object == null ? void 0 : object[key];
+}
+var _getValue = getValue$1;
+var baseIsNative = _baseIsNative, getValue = _getValue;
+function getNative$6(object, key) {
+  var value = getValue(object, key);
+  return baseIsNative(value) ? value : void 0;
+}
+var _getNative = getNative$6;
+var getNative$5 = _getNative, root$6 = _root;
+var Map$4 = getNative$5(root$6, "Map");
+var _Map = Map$4;
+var getNative$4 = _getNative;
+var nativeCreate$4 = getNative$4(Object, "create");
+var _nativeCreate = nativeCreate$4;
+var nativeCreate$3 = _nativeCreate;
+function hashClear$1() {
+  this.__data__ = nativeCreate$3 ? nativeCreate$3(null) : {};
+  this.size = 0;
+}
+var _hashClear = hashClear$1;
+function hashDelete$1(key) {
+  var result = this.has(key) && delete this.__data__[key];
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var _hashDelete = hashDelete$1;
+var nativeCreate$2 = _nativeCreate;
+var HASH_UNDEFINED$2 = "__lodash_hash_undefined__";
+var objectProto$8 = Object.prototype;
+var hasOwnProperty$6 = objectProto$8.hasOwnProperty;
+function hashGet$1(key) {
+  var data = this.__data__;
+  if (nativeCreate$2) {
+    var result = data[key];
+    return result === HASH_UNDEFINED$2 ? void 0 : result;
+  }
+  return hasOwnProperty$6.call(data, key) ? data[key] : void 0;
+}
+var _hashGet = hashGet$1;
+var nativeCreate$1 = _nativeCreate;
+var objectProto$7 = Object.prototype;
+var hasOwnProperty$5 = objectProto$7.hasOwnProperty;
+function hashHas$1(key) {
+  var data = this.__data__;
+  return nativeCreate$1 ? data[key] !== void 0 : hasOwnProperty$5.call(data, key);
+}
+var _hashHas = hashHas$1;
+var nativeCreate = _nativeCreate;
+var HASH_UNDEFINED$1 = "__lodash_hash_undefined__";
+function hashSet$1(key, value) {
+  var data = this.__data__;
+  this.size += this.has(key) ? 0 : 1;
+  data[key] = nativeCreate && value === void 0 ? HASH_UNDEFINED$1 : value;
+  return this;
+}
+var _hashSet = hashSet$1;
+var hashClear = _hashClear, hashDelete = _hashDelete, hashGet = _hashGet, hashHas = _hashHas, hashSet = _hashSet;
+function Hash$1(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+Hash$1.prototype.clear = hashClear;
+Hash$1.prototype["delete"] = hashDelete;
+Hash$1.prototype.get = hashGet;
+Hash$1.prototype.has = hashHas;
+Hash$1.prototype.set = hashSet;
+var _Hash = Hash$1;
+var Hash = _Hash, ListCache$2 = _ListCache, Map$3 = _Map;
+function mapCacheClear$1() {
+  this.size = 0;
+  this.__data__ = {
+    "hash": new Hash(),
+    "map": new (Map$3 || ListCache$2)(),
+    "string": new Hash()
+  };
+}
+var _mapCacheClear = mapCacheClear$1;
+function isKeyable$1(value) {
+  var type = typeof value;
+  return type == "string" || type == "number" || type == "symbol" || type == "boolean" ? value !== "__proto__" : value === null;
+}
+var _isKeyable = isKeyable$1;
+var isKeyable = _isKeyable;
+function getMapData$4(map, key) {
+  var data = map.__data__;
+  return isKeyable(key) ? data[typeof key == "string" ? "string" : "hash"] : data.map;
+}
+var _getMapData = getMapData$4;
+var getMapData$3 = _getMapData;
+function mapCacheDelete$1(key) {
+  var result = getMapData$3(this, key)["delete"](key);
+  this.size -= result ? 1 : 0;
+  return result;
+}
+var _mapCacheDelete = mapCacheDelete$1;
+var getMapData$2 = _getMapData;
+function mapCacheGet$1(key) {
+  return getMapData$2(this, key).get(key);
+}
+var _mapCacheGet = mapCacheGet$1;
+var getMapData$1 = _getMapData;
+function mapCacheHas$1(key) {
+  return getMapData$1(this, key).has(key);
+}
+var _mapCacheHas = mapCacheHas$1;
+var getMapData = _getMapData;
+function mapCacheSet$1(key, value) {
+  var data = getMapData(this, key), size = data.size;
+  data.set(key, value);
+  this.size += data.size == size ? 0 : 1;
+  return this;
+}
+var _mapCacheSet = mapCacheSet$1;
+var mapCacheClear = _mapCacheClear, mapCacheDelete = _mapCacheDelete, mapCacheGet = _mapCacheGet, mapCacheHas = _mapCacheHas, mapCacheSet = _mapCacheSet;
+function MapCache$2(entries) {
+  var index = -1, length = entries == null ? 0 : entries.length;
+  this.clear();
+  while (++index < length) {
+    var entry = entries[index];
+    this.set(entry[0], entry[1]);
+  }
+}
+MapCache$2.prototype.clear = mapCacheClear;
+MapCache$2.prototype["delete"] = mapCacheDelete;
+MapCache$2.prototype.get = mapCacheGet;
+MapCache$2.prototype.has = mapCacheHas;
+MapCache$2.prototype.set = mapCacheSet;
+var _MapCache = MapCache$2;
+var ListCache$1 = _ListCache, Map$2 = _Map, MapCache$1 = _MapCache;
+var LARGE_ARRAY_SIZE = 200;
+function stackSet$1(key, value) {
+  var data = this.__data__;
+  if (data instanceof ListCache$1) {
+    var pairs = data.__data__;
+    if (!Map$2 || pairs.length < LARGE_ARRAY_SIZE - 1) {
+      pairs.push([key, value]);
+      this.size = ++data.size;
+      return this;
+    }
+    data = this.__data__ = new MapCache$1(pairs);
+  }
+  data.set(key, value);
+  this.size = data.size;
+  return this;
+}
+var _stackSet = stackSet$1;
+var ListCache = _ListCache, stackClear = _stackClear, stackDelete = _stackDelete, stackGet = _stackGet, stackHas = _stackHas, stackSet = _stackSet;
+function Stack$1(entries) {
+  var data = this.__data__ = new ListCache(entries);
+  this.size = data.size;
+}
+Stack$1.prototype.clear = stackClear;
+Stack$1.prototype["delete"] = stackDelete;
+Stack$1.prototype.get = stackGet;
+Stack$1.prototype.has = stackHas;
+Stack$1.prototype.set = stackSet;
+var _Stack = Stack$1;
+var HASH_UNDEFINED = "__lodash_hash_undefined__";
+function setCacheAdd$1(value) {
+  this.__data__.set(value, HASH_UNDEFINED);
+  return this;
+}
+var _setCacheAdd = setCacheAdd$1;
+function setCacheHas$1(value) {
+  return this.__data__.has(value);
+}
+var _setCacheHas = setCacheHas$1;
+var MapCache = _MapCache, setCacheAdd = _setCacheAdd, setCacheHas = _setCacheHas;
+function SetCache$1(values) {
+  var index = -1, length = values == null ? 0 : values.length;
+  this.__data__ = new MapCache();
+  while (++index < length) {
+    this.add(values[index]);
+  }
+}
+SetCache$1.prototype.add = SetCache$1.prototype.push = setCacheAdd;
+SetCache$1.prototype.has = setCacheHas;
+var _SetCache = SetCache$1;
+function arraySome$1(array, predicate) {
+  var index = -1, length = array == null ? 0 : array.length;
+  while (++index < length) {
+    if (predicate(array[index], index, array)) {
+      return true;
+    }
+  }
+  return false;
+}
+var _arraySome = arraySome$1;
+function cacheHas$1(cache, key) {
+  return cache.has(key);
+}
+var _cacheHas = cacheHas$1;
+var SetCache = _SetCache, arraySome = _arraySome, cacheHas = _cacheHas;
+var COMPARE_PARTIAL_FLAG$3 = 1, COMPARE_UNORDERED_FLAG$1 = 2;
+function equalArrays$2(array, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG$3, arrLength = array.length, othLength = other.length;
+  if (arrLength != othLength && !(isPartial && othLength > arrLength)) {
+    return false;
+  }
+  var arrStacked = stack.get(array);
+  var othStacked = stack.get(other);
+  if (arrStacked && othStacked) {
+    return arrStacked == other && othStacked == array;
+  }
+  var index = -1, result = true, seen = bitmask & COMPARE_UNORDERED_FLAG$1 ? new SetCache() : void 0;
+  stack.set(array, other);
+  stack.set(other, array);
+  while (++index < arrLength) {
+    var arrValue = array[index], othValue = other[index];
+    if (customizer) {
+      var compared = isPartial ? customizer(othValue, arrValue, index, other, array, stack) : customizer(arrValue, othValue, index, array, other, stack);
+    }
+    if (compared !== void 0) {
+      if (compared) {
+        continue;
+      }
+      result = false;
+      break;
+    }
+    if (seen) {
+      if (!arraySome(other, function(othValue2, othIndex) {
+        if (!cacheHas(seen, othIndex) && (arrValue === othValue2 || equalFunc(arrValue, othValue2, bitmask, customizer, stack))) {
+          return seen.push(othIndex);
+        }
+      })) {
+        result = false;
+        break;
+      }
+    } else if (!(arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {
+      result = false;
+      break;
+    }
+  }
+  stack["delete"](array);
+  stack["delete"](other);
+  return result;
+}
+var _equalArrays = equalArrays$2;
+var root$5 = _root;
+var Uint8Array$1 = root$5.Uint8Array;
+var _Uint8Array = Uint8Array$1;
+function mapToArray$1(map) {
+  var index = -1, result = Array(map.size);
+  map.forEach(function(value, key) {
+    result[++index] = [key, value];
+  });
+  return result;
+}
+var _mapToArray = mapToArray$1;
+function setToArray$1(set) {
+  var index = -1, result = Array(set.size);
+  set.forEach(function(value) {
+    result[++index] = value;
+  });
+  return result;
+}
+var _setToArray = setToArray$1;
+var Symbol$1 = _Symbol, Uint8Array = _Uint8Array, eq = eq_1, equalArrays$1 = _equalArrays, mapToArray = _mapToArray, setToArray = _setToArray;
+var COMPARE_PARTIAL_FLAG$2 = 1, COMPARE_UNORDERED_FLAG = 2;
+var boolTag$1 = "[object Boolean]", dateTag$1 = "[object Date]", errorTag$1 = "[object Error]", mapTag$2 = "[object Map]", numberTag$1 = "[object Number]", regexpTag$1 = "[object RegExp]", setTag$2 = "[object Set]", stringTag$1 = "[object String]", symbolTag = "[object Symbol]";
+var arrayBufferTag$1 = "[object ArrayBuffer]", dataViewTag$2 = "[object DataView]";
+var symbolProto = Symbol$1 ? Symbol$1.prototype : void 0, symbolValueOf = symbolProto ? symbolProto.valueOf : void 0;
+function equalByTag$1(object, other, tag, bitmask, customizer, equalFunc, stack) {
+  switch (tag) {
+    case dataViewTag$2:
+      if (object.byteLength != other.byteLength || object.byteOffset != other.byteOffset) {
+        return false;
+      }
+      object = object.buffer;
+      other = other.buffer;
+    case arrayBufferTag$1:
+      if (object.byteLength != other.byteLength || !equalFunc(new Uint8Array(object), new Uint8Array(other))) {
+        return false;
+      }
+      return true;
+    case boolTag$1:
+    case dateTag$1:
+    case numberTag$1:
+      return eq(+object, +other);
+    case errorTag$1:
+      return object.name == other.name && object.message == other.message;
+    case regexpTag$1:
+    case stringTag$1:
+      return object == other + "";
+    case mapTag$2:
+      var convert = mapToArray;
+    case setTag$2:
+      var isPartial = bitmask & COMPARE_PARTIAL_FLAG$2;
+      convert || (convert = setToArray);
+      if (object.size != other.size && !isPartial) {
+        return false;
+      }
+      var stacked = stack.get(object);
+      if (stacked) {
+        return stacked == other;
+      }
+      bitmask |= COMPARE_UNORDERED_FLAG;
+      stack.set(object, other);
+      var result = equalArrays$1(convert(object), convert(other), bitmask, customizer, equalFunc, stack);
+      stack["delete"](object);
+      return result;
+    case symbolTag:
+      if (symbolValueOf) {
+        return symbolValueOf.call(object) == symbolValueOf.call(other);
+      }
+  }
+  return false;
+}
+var _equalByTag = equalByTag$1;
+function arrayPush$1(array, values) {
+  var index = -1, length = values.length, offset = array.length;
+  while (++index < length) {
+    array[offset + index] = values[index];
+  }
+  return array;
+}
+var _arrayPush = arrayPush$1;
+var arrayPush = _arrayPush, isArray$2 = isArray_1;
+function baseGetAllKeys$1(object, keysFunc, symbolsFunc) {
+  var result = keysFunc(object);
+  return isArray$2(object) ? result : arrayPush(result, symbolsFunc(object));
+}
+var _baseGetAllKeys = baseGetAllKeys$1;
+function arrayFilter$1(array, predicate) {
+  var index = -1, length = array == null ? 0 : array.length, resIndex = 0, result = [];
+  while (++index < length) {
+    var value = array[index];
+    if (predicate(value, index, array)) {
+      result[resIndex++] = value;
+    }
+  }
+  return result;
+}
+var _arrayFilter = arrayFilter$1;
+function stubArray$1() {
+  return [];
+}
+var stubArray_1 = stubArray$1;
+var arrayFilter = _arrayFilter, stubArray = stubArray_1;
+var objectProto$6 = Object.prototype;
+var propertyIsEnumerable$1 = objectProto$6.propertyIsEnumerable;
+var nativeGetSymbols = Object.getOwnPropertySymbols;
+var getSymbols$1 = !nativeGetSymbols ? stubArray : function(object) {
+  if (object == null) {
+    return [];
+  }
+  object = Object(object);
+  return arrayFilter(nativeGetSymbols(object), function(symbol) {
+    return propertyIsEnumerable$1.call(object, symbol);
+  });
+};
+var _getSymbols = getSymbols$1;
+function baseTimes$1(n, iteratee) {
+  var index = -1, result = Array(n);
+  while (++index < n) {
+    result[index] = iteratee(index);
+  }
+  return result;
+}
+var _baseTimes = baseTimes$1;
+var baseGetTag$2 = _baseGetTag, isObjectLike$3 = isObjectLike_1;
+var argsTag$2 = "[object Arguments]";
+function baseIsArguments$1(value) {
+  return isObjectLike$3(value) && baseGetTag$2(value) == argsTag$2;
+}
+var _baseIsArguments = baseIsArguments$1;
+var baseIsArguments = _baseIsArguments, isObjectLike$2 = isObjectLike_1;
+var objectProto$5 = Object.prototype;
+var hasOwnProperty$4 = objectProto$5.hasOwnProperty;
+var propertyIsEnumerable = objectProto$5.propertyIsEnumerable;
+var isArguments$1 = baseIsArguments(/* @__PURE__ */ function() {
+  return arguments;
+}()) ? baseIsArguments : function(value) {
+  return isObjectLike$2(value) && hasOwnProperty$4.call(value, "callee") && !propertyIsEnumerable.call(value, "callee");
+};
+var isArguments_1 = isArguments$1;
+var isBuffer$2 = { exports: {} };
+function stubFalse() {
+  return false;
+}
+var stubFalse_1 = stubFalse;
+isBuffer$2.exports;
+(function(module2, exports2) {
+  var root2 = _root, stubFalse2 = stubFalse_1;
+  var freeExports = exports2 && !exports2.nodeType && exports2;
+  var freeModule = freeExports && true && module2 && !module2.nodeType && module2;
+  var moduleExports = freeModule && freeModule.exports === freeExports;
+  var Buffer = moduleExports ? root2.Buffer : void 0;
+  var nativeIsBuffer = Buffer ? Buffer.isBuffer : void 0;
+  var isBuffer2 = nativeIsBuffer || stubFalse2;
+  module2.exports = isBuffer2;
+})(isBuffer$2, isBuffer$2.exports);
+var isBufferExports = isBuffer$2.exports;
+var baseGetTag$1 = _baseGetTag, isLength = isLength_1, isObjectLike$1 = isObjectLike_1;
+var argsTag$1 = "[object Arguments]", arrayTag$1 = "[object Array]", boolTag = "[object Boolean]", dateTag = "[object Date]", errorTag = "[object Error]", funcTag = "[object Function]", mapTag$1 = "[object Map]", numberTag = "[object Number]", objectTag$2 = "[object Object]", regexpTag = "[object RegExp]", setTag$1 = "[object Set]", stringTag = "[object String]", weakMapTag$1 = "[object WeakMap]";
+var arrayBufferTag = "[object ArrayBuffer]", dataViewTag$1 = "[object DataView]", float32Tag = "[object Float32Array]", float64Tag = "[object Float64Array]", int8Tag = "[object Int8Array]", int16Tag = "[object Int16Array]", int32Tag = "[object Int32Array]", uint8Tag = "[object Uint8Array]", uint8ClampedTag = "[object Uint8ClampedArray]", uint16Tag = "[object Uint16Array]", uint32Tag = "[object Uint32Array]";
+var typedArrayTags = {};
+typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = typedArrayTags[uint32Tag] = true;
+typedArrayTags[argsTag$1] = typedArrayTags[arrayTag$1] = typedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] = typedArrayTags[dataViewTag$1] = typedArrayTags[dateTag] = typedArrayTags[errorTag] = typedArrayTags[funcTag] = typedArrayTags[mapTag$1] = typedArrayTags[numberTag] = typedArrayTags[objectTag$2] = typedArrayTags[regexpTag] = typedArrayTags[setTag$1] = typedArrayTags[stringTag] = typedArrayTags[weakMapTag$1] = false;
+function baseIsTypedArray$1(value) {
+  return isObjectLike$1(value) && isLength(value.length) && !!typedArrayTags[baseGetTag$1(value)];
+}
+var _baseIsTypedArray = baseIsTypedArray$1;
+function baseUnary$1(func) {
+  return function(value) {
+    return func(value);
+  };
+}
+var _baseUnary = baseUnary$1;
+var _nodeUtil = { exports: {} };
+_nodeUtil.exports;
+(function(module2, exports2) {
+  var freeGlobal2 = _freeGlobal;
+  var freeExports = exports2 && !exports2.nodeType && exports2;
+  var freeModule = freeExports && true && module2 && !module2.nodeType && module2;
+  var moduleExports = freeModule && freeModule.exports === freeExports;
+  var freeProcess = moduleExports && freeGlobal2.process;
+  var nodeUtil2 = function() {
+    try {
+      var types = freeModule && freeModule.require && freeModule.require("util").types;
+      if (types) {
+        return types;
+      }
+      return freeProcess && freeProcess.binding && freeProcess.binding("util");
+    } catch (e) {
+    }
+  }();
+  module2.exports = nodeUtil2;
+})(_nodeUtil, _nodeUtil.exports);
+var _nodeUtilExports = _nodeUtil.exports;
+var baseIsTypedArray = _baseIsTypedArray, baseUnary = _baseUnary, nodeUtil = _nodeUtilExports;
+var nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;
+var isTypedArray$2 = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;
+var isTypedArray_1 = isTypedArray$2;
+var baseTimes = _baseTimes, isArguments = isArguments_1, isArray$1 = isArray_1, isBuffer$1 = isBufferExports, isIndex = _isIndex, isTypedArray$1 = isTypedArray_1;
+var objectProto$4 = Object.prototype;
+var hasOwnProperty$3 = objectProto$4.hasOwnProperty;
+function arrayLikeKeys$1(value, inherited) {
+  var isArr = isArray$1(value), isArg = !isArr && isArguments(value), isBuff = !isArr && !isArg && isBuffer$1(value), isType = !isArr && !isArg && !isBuff && isTypedArray$1(value), skipIndexes = isArr || isArg || isBuff || isType, result = skipIndexes ? baseTimes(value.length, String) : [], length = result.length;
+  for (var key in value) {
+    if ((inherited || hasOwnProperty$3.call(value, key)) && !(skipIndexes && // Safari 9 has enumerable `arguments.length` in strict mode.
+    (key == "length" || // Node.js 0.10 has enumerable non-index properties on buffers.
+    isBuff && (key == "offset" || key == "parent") || // PhantomJS 2 has enumerable non-index properties on typed arrays.
+    isType && (key == "buffer" || key == "byteLength" || key == "byteOffset") || // Skip index properties.
+    isIndex(key, length)))) {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var _arrayLikeKeys = arrayLikeKeys$1;
+var objectProto$3 = Object.prototype;
+function isPrototype$1(value) {
+  var Ctor = value && value.constructor, proto = typeof Ctor == "function" && Ctor.prototype || objectProto$3;
+  return value === proto;
+}
+var _isPrototype = isPrototype$1;
+function overArg$1(func, transform) {
+  return function(arg) {
+    return func(transform(arg));
+  };
+}
+var _overArg = overArg$1;
+var overArg = _overArg;
+var nativeKeys$1 = overArg(Object.keys, Object);
+var _nativeKeys = nativeKeys$1;
+var isPrototype = _isPrototype, nativeKeys = _nativeKeys;
+var objectProto$2 = Object.prototype;
+var hasOwnProperty$2 = objectProto$2.hasOwnProperty;
+function baseKeys$1(object) {
+  if (!isPrototype(object)) {
+    return nativeKeys(object);
+  }
+  var result = [];
+  for (var key in Object(object)) {
+    if (hasOwnProperty$2.call(object, key) && key != "constructor") {
+      result.push(key);
+    }
+  }
+  return result;
+}
+var _baseKeys = baseKeys$1;
+var arrayLikeKeys = _arrayLikeKeys, baseKeys = _baseKeys, isArrayLike = isArrayLike_1;
+function keys$1(object) {
+  return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);
+}
+var keys_1 = keys$1;
+var baseGetAllKeys = _baseGetAllKeys, getSymbols = _getSymbols, keys = keys_1;
+function getAllKeys$1(object) {
+  return baseGetAllKeys(object, keys, getSymbols);
+}
+var _getAllKeys = getAllKeys$1;
+var getAllKeys = _getAllKeys;
+var COMPARE_PARTIAL_FLAG$1 = 1;
+var objectProto$1 = Object.prototype;
+var hasOwnProperty$1 = objectProto$1.hasOwnProperty;
+function equalObjects$1(object, other, bitmask, customizer, equalFunc, stack) {
+  var isPartial = bitmask & COMPARE_PARTIAL_FLAG$1, objProps = getAllKeys(object), objLength = objProps.length, othProps = getAllKeys(other), othLength = othProps.length;
+  if (objLength != othLength && !isPartial) {
+    return false;
+  }
+  var index = objLength;
+  while (index--) {
+    var key = objProps[index];
+    if (!(isPartial ? key in other : hasOwnProperty$1.call(other, key))) {
+      return false;
+    }
+  }
+  var objStacked = stack.get(object);
+  var othStacked = stack.get(other);
+  if (objStacked && othStacked) {
+    return objStacked == other && othStacked == object;
+  }
+  var result = true;
+  stack.set(object, other);
+  stack.set(other, object);
+  var skipCtor = isPartial;
+  while (++index < objLength) {
+    key = objProps[index];
+    var objValue = object[key], othValue = other[key];
+    if (customizer) {
+      var compared = isPartial ? customizer(othValue, objValue, key, other, object, stack) : customizer(objValue, othValue, key, object, other, stack);
+    }
+    if (!(compared === void 0 ? objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack) : compared)) {
+      result = false;
+      break;
+    }
+    skipCtor || (skipCtor = key == "constructor");
+  }
+  if (result && !skipCtor) {
+    var objCtor = object.constructor, othCtor = other.constructor;
+    if (objCtor != othCtor && ("constructor" in object && "constructor" in other) && !(typeof objCtor == "function" && objCtor instanceof objCtor && typeof othCtor == "function" && othCtor instanceof othCtor)) {
+      result = false;
+    }
+  }
+  stack["delete"](object);
+  stack["delete"](other);
+  return result;
+}
+var _equalObjects = equalObjects$1;
+var getNative$3 = _getNative, root$4 = _root;
+var DataView$1 = getNative$3(root$4, "DataView");
+var _DataView = DataView$1;
+var getNative$2 = _getNative, root$3 = _root;
+var Promise$2 = getNative$2(root$3, "Promise");
+var _Promise = Promise$2;
+var getNative$1 = _getNative, root$2 = _root;
+var Set$2 = getNative$1(root$2, "Set");
+var _Set = Set$2;
+var getNative = _getNative, root$1 = _root;
+var WeakMap$1 = getNative(root$1, "WeakMap");
+var _WeakMap = WeakMap$1;
+var DataView = _DataView, Map$1 = _Map, Promise$1 = _Promise, Set$1 = _Set, WeakMap = _WeakMap, baseGetTag = _baseGetTag, toSource = _toSource;
+var mapTag = "[object Map]", objectTag$1 = "[object Object]", promiseTag = "[object Promise]", setTag = "[object Set]", weakMapTag = "[object WeakMap]";
+var dataViewTag = "[object DataView]";
+var dataViewCtorString = toSource(DataView), mapCtorString = toSource(Map$1), promiseCtorString = toSource(Promise$1), setCtorString = toSource(Set$1), weakMapCtorString = toSource(WeakMap);
+var getTag$1 = baseGetTag;
+if (DataView && getTag$1(new DataView(new ArrayBuffer(1))) != dataViewTag || Map$1 && getTag$1(new Map$1()) != mapTag || Promise$1 && getTag$1(Promise$1.resolve()) != promiseTag || Set$1 && getTag$1(new Set$1()) != setTag || WeakMap && getTag$1(new WeakMap()) != weakMapTag) {
+  getTag$1 = function(value) {
+    var result = baseGetTag(value), Ctor = result == objectTag$1 ? value.constructor : void 0, ctorString = Ctor ? toSource(Ctor) : "";
+    if (ctorString) {
+      switch (ctorString) {
+        case dataViewCtorString:
+          return dataViewTag;
+        case mapCtorString:
+          return mapTag;
+        case promiseCtorString:
+          return promiseTag;
+        case setCtorString:
+          return setTag;
+        case weakMapCtorString:
+          return weakMapTag;
+      }
+    }
+    return result;
+  };
+}
+var _getTag = getTag$1;
+var Stack = _Stack, equalArrays = _equalArrays, equalByTag = _equalByTag, equalObjects = _equalObjects, getTag = _getTag, isArray = isArray_1, isBuffer = isBufferExports, isTypedArray = isTypedArray_1;
+var COMPARE_PARTIAL_FLAG = 1;
+var argsTag = "[object Arguments]", arrayTag = "[object Array]", objectTag = "[object Object]";
+var objectProto = Object.prototype;
+var hasOwnProperty = objectProto.hasOwnProperty;
+function baseIsEqualDeep$1(object, other, bitmask, customizer, equalFunc, stack) {
+  var objIsArr = isArray(object), othIsArr = isArray(other), objTag = objIsArr ? arrayTag : getTag(object), othTag = othIsArr ? arrayTag : getTag(other);
+  objTag = objTag == argsTag ? objectTag : objTag;
+  othTag = othTag == argsTag ? objectTag : othTag;
+  var objIsObj = objTag == objectTag, othIsObj = othTag == objectTag, isSameTag = objTag == othTag;
+  if (isSameTag && isBuffer(object)) {
+    if (!isBuffer(other)) {
+      return false;
+    }
+    objIsArr = true;
+    objIsObj = false;
+  }
+  if (isSameTag && !objIsObj) {
+    stack || (stack = new Stack());
+    return objIsArr || isTypedArray(object) ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);
+  }
+  if (!(bitmask & COMPARE_PARTIAL_FLAG)) {
+    var objIsWrapped = objIsObj && hasOwnProperty.call(object, "__wrapped__"), othIsWrapped = othIsObj && hasOwnProperty.call(other, "__wrapped__");
+    if (objIsWrapped || othIsWrapped) {
+      var objUnwrapped = objIsWrapped ? object.value() : object, othUnwrapped = othIsWrapped ? other.value() : other;
+      stack || (stack = new Stack());
+      return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);
+    }
+  }
+  if (!isSameTag) {
+    return false;
+  }
+  stack || (stack = new Stack());
+  return equalObjects(object, other, bitmask, customizer, equalFunc, stack);
+}
+var _baseIsEqualDeep = baseIsEqualDeep$1;
+var baseIsEqualDeep = _baseIsEqualDeep, isObjectLike = isObjectLike_1;
+function baseIsEqual$1(value, other, bitmask, customizer, stack) {
+  if (value === other) {
+    return true;
+  }
+  if (value == null || other == null || !isObjectLike(value) && !isObjectLike(other)) {
+    return value !== value && other !== other;
+  }
+  return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual$1, stack);
+}
+var _baseIsEqual = baseIsEqual$1;
+var baseIsEqual = _baseIsEqual;
+function isEqual(value, other) {
+  return baseIsEqual(value, other);
+}
+var isEqual_1 = isEqual;
+const isEqual$1 = /* @__PURE__ */ getDefaultExportFromCjs(isEqual_1);
+function addTrackingPixel(url) {
+  const img = document.createElement("img");
+  img.src = url.toString();
+  img.style.height = "1px";
+  img.style.width = "1px";
+  img.style.margin = "-1px";
+  img.style.border = "0";
+  img.style.position = "absolute";
+  img.style.top = "0";
+  return document.body.appendChild(img);
+}
+var toFinite = toFinite_1;
+function toInteger$1(value) {
+  var result = toFinite(value), remainder = result % 1;
+  return result === result ? remainder ? result - remainder : result : 0;
+}
+var toInteger_1 = toInteger$1;
+var root = _root, toInteger = toInteger_1, toNumber = toNumber_1, toString = toString_1;
+var nativeIsFinite = root.isFinite, nativeMin = Math.min;
+function createRound$1(methodName) {
+  var func = Math[methodName];
+  return function(number, precision) {
+    number = toNumber(number);
+    precision = precision == null ? 0 : nativeMin(toInteger(precision), 292);
+    if (precision && nativeIsFinite(number)) {
+      var pair = (toString(number) + "e").split("e"), value = func(pair[0] + "e" + (+pair[1] + precision));
+      pair = (toString(value) + "e").split("e");
+      return +(pair[0] + "e" + (+pair[1] - precision));
+    }
+    return func(number);
+  };
+}
+var _createRound = createRound$1;
+var createRound = _createRound;
+var round = createRound("round");
+var round_1 = round;
+const round$1 = /* @__PURE__ */ getDefaultExportFromCjs(round_1);
+function useViewabilityObserver({ context, ad, name, element }) {
+  let timeoutId = null;
+  const {
+    threshold,
+    duration,
+    rootMargin
+  } = {
+    threshold: 0.2,
+    duration: 1e3,
+    rootMargin: "0px",
+    ...context.options.viewabilityTrackingOptions
+  };
+  const trackingPixel = runtimeCore.ref(null);
+  const isTracked = runtimeCore.computed(() => Boolean(trackingPixel.value));
+  const viewabilityObserver = new IntersectionObserver(([entry]) => {
+    if (context.options.viewabilityTracking && !trackingPixel.value && ad) {
+      const ratio = round$1(entry.intersectionRatio, 1);
+      if (ratio >= threshold && !timeoutId) {
+        timeoutId = setTimeout(() => {
+          var _a, _b, _c;
+          timeoutId = null;
+          if ((_a = ad.value) == null ? void 0 : _a.viewableImpressionCounter) {
+            trackingPixel.value = addTrackingPixel(ad.value.viewableImpressionCounter);
+            logger.debug(`Viewability tracking pixel fired for ${name.value}`);
+            (_c = context.events) == null ? void 0 : _c.changeSlots.dispatch(Array.from(((_b = context.getAll) == null ? void 0 : _b.call(context)) ?? []));
+          }
+        }, duration);
+      } else if (ratio < threshold && timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+    }
+  }, {
+    rootMargin,
+    threshold: Array.from({ length: 11 }, (_, i) => i * 0.1)
+  });
+  function observe(newElement, oldElement) {
+    if (oldElement)
+      viewabilityObserver.unobserve(oldElement);
+    if (newElement && context.options.viewabilityTracking)
+      viewabilityObserver.observe(newElement);
+    return () => {
+      if (newElement)
+        viewabilityObserver.unobserve(newElement);
+    };
+  }
+  runtimeCore.watch(element, observe);
+  observe(element.value);
+  return [isTracked, () => {
+    var _a;
+    (_a = trackingPixel.value) == null ? void 0 : _a.remove();
+    viewabilityObserver.disconnect();
+  }];
+}
+function useRenderIntersectionObserver({ ad, options, element, render }) {
+  var _a;
+  const isInViewport = runtimeCore.ref(false);
+  const renderIntersectionObserver = new IntersectionObserver((entries) => {
+    isInViewport.value = entries.some((entry) => entry.isIntersecting);
+    if (isInViewport.value) {
+      (async () => {
+        if (!ad.value && options.lazyLoading)
+          await render();
+        await render(ad.value ?? void 0);
+      })().catch(logger.error);
+    }
+  }, {
+    rootMargin: ((_a = options.lazyLoadingOptions) == null ? void 0 : _a.rootMargin) ?? "200px",
+    threshold: 0
+  });
+  function observe(newElement, oldElement) {
+    if (oldElement)
+      renderIntersectionObserver.unobserve(oldElement);
+    if (newElement)
+      renderIntersectionObserver.observe(newElement);
+    return () => {
+      if (newElement)
+        renderIntersectionObserver.unobserve(newElement);
+    };
+  }
+  runtimeCore.watch(element, observe);
+  observe(element.value);
+  return [isInViewport, () => {
+    renderIntersectionObserver.disconnect();
+  }];
+}
+const renderFunctions = {
+  iframe: renderIframe,
+  inline: renderInline
+};
+function createSlot(options) {
+  const scope = runtimeCore.effectScope();
+  return scope.run(() => {
+    const {
+      containingElement,
+      slot,
+      context,
+      renderMode = "iframe"
+    } = options;
+    const parameters = runtimeCore.reactive(new Map(Object.entries(options.parameters ?? {})));
+    let queryDetector = null;
+    if (typeof options.format !== "string") {
+      queryDetector = createQueryDetector({
+        onChange: onQueryChange,
+        queries: Object.fromEntries(options.format.map((item) => [item.format, item.query]))
+      });
+    }
+    const format = runtimeCore.ref(queryDetector ? queryDetector.getQuery() : options.format);
+    function onQueryChange(newFormat) {
+      format.value = newFormat;
+    }
+    const ad = runtimeCore.ref(null);
+    const originalAd = runtimeCore.ref(ad.value);
+    const name = runtimeCore.computed(() => generateName(context.location, format.value, slot));
+    runtimeCore.watch(name, async (newName, oldName) => {
+      var _a;
+      if (newName === oldName)
+        return;
+      (_a = options.onNameChange) == null ? void 0 : _a.call(options, newName, oldName);
+      const newAd = await requestAd$1();
+      cleanElement();
+      ad.value = newAd;
+      originalAd.value = newAd;
+    });
+    const isDomLoaded = useDomLoaded();
+    const element = runtimeCore.computed(
+      () => {
+        if (!(typeof containingElement === "string" || !containingElement))
+          return containingElement;
+        if (!isDomLoaded.value)
+          return null;
+        return document.querySelector(`.adunit[data-format="${format.value}"]#${containingElement}${slot ? `[data-slot="${slot}"]` : ""}`);
+      }
+    );
+    function getElement() {
+      var _a, _b;
+      if (renderMode === "iframe")
+        return ((_a = element.value) == null ? void 0 : _a.querySelector("iframe")) ?? null;
+      return ((_b = element.value) == null ? void 0 : _b.innerHTML) ? element.value.firstElementChild : null;
+    }
+    const [isInViewport, disposeRenderIntersectionObserver] = useRenderIntersectionObserver({
+      ad,
+      options,
+      element,
+      render
+    });
+    runtimeCore.watch([ad, isInViewport], async ([newAd, newIsInViewport], [oldAd]) => {
+      var _a, _b;
+      if (!newAd || isEqual$1(newAd, oldAd))
+        return;
+      if (newIsInViewport || context.options.eagerRendering)
+        await render(newAd);
+      (_b = context.events) == null ? void 0 : _b.changeSlots.dispatch(Array.from(((_a = context.getAll) == null ? void 0 : _a.call(context)) ?? []));
+    });
+    const [
+      isViewabilityTracked,
+      disposeViewabilityObserver
+    ] = useViewabilityObserver({
+      context,
+      ad,
+      name,
+      element
+    });
+    const impressionTrackingPixelElement = runtimeCore.ref(null);
+    const isImpressionTracked = runtimeCore.computed(() => Boolean(impressionTrackingPixelElement.value));
+    async function requestAd$1() {
+      const response = await requestAd({
+        slot: {
+          name: name.value,
+          parameters
+        },
+        context
+      });
+      originalAd.value = response;
+      return response;
+    }
+    async function render(adToRender) {
+      var _a, _b;
+      await waitForDomLoad();
+      await waitOnInit;
+      const renderAd = adToRender ?? ad.value ?? await requestAd$1();
+      if (originalAd.value) {
+        ad.value = ((_a = options.onBeforeRender) == null ? void 0 : _a.call(options, adToRender ?? originalAd.value)) ?? renderAd;
+      }
+      if (!element.value) {
+        const error = `Could not create slot for format ${format.value}. No element found.`;
+        logger.error(error, options);
+        throw new Error(error);
+      }
+      if (context.debug)
+        element.value.style.position = "relative";
+      if (context.safeFrame && ad.value && renderMode === "iframe") {
+        const position = context.safeFrame.addPosition(ad.value, element.value);
+        await context.safeFrame.render(position);
+      } else {
+        renderFunctions[renderMode](renderAd, element.value);
+      }
+      if (renderAd.impressionCounter && !impressionTrackingPixelElement.value) {
+        impressionTrackingPixelElement.value = addTrackingPixel(renderAd.impressionCounter);
+        logger.debug(`Impression tracking pixel fired for ${name.value}`);
+      }
+      logger.debug("Slot rendered", {
+        renderedElement: element,
+        location: context.location,
+        format,
+        containingElement
+      });
+      (_b = options.onRender) == null ? void 0 : _b.call(options, element.value);
+      disposeRenderIntersectionObserver();
+      return element.value;
+    }
+    function cleanElement() {
+      if (!element.value)
+        return;
+      element.value.innerHTML = "";
+      element.value.style.position = "";
+      element.value.style.width = "";
+      element.value.style.height = "";
+    }
+    function dispose() {
+      var _a, _b;
+      cleanElement();
+      (_a = impressionTrackingPixelElement.value) == null ? void 0 : _a.remove();
+      ad.value = null;
+      disposeRenderIntersectionObserver();
+      disposeViewabilityObserver();
+      (_b = options.onDispose) == null ? void 0 : _b.call(options);
+      queryDetector == null ? void 0 : queryDetector.dispose();
+      scope.stop();
+    }
+    return {
+      location: context.location,
+      lazyLoading: options.lazyLoading ?? false,
+      slot,
+      parameters,
+      format,
+      name,
+      ad,
+      isViewabilityTracked,
+      isImpressionTracked,
+      render,
+      getElement,
+      dispose
+    };
+  });
+}
+function useDomLoaded() {
+  const isDomLoaded = runtimeCore.ref(false);
+  onInit(async () => {
+    await waitForDomLoad();
+    isDomLoaded.value = true;
+  });
+  return isDomLoaded;
+}
+const numberLike = zod.union([zod.coerce.string().regex(/^\d+$/), zod.literal("")]).transform((value) => value === "" ? void 0 : Number(value));
+const booleanLike = zod.union([zod.coerce.boolean(), zod.literal("")]);
+const urlLike = zod.union([zod.coerce.string(), zod.literal("")]).transform((value) => {
+  try {
+    return new URL(value);
+  } catch {
+    return void 0;
+  }
+});
+const dateLike = zod.union([zod.coerce.string(), zod.literal("")]).transform((value) => {
+  if (value === "")
+    return void 0;
+  const date = new Date(numberLike.safeParse(value).success ? Number(value) : value);
+  if (Number.isNaN(date.getTime()))
+    return void 0;
+  return date;
+});
+const cssValueLike = zod.union([zod.coerce.string(), zod.literal(""), zod.number()]).transform((value) => {
+  if (value === "" || value === 0 || value === "0")
+    return void 0;
+  if (numberLike.parse(value))
+    return `${numberLike.parse(value)}px`;
+  return String(value);
+});
+const isJson = zod.string().transform((value, { addIssue }) => {
+  try {
+    return JSON.parse(value.replaceAll("'", '"'));
+  } catch (error) {
+    addIssue({
+      code: zod.ZodIssueCode.custom,
+      message: `Invalid JSON: ${error.message}`
+    });
+    return zod.NEVER;
+  }
+});
+const isHtmlString = zod.string().transform((value, { addIssue }) => {
+  var _a;
+  const htmlParser = new DOMParser();
+  try {
+    const html = htmlParser.parseFromString(value, "text/html");
+    if (((_a = html.body) == null ? void 0 : _a.children.length) === 0)
+      throw new Error("Invalid HTML");
+    return value;
+  } catch (error) {
+    addIssue({
+      code: zod.ZodIssueCode.custom,
+      message: error.message
+    });
+    return zod.NEVER;
+  }
+});
+const isJsonOrHtmlString = zod.union([isJson, isHtmlString]);
+const isJsonOrHtmlOptionalString = zod.union([zod.coerce.string(), isJsonOrHtmlString]).transform((value) => {
+  if (value === "")
+    return void 0;
+  return value;
+}).optional();
+const baseSchema = zod.object({
+  adDuration: numberLike.optional(),
+  adFormat: zod.string().optional(),
+  adType: zod.string(),
+  additionalCreativeTracker: urlLike.optional(),
+  additionalViewableTracker: zod.string().optional(),
+  adspaceEnd: dateLike.optional(),
+  adspaceId: zod.string().optional(),
+  adspaceKey: zod.string().optional(),
+  adspaceStart: dateLike.optional(),
+  advertiserId: zod.string().optional(),
+  altText: zod.string().optional(),
+  auctionable: booleanLike.optional(),
+  body: isJsonOrHtmlOptionalString,
+  clickTag: urlLike.optional(),
+  comment: zod.string().optional(),
+  creativeName: zod.string().optional(),
+  deliveryGroupId: zod.string().optional(),
+  deliveryMultiples: zod.string().optional(),
+  ext: zod.string().optional(),
+  extension: zod.object({
+    mediaType: zod.string(),
+    prebid: zod.unknown().optional()
+  }).optional(),
+  height: numberLike.optional(),
+  id: zod.string(),
+  impressionCounter: urlLike.optional(),
+  libId: zod.string().optional(),
+  orderId: zod.string().optional(),
+  orderName: zod.string().optional(),
+  orderProperty: zod.string().optional(),
+  origin: zod.union([zod.literal("JERLICIA"), zod.literal("DALE")]),
+  originData: zod.unknown().optional(),
+  originInstance: zod.string().optional(),
+  poolPath: urlLike.optional(),
+  preview: booleanLike.optional(),
+  priority: numberLike.optional(),
+  sfSrc: urlLike.optional(),
+  share: zod.string().optional(),
+  // eslint-disable-next-line ts/naming-convention
+  slotID: zod.string(),
+  slotName: zod.string(),
+  swfSrc: urlLike.optional(),
+  tag: isJsonOrHtmlOptionalString,
+  tagUrl: urlLike.optional(),
+  timeStamp: dateLike.optional(),
+  trackedImpressionCounter: urlLike.optional(),
+  tracker: urlLike.optional(),
+  trackingUrl: urlLike.optional(),
+  url: urlLike.optional(),
+  viewableImpressionCounter: urlLike.optional(),
+  width: numberLike.optional(),
+  widthLarge: cssValueLike.optional()
+});
+const jerliciaSchema = zod.object({
+  origin: zod.literal("JERLICIA"),
+  tag: isJsonOrHtmlString
+}).passthrough();
+const daleSchema = zod.object({
+  origin: zod.literal("DALE"),
+  body: isJsonOrHtmlString
+}).passthrough().transform(({ body, ...data }) => ({
+  ...data,
+  tag: body
+}));
+const adResponseSchema = baseSchema.extend({
+  additionalCreatives: zod.lazy(() => zod.union([adResponseSchema.array(), zod.string()]).optional())
+});
+const adSchema = adResponseSchema.transform(({
+  additionalCreatives,
+  ...data
+}) => {
+  const filteredValue = Object.fromEntries(
+    Object.entries(data).filter(([, value]) => Boolean(value) && JSON.stringify(value) !== "{}" && JSON.stringify(value) !== "[]")
+  );
+  return {
+    ...filteredValue,
+    additionalCreatives: Array.isArray(additionalCreatives) ? additionalCreatives.map((creative) => adSchema.parse(creative)) : additionalCreatives
+  };
+});
+function parseResponse(response) {
+  const schemaMap = {
+    /* eslint-disable ts/naming-convention */
+    JERLICIA: jerliciaSchema,
+    DALE: daleSchema
+    /* eslint-enable ts/naming-convention */
+  };
+  const preParsed = adResponseSchema.array().parse(response);
+  return preParsed.map((item) => {
+    const schema = schemaMap[item.origin];
+    if (!schema)
+      return adSchema.parse(item);
+    return schema.parse(item);
+  });
+}
+async function requestPreviews(account) {
+  const previewObjects = getPreviewObjects();
+  const list = (await Promise.allSettled(previewObjects.filter((previewObject) => "adhesePreviewCreativeId" in previewObject).map(async (previewObject) => {
+    const endpoint = new URL(`https://${account}-preview.adhese.org/creatives/preview/json/tag.do`);
+    endpoint.searchParams.set(
+      "id",
+      previewObject.adhesePreviewCreativeId
+    );
+    const response = await fetch(endpoint.href, {
+      method: "GET",
+      headers: {
+        accept: "application/json"
+      }
+    });
+    if (!response.ok)
+      return Promise.reject(new Error(`Failed to request preview ad with ID: ${previewObject.adhesePreviewCreativeId}`));
+    return await response.json();
+  }))).filter((response) => {
+    if (response.status === "rejected") {
+      logger.error(response.reason);
+      return false;
+    }
+    return response.status === "fulfilled";
+  }).map((response) => response.value.map((item) => ({
+    ...item,
+    preview: true
+  })));
+  return adSchema.array().parse(list.flat());
+}
+function getPreviewObjects() {
+  const currentUrl = new URL(window.location.href);
+  const previewObjects = [];
+  let currentObject = {};
+  for (const [key, value] of currentUrl.searchParams.entries()) {
+    if (key === "adhesePreviewCreativeId" && Object.keys(currentObject).length > 0) {
+      previewObjects.push(currentObject);
+      currentObject = {};
+    }
+    currentObject[key] = value;
+  }
+  if (Object.keys(currentObject).length > 0)
+    previewObjects.push(currentObject);
+  return previewObjects;
+}
+function requestWithPost({
+  context: { options: { host }, parameters },
+  ...options
+}) {
+  const payload = {
+    ...options,
+    slots: options.slots.map((slot) => ({
+      slotname: runtimeCore.toValue(slot.name),
+      parameters: parseParameters(slot.parameters)
+    })),
+    parameters: parameters && parseParameters(parameters)
+  };
+  return fetch(`${new URL(host).href}json`, {
+    method: "POST",
+    body: JSON.stringify(payload),
+    headers: {
+      // eslint-disable-next-line ts/naming-convention
+      "Content-Type": "application/json"
+    }
+  });
+}
+async function requestWithGet({ context, slots }) {
+  return fetch(new URL(`${context.options.host}/json/sl${slots.map((slot) => runtimeCore.toValue(slot.name)).join("/sl")}`), {
+    method: "GET",
+    headers: {
+      // eslint-disable-next-line ts/naming-convention
+      "Content-Type": "application/json"
+    }
+  });
+}
+function parseParameters(parameters) {
+  return Object.fromEntries(Array.from(parameters.entries()).filter(([key]) => {
+    if (key.length === 2)
+      return true;
+    logger.warn(`Invalid parameter key: ${key}. Key should be exactly 2 characters long. Key will be ignored.`);
+    return false;
+  }));
+}
+async function requestAds(options) {
+  var _a, _b, _c, _d, _e;
+  const { context } = options;
+  try {
+    (_a = context.events) == null ? void 0 : _a.requestAd.dispatch({
+      ...options,
+      context
+    });
+    const [response, previews] = await Promise.all([((_b = context.options.requestType) == null ? void 0 : _b.toUpperCase()) === "POST" ? requestWithPost(options) : requestWithGet(options), requestPreviews(context.options.account)]);
+    logger.debug("Received response", response);
+    if (!response.ok)
+      throw new Error(`Failed to request ad: ${response.status} ${response.statusText}`);
+    const result = parseResponse(await response.json());
+    logger.debug("Parsed ad", result);
+    if (previews.length > 0)
+      logger.info(`Found ${previews.length} ${previews.length === 1 ? "preview" : "previews"}. Replacing ads in response with preview items`, previews);
+    const matchedPreviews = previews.map(({ slotName, ...preview }) => {
+      const partnerAd = result.find((ad) => ad.libId === preview.libId);
+      return {
+        slotName: `${(partnerAd == null ? void 0 : partnerAd.slotName) ?? slotName}`,
+        ...preview
+      };
+    });
+    if (matchedPreviews.length > 0)
+      (_c = context.events) == null ? void 0 : _c.previewReceived.dispatch(matchedPreviews);
+    const mergedResult = [
+      ...result.filter((ad) => !previews.some((preview) => preview.libId === ad.libId)),
+      ...matchedPreviews
+    ];
+    if (mergedResult.length === 0)
+      throw new Error("No ads found");
+    (_d = context.events) == null ? void 0 : _d.responseReceived.dispatch(mergedResult);
+    return mergedResult;
+  } catch (error) {
+    logger.error(String(error));
+    (_e = context.events) == null ? void 0 : _e.requestError.dispatch(error);
+    throw error;
+  }
+}
+async function requestAd({
+  slot,
+  ...options
+}) {
+  const [ad] = await requestAds({
+    slots: [slot],
+    ...options
+  });
+  return ad;
+}
+exports.createAdhese = createAdhese;
+//# sourceMappingURL=index.cjs.map