@builder.io/sdk-solid 0.5.9 → 0.6.1

package/lib/browser/index.js

@@ -0,0 +1,4767 @@
+import { delegateEvents, createComponent, spread, mergeProps, insert, effect, setAttribute, className, style, template, memo, Dynamic, use } from 'solid-js/web';
+import { createContext, Show, useContext, For, createSignal, onMount, createEffect, on } from 'solid-js';
+import { css } from 'solid-styled-components';
+
+// src/blocks/button/button.jsx
+var _tmpl$ = /* @__PURE__ */ template(`<a role="button">`);
+var _tmpl$2 = /* @__PURE__ */ template(`<button>`);
+function Button(props) {
+  return createComponent(Show, {
+    get fallback() {
+      return (() => {
+        const _el$2 = _tmpl$2();
+        spread(_el$2, mergeProps({
+          get ["class"]() {
+            return props.attributes.class + " " + css({
+              all: "unset"
+            });
+          }
+        }, {}, () => props.attributes, {
+          get style() {
+            return props.attributes.style;
+          }
+        }), false, true);
+        insert(_el$2, () => props.text);
+        return _el$2;
+      })();
+    },
+    get when() {
+      return props.link;
+    },
+    get children() {
+      const _el$ = _tmpl$();
+      spread(_el$, mergeProps({}, () => props.attributes, {
+        get href() {
+          return props.link;
+        },
+        get target() {
+          return props.openLinkInNewTab ? "_blank" : void 0;
+        }
+      }), false, true);
+      insert(_el$, () => props.text);
+      return _el$;
+    }
+  });
+}
+var button_default = Button;
+
+// src/functions/fast-clone.js
+var fastClone = (obj) => JSON.parse(JSON.stringify(obj));
+
+// src/constants/device-sizes.js
+var SIZES = {
+  small: {
+    min: 320,
+    default: 321,
+    max: 640
+  },
+  medium: {
+    min: 641,
+    default: 642,
+    max: 991
+  },
+  large: {
+    min: 990,
+    default: 991,
+    max: 1200
+  }
+};
+var getMaxWidthQueryForSize = (size, sizeValues = SIZES) => `@media (max-width: ${sizeValues[size].max}px)`;
+var getSizesForBreakpoints = ({
+  small,
+  medium
+}) => {
+  const newSizes = fastClone(SIZES);
+  if (!small || !medium) {
+    return newSizes;
+  }
+  const smallMin = Math.floor(small / 2);
+  newSizes.small = {
+    max: small,
+    min: smallMin,
+    default: smallMin + 1
+  };
+  const mediumMin = newSizes.small.max + 1;
+  newSizes.medium = {
+    max: medium,
+    min: mediumMin,
+    default: mediumMin + 1
+  };
+  const largeMin = newSizes.medium.max + 1;
+  newSizes.large = {
+    max: 2e3,
+    min: largeMin,
+    default: largeMin + 1
+  };
+  return newSizes;
+};
+
+// src/constants/target.js
+var TARGET = "solid";
+
+// src/helpers/logger.js
+var logger = {
+  log: (...message) => void 0,
+  error: (...message) => void 0,
+  warn: (...message) => void 0,
+  debug: (...message) => void 0
+};
+
+// src/functions/is-browser.js
+function isBrowser() {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+
+// src/functions/is-iframe.js
+function isIframe() {
+  return isBrowser() && window.self !== window.top;
+}
+
+// src/functions/is-editing.js
+function isEditing() {
+  return isIframe() && (TARGET === "reactNative" || window.location.search.indexOf("builder.frameEditing=") !== -1);
+}
+
+// src/functions/track/helpers.js
+var getLocation = () => {
+  if (TARGET === "reactNative") {
+    return null;
+  } else if (isBrowser()) {
+    const parsedLocation = new URL(location.href);
+    if (parsedLocation.pathname === "") {
+      parsedLocation.pathname = "/";
+    }
+    return parsedLocation;
+  } else {
+    return null;
+  }
+};
+var getUserAgent = () => typeof navigator === "object" && navigator.userAgent || "";
+var getUserAttributes = () => {
+  const userAgent = getUserAgent();
+  const isMobile = {
+    Android() {
+      return userAgent.match(/Android/i);
+    },
+    BlackBerry() {
+      return userAgent.match(/BlackBerry/i);
+    },
+    iOS() {
+      return userAgent.match(/iPhone|iPod/i);
+    },
+    Opera() {
+      return userAgent.match(/Opera Mini/i);
+    },
+    Windows() {
+      return userAgent.match(/IEMobile/i) || userAgent.match(/WPDesktop/i);
+    },
+    any() {
+      return isMobile.Android() || isMobile.BlackBerry() || isMobile.iOS() || isMobile.Opera() || isMobile.Windows() || TARGET === "reactNative";
+    }
+  };
+  const isTablet = userAgent.match(/Tablet|iPad/i);
+  const url = getLocation();
+  return {
+    urlPath: url == null ? void 0 : url.pathname,
+    host: (url == null ? void 0 : url.host) || (url == null ? void 0 : url.hostname),
+    device: isTablet ? "tablet" : isMobile.any() ? "mobile" : "desktop"
+  };
+};
+
+// src/functions/evaluate/helpers.js
+var getFunctionArguments = ({
+  builder,
+  context,
+  event,
+  state
+}) => {
+  return Object.entries({
+    state,
+    Builder: builder,
+    builder,
+    context,
+    event
+  });
+};
+
+// src/functions/evaluate/browser-runtime/browser.js
+var runInBrowser = ({
+  code,
+  builder,
+  context,
+  event,
+  localState,
+  rootSetState,
+  rootState
+}) => {
+  const functionArgs = getFunctionArguments({
+    builder,
+    context,
+    event,
+    state: flattenState(rootState, localState, rootSetState)
+  });
+  return new Function(...functionArgs.map(([name]) => name), code)(...functionArgs.map(([, value]) => value));
+};
+function flattenState(rootState, localState, rootSetState) {
+  if (rootState === localState) {
+    throw new Error("rootState === localState");
+  }
+  return new Proxy(rootState, {
+    get: (_, prop) => {
+      if (localState && prop in localState) {
+        return localState[prop];
+      }
+      return rootState[prop];
+    },
+    set: (_, prop, value) => {
+      if (localState && prop in localState) {
+        throw new Error("Writing to local state is not allowed as it is read-only.");
+      }
+      rootState[prop] = value;
+      rootSetState == null ? void 0 : rootSetState(rootState);
+      return true;
+    }
+  });
+}
+
+// src/functions/evaluate/evaluate.js
+function evaluate({
+  code,
+  context,
+  localState,
+  rootState,
+  rootSetState,
+  event,
+  isExpression = true
+}) {
+  if (code === "") {
+    logger.warn("Skipping evaluation of empty code block.");
+    return;
+  }
+  const builder = {
+    isEditing: isEditing(),
+    isBrowser: isBrowser(),
+    isServer: !isBrowser(),
+    getUserAttributes: () => getUserAttributes()
+  };
+  const useReturn = isExpression && !(code.includes(";") || code.includes(" return ") || code.trim().startsWith("return "));
+  const useCode = useReturn ? `return (${code});` : code;
+  const args = {
+    code: useCode,
+    builder,
+    context,
+    event,
+    rootSetState,
+    rootState,
+    localState
+  };
+  try {
+    return runInBrowser(args);
+  } catch (e) {
+    logger.error("Failed code evaluation: " + e.message, {
+      code
+    });
+    return void 0;
+  }
+}
+
+// src/functions/set.js
+var set = (obj, _path, value) => {
+  if (Object(obj) !== obj) {
+    return obj;
+  }
+  const path = Array.isArray(_path) ? _path : _path.toString().match(/[^.[\]]+/g);
+  path.slice(0, -1).reduce((a, c, i) => Object(a[c]) === a[c] ? a[c] : a[c] = Math.abs(Number(path[i + 1])) >> 0 === +path[i + 1] ? [] : {}, obj)[path[path.length - 1]] = value;
+  return obj;
+};
+
+// src/functions/transform-block.js
+function transformBlock(block) {
+  return block;
+}
+
+// src/functions/get-processed-block.js
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var evaluateBindings = ({
+  block,
+  context,
+  localState,
+  rootState,
+  rootSetState
+}) => {
+  if (!block.bindings) {
+    return block;
+  }
+  const copy = fastClone(block);
+  const copied = __spreadProps(__spreadValues({}, copy), {
+    properties: __spreadValues({}, copy.properties),
+    actions: __spreadValues({}, copy.actions)
+  });
+  for (const binding in block.bindings) {
+    const expression = block.bindings[binding];
+    const value = evaluate({
+      code: expression,
+      localState,
+      rootState,
+      rootSetState,
+      context
+    });
+    set(copied, binding, value);
+  }
+  return copied;
+};
+function getProcessedBlock({
+  block,
+  context,
+  shouldEvaluateBindings,
+  localState,
+  rootState,
+  rootSetState
+}) {
+  const transformedBlock = transformBlock(block);
+  if (shouldEvaluateBindings) {
+    return evaluateBindings({
+      block: transformedBlock,
+      localState,
+      rootState,
+      rootSetState,
+      context
+    });
+  } else {
+    return transformedBlock;
+  }
+}
+
+// src/functions/camel-to-kebab-case.js
+var camelToKebabCase = (string) => string.replace(/([a-z0-9]|(?=[A-Z]))([A-Z])/g, "$1-$2").toLowerCase();
+
+// src/helpers/nullable.js
+var checkIsDefined = (maybeT) => maybeT !== null && maybeT !== void 0;
+
+// src/helpers/css.js
+var convertStyleMapToCSSArray = (style) => {
+  const cssProps = Object.entries(style).map(([key, value]) => {
+    if (typeof value === "string") {
+      return `${camelToKebabCase(key)}: ${value};`;
+    } else {
+      return void 0;
+    }
+  });
+  return cssProps.filter(checkIsDefined);
+};
+var convertStyleMapToCSS = (style) => convertStyleMapToCSSArray(style).join("\n");
+var createCssClass = ({
+  mediaQuery,
+  className,
+  styles
+}) => {
+  const cssClass = `.${className} {
+    ${convertStyleMapToCSS(styles)}
+  }`;
+  if (mediaQuery) {
+    return `${mediaQuery} {
+      ${cssClass}
+    }`;
+  } else {
+    return cssClass;
+  }
+};
+var _tmpl$3 = /* @__PURE__ */ template(`<style>`);
+function InlinedStyles(props) {
+  return (() => {
+    const _el$ = _tmpl$3();
+    effect((_p$) => {
+      const _v$ = props.styles, _v$2 = props.id;
+      _v$ !== _p$._v$ && (_el$.innerHTML = _p$._v$ = _v$);
+      _v$2 !== _p$._v$2 && setAttribute(_el$, "id", _p$._v$2 = _v$2);
+      return _p$;
+    }, {
+      _v$: void 0,
+      _v$2: void 0
+    });
+    return _el$;
+  })();
+}
+var inlined_styles_default = InlinedStyles;
+
+// src/components/block/components/block-styles.jsx
+function BlockStyles(props) {
+  const [processedBlock, setProcessedBlock] = createSignal(getProcessedBlock({
+    block: props.block,
+    localState: props.context.localState,
+    rootState: props.context.rootState,
+    rootSetState: props.context.rootSetState,
+    context: props.context.context,
+    shouldEvaluateBindings: true
+  }));
+  function canShowBlock() {
+    if (checkIsDefined(processedBlock().hide)) {
+      return !processedBlock().hide;
+    }
+    if (checkIsDefined(processedBlock().show)) {
+      return processedBlock().show;
+    }
+    return true;
+  }
+  function css5() {
+    const styles = processedBlock().responsiveStyles;
+    const content = props.context.content;
+    const sizesWithUpdatedBreakpoints = getSizesForBreakpoints(content?.meta?.breakpoints || {});
+    const largeStyles = styles?.large;
+    const mediumStyles = styles?.medium;
+    const smallStyles = styles?.small;
+    const className = processedBlock().id;
+    if (!className) {
+      return "";
+    }
+    const largeStylesClass = largeStyles ? createCssClass({
+      className,
+      styles: largeStyles
+    }) : "";
+    const mediumStylesClass = mediumStyles ? createCssClass({
+      className,
+      styles: mediumStyles,
+      mediaQuery: getMaxWidthQueryForSize("medium", sizesWithUpdatedBreakpoints)
+    }) : "";
+    const smallStylesClass = smallStyles ? createCssClass({
+      className,
+      styles: smallStyles,
+      mediaQuery: getMaxWidthQueryForSize("small", sizesWithUpdatedBreakpoints)
+    }) : "";
+    return [largeStylesClass, mediumStylesClass, smallStylesClass].join(" ");
+  }
+  return createComponent(Show, {
+    get when() {
+      return memo(() => !!(TARGET !== "reactNative" && css5()))() && canShowBlock();
+    },
+    get children() {
+      return createComponent(inlined_styles_default, {
+        get styles() {
+          return css5();
+        }
+      });
+    }
+  });
+}
+var block_styles_default = BlockStyles;
+
+// src/functions/get-block-component-options.js
+var __defProp2 = Object.defineProperty;
+var __defProps2 = Object.defineProperties;
+var __getOwnPropDescs2 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols2 = Object.getOwnPropertySymbols;
+var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+var __propIsEnum2 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp2 = (obj, key, value) => key in obj ? __defProp2(obj, key, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __spreadValues2 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp2.call(b, prop))
+      __defNormalProp2(a, prop, b[prop]);
+  if (__getOwnPropSymbols2)
+    for (var prop of __getOwnPropSymbols2(b)) {
+      if (__propIsEnum2.call(b, prop))
+        __defNormalProp2(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps2 = (a, b) => __defProps2(a, __getOwnPropDescs2(b));
+function getBlockComponentOptions(block) {
+  var _a;
+  return __spreadProps2(__spreadValues2(__spreadValues2({}, (_a = block.component) == null ? void 0 : _a.options), block.options), {
+    builderBlock: block
+  });
+}
+
+// src/functions/sanitize-react-native-block-styles.js
+var __defProp3 = Object.defineProperty;
+var __defProps3 = Object.defineProperties;
+var __getOwnPropDescs3 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols3 = Object.getOwnPropertySymbols;
+var __hasOwnProp3 = Object.prototype.hasOwnProperty;
+var __propIsEnum3 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp3 = (obj, key, value) => key in obj ? __defProp3(obj, key, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __spreadValues3 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp3.call(b, prop))
+      __defNormalProp3(a, prop, b[prop]);
+  if (__getOwnPropSymbols3)
+    for (var prop of __getOwnPropSymbols3(b)) {
+      if (__propIsEnum3.call(b, prop))
+        __defNormalProp3(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps3 = (a, b) => __defProps3(a, __getOwnPropDescs3(b));
+var propertiesThatMustBeNumber = /* @__PURE__ */ new Set(["lineHeight"]);
+var displayValues = /* @__PURE__ */ new Set(["flex", "none"]);
+var normalizeNumber = (value) => {
+  if (Number.isNaN(value)) {
+    return void 0;
+  } else if (value < 0) {
+    return 0;
+  } else {
+    return value;
+  }
+};
+var sanitizeReactNativeBlockStyles = (styles) => {
+  return Object.keys(styles).reduce((acc, key) => {
+    const propertyValue = styles[key];
+    if (key === "display" && !displayValues.has(propertyValue)) {
+      return acc;
+    }
+    if (propertiesThatMustBeNumber.has(key) && typeof propertyValue !== "number") {
+      return acc;
+    }
+    if (typeof propertyValue === "string") {
+      const isPixelUnit = propertyValue.match(/^-?(\d*)(\.?)(\d*)*px$/);
+      if (isPixelUnit) {
+        const newValue = parseFloat(propertyValue);
+        const normalizedValue = normalizeNumber(newValue);
+        if (normalizedValue) {
+          return __spreadProps3(__spreadValues3({}, acc), {
+            [key]: normalizedValue
+          });
+        } else {
+          return acc;
+        }
+      } else if (propertyValue === "0") {
+        return __spreadProps3(__spreadValues3({}, acc), {
+          [key]: 0
+        });
+      }
+    }
+    return __spreadProps3(__spreadValues3({}, acc), {
+      [key]: propertyValue
+    });
+  }, {});
+};
+
+// src/functions/get-react-native-block-styles.js
+var __defProp4 = Object.defineProperty;
+var __getOwnPropSymbols4 = Object.getOwnPropertySymbols;
+var __hasOwnProp4 = Object.prototype.hasOwnProperty;
+var __propIsEnum4 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp4 = (obj, key, value) => key in obj ? __defProp4(obj, key, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __spreadValues4 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp4.call(b, prop))
+      __defNormalProp4(a, prop, b[prop]);
+  if (__getOwnPropSymbols4)
+    for (var prop of __getOwnPropSymbols4(b)) {
+      if (__propIsEnum4.call(b, prop))
+        __defNormalProp4(a, prop, b[prop]);
+    }
+  return a;
+};
+function getReactNativeBlockStyles({
+  block,
+  context,
+  blockStyles
+}) {
+  const responsiveStyles = block.responsiveStyles;
+  if (!responsiveStyles) {
+    return {};
+  }
+  const styles = __spreadValues4(__spreadValues4(__spreadValues4(__spreadValues4(__spreadValues4({}, context.inheritedStyles), responsiveStyles.large || {}), responsiveStyles.medium || {}), responsiveStyles.small || {}), blockStyles);
+  const newStyles = sanitizeReactNativeBlockStyles(styles);
+  return newStyles;
+}
+
+// src/functions/transform-block-properties.js
+function transformBlockProperties(properties) {
+  return properties;
+}
+
+// src/functions/get-block-properties.js
+var __defProp5 = Object.defineProperty;
+var __defProps4 = Object.defineProperties;
+var __getOwnPropDescs4 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols5 = Object.getOwnPropertySymbols;
+var __hasOwnProp5 = Object.prototype.hasOwnProperty;
+var __propIsEnum5 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp5 = (obj, key, value) => key in obj ? __defProp5(obj, key, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __spreadValues5 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp5.call(b, prop))
+      __defNormalProp5(a, prop, b[prop]);
+  if (__getOwnPropSymbols5)
+    for (var prop of __getOwnPropSymbols5(b)) {
+      if (__propIsEnum5.call(b, prop))
+        __defNormalProp5(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps4 = (a, b) => __defProps4(a, __getOwnPropDescs4(b));
+var extractRelevantRootBlockProperties = (block) => {
+  return {
+    href: block.href
+  };
+};
+function getBlockProperties({
+  block,
+  context
+}) {
+  var _a;
+  const properties = __spreadProps4(__spreadValues5(__spreadValues5({}, extractRelevantRootBlockProperties(block)), block.properties), {
+    "builder-id": block.id,
+    style: block.style ? getStyleAttribute(block.style) : void 0,
+    class: [block.id, "builder-block", block.class, (_a = block.properties) == null ? void 0 : _a.class].filter(Boolean).join(" ")
+  });
+  if (TARGET === "reactNative") {
+    properties.style = getReactNativeBlockStyles({
+      block,
+      context,
+      blockStyles: properties.style
+    });
+  }
+  return transformBlockProperties(properties);
+}
+function getStyleAttribute(style) {
+  switch (TARGET) {
+    case "svelte":
+    case "vue2":
+    case "vue3":
+    case "solid":
+      return convertStyleMapToCSSArray(style).join(" ");
+    case "qwik":
+    case "reactNative":
+    case "react":
+    case "rsc":
+      return style;
+  }
+}
+
+// src/components/block/block.helpers.js
+var __defProp6 = Object.defineProperty;
+var __defProps5 = Object.defineProperties;
+var __getOwnPropDescs5 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols6 = Object.getOwnPropertySymbols;
+var __hasOwnProp6 = Object.prototype.hasOwnProperty;
+var __propIsEnum6 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp6 = (obj, key, value) => key in obj ? __defProp6(obj, key, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __spreadValues6 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp6.call(b, prop))
+      __defNormalProp6(a, prop, b[prop]);
+  if (__getOwnPropSymbols6)
+    for (var prop of __getOwnPropSymbols6(b)) {
+      if (__propIsEnum6.call(b, prop))
+        __defNormalProp6(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps5 = (a, b) => __defProps5(a, __getOwnPropDescs5(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp6.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols6)
+    for (var prop of __getOwnPropSymbols6(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum6.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var EMPTY_HTML_ELEMENTS = ["area", "base", "br", "col", "embed", "hr", "img", "input", "keygen", "link", "meta", "param", "source", "track", "wbr"];
+var isEmptyHtmlElement = (tagName) => {
+  return typeof tagName === "string" && EMPTY_HTML_ELEMENTS.includes(tagName.toLowerCase());
+};
+var getComponent = ({
+  block,
+  context,
+  registeredComponents
+}) => {
+  var _a;
+  const componentName = (_a = getProcessedBlock({
+    block,
+    localState: context.localState,
+    rootState: context.rootState,
+    rootSetState: context.rootSetState,
+    context: context.context,
+    shouldEvaluateBindings: false
+  }).component) == null ? void 0 : _a.name;
+  if (!componentName) {
+    return null;
+  }
+  const ref = registeredComponents[componentName];
+  if (!ref) {
+    return void 0;
+  } else {
+    return ref;
+  }
+};
+var getRepeatItemData = ({
+  block,
+  context
+}) => {
+  const _a = block, {
+    repeat
+  } = _a, blockWithoutRepeat = __objRest(_a, ["repeat"]);
+  if (!(repeat == null ? void 0 : repeat.collection)) {
+    return void 0;
+  }
+  const itemsArray = evaluate({
+    code: repeat.collection,
+    localState: context.localState,
+    rootState: context.rootState,
+    rootSetState: context.rootSetState,
+    context: context.context
+  });
+  if (!Array.isArray(itemsArray)) {
+    return void 0;
+  }
+  const collectionName = repeat.collection.split(".").pop();
+  const itemNameToUse = repeat.itemName || (collectionName ? collectionName + "Item" : "item");
+  const repeatArray = itemsArray.map((item, index) => ({
+    context: __spreadProps5(__spreadValues6({}, context), {
+      localState: __spreadProps5(__spreadValues6({}, context.localState), {
+        $index: index,
+        $item: item,
+        [itemNameToUse]: item,
+        [`$${itemNameToUse}Index`]: index
+      })
+    }),
+    block: blockWithoutRepeat
+  }));
+  return repeatArray;
+};
+var stdin_default = createContext({
+  content: null,
+  context: {},
+  localState: void 0,
+  rootSetState() {
+  },
+  rootState: {},
+  apiKey: null,
+  apiVersion: void 0,
+  componentInfos: {},
+  inheritedStyles: {}
+});
+
+// src/components/block/components/repeated-block.jsx
+function RepeatedBlock(props) {
+  const [store, setStore] = createSignal(props.repeatContext);
+  return createComponent(stdin_default.Provider, {
+    get value() {
+      return store();
+    },
+    get children() {
+      return createComponent(block_default, {
+        get block() {
+          return props.block;
+        },
+        get context() {
+          return store();
+        },
+        get registeredComponents() {
+          return props.registeredComponents;
+        }
+      });
+    }
+  });
+}
+var repeated_block_default = RepeatedBlock;
+
+// src/functions/event-handler-name.js
+function capitalizeFirstLetter(string) {
+  return string.charAt(0).toUpperCase() + string.slice(1);
+}
+var getEventHandlerName = (key) => `on${capitalizeFirstLetter(key)}`;
+
+// src/functions/get-block-actions-handler.js
+var createEventHandler = (value, options) => (event) => evaluate({
+  code: value,
+  context: options.context,
+  localState: options.localState,
+  rootState: options.rootState,
+  rootSetState: options.rootSetState,
+  event,
+  isExpression: false
+});
+
+// src/functions/get-block-actions.js
+function getBlockActions(options) {
+  var _a;
+  const obj = {};
+  const optionActions = (_a = options.block.actions) != null ? _a : {};
+  for (const key in optionActions) {
+    if (!optionActions.hasOwnProperty(key)) {
+      continue;
+    }
+    const value = optionActions[key];
+    let eventHandlerName = getEventHandlerName(key);
+    if (options.stripPrefix) {
+      switch (TARGET) {
+        case "vue2":
+        case "vue3":
+          eventHandlerName = eventHandlerName.replace("v-on:", "");
+          break;
+        case "svelte":
+          eventHandlerName = eventHandlerName.replace("on:", "");
+          break;
+      }
+    }
+    obj[eventHandlerName] = createEventHandler(value, options);
+  }
+  return obj;
+}
+
+// src/components/block/components/interactive-element.jsx
+function InteractiveElement(props) {
+  return createComponent(Dynamic, mergeProps(() => props.wrapperProps, {
+    get attributes() {
+      return {
+        ...getBlockProperties({
+          block: props.block,
+          context: props.context
+        }),
+        ...getBlockActions({
+          block: props.block,
+          rootState: props.context.rootState,
+          rootSetState: props.context.rootSetState,
+          localState: props.context.localState,
+          context: props.context.context
+        })
+      };
+    },
+    get component() {
+      return props.Wrapper;
+    },
+    get children() {
+      return props.children;
+    }
+  }));
+}
+var interactive_element_default = InteractiveElement;
+
+// src/components/block/components/component-ref/component-ref.helpers.js
+var __defProp7 = Object.defineProperty;
+var __getOwnPropSymbols7 = Object.getOwnPropertySymbols;
+var __hasOwnProp7 = Object.prototype.hasOwnProperty;
+var __propIsEnum7 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp7 = (obj, key, value) => key in obj ? __defProp7(obj, key, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __spreadValues7 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp7.call(b, prop))
+      __defNormalProp7(a, prop, b[prop]);
+  if (__getOwnPropSymbols7)
+    for (var prop of __getOwnPropSymbols7(b)) {
+      if (__propIsEnum7.call(b, prop))
+        __defNormalProp7(a, prop, b[prop]);
+    }
+  return a;
+};
+var getWrapperProps = ({
+  componentOptions,
+  builderBlock,
+  context,
+  componentRef,
+  includeBlockProps,
+  isInteractive,
+  contextValue
+}) => {
+  const interactiveElementProps = {
+    Wrapper: componentRef,
+    block: builderBlock,
+    context,
+    wrapperProps: componentOptions
+  };
+  return isInteractive ? interactiveElementProps : __spreadValues7(__spreadValues7({}, componentOptions), includeBlockProps ? {
+    attributes: getBlockProperties({
+      block: builderBlock,
+      context: contextValue
+    })
+  } : {});
+};
+
+// src/components/block/components/component-ref/component-ref.jsx
+function ComponentRef(props) {
+  const [Wrapper, setWrapper] = createSignal(props.isInteractive ? interactive_element_default : props.componentRef);
+  return createComponent(Show, {
+    get when() {
+      return props.componentRef;
+    },
+    get children() {
+      return createComponent(Dynamic, mergeProps(() => getWrapperProps({
+        componentOptions: props.componentOptions,
+        builderBlock: props.builderBlock,
+        context: props.context,
+        componentRef: props.componentRef,
+        includeBlockProps: props.includeBlockProps,
+        isInteractive: props.isInteractive,
+        contextValue: props.context
+      }), {
+        get component() {
+          return Wrapper();
+        },
+        get children() {
+          return [createComponent(For, {
+            get each() {
+              return props.blockChildren;
+            },
+            children: (child, _index) => {
+              _index();
+              return createComponent(block_default, {
+                get key() {
+                  return "block-" + child.id;
+                },
+                block: child,
+                get context() {
+                  return props.context;
+                },
+                get registeredComponents() {
+                  return props.registeredComponents;
+                }
+              });
+            }
+          }), createComponent(For, {
+            get each() {
+              return props.blockChildren;
+            },
+            children: (child, _index) => {
+              _index();
+              return createComponent(block_styles_default, {
+                get key() {
+                  return "block-style-" + child.id;
+                },
+                block: child,
+                get context() {
+                  return props.context;
+                }
+              });
+            }
+          })];
+        }
+      }));
+    }
+  });
+}
+var component_ref_default = ComponentRef;
+function BlockWrapper(props) {
+  return createComponent(Show, {
+    get fallback() {
+      return createComponent(Dynamic, mergeProps(() => getBlockProperties({
+        block: props.block,
+        context: props.context
+      }), () => getBlockActions({
+        block: props.block,
+        rootState: props.context.rootState,
+        rootSetState: props.context.rootSetState,
+        localState: props.context.localState,
+        context: props.context.context,
+        stripPrefix: true
+      }), {
+        get component() {
+          return props.Wrapper;
+        }
+      }));
+    },
+    get when() {
+      return props.hasChildren;
+    },
+    get children() {
+      return createComponent(Dynamic, mergeProps(() => getBlockProperties({
+        block: props.block,
+        context: props.context
+      }), () => getBlockActions({
+        block: props.block,
+        rootState: props.context.rootState,
+        rootSetState: props.context.rootSetState,
+        localState: props.context.localState,
+        context: props.context.context,
+        stripPrefix: true
+      }), {
+        get component() {
+          return props.Wrapper;
+        },
+        get children() {
+          return props.children;
+        }
+      }));
+    }
+  });
+}
+var block_wrapper_default = BlockWrapper;
+
+// src/components/block/block.jsx
+function Block(props) {
+  const [childrenContext, setChildrenContext] = createSignal(props.context);
+  function blockComponent() {
+    return getComponent({
+      block: props.block,
+      context: props.context,
+      registeredComponents: props.registeredComponents
+    });
+  }
+  function repeatItem() {
+    return getRepeatItemData({
+      block: props.block,
+      context: props.context
+    });
+  }
+  function processedBlock() {
+    return repeatItem() ? props.block : getProcessedBlock({
+      block: props.block,
+      localState: props.context.localState,
+      rootState: props.context.rootState,
+      rootSetState: props.context.rootSetState,
+      context: props.context.context,
+      shouldEvaluateBindings: true
+    });
+  }
+  function Tag() {
+    return props.block.tagName || "div";
+  }
+  function canShowBlock() {
+    if ("hide" in processedBlock()) {
+      return !processedBlock().hide;
+    }
+    if ("show" in processedBlock()) {
+      return processedBlock().show;
+    }
+    return true;
+  }
+  function childrenWithoutParentComponent() {
+    const shouldRenderChildrenOutsideRef = !blockComponent()?.component && !repeatItem();
+    return shouldRenderChildrenOutsideRef ? processedBlock().children ?? [] : [];
+  }
+  function componentRefProps() {
+    return {
+      blockChildren: processedBlock().children ?? [],
+      componentRef: blockComponent()?.component,
+      componentOptions: {
+        ...getBlockComponentOptions(processedBlock()),
+        builderContext: props.context,
+        ...blockComponent()?.name === "Symbol" || blockComponent()?.name === "Columns" ? {
+          builderComponents: props.registeredComponents
+        } : {}
+      },
+      context: childrenContext(),
+      registeredComponents: props.registeredComponents,
+      builderBlock: processedBlock(),
+      includeBlockProps: blockComponent()?.noWrap === true,
+      isInteractive: !blockComponent()?.isRSC
+    };
+  }
+  return createComponent(Show, {
+    get when() {
+      return canShowBlock();
+    },
+    get children() {
+      return createComponent(Show, {
+        get fallback() {
+          return createComponent(component_ref_default, mergeProps(componentRefProps));
+        },
+        get when() {
+          return !blockComponent()?.noWrap;
+        },
+        get children() {
+          return [createComponent(Show, {
+            get when() {
+              return isEmptyHtmlElement(Tag());
+            },
+            get children() {
+              return createComponent(block_wrapper_default, {
+                get Wrapper() {
+                  return Tag();
+                },
+                get block() {
+                  return processedBlock();
+                },
+                get context() {
+                  return props.context;
+                },
+                hasChildren: false
+              });
+            }
+          }), createComponent(Show, {
+            get when() {
+              return memo(() => !!!isEmptyHtmlElement(Tag()))() && repeatItem();
+            },
+            get children() {
+              return createComponent(For, {
+                get each() {
+                  return repeatItem();
+                },
+                children: (data, _index) => {
+                  const index = _index();
+                  return createComponent(repeated_block_default, {
+                    key: index,
+                    get repeatContext() {
+                      return data.context;
+                    },
+                    get block() {
+                      return data.block;
+                    },
+                    get registeredComponents() {
+                      return props.registeredComponents;
+                    }
+                  });
+                }
+              });
+            }
+          }), createComponent(Show, {
+            get when() {
+              return memo(() => !!!isEmptyHtmlElement(Tag()))() && !repeatItem();
+            },
+            get children() {
+              return createComponent(block_wrapper_default, {
+                get Wrapper() {
+                  return Tag();
+                },
+                get block() {
+                  return processedBlock();
+                },
+                get context() {
+                  return props.context;
+                },
+                hasChildren: true,
+                get children() {
+                  return [createComponent(component_ref_default, mergeProps(componentRefProps)), createComponent(For, {
+                    get each() {
+                      return childrenWithoutParentComponent();
+                    },
+                    children: (child, _index) => {
+                      _index();
+                      return createComponent(Block, {
+                        get key() {
+                          return "block-" + child.id;
+                        },
+                        block: child,
+                        get context() {
+                          return childrenContext();
+                        },
+                        get registeredComponents() {
+                          return props.registeredComponents;
+                        }
+                      });
+                    }
+                  }), createComponent(For, {
+                    get each() {
+                      return childrenWithoutParentComponent();
+                    },
+                    children: (child, _index) => {
+                      _index();
+                      return createComponent(block_styles_default, {
+                        get key() {
+                          return "block-style-" + child.id;
+                        },
+                        block: child,
+                        get context() {
+                          return childrenContext();
+                        }
+                      });
+                    }
+                  })];
+                }
+              });
+            }
+          })];
+        }
+      });
+    }
+  });
+}
+var block_default = Block;
+var _tmpl$4 = /* @__PURE__ */ template(`<div>`);
+function BlocksWrapper(props) {
+  function className() {
+    return "builder-blocks" + (!props.blocks?.length ? " no-blocks" : "");
+  }
+  function onClick() {
+    if (isEditing() && !props.blocks?.length) {
+      window.parent?.postMessage({
+        type: "builder.clickEmptyBlocks",
+        data: {
+          parentElementId: props.parent,
+          dataPath: props.path
+        }
+      }, "*");
+    }
+  }
+  function onMouseEnter() {
+    if (isEditing() && !props.blocks?.length) {
+      window.parent?.postMessage({
+        type: "builder.hoverEmptyBlocks",
+        data: {
+          parentElementId: props.parent,
+          dataPath: props.path
+        }
+      }, "*");
+    }
+  }
+  return (() => {
+    const _el$ = _tmpl$4();
+    spread(_el$, mergeProps({
+      get ["class"]() {
+        return className() + " " + css({
+          display: "flex",
+          flexDirection: "column",
+          alignItems: "stretch"
+        });
+      },
+      get ["builder-path"]() {
+        return props.path;
+      },
+      get ["builder-parent-id"]() {
+        return props.parent;
+      }
+    }, {}, {
+      get style() {
+        return props.styleProp;
+      },
+      "onClick": (event) => onClick(),
+      "onMouseEnter": (event) => onMouseEnter(),
+      "onKeyPress": (event) => onClick()
+    }), false, true);
+    insert(_el$, () => props.children);
+    return _el$;
+  })();
+}
+var blocks_wrapper_default = BlocksWrapper;
+var stdin_default2 = createContext({ registeredComponents: {} });
+
+// src/components/blocks/blocks.jsx
+function Blocks(props) {
+  const builderContext = useContext(stdin_default);
+  const componentsContext = useContext(stdin_default2);
+  return createComponent(blocks_wrapper_default, {
+    get blocks() {
+      return props.blocks;
+    },
+    get parent() {
+      return props.parent;
+    },
+    get path() {
+      return props.path;
+    },
+    get styleProp() {
+      return props.styleProp;
+    },
+    get children() {
+      return [createComponent(Show, {
+        get when() {
+          return props.blocks;
+        },
+        get children() {
+          return createComponent(For, {
+            get each() {
+              return props.blocks;
+            },
+            children: (block, _index) => {
+              _index();
+              return createComponent(block_default, {
+                get key() {
+                  return "render-block-" + block.id;
+                },
+                block,
+                get context() {
+                  return props.context || builderContext;
+                },
+                get registeredComponents() {
+                  return props.registeredComponents || componentsContext.registeredComponents;
+                }
+              });
+            }
+          });
+        }
+      }), createComponent(Show, {
+        get when() {
+          return props.blocks;
+        },
+        get children() {
+          return createComponent(For, {
+            get each() {
+              return props.blocks;
+            },
+            children: (block, _index) => {
+              _index();
+              return createComponent(block_styles_default, {
+                get key() {
+                  return "block-style-" + block.id;
+                },
+                block,
+                get context() {
+                  return props.context || builderContext;
+                }
+              });
+            }
+          });
+        }
+      })];
+    }
+  });
+}
+var blocks_default = Blocks;
+
+// src/blocks/columns/columns.jsx
+var _tmpl$5 = /* @__PURE__ */ template(`<div>`);
+function Columns(props) {
+  const [gutterSize, setGutterSize] = createSignal(typeof props.space === "number" ? props.space || 0 : 20);
+  const [cols, setCols] = createSignal(props.columns || []);
+  const [stackAt, setStackAt] = createSignal(props.stackColumnsAt || "tablet");
+  const [flexDir, setFlexDir] = createSignal(props.stackColumnsAt === "never" ? "row" : props.reverseColumnsWhenStacked ? "column-reverse" : "column");
+  function getWidth(index) {
+    return cols()[index]?.width || 100 / cols().length;
+  }
+  function getColumnCssWidth(index) {
+    const subtractWidth = gutterSize() * (cols().length - 1) / cols().length;
+    return `calc(${getWidth(index)}% - ${subtractWidth}px)`;
+  }
+  function getTabletStyle({
+    stackedStyle,
+    desktopStyle
+  }) {
+    return stackAt() === "tablet" ? stackedStyle : desktopStyle;
+  }
+  function getMobileStyle({
+    stackedStyle,
+    desktopStyle
+  }) {
+    return stackAt() === "never" ? desktopStyle : stackedStyle;
+  }
+  function columnsCssVars() {
+    return {
+      "--flex-dir": flexDir(),
+      "--flex-dir-tablet": getTabletStyle({
+        stackedStyle: flexDir(),
+        desktopStyle: "row"
+      })
+    };
+  }
+  function columnCssVars(index) {
+    const gutter = index === 0 ? 0 : gutterSize();
+    const width = getColumnCssWidth(index);
+    const gutterPixels = `${gutter}px`;
+    const mobileWidth = "100%";
+    const mobileMarginLeft = 0;
+    const marginLeftKey = "margin-left";
+    return {
+      width,
+      [marginLeftKey]: gutterPixels,
+      "--column-width-mobile": getMobileStyle({
+        stackedStyle: mobileWidth,
+        desktopStyle: width
+      }),
+      "--column-margin-left-mobile": getMobileStyle({
+        stackedStyle: mobileMarginLeft,
+        desktopStyle: gutterPixels
+      }),
+      "--column-width-tablet": getTabletStyle({
+        stackedStyle: mobileWidth,
+        desktopStyle: width
+      }),
+      "--column-margin-left-tablet": getTabletStyle({
+        stackedStyle: mobileMarginLeft,
+        desktopStyle: gutterPixels
+      })
+    };
+  }
+  function getWidthForBreakpointSize(size) {
+    const breakpointSizes = getSizesForBreakpoints(props.builderContext.content?.meta?.breakpoints || {});
+    return breakpointSizes[size].max;
+  }
+  function columnsStyles() {
+    return `
+        @media (max-width: ${getWidthForBreakpointSize("medium")}px) {
+          .${props.builderBlock.id}-breakpoints {
+            flex-direction: var(--flex-dir-tablet);
+            align-items: stretch;
+          }
+
+          .${props.builderBlock.id}-breakpoints > .builder-column {
+            width: var(--column-width-tablet) !important;
+            margin-left: var(--column-margin-left-tablet) !important;
+          }
+        }
+
+        @media (max-width: ${getWidthForBreakpointSize("small")}px) {
+          .${props.builderBlock.id}-breakpoints {
+            flex-direction: var(--flex-dir);
+            align-items: stretch;
+          }
+
+          .${props.builderBlock.id}-breakpoints > .builder-column {
+            width: var(--column-width-mobile) !important;
+            margin-left: var(--column-margin-left-mobile) !important;
+          }
+        },
+      `;
+  }
+  return (() => {
+    const _el$ = _tmpl$5();
+    spread(_el$, mergeProps({
+      get ["class"]() {
+        return `builder-columns ${props.builderBlock.id}-breakpoints ` + css({
+          display: "flex",
+          lineHeight: "normal"
+        });
+      },
+      get style() {
+        return columnsCssVars();
+      }
+    }, {}), false, true);
+    insert(_el$, createComponent(Show, {
+      when: TARGET !== "reactNative",
+      get children() {
+        return createComponent(inlined_styles_default, {
+          get styles() {
+            return columnsStyles();
+          }
+        });
+      }
+    }), null);
+    insert(_el$, createComponent(For, {
+      get each() {
+        return props.columns;
+      },
+      children: (column, _index) => {
+        const index = _index();
+        return (() => {
+          const _el$2 = _tmpl$5();
+          spread(_el$2, mergeProps({
+            get ["class"]() {
+              return "builder-column " + css({
+                display: "flex",
+                flexDirection: "column",
+                alignItems: "stretch"
+              });
+            },
+            get style() {
+              return columnCssVars(index);
+            }
+          }, {}, {
+            "key": index
+          }), false, true);
+          insert(_el$2, createComponent(blocks_default, {
+            path: `component.options.columns.${index}.blocks`,
+            get parent() {
+              return props.builderBlock.id;
+            },
+            styleProp: {
+              flexGrow: "1"
+            },
+            get context() {
+              return props.builderContext;
+            },
+            get registeredComponents() {
+              return props.builderComponents;
+            },
+            get blocks() {
+              return column.blocks;
+            }
+          }));
+          return _el$2;
+        })();
+      }
+    }), null);
+    return _el$;
+  })();
+}
+var columns_default = Columns;
+var _tmpl$6 = /* @__PURE__ */ template(`<span>`);
+function FragmentComponent(props) {
+  return (() => {
+    const _el$ = _tmpl$6();
+    insert(_el$, () => props.children);
+    return _el$;
+  })();
+}
+var fragment_default = FragmentComponent;
+
+// src/blocks/image/image.helpers.js
+function removeProtocol(path) {
+  return path.replace(/http(s)?:/, "");
+}
+function updateQueryParam(uri = "", key, value) {
+  const re = new RegExp("([?&])" + key + "=.*?(&|$)", "i");
+  const separator = uri.indexOf("?") !== -1 ? "&" : "?";
+  if (uri.match(re)) {
+    return uri.replace(re, "$1" + key + "=" + encodeURIComponent(value) + "$2");
+  }
+  return uri + separator + key + "=" + encodeURIComponent(value);
+}
+function getShopifyImageUrl(src, size) {
+  if (!src || !(src == null ? void 0 : src.match(/cdn\.shopify\.com/)) || !size) {
+    return src;
+  }
+  if (size === "master") {
+    return removeProtocol(src);
+  }
+  const match = src.match(/(_\d+x(\d+)?)?(\.(jpg|jpeg|gif|png|bmp|bitmap|tiff|tif)(\?v=\d+)?)/i);
+  if (match) {
+    const prefix = src.split(match[0]);
+    const suffix = match[3];
+    const useSize = size.match("x") ? size : `${size}x`;
+    return removeProtocol(`${prefix[0]}_${useSize}${suffix}`);
+  }
+  return null;
+}
+function getSrcSet(url) {
+  if (!url) {
+    return url;
+  }
+  const sizes = [100, 200, 400, 800, 1200, 1600, 2e3];
+  if (url.match(/builder\.io/)) {
+    let srcUrl = url;
+    const widthInSrc = Number(url.split("?width=")[1]);
+    if (!isNaN(widthInSrc)) {
+      srcUrl = `${srcUrl} ${widthInSrc}w`;
+    }
+    return sizes.filter((size) => size !== widthInSrc).map((size) => `${updateQueryParam(url, "width", size)} ${size}w`).concat([srcUrl]).join(", ");
+  }
+  if (url.match(/cdn\.shopify\.com/)) {
+    return sizes.map((size) => [getShopifyImageUrl(url, `${size}x${size}`), size]).filter(([sizeUrl]) => !!sizeUrl).map(([sizeUrl, size]) => `${sizeUrl} ${size}w`).concat([url]).join(", ");
+  }
+  return url;
+}
+
+// src/blocks/image/image.jsx
+var _tmpl$7 = /* @__PURE__ */ template(`<source type="image/webp">`);
+var _tmpl$22 = /* @__PURE__ */ template(`<picture><img loading="lazy">`);
+var _tmpl$32 = /* @__PURE__ */ template(`<div>`);
+function Image(props) {
+  function srcSetToUse() {
+    const imageToUse = props.image || props.src;
+    const url = imageToUse;
+    if (!url || // We can auto add srcset for cdn.builder.io and shopify
+    // images, otherwise you can supply this prop manually
+    !(url.match(/builder\.io/) || url.match(/cdn\.shopify\.com/))) {
+      return props.srcset;
+    }
+    if (props.srcset && props.image?.includes("builder.io/api/v1/image")) {
+      if (!props.srcset.includes(props.image.split("?")[0])) {
+        return getSrcSet(url);
+      }
+    } else if (props.image && !props.srcset) {
+      return getSrcSet(url);
+    }
+    return getSrcSet(url);
+  }
+  function webpSrcSet() {
+    if (srcSetToUse()?.match(/builder\.io/) && !props.noWebp) {
+      return srcSetToUse().replace(/\?/g, "?format=webp&");
+    } else {
+      return "";
+    }
+  }
+  function aspectRatioCss() {
+    const aspectRatioStyles = {
+      position: "absolute",
+      height: "100%",
+      width: "100%",
+      left: "0px",
+      top: "0px"
+    };
+    const out = props.aspectRatio ? aspectRatioStyles : void 0;
+    return out;
+  }
+  return [(() => {
+    const _el$ = _tmpl$22(), _el$3 = _el$.firstChild;
+    insert(_el$, createComponent(Show, {
+      get when() {
+        return webpSrcSet();
+      },
+      get children() {
+        const _el$2 = _tmpl$7();
+        effect(() => setAttribute(_el$2, "srcset", webpSrcSet()));
+        return _el$2;
+      }
+    }), _el$3);
+    effect((_p$) => {
+      const _v$ = "builder-image" + (props.className ? " " + props.className : "") + " " + css({
+        opacity: "1",
+        transition: "opacity 0.2s ease-in-out"
+      }), _v$2 = props.altText, _v$3 = props.altText ? "presentation" : void 0, _v$4 = {
+        "object-position": props.backgroundPosition || "center",
+        "object-fit": props.backgroundSize || "cover",
+        ...aspectRatioCss()
+      }, _v$5 = props.image, _v$6 = srcSetToUse(), _v$7 = props.sizes;
+      _v$ !== _p$._v$ && className(_el$3, _p$._v$ = _v$);
+      _v$2 !== _p$._v$2 && setAttribute(_el$3, "alt", _p$._v$2 = _v$2);
+      _v$3 !== _p$._v$3 && setAttribute(_el$3, "role", _p$._v$3 = _v$3);
+      _p$._v$4 = style(_el$3, _v$4, _p$._v$4);
+      _v$5 !== _p$._v$5 && setAttribute(_el$3, "src", _p$._v$5 = _v$5);
+      _v$6 !== _p$._v$6 && setAttribute(_el$3, "srcset", _p$._v$6 = _v$6);
+      _v$7 !== _p$._v$7 && setAttribute(_el$3, "sizes", _p$._v$7 = _v$7);
+      return _p$;
+    }, {
+      _v$: void 0,
+      _v$2: void 0,
+      _v$3: void 0,
+      _v$4: void 0,
+      _v$5: void 0,
+      _v$6: void 0,
+      _v$7: void 0
+    });
+    return _el$;
+  })(), createComponent(Show, {
+    get when() {
+      return props.aspectRatio && !(props.builderBlock?.children?.length && props.fitContent);
+    },
+    get children() {
+      const _el$4 = _tmpl$32();
+      effect((_p$) => {
+        const _v$8 = "builder-image-sizer " + css({
+          width: "100%",
+          pointerEvents: "none",
+          fontSize: "0"
+        }), _v$9 = props.aspectRatio * 100 + "%";
+        _v$8 !== _p$._v$8 && className(_el$4, _p$._v$8 = _v$8);
+        _v$9 !== _p$._v$9 && ((_p$._v$9 = _v$9) != null ? _el$4.style.setProperty("padding-top", _v$9) : _el$4.style.removeProperty("padding-top"));
+        return _p$;
+      }, {
+        _v$8: void 0,
+        _v$9: void 0
+      });
+      return _el$4;
+    }
+  }), createComponent(Show, {
+    get when() {
+      return props.builderBlock?.children?.length && props.fitContent;
+    },
+    get children() {
+      return props.children;
+    }
+  }), createComponent(Show, {
+    get when() {
+      return !props.fitContent && props.children;
+    },
+    get children() {
+      const _el$5 = _tmpl$32();
+      insert(_el$5, () => props.children);
+      effect(() => className(_el$5, css({
+        display: "flex",
+        flexDirection: "column",
+        alignItems: "stretch",
+        position: "absolute",
+        top: "0",
+        left: "0",
+        width: "100%",
+        height: "100%"
+      })));
+      return _el$5;
+    }
+  })];
+}
+var image_default = Image;
+var _tmpl$8 = /* @__PURE__ */ template(`<section>`);
+function SectionComponent(props) {
+  return (() => {
+    const _el$ = _tmpl$8();
+    spread(_el$, mergeProps({}, () => props.attributes, {
+      get style() {
+        return {
+          width: "100%",
+          "align-self": "stretch",
+          "flex-grow": 1,
+          "box-sizing": "border-box",
+          "max-width": props.maxWidth || 1200,
+          display: "flex",
+          "flex-direction": "column",
+          "align-items": "stretch",
+          "margin-left": "auto",
+          "margin-right": "auto"
+        };
+      }
+    }), false, true);
+    insert(_el$, () => props.children);
+    return _el$;
+  })();
+}
+var section_default = SectionComponent;
+
+// src/components/content-variants/helpers.js
+var __defProp8 = Object.defineProperty;
+var __defProps6 = Object.defineProperties;
+var __getOwnPropDescs6 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols8 = Object.getOwnPropertySymbols;
+var __hasOwnProp8 = Object.prototype.hasOwnProperty;
+var __propIsEnum8 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp8 = (obj, key, value) => key in obj ? __defProp8(obj, key, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __spreadValues8 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp8.call(b, prop))
+      __defNormalProp8(a, prop, b[prop]);
+  if (__getOwnPropSymbols8)
+    for (var prop of __getOwnPropSymbols8(b)) {
+      if (__propIsEnum8.call(b, prop))
+        __defNormalProp8(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps6 = (a, b) => __defProps6(a, __getOwnPropDescs6(b));
+var getVariants = (content) => Object.values((content == null ? void 0 : content.variations) || {}).map((variant) => __spreadProps6(__spreadValues8({}, variant), {
+  testVariationId: variant.id,
+  id: content == null ? void 0 : content.id
+}));
+var checkShouldRunVariants = ({
+  canTrack,
+  content
+}) => {
+  const hasVariants = getVariants(content).length > 0;
+  if (TARGET === "reactNative")
+    return false;
+  if (!hasVariants)
+    return false;
+  if (!canTrack)
+    return false;
+  if (TARGET === "vue2" || TARGET === "vue3")
+    return true;
+  if (isBrowser())
+    return false;
+  return true;
+};
+function bldrAbTest(contentId, variants, isHydrationTarget2) {
+  var _a;
+  function getAndSetVariantId2() {
+    function setCookie2(name, value, days) {
+      let expires = "";
+      if (days) {
+        const date = /* @__PURE__ */ new Date();
+        date.setTime(date.getTime() + days * 24 * 60 * 60 * 1e3);
+        expires = "; expires=" + date.toUTCString();
+      }
+      document.cookie = name + "=" + (value || "") + expires + "; path=/; Secure; SameSite=None";
+    }
+    function getCookie2(name) {
+      const nameEQ = name + "=";
+      const ca = document.cookie.split(";");
+      for (let i = 0; i < ca.length; i++) {
+        let c = ca[i];
+        while (c.charAt(0) === " ")
+          c = c.substring(1, c.length);
+        if (c.indexOf(nameEQ) === 0)
+          return c.substring(nameEQ.length, c.length);
+      }
+      return null;
+    }
+    const cookieName = `builder.tests.${contentId}`;
+    const variantInCookie = getCookie2(cookieName);
+    const availableIDs = variants.map((vr) => vr.id).concat(contentId);
+    if (variantInCookie && availableIDs.includes(variantInCookie)) {
+      return variantInCookie;
+    }
+    let n = 0;
+    const random = Math.random();
+    for (let i = 0; i < variants.length; i++) {
+      const variant = variants[i];
+      const testRatio = variant.testRatio;
+      n += testRatio;
+      if (random < n) {
+        setCookie2(cookieName, variant.id);
+        return variant.id;
+      }
+    }
+    setCookie2(cookieName, contentId);
+    return contentId;
+  }
+  const winningVariantId = getAndSetVariantId2();
+  const styleEl = (_a = document.currentScript) == null ? void 0 : _a.previousElementSibling;
+  if (isHydrationTarget2) {
+    styleEl.remove();
+    const thisScriptEl = document.currentScript;
+    thisScriptEl == null ? void 0 : thisScriptEl.remove();
+  } else {
+    const newStyleStr = variants.concat({
+      id: contentId
+    }).filter((variant) => variant.id !== winningVariantId).map((value) => {
+      return `.variant-${value.id} {  display: none; }
+        `;
+    }).join("");
+    styleEl.innerHTML = newStyleStr;
+  }
+}
+function bldrCntntScrpt(variantContentId, defaultContentId, isHydrationTarget2) {
+  var _a;
+  if (!navigator.cookieEnabled) {
+    return;
+  }
+  function getCookie2(name) {
+    const nameEQ = name + "=";
+    const ca = document.cookie.split(";");
+    for (let i = 0; i < ca.length; i++) {
+      let c = ca[i];
+      while (c.charAt(0) === " ")
+        c = c.substring(1, c.length);
+      if (c.indexOf(nameEQ) === 0)
+        return c.substring(nameEQ.length, c.length);
+    }
+    return null;
+  }
+  const cookieName = `builder.tests.${defaultContentId}`;
+  const variantId = getCookie2(cookieName);
+  const parentDiv = (_a = document.currentScript) == null ? void 0 : _a.parentElement;
+  const variantIsDefaultContent = variantContentId === defaultContentId;
+  if (variantId === variantContentId) {
+    if (variantIsDefaultContent) {
+      return;
+    }
+    parentDiv == null ? void 0 : parentDiv.removeAttribute("hidden");
+    parentDiv == null ? void 0 : parentDiv.removeAttribute("aria-hidden");
+  } else {
+    if (variantIsDefaultContent) {
+      if (isHydrationTarget2) {
+        parentDiv == null ? void 0 : parentDiv.remove();
+      } else {
+        parentDiv == null ? void 0 : parentDiv.setAttribute("hidden", "true");
+        parentDiv == null ? void 0 : parentDiv.setAttribute("aria-hidden", "true");
+      }
+    }
+    return;
+  }
+  return;
+}
+var getIsHydrationTarget = (target) => target === "react" || target === "reactNative";
+var isHydrationTarget = getIsHydrationTarget(TARGET);
+var AB_TEST_FN_NAME = "builderIoAbTest";
+var CONTENT_FN_NAME = "builderIoRenderContent";
+var getScriptString = () => {
+  const fnStr = bldrAbTest.toString().replace(/\s+/g, " ");
+  const fnStr2 = bldrCntntScrpt.toString().replace(/\s+/g, " ");
+  return `
+  window.${AB_TEST_FN_NAME} = ${fnStr}
+  window.${CONTENT_FN_NAME} = ${fnStr2}
+  `;
+};
+var getVariantsScriptString = (variants, contentId) => {
+  return `
+  window.${AB_TEST_FN_NAME}("${contentId}",${JSON.stringify(variants)}, ${isHydrationTarget})`;
+};
+var getRenderContentScriptString = ({
+  contentId,
+  variationId
+}) => {
+  return `
+  window.${CONTENT_FN_NAME}("${variationId}", "${contentId}", ${isHydrationTarget})`;
+};
+
+// src/blocks/button/component-info.js
+var componentInfo = {
+  name: "Core:Button",
+  image: "https://cdn.builder.io/api/v1/image/assets%2FIsxPKMo2gPRRKeakUztj1D6uqed2%2F81a15681c3e74df09677dfc57a615b13",
+  defaultStyles: {
+    appearance: "none",
+    paddingTop: "15px",
+    paddingBottom: "15px",
+    paddingLeft: "25px",
+    paddingRight: "25px",
+    backgroundColor: "#000000",
+    color: "white",
+    borderRadius: "4px",
+    textAlign: "center",
+    cursor: "pointer"
+  },
+  inputs: [{
+    name: "text",
+    type: "text",
+    defaultValue: "Click me!",
+    bubble: true
+  }, {
+    name: "link",
+    type: "url",
+    bubble: true
+  }, {
+    name: "openLinkInNewTab",
+    type: "boolean",
+    defaultValue: false,
+    friendlyName: "Open link in new tab"
+  }],
+  static: true,
+  noWrap: true
+};
+
+// src/blocks/columns/component-info.js
+var componentInfo2 = {
+  name: "Columns",
+  isRSC: true,
+  inputs: [{
+    name: "columns",
+    type: "array",
+    broadcast: true,
+    subFields: [{
+      name: "blocks",
+      type: "array",
+      hideFromUI: true,
+      defaultValue: [{
+        "@type": "@builder.io/sdk:Element",
+        responsiveStyles: {
+          large: {
+            display: "flex",
+            flexDirection: "column",
+            alignItems: "stretch",
+            flexShrink: "0",
+            position: "relative",
+            marginTop: "30px",
+            textAlign: "center",
+            lineHeight: "normal",
+            height: "auto",
+            minHeight: "20px",
+            minWidth: "20px",
+            overflow: "hidden"
+          }
+        },
+        component: {
+          name: "Image",
+          options: {
+            image: "https://builder.io/api/v1/image/assets%2Fpwgjf0RoYWbdnJSbpBAjXNRMe9F2%2Ffb27a7c790324294af8be1c35fe30f4d",
+            backgroundPosition: "center",
+            backgroundSize: "cover",
+            aspectRatio: 0.7004048582995948
+          }
+        }
+      }, {
+        "@type": "@builder.io/sdk:Element",
+        responsiveStyles: {
+          large: {
+            display: "flex",
+            flexDirection: "column",
+            alignItems: "stretch",
+            flexShrink: "0",
+            position: "relative",
+            marginTop: "30px",
+            textAlign: "center",
+            lineHeight: "normal",
+            height: "auto"
+          }
+        },
+        component: {
+          name: "Text",
+          options: {
+            text: "<p>Enter some text...</p>"
+          }
+        }
+      }]
+    }, {
+      name: "width",
+      type: "number",
+      hideFromUI: true,
+      helperText: "Width %, e.g. set to 50 to fill half of the space"
+    }, {
+      name: "link",
+      type: "url",
+      helperText: "Optionally set a url that clicking this column will link to"
+    }],
+    defaultValue: [{
+      blocks: [{
+        "@type": "@builder.io/sdk:Element",
+        responsiveStyles: {
+          large: {
+            display: "flex",
+            flexDirection: "column",
+            alignItems: "stretch",
+            flexShrink: "0",
+            position: "relative",
+            marginTop: "30px",
+            textAlign: "center",
+            lineHeight: "normal",
+            height: "auto",
+            minHeight: "20px",
+            minWidth: "20px",
+            overflow: "hidden"
+          }
+        },
+        component: {
+          name: "Image",
+          options: {
+            image: "https://builder.io/api/v1/image/assets%2Fpwgjf0RoYWbdnJSbpBAjXNRMe9F2%2Ffb27a7c790324294af8be1c35fe30f4d",
+            backgroundPosition: "center",
+            backgroundSize: "cover",
+            aspectRatio: 0.7004048582995948
+          }
+        }
+      }, {
+        "@type": "@builder.io/sdk:Element",
+        responsiveStyles: {
+          large: {
+            display: "flex",
+            flexDirection: "column",
+            alignItems: "stretch",
+            flexShrink: "0",
+            position: "relative",
+            marginTop: "30px",
+            textAlign: "center",
+            lineHeight: "normal",
+            height: "auto"
+          }
+        },
+        component: {
+          name: "Text",
+          options: {
+            text: "<p>Enter some text...</p>"
+          }
+        }
+      }]
+    }, {
+      blocks: [{
+        "@type": "@builder.io/sdk:Element",
+        responsiveStyles: {
+          large: {
+            display: "flex",
+            flexDirection: "column",
+            alignItems: "stretch",
+            flexShrink: "0",
+            position: "relative",
+            marginTop: "30px",
+            textAlign: "center",
+            lineHeight: "normal",
+            height: "auto",
+            minHeight: "20px",
+            minWidth: "20px",
+            overflow: "hidden"
+          }
+        },
+        component: {
+          name: "Image",
+          options: {
+            image: "https://builder.io/api/v1/image/assets%2Fpwgjf0RoYWbdnJSbpBAjXNRMe9F2%2Ffb27a7c790324294af8be1c35fe30f4d",
+            backgroundPosition: "center",
+            backgroundSize: "cover",
+            aspectRatio: 0.7004048582995948
+          }
+        }
+      }, {
+        "@type": "@builder.io/sdk:Element",
+        responsiveStyles: {
+          large: {
+            display: "flex",
+            flexDirection: "column",
+            alignItems: "stretch",
+            flexShrink: "0",
+            position: "relative",
+            marginTop: "30px",
+            textAlign: "center",
+            lineHeight: "normal",
+            height: "auto"
+          }
+        },
+        component: {
+          name: "Text",
+          options: {
+            text: "<p>Enter some text...</p>"
+          }
+        }
+      }]
+    }],
+    onChange: (options) => {
+      function clearWidths() {
+        columns.forEach((col) => {
+          col.delete("width");
+        });
+      }
+      const columns = options.get("columns");
+      if (Array.isArray(columns)) {
+        const containsColumnWithWidth = !!columns.find((col) => col.get("width"));
+        if (containsColumnWithWidth) {
+          const containsColumnWithoutWidth = !!columns.find((col) => !col.get("width"));
+          if (containsColumnWithoutWidth) {
+            clearWidths();
+          } else {
+            const sumWidths = columns.reduce((memo, col) => {
+              return memo + col.get("width");
+            }, 0);
+            const widthsDontAddUp = sumWidths !== 100;
+            if (widthsDontAddUp) {
+              clearWidths();
+            }
+          }
+        }
+      }
+    }
+  }, {
+    name: "space",
+    type: "number",
+    defaultValue: 20,
+    helperText: "Size of gap between columns",
+    advanced: true
+  }, {
+    name: "stackColumnsAt",
+    type: "string",
+    defaultValue: "tablet",
+    helperText: "Convert horizontal columns to vertical at what device size",
+    enum: ["tablet", "mobile", "never"],
+    advanced: true
+  }, {
+    name: "reverseColumnsWhenStacked",
+    type: "boolean",
+    defaultValue: false,
+    helperText: "When stacking columns for mobile devices, reverse the ordering",
+    advanced: true
+  }]
+};
+
+// src/blocks/fragment/component-info.js
+var componentInfo3 = {
+  name: "Fragment",
+  static: true,
+  hidden: true,
+  canHaveChildren: true,
+  noWrap: true
+};
+
+// src/blocks/image/component-info.js
+var componentInfo4 = {
+  name: "Image",
+  static: true,
+  image: "https://firebasestorage.googleapis.com/v0/b/builder-3b0a2.appspot.com/o/images%2Fbaseline-insert_photo-24px.svg?alt=media&token=4e5d0ef4-f5e8-4e57-b3a9-38d63a9b9dc4",
+  defaultStyles: {
+    position: "relative",
+    minHeight: "20px",
+    minWidth: "20px",
+    overflow: "hidden"
+  },
+  canHaveChildren: true,
+  inputs: [{
+    name: "image",
+    type: "file",
+    bubble: true,
+    allowedFileTypes: ["jpeg", "jpg", "png", "svg"],
+    required: true,
+    defaultValue: "https://cdn.builder.io/api/v1/image/assets%2FYJIGb4i01jvw0SRdL5Bt%2F72c80f114dc149019051b6852a9e3b7a",
+    onChange: (options) => {
+      const DEFAULT_ASPECT_RATIO = 0.7041;
+      options.delete("srcset");
+      options.delete("noWebp");
+      function loadImage(url, timeout = 6e4) {
+        return new Promise((resolve, reject) => {
+          const img = document.createElement("img");
+          let loaded = false;
+          img.onload = () => {
+            loaded = true;
+            resolve(img);
+          };
+          img.addEventListener("error", (event) => {
+            reject(event.error);
+          });
+          img.src = url;
+          setTimeout(() => {
+            if (!loaded) {
+              reject(new Error("Image load timed out"));
+            }
+          }, timeout);
+        });
+      }
+      function round2(num) {
+        return Math.round(num * 1e3) / 1e3;
+      }
+      const value = options.get("image");
+      const aspectRatio = options.get("aspectRatio");
+      fetch(value).then((res) => res.blob()).then((blob) => {
+        if (blob.type.includes("svg")) {
+          options.set("noWebp", true);
+        }
+      });
+      if (value && (!aspectRatio || aspectRatio === DEFAULT_ASPECT_RATIO)) {
+        return loadImage(value).then((img) => {
+          const possiblyUpdatedAspectRatio = options.get("aspectRatio");
+          if (options.get("image") === value && (!possiblyUpdatedAspectRatio || possiblyUpdatedAspectRatio === DEFAULT_ASPECT_RATIO)) {
+            if (img.width && img.height) {
+              options.set("aspectRatio", round2(img.height / img.width));
+              options.set("height", img.height);
+              options.set("width", img.width);
+            }
+          }
+        });
+      }
+    }
+  }, {
+    name: "backgroundSize",
+    type: "text",
+    defaultValue: "cover",
+    enum: [{
+      label: "contain",
+      value: "contain",
+      helperText: "The image should never get cropped"
+    }, {
+      label: "cover",
+      value: "cover",
+      helperText: "The image should fill it's box, cropping when needed"
+    }]
+  }, {
+    name: "backgroundPosition",
+    type: "text",
+    defaultValue: "center",
+    enum: ["center", "top", "left", "right", "bottom", "top left", "top right", "bottom left", "bottom right"]
+  }, {
+    name: "altText",
+    type: "string",
+    helperText: "Text to display when the user has images off"
+  }, {
+    name: "height",
+    type: "number",
+    hideFromUI: true
+  }, {
+    name: "width",
+    type: "number",
+    hideFromUI: true
+  }, {
+    name: "sizes",
+    type: "string",
+    hideFromUI: true
+  }, {
+    name: "srcset",
+    type: "string",
+    hideFromUI: true
+  }, {
+    name: "lazy",
+    type: "boolean",
+    defaultValue: true,
+    hideFromUI: true
+  }, {
+    name: "fitContent",
+    type: "boolean",
+    helperText: "When child blocks are provided, fit to them instead of using the image's aspect ratio",
+    defaultValue: true
+  }, {
+    name: "aspectRatio",
+    type: "number",
+    helperText: "This is the ratio of height/width, e.g. set to 1.5 for a 300px wide and 200px tall photo. Set to 0 to not force the image to maintain it's aspect ratio",
+    advanced: true,
+    defaultValue: 0.7041
+  }]
+};
+
+// src/blocks/section/component-info.js
+var componentInfo5 = {
+  name: "Core:Section",
+  static: true,
+  image: "https://cdn.builder.io/api/v1/image/assets%2FIsxPKMo2gPRRKeakUztj1D6uqed2%2F682efef23ace49afac61748dd305c70a",
+  inputs: [{
+    name: "maxWidth",
+    type: "number",
+    defaultValue: 1200
+  }, {
+    name: "lazyLoad",
+    type: "boolean",
+    defaultValue: false,
+    advanced: true,
+    description: "Only render this section when in view"
+  }],
+  defaultStyles: {
+    paddingLeft: "20px",
+    paddingRight: "20px",
+    paddingTop: "50px",
+    paddingBottom: "50px",
+    marginTop: "0px",
+    width: "100vw",
+    marginLeft: "calc(50% - 50vw)"
+  },
+  canHaveChildren: true,
+  defaultChildren: [{
+    "@type": "@builder.io/sdk:Element",
+    responsiveStyles: {
+      large: {
+        textAlign: "center"
+      }
+    },
+    component: {
+      name: "Text",
+      options: {
+        text: "<p><b>I am a section! My content keeps from getting too wide, so that it's easy to read even on big screens.</b></p><p>Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur</p>"
+      }
+    }
+  }]
+};
+
+// src/blocks/symbol/component-info.js
+var componentInfo6 = {
+  name: "Symbol",
+  noWrap: true,
+  static: true,
+  isRSC: true,
+  inputs: [{
+    name: "symbol",
+    type: "uiSymbol"
+  }, {
+    name: "dataOnly",
+    helperText: "Make this a data symbol that doesn't display any UI",
+    type: "boolean",
+    defaultValue: false,
+    advanced: true,
+    hideFromUI: true
+  }, {
+    name: "inheritState",
+    helperText: "Inherit the parent component state and data",
+    type: "boolean",
+    defaultValue: false,
+    advanced: true
+  }, {
+    name: "renderToLiquid",
+    helperText: "Render this symbols contents to liquid. Turn off to fetch with javascript and use custom targeting",
+    type: "boolean",
+    defaultValue: false,
+    advanced: true,
+    hideFromUI: true
+  }, {
+    name: "useChildren",
+    hideFromUI: true,
+    type: "boolean"
+  }]
+};
+
+// src/blocks/text/component-info.js
+var componentInfo7 = {
+  name: "Text",
+  static: true,
+  isRSC: true,
+  image: "https://firebasestorage.googleapis.com/v0/b/builder-3b0a2.appspot.com/o/images%2Fbaseline-text_fields-24px%20(1).svg?alt=media&token=12177b73-0ee3-42ca-98c6-0dd003de1929",
+  inputs: [{
+    name: "text",
+    type: "html",
+    required: true,
+    autoFocus: true,
+    bubble: true,
+    defaultValue: "Enter some text..."
+  }],
+  defaultStyles: {
+    lineHeight: "normal",
+    height: "auto",
+    textAlign: "center"
+  }
+};
+var _tmpl$9 = /* @__PURE__ */ template(`<span class="builder-text">`);
+function Text(props) {
+  return (() => {
+    const _el$ = _tmpl$9();
+    _el$.style.setProperty("outline", "none");
+    effect(() => _el$.innerHTML = props.text?.toString() || "");
+    return _el$;
+  })();
+}
+var text_default = Text;
+
+// src/blocks/video/component-info.js
+var componentInfo8 = {
+  name: "Video",
+  canHaveChildren: true,
+  defaultStyles: {
+    minHeight: "20px",
+    minWidth: "20px"
+  },
+  image: "https://firebasestorage.googleapis.com/v0/b/builder-3b0a2.appspot.com/o/images%2Fbaseline-videocam-24px%20(1).svg?alt=media&token=49a84e4a-b20e-4977-a650-047f986874bb",
+  inputs: [{
+    name: "video",
+    type: "file",
+    allowedFileTypes: ["mp4"],
+    bubble: true,
+    defaultValue: "https://firebasestorage.googleapis.com/v0/b/builder-3b0a2.appspot.com/o/assets%2FKQlEmWDxA0coC3PK6UvkrjwkIGI2%2F28cb070609f546cdbe5efa20e931aa4b?alt=media&token=912e9551-7a7c-4dfb-86b6-3da1537d1a7f",
+    required: true
+  }, {
+    name: "posterImage",
+    type: "file",
+    allowedFileTypes: ["jpeg", "png"],
+    helperText: "Image to show before the video plays"
+  }, {
+    name: "autoPlay",
+    type: "boolean",
+    defaultValue: true
+  }, {
+    name: "controls",
+    type: "boolean",
+    defaultValue: false
+  }, {
+    name: "muted",
+    type: "boolean",
+    defaultValue: true
+  }, {
+    name: "loop",
+    type: "boolean",
+    defaultValue: true
+  }, {
+    name: "playsInline",
+    type: "boolean",
+    defaultValue: true
+  }, {
+    name: "fit",
+    type: "text",
+    defaultValue: "cover",
+    enum: ["contain", "cover", "fill", "auto"]
+  }, {
+    name: "preload",
+    type: "text",
+    defaultValue: "metadata",
+    enum: ["auto", "metadata", "none"]
+  }, {
+    name: "fitContent",
+    type: "boolean",
+    helperText: "When child blocks are provided, fit to them instead of using the aspect ratio",
+    defaultValue: true,
+    advanced: true
+  }, {
+    name: "position",
+    type: "text",
+    defaultValue: "center",
+    enum: ["center", "top", "left", "right", "bottom", "top left", "top right", "bottom left", "bottom right"]
+  }, {
+    name: "height",
+    type: "number",
+    advanced: true
+  }, {
+    name: "width",
+    type: "number",
+    advanced: true
+  }, {
+    name: "aspectRatio",
+    type: "number",
+    advanced: true,
+    defaultValue: 0.7004048582995948
+  }, {
+    name: "lazyLoad",
+    type: "boolean",
+    helperText: 'Load this video "lazily" - as in only when a user scrolls near the video. Recommended for optmized performance and bandwidth consumption',
+    defaultValue: true,
+    advanced: true
+  }]
+};
+var _tmpl$10 = /* @__PURE__ */ template(`<video>`);
+function Video(props) {
+  function videoProps() {
+    return {
+      ...props.autoPlay === true ? {
+        autoPlay: true
+      } : {},
+      ...props.muted === true ? {
+        muted: true
+      } : {},
+      ...props.controls === true ? {
+        controls: true
+      } : {},
+      ...props.loop === true ? {
+        loop: true
+      } : {},
+      ...props.playsInline === true ? {
+        playsInline: true
+      } : {}
+    };
+  }
+  function spreadProps() {
+    return {
+      ...props.attributes,
+      ...videoProps()
+    };
+  }
+  return (() => {
+    const _el$ = _tmpl$10();
+    spread(_el$, mergeProps(spreadProps, {
+      get preload() {
+        return props.preload || "metadata";
+      },
+      get style() {
+        return {
+          width: "100%",
+          height: "100%",
+          ...props.attributes?.style,
+          "object-fit": props.fit,
+          "object-position": props.position,
+          // Hack to get object fit to work as expected and
+          // not have the video overflow
+          "border-radius": 1
+        };
+      },
+      get src() {
+        return props.video || "no-src";
+      },
+      get poster() {
+        return props.posterImage;
+      }
+    }), false, false);
+    return _el$;
+  })();
+}
+var video_default = Video;
+
+// src/blocks/embed/component-info.js
+var componentInfo9 = {
+  name: "Embed",
+  static: true,
+  inputs: [{
+    name: "url",
+    type: "url",
+    required: true,
+    defaultValue: "",
+    helperText: "e.g. enter a youtube url, google map, etc",
+    onChange: (options) => {
+      const url = options.get("url");
+      if (url) {
+        options.set("content", "Loading...");
+        const apiKey = "ae0e60e78201a3f2b0de4b";
+        return fetch(`https://iframe.ly/api/iframely?url=${url}&api_key=${apiKey}`).then((res) => res.json()).then((data) => {
+          if (options.get("url") === url) {
+            if (data.html) {
+              options.set("content", data.html);
+            } else {
+              options.set("content", "Invalid url, please try another");
+            }
+          }
+        }).catch((_err) => {
+          options.set("content", "There was an error embedding this URL, please try again or another URL");
+        });
+      } else {
+        options.delete("content");
+      }
+    }
+  }, {
+    name: "content",
+    type: "html",
+    defaultValue: '<div style="padding: 20px; text-align: center">(Choose an embed URL)<div>',
+    hideFromUI: true
+  }]
+};
+
+// src/blocks/embed/helpers.js
+var SCRIPT_MIME_TYPES = ["text/javascript", "application/javascript", "application/ecmascript"];
+var isJsScript = (script) => SCRIPT_MIME_TYPES.includes(script.type);
+
+// src/blocks/embed/embed.jsx
+var _tmpl$11 = /* @__PURE__ */ template(`<div class="builder-embed">`);
+function Embed(props) {
+  const [scriptsInserted, setScriptsInserted] = createSignal([]);
+  const [scriptsRun, setScriptsRun] = createSignal([]);
+  const [ranInitFn, setRanInitFn] = createSignal(false);
+  function findAndRunScripts() {
+    if (!elem || !elem.getElementsByTagName)
+      return;
+    const scripts = elem.getElementsByTagName("script");
+    for (let i = 0; i < scripts.length; i++) {
+      const script = scripts[i];
+      if (script.src && !scriptsInserted().includes(script.src)) {
+        scriptsInserted().push(script.src);
+        const newScript = document.createElement("script");
+        newScript.async = true;
+        newScript.src = script.src;
+        document.head.appendChild(newScript);
+      } else if (isJsScript(script) && !scriptsRun().includes(script.innerText)) {
+        try {
+          scriptsRun().push(script.innerText);
+          new Function(script.innerText)();
+        } catch (error) {
+        }
+      }
+    }
+  }
+  let elem;
+  function onUpdateFn_0() {
+    if (elem && !ranInitFn()) {
+      setRanInitFn(true);
+      findAndRunScripts();
+    }
+  }
+  createEffect(on(() => [elem, ranInitFn()], onUpdateFn_0));
+  return (() => {
+    const _el$ = _tmpl$11();
+    const _ref$ = elem;
+    typeof _ref$ === "function" ? use(_ref$, _el$) : elem = _el$;
+    effect(() => _el$.innerHTML = props.content);
+    return _el$;
+  })();
+}
+var embed_default = Embed;
+var _tmpl$12 = /* @__PURE__ */ template(`<img>`);
+function ImgComponent(props) {
+  return (() => {
+    const _el$ = _tmpl$12();
+    spread(_el$, mergeProps({
+      get style() {
+        return {
+          "object-fit": props.backgroundSize || "cover",
+          "object-position": props.backgroundPosition || "center"
+        };
+      },
+      get key() {
+        return isEditing() && props.imgSrc || "default-key";
+      },
+      get alt() {
+        return props.altText;
+      },
+      get src() {
+        return props.imgSrc || props.image;
+      }
+    }, {}, () => props.attributes), false, false);
+    return _el$;
+  })();
+}
+var img_default = ImgComponent;
+
+// src/blocks/img/component-info.js
+var componentInfo10 = {
+  name: "Raw:Img",
+  hideFromInsertMenu: true,
+  image: "https://firebasestorage.googleapis.com/v0/b/builder-3b0a2.appspot.com/o/images%2Fbaseline-insert_photo-24px.svg?alt=media&token=4e5d0ef4-f5e8-4e57-b3a9-38d63a9b9dc4",
+  inputs: [{
+    name: "image",
+    bubble: true,
+    type: "file",
+    allowedFileTypes: ["jpeg", "jpg", "png", "svg", "gif", "webp"],
+    required: true
+  }],
+  noWrap: true,
+  static: true
+};
+var _tmpl$13 = /* @__PURE__ */ template(`<div>`);
+function CustomCode(props) {
+  const [scriptsInserted, setScriptsInserted] = createSignal([]);
+  const [scriptsRun, setScriptsRun] = createSignal([]);
+  function findAndRunScripts() {
+    if (elem && elem.getElementsByTagName && typeof window !== "undefined") {
+      const scripts = elem.getElementsByTagName("script");
+      for (let i = 0; i < scripts.length; i++) {
+        const script = scripts[i];
+        if (script.src) {
+          if (scriptsInserted().includes(script.src)) {
+            continue;
+          }
+          scriptsInserted().push(script.src);
+          const newScript = document.createElement("script");
+          newScript.async = true;
+          newScript.src = script.src;
+          document.head.appendChild(newScript);
+        } else if (!script.type || ["text/javascript", "application/javascript", "application/ecmascript"].includes(script.type)) {
+          if (scriptsRun().includes(script.innerText)) {
+            continue;
+          }
+          try {
+            scriptsRun().push(script.innerText);
+            new Function(script.innerText)();
+          } catch (error) {
+          }
+        }
+      }
+    }
+  }
+  let elem;
+  onMount(() => {
+    findAndRunScripts();
+  });
+  return (() => {
+    const _el$ = _tmpl$13();
+    const _ref$ = elem;
+    typeof _ref$ === "function" ? use(_ref$, _el$) : elem = _el$;
+    effect((_p$) => {
+      const _v$ = "builder-custom-code" + (props.replaceNodes ? " replace-nodes" : ""), _v$2 = props.code;
+      _v$ !== _p$._v$ && className(_el$, _p$._v$ = _v$);
+      _v$2 !== _p$._v$2 && (_el$.innerHTML = _p$._v$2 = _v$2);
+      return _p$;
+    }, {
+      _v$: void 0,
+      _v$2: void 0
+    });
+    return _el$;
+  })();
+}
+var custom_code_default = CustomCode;
+
+// src/blocks/custom-code/component-info.js
+var componentInfo11 = {
+  name: "Custom Code",
+  static: true,
+  requiredPermissions: ["editCode"],
+  inputs: [{
+    name: "code",
+    type: "html",
+    required: true,
+    defaultValue: "<p>Hello there, I am custom HTML code!</p>",
+    code: true
+  }, {
+    name: "replaceNodes",
+    type: "boolean",
+    helperText: "Preserve server rendered dom nodes",
+    advanced: true
+  }, {
+    name: "scriptsClientOnly",
+    type: "boolean",
+    defaultValue: false,
+    helperText: "Only print and run scripts on the client. Important when scripts influence DOM that could be replaced when client loads",
+    advanced: true
+  }]
+};
+
+// src/constants/builder-registered-components.js
+var __defProp9 = Object.defineProperty;
+var __getOwnPropSymbols9 = Object.getOwnPropertySymbols;
+var __hasOwnProp9 = Object.prototype.hasOwnProperty;
+var __propIsEnum9 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp9 = (obj, key, value) => key in obj ? __defProp9(obj, key, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __spreadValues9 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp9.call(b, prop))
+      __defNormalProp9(a, prop, b[prop]);
+  if (__getOwnPropSymbols9)
+    for (var prop of __getOwnPropSymbols9(b)) {
+      if (__propIsEnum9.call(b, prop))
+        __defNormalProp9(a, prop, b[prop]);
+    }
+  return a;
+};
+var getDefaultRegisteredComponents = () => [__spreadValues9({
+  component: button_default
+}, componentInfo), __spreadValues9({
+  component: columns_default
+}, componentInfo2), __spreadValues9({
+  component: custom_code_default
+}, componentInfo11), __spreadValues9({
+  component: embed_default
+}, componentInfo9), __spreadValues9({
+  component: fragment_default
+}, componentInfo3), __spreadValues9({
+  component: image_default
+}, componentInfo4), __spreadValues9({
+  component: img_default
+}, componentInfo10), __spreadValues9({
+  component: section_default
+}, componentInfo5), __spreadValues9({
+  component: symbol_default
+}, componentInfo6), __spreadValues9({
+  component: text_default
+}, componentInfo7), __spreadValues9({
+  component: video_default
+}, componentInfo8)];
+
+// src/functions/register-component.js
+var __defProp10 = Object.defineProperty;
+var __defProps7 = Object.defineProperties;
+var __getOwnPropDescs7 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols10 = Object.getOwnPropertySymbols;
+var __hasOwnProp10 = Object.prototype.hasOwnProperty;
+var __propIsEnum10 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp10 = (obj, key, value) => key in obj ? __defProp10(obj, key, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __spreadValues10 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp10.call(b, prop))
+      __defNormalProp10(a, prop, b[prop]);
+  if (__getOwnPropSymbols10)
+    for (var prop of __getOwnPropSymbols10(b)) {
+      if (__propIsEnum10.call(b, prop))
+        __defNormalProp10(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps7 = (a, b) => __defProps7(a, __getOwnPropDescs7(b));
+var __objRest2 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp10.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols10)
+    for (var prop of __getOwnPropSymbols10(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum10.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var components = [];
+var createRegisterComponentMessage = (info) => ({
+  type: "builder.registerComponent",
+  data: serializeComponentInfo(info)
+});
+var serializeFn = (fnValue) => {
+  const fnStr = fnValue.toString().trim();
+  const appendFunction = !fnStr.startsWith("function") && !fnStr.startsWith("(");
+  return `return (${appendFunction ? "function " : ""}${fnStr}).apply(this, arguments)`;
+};
+var serializeValue = (value) => typeof value === "function" ? serializeFn(value) : fastClone(value);
+var serializeComponentInfo = (_a) => {
+  var _b = _a, {
+    inputs
+  } = _b, info = __objRest2(_b, ["inputs"]);
+  return __spreadProps7(__spreadValues10({}, fastClone(info)), {
+    inputs: inputs == null ? void 0 : inputs.map((input) => Object.entries(input).reduce((acc, [key, value]) => __spreadProps7(__spreadValues10({}, acc), {
+      [key]: serializeValue(value)
+    }), {}))
+  });
+};
+
+// src/components/content/components/styles.helpers.js
+var getCssFromFont = (font) => {
+  var _a, _b;
+  const family = font.family + (font.kind && !font.kind.includes("#") ? ", " + font.kind : "");
+  const name = family.split(",")[0];
+  const url = (_b = font.fileUrl) != null ? _b : (_a = font == null ? void 0 : font.files) == null ? void 0 : _a.regular;
+  let str = "";
+  if (url && family && name) {
+    str += `
+@font-face {
+font-family: "${family}";
+src: local("${name}"), url('${url}') format('woff2');
+font-display: fallback;
+font-weight: 400;
+}
+      `.trim();
+  }
+  if (font.files) {
+    for (const weight in font.files) {
+      const isNumber = String(Number(weight)) === weight;
+      if (!isNumber) {
+        continue;
+      }
+      const weightUrl = font.files[weight];
+      if (weightUrl && weightUrl !== url) {
+        str += `
+@font-face {
+font-family: "${family}";
+src: url('${weightUrl}') format('woff2');
+font-display: fallback;
+font-weight: ${weight};
+}
+        `.trim();
+      }
+    }
+  }
+  return str;
+};
+var getFontCss = ({
+  customFonts
+}) => {
+  var _a;
+  return ((_a = customFonts == null ? void 0 : customFonts.map((font) => getCssFromFont(font))) == null ? void 0 : _a.join(" ")) || "";
+};
+var getCss = ({
+  cssCode,
+  contentId
+}) => {
+  if (!cssCode) {
+    return "";
+  }
+  if (!contentId) {
+    return cssCode;
+  }
+  return (cssCode == null ? void 0 : cssCode.replace(/&/g, `div[builder-content-id="${contentId}"]`)) || "";
+};
+
+// src/components/content/components/styles.jsx
+function ContentStyles(props) {
+  const [injectedStyles, setInjectedStyles] = createSignal(`
+${getCss({
+    cssCode: props.cssCode,
+    contentId: props.contentId
+  })}
+${getFontCss({
+    customFonts: props.customFonts
+  })}
+
+.builder-text > p:first-of-type, .builder-text > .builder-paragraph:first-of-type {
+  margin: 0;
+}
+.builder-text > p, .builder-text > .builder-paragraph {
+  color: inherit;
+  line-height: inherit;
+  letter-spacing: inherit;
+  font-weight: inherit;
+  font-size: inherit;
+  text-align: inherit;
+  font-family: inherit;
+}
+`.trim());
+  return createComponent(inlined_styles_default, {
+    get styles() {
+      return injectedStyles();
+    }
+  });
+}
+var styles_default = ContentStyles;
+
+// src/components/content/content.helpers.js
+var __defProp11 = Object.defineProperty;
+var __defProps8 = Object.defineProperties;
+var __getOwnPropDescs8 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols11 = Object.getOwnPropertySymbols;
+var __hasOwnProp11 = Object.prototype.hasOwnProperty;
+var __propIsEnum11 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp11 = (obj, key, value) => key in obj ? __defProp11(obj, key, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __spreadValues11 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp11.call(b, prop))
+      __defNormalProp11(a, prop, b[prop]);
+  if (__getOwnPropSymbols11)
+    for (var prop of __getOwnPropSymbols11(b)) {
+      if (__propIsEnum11.call(b, prop))
+        __defNormalProp11(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps8 = (a, b) => __defProps8(a, __getOwnPropDescs8(b));
+var getContextStateInitialValue = ({
+  content,
+  data,
+  locale
+}) => {
+  var _a, _b, _c;
+  const defaultValues = {};
+  (_b = (_a = content == null ? void 0 : content.data) == null ? void 0 : _a.inputs) == null ? void 0 : _b.forEach((input) => {
+    var _a2;
+    if (input.name && input.defaultValue !== void 0 && ((_a2 = content == null ? void 0 : content.data) == null ? void 0 : _a2.state) && content.data.state[input.name] === void 0) {
+      defaultValues[input.name] = input.defaultValue;
+    }
+  });
+  const stateToUse = __spreadValues11(__spreadValues11(__spreadValues11({}, (_c = content == null ? void 0 : content.data) == null ? void 0 : _c.state), data), locale ? {
+    locale
+  } : {});
+  return __spreadValues11(__spreadValues11({}, defaultValues), stateToUse);
+};
+var getContentInitialValue = ({
+  content,
+  data
+}) => {
+  return !content ? void 0 : __spreadProps8(__spreadValues11({}, content), {
+    data: __spreadValues11(__spreadValues11({}, content == null ? void 0 : content.data), data),
+    meta: content == null ? void 0 : content.meta
+  });
+};
+
+// src/functions/get-global-this.js
+function getGlobalThis() {
+  if (typeof globalThis !== "undefined") {
+    return globalThis;
+  }
+  if (typeof window !== "undefined") {
+    return window;
+  }
+  if (typeof global !== "undefined") {
+    return global;
+  }
+  if (typeof self !== "undefined") {
+    return self;
+  }
+  return globalThis;
+}
+
+// src/functions/get-fetch.js
+function getFetch() {
+  const globalFetch = getGlobalThis().fetch;
+  if (typeof globalFetch === "undefined") {
+    throw new Error("Builder SDK could not find a global `fetch` function");
+  }
+  return globalFetch;
+}
+var fetch2 = getFetch();
+
+// src/helpers/url.js
+var getTopLevelDomain = (host) => {
+  if (host === "localhost" || host === "127.0.0.1") {
+    return host;
+  }
+  const parts = host.split(".");
+  if (parts.length > 2) {
+    return parts.slice(1).join(".");
+  }
+  return host;
+};
+
+// src/helpers/cookie.js
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var getCookieSync = ({
+  name,
+  canTrack
+}) => {
+  var _a;
+  try {
+    if (!canTrack) {
+      return void 0;
+    }
+    return (_a = document.cookie.split("; ").find((row) => row.startsWith(`${name}=`))) == null ? void 0 : _a.split("=")[1];
+  } catch (err) {
+    logger.warn("[COOKIE] GET error: ", (err == null ? void 0 : err.message) || err);
+    return void 0;
+  }
+};
+var getCookie = (args) => __async(void 0, null, function* () {
+  return getCookieSync(args);
+});
+var stringifyCookie = (cookie) => cookie.map(([key, value]) => value ? `${key}=${value}` : key).filter(checkIsDefined).join("; ");
+var SECURE_CONFIG = [["secure", ""], ["SameSite", "None"]];
+var createCookieString = ({
+  name,
+  value,
+  expires
+}) => {
+  const secure = isBrowser() ? location.protocol === "https:" : true;
+  const secureObj = secure ? SECURE_CONFIG : [[]];
+  const expiresObj = expires ? [["expires", expires.toUTCString()]] : [[]];
+  const cookieValue = [[name, value], ...expiresObj, ["path", "/"], ["domain", getTopLevelDomain(window.location.hostname)], ...secureObj];
+  const cookie = stringifyCookie(cookieValue);
+  return cookie;
+};
+var setCookie = (_0) => __async(void 0, [_0], function* ({
+  name,
+  value,
+  expires,
+  canTrack
+}) {
+  try {
+    if (!canTrack) {
+      return;
+    }
+    const cookie = createCookieString({
+      name,
+      value,
+      expires
+    });
+    document.cookie = cookie;
+  } catch (err) {
+    logger.warn("[COOKIE] SET error: ", (err == null ? void 0 : err.message) || err);
+  }
+});
+
+// src/helpers/uuid.js
+function uuidv4() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+    const r = Math.random() * 16 | 0, v = c == "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+function uuid() {
+  return uuidv4().replace(/-/g, "");
+}
+
+// src/helpers/sessionId.js
+var __async2 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var SESSION_LOCAL_STORAGE_KEY = "builderSessionId";
+var getSessionId = (_0) => __async2(void 0, [_0], function* ({
+  canTrack
+}) {
+  if (!canTrack) {
+    return void 0;
+  }
+  const sessionId = yield getCookie({
+    name: SESSION_LOCAL_STORAGE_KEY,
+    canTrack
+  });
+  if (checkIsDefined(sessionId)) {
+    return sessionId;
+  } else {
+    const newSessionId = createSessionId();
+    setSessionId({
+      id: newSessionId,
+      canTrack
+    });
+    return newSessionId;
+  }
+});
+var createSessionId = () => uuid();
+var setSessionId = ({
+  id,
+  canTrack
+}) => setCookie({
+  name: SESSION_LOCAL_STORAGE_KEY,
+  value: id,
+  canTrack
+});
+
+// src/helpers/localStorage.js
+var getLocalStorage = () => isBrowser() && typeof localStorage !== "undefined" ? localStorage : void 0;
+var getLocalStorageItem = ({
+  key,
+  canTrack
+}) => {
+  var _a;
+  try {
+    if (canTrack) {
+      return (_a = getLocalStorage()) == null ? void 0 : _a.getItem(key);
+    }
+    return void 0;
+  } catch (err) {
+    return void 0;
+  }
+};
+var setLocalStorageItem = ({
+  key,
+  canTrack,
+  value
+}) => {
+  var _a;
+  try {
+    if (canTrack) {
+      (_a = getLocalStorage()) == null ? void 0 : _a.setItem(key, value);
+    }
+  } catch (err) {
+  }
+};
+
+// src/helpers/visitorId.js
+var VISITOR_LOCAL_STORAGE_KEY = "builderVisitorId";
+var getVisitorId = ({
+  canTrack
+}) => {
+  if (!canTrack) {
+    return void 0;
+  }
+  const visitorId = getLocalStorageItem({
+    key: VISITOR_LOCAL_STORAGE_KEY,
+    canTrack
+  });
+  if (checkIsDefined(visitorId)) {
+    return visitorId;
+  } else {
+    const newVisitorId = createVisitorId();
+    setVisitorId({
+      id: newVisitorId,
+      canTrack
+    });
+    return newVisitorId;
+  }
+};
+var createVisitorId = () => uuid();
+var setVisitorId = ({
+  id,
+  canTrack
+}) => setLocalStorageItem({
+  key: VISITOR_LOCAL_STORAGE_KEY,
+  value: id,
+  canTrack
+});
+
+// src/functions/track/index.js
+var __defProp12 = Object.defineProperty;
+var __defProps9 = Object.defineProperties;
+var __getOwnPropDescs9 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols12 = Object.getOwnPropertySymbols;
+var __hasOwnProp12 = Object.prototype.hasOwnProperty;
+var __propIsEnum12 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp12 = (obj, key, value) => key in obj ? __defProp12(obj, key, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __spreadValues12 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp12.call(b, prop))
+      __defNormalProp12(a, prop, b[prop]);
+  if (__getOwnPropSymbols12)
+    for (var prop of __getOwnPropSymbols12(b)) {
+      if (__propIsEnum12.call(b, prop))
+        __defNormalProp12(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps9 = (a, b) => __defProps9(a, __getOwnPropDescs9(b));
+var __objRest3 = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp12.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols12)
+    for (var prop of __getOwnPropSymbols12(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum12.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __async3 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var getTrackingEventData = (_0) => __async3(void 0, [_0], function* ({
+  canTrack
+}) {
+  if (!canTrack) {
+    return {
+      visitorId: void 0,
+      sessionId: void 0
+    };
+  }
+  const sessionId = yield getSessionId({
+    canTrack
+  });
+  const visitorId = getVisitorId({
+    canTrack
+  });
+  return {
+    sessionId,
+    visitorId
+  };
+});
+var createEvent = (_a) => __async3(void 0, null, function* () {
+  var _b = _a, {
+    type: eventType,
+    canTrack,
+    apiKey,
+    metadata
+  } = _b, properties = __objRest3(_b, ["type", "canTrack", "apiKey", "metadata"]);
+  return {
+    type: eventType,
+    data: __spreadProps9(__spreadValues12(__spreadProps9(__spreadValues12({}, properties), {
+      metadata: __spreadValues12({
+        url: location.href
+      }, metadata)
+    }), yield getTrackingEventData({
+      canTrack
+    })), {
+      userAttributes: getUserAttributes(),
+      ownerId: apiKey
+    })
+  };
+});
+function _track(eventProps) {
+  return __async3(this, null, function* () {
+    if (!eventProps.apiKey) {
+      logger.error("Missing API key for track call. Please provide your API key.");
+      return;
+    }
+    if (!eventProps.canTrack) {
+      return;
+    }
+    if (isEditing()) {
+      return;
+    }
+    if (!(isBrowser() || TARGET === "reactNative")) {
+      return;
+    }
+    return fetch(`https://cdn.builder.io/api/v1/track`, {
+      method: "POST",
+      body: JSON.stringify({
+        events: [yield createEvent(eventProps)]
+      }),
+      headers: {
+        "content-type": "application/json"
+      },
+      mode: "cors"
+    }).catch((err) => {
+    });
+  });
+}
+var track = (args) => _track(__spreadProps9(__spreadValues12({}, args), {
+  canTrack: true
+}));
+
+// src/constants/sdk-version.js
+var SDK_VERSION = "0.6.1";
+
+// src/functions/register.js
+var registry = {};
+function register(type, info) {
+  let typeList = registry[type];
+  if (!typeList) {
+    typeList = registry[type] = [];
+  }
+  typeList.push(info);
+  if (isBrowser()) {
+    const message = {
+      type: "builder.register",
+      data: {
+        type,
+        info
+      }
+    };
+    try {
+      parent.postMessage(message, "*");
+      if (parent !== window) {
+        window.postMessage(message, "*");
+      }
+    } catch (err) {
+    }
+  }
+}
+
+// src/scripts/init-editing.js
+var registerInsertMenu = () => {
+  register("insertMenu", {
+    name: "_default",
+    default: true,
+    items: [{
+      name: "Box"
+    }, {
+      name: "Text"
+    }, {
+      name: "Image"
+    }, {
+      name: "Columns"
+    }, ...TARGET === "reactNative" ? [] : [{
+      name: "Core:Section"
+    }, {
+      name: "Core:Button"
+    }, {
+      name: "Embed"
+    }, {
+      name: "Custom Code"
+    }]]
+  });
+};
+var isSetupForEditing = false;
+var setupBrowserForEditing = (options = {}) => {
+  var _a, _b;
+  if (isSetupForEditing) {
+    return;
+  }
+  isSetupForEditing = true;
+  if (isBrowser()) {
+    (_a = window.parent) == null ? void 0 : _a.postMessage({
+      type: "builder.sdkInfo",
+      data: {
+        target: TARGET,
+        version: SDK_VERSION,
+        supportsPatchUpdates: false,
+        supportsAddBlockScoping: true,
+        supportsCustomBreakpoints: true
+      }
+    }, "*");
+    (_b = window.parent) == null ? void 0 : _b.postMessage({
+      type: "builder.updateContent",
+      data: {
+        options
+      }
+    }, "*");
+    window.addEventListener("message", ({
+      data
+    }) => {
+      var _a2, _b2;
+      if (!(data == null ? void 0 : data.type)) {
+        return;
+      }
+      switch (data.type) {
+        case "builder.evaluate": {
+          const text = data.data.text;
+          const args = data.data.arguments || [];
+          const id = data.data.id;
+          const fn = new Function(text);
+          let result;
+          let error = null;
+          try {
+            result = fn.apply(null, args);
+          } catch (err) {
+            error = err;
+          }
+          if (error) {
+            (_a2 = window.parent) == null ? void 0 : _a2.postMessage({
+              type: "builder.evaluateError",
+              data: {
+                id,
+                error: error.message
+              }
+            }, "*");
+          } else {
+            if (result && typeof result.then === "function") {
+              result.then((finalResult) => {
+                var _a3;
+                (_a3 = window.parent) == null ? void 0 : _a3.postMessage({
+                  type: "builder.evaluateResult",
+                  data: {
+                    id,
+                    result: finalResult
+                  }
+                }, "*");
+              }).catch(console.error);
+            } else {
+              (_b2 = window.parent) == null ? void 0 : _b2.postMessage({
+                type: "builder.evaluateResult",
+                data: {
+                  result,
+                  id
+                }
+              }, "*");
+            }
+          }
+          break;
+        }
+      }
+    });
+  }
+};
+
+// src/functions/track/interaction.js
+function round(num) {
+  return Math.round(num * 1e3) / 1e3;
+}
+var findParentElement = (target, callback, checkElement = true) => {
+  if (!(target instanceof HTMLElement)) {
+    return null;
+  }
+  let parent2 = checkElement ? target : target.parentElement;
+  do {
+    if (!parent2) {
+      return null;
+    }
+    const matches = callback(parent2);
+    if (matches) {
+      return parent2;
+    }
+  } while (parent2 = parent2.parentElement);
+  return null;
+};
+var findBuilderParent = (target) => findParentElement(target, (el) => {
+  const id = el.getAttribute("builder-id") || el.id;
+  return Boolean((id == null ? void 0 : id.indexOf("builder-")) === 0);
+});
+var computeOffset = ({
+  event,
+  target
+}) => {
+  const targetRect = target.getBoundingClientRect();
+  const xOffset = event.clientX - targetRect.left;
+  const yOffset = event.clientY - targetRect.top;
+  const xRatio = round(xOffset / targetRect.width);
+  const yRatio = round(yOffset / targetRect.height);
+  return {
+    x: xRatio,
+    y: yRatio
+  };
+};
+var getInteractionPropertiesForEvent = (event) => {
+  const target = event.target;
+  const targetBuilderElement = target && findBuilderParent(target);
+  const builderId = (targetBuilderElement == null ? void 0 : targetBuilderElement.getAttribute("builder-id")) || (targetBuilderElement == null ? void 0 : targetBuilderElement.id);
+  return {
+    targetBuilderElement: builderId || void 0,
+    metadata: {
+      targetOffset: target ? computeOffset({
+        event,
+        target
+      }) : void 0,
+      builderTargetOffset: targetBuilderElement ? computeOffset({
+        event,
+        target: targetBuilderElement
+      }) : void 0,
+      builderElementIndex: targetBuilderElement && builderId ? [].slice.call(document.getElementsByClassName(builderId)).indexOf(targetBuilderElement) : void 0
+    }
+  };
+};
+
+// src/helpers/ab-tests.js
+var __defProp13 = Object.defineProperty;
+var __getOwnPropSymbols13 = Object.getOwnPropertySymbols;
+var __hasOwnProp13 = Object.prototype.hasOwnProperty;
+var __propIsEnum13 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp13 = (obj, key, value) => key in obj ? __defProp13(obj, key, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __spreadValues13 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp13.call(b, prop))
+      __defNormalProp13(a, prop, b[prop]);
+  if (__getOwnPropSymbols13)
+    for (var prop of __getOwnPropSymbols13(b)) {
+      if (__propIsEnum13.call(b, prop))
+        __defNormalProp13(a, prop, b[prop]);
+    }
+  return a;
+};
+var __async4 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var BUILDER_STORE_PREFIX = "builder.tests";
+var getContentTestKey = (id) => `${BUILDER_STORE_PREFIX}.${id}`;
+var getContentVariationCookie = ({
+  contentId
+}) => getCookie({
+  name: getContentTestKey(contentId),
+  canTrack: true
+});
+var getContentVariationCookieSync = ({
+  contentId
+}) => getCookieSync({
+  name: getContentTestKey(contentId),
+  canTrack: true
+});
+var setContentVariationCookie = ({
+  contentId,
+  value
+}) => setCookie({
+  name: getContentTestKey(contentId),
+  value,
+  canTrack: true
+});
+var checkIsBuilderContentWithVariations = (item) => checkIsDefined(item.id) && checkIsDefined(item.variations) && Object.keys(item.variations).length > 0;
+var getRandomVariationId = ({
+  id,
+  variations
+}) => {
+  var _a;
+  let n = 0;
+  const random = Math.random();
+  for (const id2 in variations) {
+    const testRatio = (_a = variations[id2]) == null ? void 0 : _a.testRatio;
+    n += testRatio;
+    if (random < n) {
+      return id2;
+    }
+  }
+  return id;
+};
+var getAndSetVariantId = (args) => {
+  const randomVariationId = getRandomVariationId(args);
+  setContentVariationCookie({
+    contentId: args.id,
+    value: randomVariationId
+  }).catch((err) => {
+    logger.error("could not store A/B test variation: ", err);
+  });
+  return randomVariationId;
+};
+var getTestFields = ({
+  item,
+  testGroupId
+}) => {
+  const variationValue = item.variations[testGroupId];
+  if (testGroupId === item.id || !variationValue) {
+    return {
+      testVariationId: item.id,
+      testVariationName: "Default"
+    };
+  } else {
+    return {
+      data: variationValue.data,
+      testVariationId: variationValue.id,
+      testVariationName: variationValue.name || (variationValue.id === item.id ? "Default" : "")
+    };
+  }
+};
+var handleABTestingSync = ({
+  item,
+  canTrack
+}) => {
+  if (TARGET === "reactNative")
+    return item;
+  if (!canTrack) {
+    return item;
+  }
+  if (!item) {
+    return void 0;
+  }
+  if (!checkIsBuilderContentWithVariations(item)) {
+    return item;
+  }
+  const testGroupId = getContentVariationCookieSync({
+    contentId: item.id
+  }) || getAndSetVariantId({
+    variations: item.variations,
+    id: item.id
+  });
+  const variationValue = getTestFields({
+    item,
+    testGroupId
+  });
+  return __spreadValues13(__spreadValues13({}, item), variationValue);
+};
+var handleABTesting = (_0) => __async4(void 0, [_0], function* ({
+  item,
+  canTrack
+}) {
+  if (!canTrack) {
+    return item;
+  }
+  if (!checkIsBuilderContentWithVariations(item)) {
+    return item;
+  }
+  const cookieValue = yield getContentVariationCookie({
+    contentId: item.id
+  });
+  const testGroupId = cookieValue || getAndSetVariantId({
+    variations: item.variations,
+    id: item.id
+  });
+  const variationValue = getTestFields({
+    item,
+    testGroupId
+  });
+  return __spreadValues13(__spreadValues13({}, item), variationValue);
+});
+
+// src/helpers/canTrack.js
+var getDefaultCanTrack = (canTrack) => checkIsDefined(canTrack) ? canTrack : true;
+
+// src/helpers/preview-lru-cache/get.js
+function getPreviewContent(_searchParams) {
+  return void 0;
+}
+
+// src/helpers/flatten.js
+var __defProp14 = Object.defineProperty;
+var __defProps10 = Object.defineProperties;
+var __getOwnPropDescs10 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols14 = Object.getOwnPropertySymbols;
+var __hasOwnProp14 = Object.prototype.hasOwnProperty;
+var __propIsEnum14 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp14 = (obj, key, value) => key in obj ? __defProp14(obj, key, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __spreadValues14 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp14.call(b, prop))
+      __defNormalProp14(a, prop, b[prop]);
+  if (__getOwnPropSymbols14)
+    for (var prop of __getOwnPropSymbols14(b)) {
+      if (__propIsEnum14.call(b, prop))
+        __defNormalProp14(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps10 = (a, b) => __defProps10(a, __getOwnPropDescs10(b));
+function flatten(object, path = null, separator = ".") {
+  return Object.keys(object).reduce((acc, key) => {
+    const value = object[key];
+    const newPath = [path, key].filter(Boolean).join(separator);
+    const isObject = [typeof value === "object", value !== null, !(Array.isArray(value) && value.length === 0)].every(Boolean);
+    return isObject ? __spreadValues14(__spreadValues14({}, acc), flatten(value, newPath, separator)) : __spreadProps10(__spreadValues14({}, acc), {
+      [newPath]: value
+    });
+  }, {});
+}
+
+// src/functions/get-builder-search-params/index.js
+var BUILDER_SEARCHPARAMS_PREFIX = "builder.";
+var BUILDER_OPTIONS_PREFIX = "options.";
+var convertSearchParamsToQueryObject = (searchParams) => {
+  const options = {};
+  searchParams.forEach((value, key) => {
+    options[key] = value;
+  });
+  return options;
+};
+var getBuilderSearchParams = (_options) => {
+  if (!_options) {
+    return {};
+  }
+  const options = normalizeSearchParams(_options);
+  const newOptions = {};
+  Object.keys(options).forEach((key) => {
+    if (key.startsWith(BUILDER_SEARCHPARAMS_PREFIX)) {
+      const trimmedKey = key.replace(BUILDER_SEARCHPARAMS_PREFIX, "").replace(BUILDER_OPTIONS_PREFIX, "");
+      newOptions[trimmedKey] = options[key];
+    }
+  });
+  return newOptions;
+};
+var getBuilderSearchParamsFromWindow = () => {
+  if (!isBrowser()) {
+    return {};
+  }
+  const searchParams = new URLSearchParams(window.location.search);
+  return getBuilderSearchParams(searchParams);
+};
+var normalizeSearchParams = (searchParams) => searchParams instanceof URLSearchParams ? convertSearchParamsToQueryObject(searchParams) : searchParams;
+
+// src/types/api-version.js
+var DEFAULT_API_VERSION = "v3";
+
+// src/functions/get-content/generate-content-url.js
+var __defProp15 = Object.defineProperty;
+var __getOwnPropSymbols15 = Object.getOwnPropertySymbols;
+var __hasOwnProp15 = Object.prototype.hasOwnProperty;
+var __propIsEnum15 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp15 = (obj, key, value) => key in obj ? __defProp15(obj, key, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __spreadValues15 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp15.call(b, prop))
+      __defNormalProp15(a, prop, b[prop]);
+  if (__getOwnPropSymbols15)
+    for (var prop of __getOwnPropSymbols15(b)) {
+      if (__propIsEnum15.call(b, prop))
+        __defNormalProp15(a, prop, b[prop]);
+    }
+  return a;
+};
+var generateContentUrl = (options) => {
+  const {
+    limit = 30,
+    userAttributes,
+    query,
+    noTraverse = false,
+    model,
+    apiKey,
+    includeRefs = true,
+    enrich,
+    locale,
+    apiVersion = DEFAULT_API_VERSION
+  } = options;
+  if (!apiKey) {
+    throw new Error("Missing API key");
+  }
+  if (!["v2", "v3"].includes(apiVersion)) {
+    throw new Error(`Invalid apiVersion: expected 'v2' or 'v3', received '${apiVersion}'`);
+  }
+  const url = new URL(`https://cdn.builder.io/api/${apiVersion}/content/${model}?apiKey=${apiKey}&limit=${limit}&noTraverse=${noTraverse}&includeRefs=${includeRefs}${locale ? `&locale=${locale}` : ""}${enrich ? `&enrich=${enrich}` : ""}`);
+  const queryOptions = __spreadValues15(__spreadValues15({}, getBuilderSearchParamsFromWindow()), normalizeSearchParams(options.options || {}));
+  const flattened = flatten(queryOptions);
+  for (const key in flattened) {
+    url.searchParams.set(key, String(flattened[key]));
+  }
+  if (userAttributes) {
+    url.searchParams.set("userAttributes", JSON.stringify(userAttributes));
+  }
+  if (query) {
+    const flattened2 = flatten({
+      query
+    });
+    for (const key in flattened2) {
+      url.searchParams.set(key, JSON.stringify(flattened2[key]));
+    }
+  }
+  return url;
+};
+
+// src/functions/get-content/index.js
+var __defProp16 = Object.defineProperty;
+var __defProps11 = Object.defineProperties;
+var __getOwnPropDescs11 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols16 = Object.getOwnPropertySymbols;
+var __hasOwnProp16 = Object.prototype.hasOwnProperty;
+var __propIsEnum16 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp16 = (obj, key, value) => key in obj ? __defProp16(obj, key, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __spreadValues16 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp16.call(b, prop))
+      __defNormalProp16(a, prop, b[prop]);
+  if (__getOwnPropSymbols16)
+    for (var prop of __getOwnPropSymbols16(b)) {
+      if (__propIsEnum16.call(b, prop))
+        __defNormalProp16(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps11 = (a, b) => __defProps11(a, __getOwnPropDescs11(b));
+var __async5 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var checkContentHasResults = (content) => "results" in content;
+function fetchOneEntry(options) {
+  return __async5(this, null, function* () {
+    const allContent = yield fetchEntries(__spreadProps11(__spreadValues16({}, options), {
+      limit: 1
+    }));
+    if (allContent) {
+      return allContent.results[0] || null;
+    }
+    return null;
+  });
+}
+var getContent = fetchOneEntry;
+var _fetchContent = (options) => __async5(void 0, null, function* () {
+  const url = generateContentUrl(options);
+  const res = yield fetch2(url.href);
+  const content = yield res.json();
+  return content;
+});
+var _processContentResult = (_0, _1, ..._2) => __async5(void 0, [_0, _1, ..._2], function* (options, content, url = generateContentUrl(options)) {
+  const canTrack = getDefaultCanTrack(options.canTrack);
+  const isPreviewing2 = url.search.includes(`preview=`);
+  if (TARGET === "rsc" && isPreviewing2) {
+    const newResults = [];
+    for (const item of content.results) {
+      getPreviewContent(url.searchParams);
+      newResults.push(item);
+    }
+    content.results = newResults;
+  }
+  if (!canTrack)
+    return content;
+  if (!(isBrowser() || TARGET === "reactNative"))
+    return content;
+  try {
+    const newResults = [];
+    for (const item of content.results) {
+      newResults.push(yield handleABTesting({
+        item,
+        canTrack
+      }));
+    }
+    content.results = newResults;
+  } catch (e) {
+    logger.error("Could not process A/B tests. ", e);
+  }
+  return content;
+});
+function fetchEntries(options) {
+  return __async5(this, null, function* () {
+    try {
+      const url = generateContentUrl(options);
+      const content = yield _fetchContent(options);
+      if (!checkContentHasResults(content)) {
+        logger.error("Error fetching data. ", {
+          url,
+          content,
+          options
+        });
+        return null;
+      }
+      return _processContentResult(options, content);
+    } catch (error) {
+      logger.error("Error fetching data. ", error);
+      return null;
+    }
+  });
+}
+var getAllContent = fetchEntries;
+
+// src/functions/is-previewing.js
+function isPreviewing() {
+  if (!isBrowser()) {
+    return false;
+  }
+  if (isEditing()) {
+    return false;
+  }
+  return Boolean(location.search.indexOf("builder.preview=") !== -1);
+}
+
+// src/components/content/components/enable-editor.jsx
+var _tmpl$14 = /* @__PURE__ */ template(`<div>`);
+function EnableEditor(props) {
+  const [canTrackToUse, setCanTrackToUse] = createSignal(checkIsDefined(props.canTrack) ? props.canTrack : true);
+  const [forceReRenderCount, setForceReRenderCount] = createSignal(0);
+  createSignal(0);
+  const [shouldSendResetCookie, setShouldSendResetCookie] = createSignal(false);
+  const [httpReqsData, setHttpReqsData] = createSignal({});
+  const [clicked, setClicked] = createSignal(false);
+  function mergeNewContent(newContent) {
+    const newContentValue = {
+      ...props.builderContextSignal.content,
+      ...newContent,
+      data: {
+        ...props.builderContextSignal.content?.data,
+        ...newContent?.data
+      },
+      meta: {
+        ...props.builderContextSignal.content?.meta,
+        ...newContent?.meta,
+        breakpoints: newContent?.meta?.breakpoints || props.builderContextSignal.content?.meta?.breakpoints
+      }
+    };
+    props.setBuilderContextSignal((PREVIOUS_VALUE) => ({
+      ...PREVIOUS_VALUE,
+      content: newContentValue
+    }));
+  }
+  function processMessage(event) {
+    const {
+      data
+    } = event;
+    if (data) {
+      switch (data.type) {
+        case "builder.configureSdk": {
+          const messageContent = data.data;
+          const {
+            breakpoints,
+            contentId
+          } = messageContent;
+          if (!contentId || contentId !== props.builderContextSignal.content?.id) {
+            return;
+          }
+          if (breakpoints) {
+            mergeNewContent({
+              meta: {
+                breakpoints
+              }
+            });
+          }
+          setForceReRenderCount(forceReRenderCount() + 1);
+          break;
+        }
+        case "builder.contentUpdate": {
+          const messageContent = data.data;
+          const key = messageContent.key || messageContent.alias || messageContent.entry || messageContent.modelName;
+          const contentData = messageContent.data;
+          if (key === props.model) {
+            mergeNewContent(contentData);
+            setForceReRenderCount(forceReRenderCount() + 1);
+          }
+          break;
+        }
+      }
+    }
+  }
+  function evaluateJsCode() {
+    const jsCode = props.builderContextSignal.content?.data?.jsCode;
+    if (jsCode) {
+      evaluate({
+        code: jsCode,
+        context: props.context || {},
+        localState: void 0,
+        rootState: props.builderContextSignal.rootState,
+        rootSetState: props.builderContextSignal.rootSetState
+      });
+    }
+  }
+  function onClick(event) {
+    if (props.builderContextSignal.content) {
+      const variationId = props.builderContextSignal.content?.testVariationId;
+      const contentId = props.builderContextSignal.content?.id;
+      _track({
+        type: "click",
+        canTrack: canTrackToUse(),
+        contentId,
+        apiKey: props.apiKey,
+        variationId: variationId !== contentId ? variationId : void 0,
+        ...getInteractionPropertiesForEvent(event),
+        unique: !clicked()
+      });
+    }
+    if (!clicked()) {
+      setClicked(true);
+    }
+  }
+  function evalExpression(expression) {
+    return expression.replace(/{{([^}]+)}}/g, (_match, group) => evaluate({
+      code: group,
+      context: props.context || {},
+      localState: void 0,
+      rootState: props.builderContextSignal.rootState,
+      rootSetState: props.builderContextSignal.rootSetState
+    }));
+  }
+  function handleRequest({
+    url,
+    key
+  }) {
+    fetch2(url).then((response) => response.json()).then((json) => {
+      const newState = {
+        ...props.builderContextSignal.rootState,
+        [key]: json
+      };
+      props.builderContextSignal.rootSetState?.(newState);
+      httpReqsData()[key] = true;
+    }).catch((err) => {
+    });
+  }
+  function runHttpRequests() {
+    const requests = props.builderContextSignal.content?.data?.httpRequests ?? {};
+    Object.entries(requests).forEach(([key, url]) => {
+      if (url && (!httpReqsData()[key] || isEditing())) {
+        const evaluatedUrl = evalExpression(url);
+        handleRequest({
+          url: evaluatedUrl,
+          key
+        });
+      }
+    });
+  }
+  function emitStateUpdate() {
+    if (isEditing()) {
+      window.dispatchEvent(new CustomEvent("builder:component:stateChange", {
+        detail: {
+          state: fastClone(props.builderContextSignal.rootState),
+          ref: {
+            name: props.model
+          }
+        }
+      }));
+    }
+  }
+  let elementRef;
+  onMount(() => {
+    if (!props.apiKey) {
+      logger.error("No API key provided to `RenderContent` component. This can cause issues. Please provide an API key using the `apiKey` prop.");
+    }
+    if (isBrowser()) {
+      if (isEditing()) {
+        setForceReRenderCount(forceReRenderCount() + 1);
+        window.addEventListener("message", processMessage);
+        registerInsertMenu();
+        setupBrowserForEditing({
+          ...props.locale ? {
+            locale: props.locale
+          } : {},
+          ...props.includeRefs ? {
+            includeRefs: props.includeRefs
+          } : {},
+          ...props.enrich ? {
+            enrich: props.enrich
+          } : {}
+        });
+        Object.values(props.builderContextSignal.componentInfos).forEach((registeredComponent) => {
+          const message = createRegisterComponentMessage(registeredComponent);
+          window.parent?.postMessage(message, "*");
+        });
+        window.addEventListener("builder:component:stateChangeListenerActivated", emitStateUpdate);
+      }
+      if (props.builderContextSignal.content) {
+        const variationId = props.builderContextSignal.content?.testVariationId;
+        const contentId = props.builderContextSignal.content?.id;
+        _track({
+          type: "impression",
+          canTrack: canTrackToUse(),
+          contentId,
+          apiKey: props.apiKey,
+          variationId: variationId !== contentId ? variationId : void 0
+        });
+      }
+      if (isPreviewing()) {
+        const searchParams = new URL(location.href).searchParams;
+        const searchParamPreviewModel = searchParams.get("builder.preview");
+        const searchParamPreviewId = searchParams.get(`builder.preview.${searchParamPreviewModel}`);
+        const previewApiKey = searchParams.get("apiKey") || searchParams.get("builder.space");
+        if (searchParamPreviewModel === props.model && previewApiKey === props.apiKey && (!props.content || searchParamPreviewId === props.content.id)) {
+          fetchOneEntry({
+            model: props.model,
+            apiKey: props.apiKey,
+            apiVersion: props.builderContextSignal.apiVersion
+          }).then((content) => {
+            if (content) {
+              mergeNewContent(content);
+            }
+          });
+        }
+      }
+      evaluateJsCode();
+      runHttpRequests();
+      emitStateUpdate();
+    }
+  });
+  function onUpdateFn_0() {
+    if (props.content) {
+      mergeNewContent(props.content);
+    }
+  }
+  createEffect(on(() => [props.content], onUpdateFn_0));
+  function onUpdateFn_1() {
+  }
+  createEffect(on(() => [shouldSendResetCookie()], onUpdateFn_1));
+  function onUpdateFn_2() {
+    evaluateJsCode();
+  }
+  createEffect(on(() => [props.builderContextSignal.content?.data?.jsCode, props.builderContextSignal.rootState], onUpdateFn_2));
+  function onUpdateFn_3() {
+    runHttpRequests();
+  }
+  createEffect(on(() => [props.builderContextSignal.content?.data?.httpRequests], onUpdateFn_3));
+  function onUpdateFn_4() {
+    emitStateUpdate();
+  }
+  createEffect(on(() => [props.builderContextSignal.rootState], onUpdateFn_4));
+  return createComponent(stdin_default.Provider, {
+    get value() {
+      return props.builderContextSignal;
+    },
+    get children() {
+      return createComponent(Show, {
+        get when() {
+          return props.builderContextSignal.content;
+        },
+        get children() {
+          const _el$ = _tmpl$14();
+          _el$.$$click = (event) => onClick(event);
+          const _ref$ = elementRef;
+          typeof _ref$ === "function" ? use(_ref$, _el$) : elementRef = _el$;
+          spread(_el$, mergeProps({
+            get ["class"]() {
+              return props.classNameProp;
+            },
+            get key() {
+              return forceReRenderCount();
+            },
+            get ["builder-content-id"]() {
+              return props.builderContextSignal.content?.id;
+            },
+            get ["builder-model"]() {
+              return props.model;
+            }
+          }, {}, () => props.showContent ? {} : {
+            hidden: true,
+            "aria-hidden": true
+          }), false, true);
+          insert(_el$, () => props.children);
+          return _el$;
+        }
+      });
+    }
+  });
+}
+var enable_editor_default = EnableEditor;
+delegateEvents(["click"]);
+var _tmpl$15 = /* @__PURE__ */ template(`<script>`);
+function InlinedScript(props) {
+  return (() => {
+    const _el$ = _tmpl$15();
+    effect((_p$) => {
+      const _v$ = props.scriptStr, _v$2 = props.id;
+      _v$ !== _p$._v$ && (_el$.innerHTML = _p$._v$ = _v$);
+      _v$2 !== _p$._v$2 && setAttribute(_el$, "id", _p$._v$2 = _v$2);
+      return _p$;
+    }, {
+      _v$: void 0,
+      _v$2: void 0
+    });
+    return _el$;
+  })();
+}
+var inlined_script_default = InlinedScript;
+
+// src/components/content/content.jsx
+function ContentComponent(props) {
+  const [scriptStr, setScriptStr] = createSignal(getRenderContentScriptString({
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion, @typescript-eslint/no-non-null-asserted-optional-chain
+    variationId: props.content?.testVariationId,
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion, @typescript-eslint/no-non-null-asserted-optional-chain
+    contentId: props.content?.id
+  }));
+  const [registeredComponents, setRegisteredComponents] = createSignal([
+    ...getDefaultRegisteredComponents(),
+    // While this `components` object is deprecated, we must maintain support for it.
+    // Since users are able to override our default components, we need to make sure that we do not break such
+    // existing usage.
+    // This is why we spread `components` after the default Builder.io components, but before the `props.customComponents`,
+    // which is the new standard way of providing custom components, and must therefore take precedence.
+    ...components,
+    ...props.customComponents || []
+  ].reduce((acc, {
+    component,
+    ...info
+  }) => ({
+    ...acc,
+    [info.name]: {
+      component,
+      ...serializeComponentInfo(info)
+    }
+  }), {}));
+  const [builderContextSignal, setBuilderContextSignal] = createSignal({
+    content: getContentInitialValue({
+      content: props.content,
+      data: props.data
+    }),
+    localState: void 0,
+    rootState: getContextStateInitialValue({
+      content: props.content,
+      data: props.data,
+      locale: props.locale
+    }),
+    rootSetState: contentSetState,
+    context: props.context || {},
+    apiKey: props.apiKey,
+    apiVersion: props.apiVersion,
+    componentInfos: [
+      ...getDefaultRegisteredComponents(),
+      // While this `components` object is deprecated, we must maintain support for it.
+      // Since users are able to override our default components, we need to make sure that we do not break such
+      // existing usage.
+      // This is why we spread `components` after the default Builder.io components, but before the `props.customComponents`,
+      // which is the new standard way of providing custom components, and must therefore take precedence.
+      ...components,
+      ...props.customComponents || []
+    ].reduce((acc, {
+      component: _,
+      ...info
+    }) => ({
+      ...acc,
+      [info.name]: serializeComponentInfo(info)
+    }), {}),
+    inheritedStyles: {}
+  });
+  function contentSetState(newRootState) {
+    setBuilderContextSignal((PREVIOUS_VALUE) => ({
+      ...PREVIOUS_VALUE,
+      rootState: newRootState
+    }));
+  }
+  return createComponent(stdin_default2.Provider, {
+    get value() {
+      return {
+        registeredComponents: registeredComponents()
+      };
+    },
+    get children() {
+      return createComponent(enable_editor_default, mergeProps({
+        get content() {
+          return props.content;
+        },
+        get model() {
+          return props.model;
+        },
+        get context() {
+          return props.context;
+        },
+        get apiKey() {
+          return props.apiKey;
+        },
+        get canTrack() {
+          return props.canTrack;
+        },
+        get locale() {
+          return props.locale;
+        },
+        get includeRefs() {
+          return props.includeRefs;
+        },
+        get enrich() {
+          return props.enrich;
+        },
+        get classNameProp() {
+          return props.classNameProp;
+        },
+        get showContent() {
+          return props.showContent;
+        },
+        get builderContextSignal() {
+          return builderContextSignal();
+        }
+      }, {
+        setBuilderContextSignal
+      }, {
+        get children() {
+          return [createComponent(Show, {
+            get when() {
+              return props.isSsrAbTest;
+            },
+            get children() {
+              return createComponent(inlined_script_default, {
+                get scriptStr() {
+                  return scriptStr();
+                }
+              });
+            }
+          }), createComponent(Show, {
+            when: TARGET !== "reactNative",
+            get children() {
+              return createComponent(styles_default, {
+                get contentId() {
+                  return builderContextSignal().content?.id;
+                },
+                get cssCode() {
+                  return builderContextSignal().content?.data?.cssCode;
+                },
+                get customFonts() {
+                  return builderContextSignal().content?.data?.customFonts;
+                }
+              });
+            }
+          }), createComponent(blocks_default, {
+            get blocks() {
+              return builderContextSignal().content?.data?.blocks;
+            },
+            get context() {
+              return builderContextSignal();
+            },
+            get registeredComponents() {
+              return registeredComponents();
+            }
+          })];
+        }
+      }));
+    }
+  });
+}
+var content_default = ContentComponent;
+
+// src/components/content-variants/content-variants.jsx
+function ContentVariants(props) {
+  const [shouldRenderVariants, setShouldRenderVariants] = createSignal(checkShouldRunVariants({
+    canTrack: getDefaultCanTrack(props.canTrack),
+    content: props.content
+  }));
+  function variantScriptStr() {
+    return getVariantsScriptString(getVariants(props.content).map((value) => ({
+      id: value.testVariationId,
+      testRatio: value.testRatio
+    })), props.content?.id || "");
+  }
+  function hideVariantsStyleString() {
+    return getVariants(props.content).map((value) => `.variant-${value.testVariationId} { display: none; } `).join("");
+  }
+  function defaultContent() {
+    return shouldRenderVariants() ? {
+      ...props.content,
+      testVariationId: props.content?.id
+    } : handleABTestingSync({
+      item: props.content,
+      canTrack: getDefaultCanTrack(props.canTrack)
+    });
+  }
+  onMount(() => {
+  });
+  return [createComponent(Show, {
+    get when() {
+      return !props.__isNestedRender && TARGET !== "reactNative";
+    },
+    get children() {
+      return createComponent(inlined_script_default, {
+        get scriptStr() {
+          return getScriptString();
+        }
+      });
+    }
+  }), createComponent(Show, {
+    get when() {
+      return shouldRenderVariants();
+    },
+    get children() {
+      return [createComponent(inlined_styles_default, {
+        get id() {
+          return `variants-styles-${props.content?.id}`;
+        },
+        get styles() {
+          return hideVariantsStyleString();
+        }
+      }), createComponent(inlined_script_default, {
+        get scriptStr() {
+          return variantScriptStr();
+        }
+      }), createComponent(For, {
+        get each() {
+          return getVariants(props.content);
+        },
+        children: (variant, _index) => {
+          _index();
+          return createComponent(content_default, {
+            get key() {
+              return variant.testVariationId;
+            },
+            content: variant,
+            showContent: false,
+            classNameProp: void 0,
+            get model() {
+              return props.model;
+            },
+            get data() {
+              return props.data;
+            },
+            get context() {
+              return props.context;
+            },
+            get apiKey() {
+              return props.apiKey;
+            },
+            get apiVersion() {
+              return props.apiVersion;
+            },
+            get customComponents() {
+              return props.customComponents;
+            },
+            get canTrack() {
+              return props.canTrack;
+            },
+            get locale() {
+              return props.locale;
+            },
+            get includeRefs() {
+              return props.includeRefs;
+            },
+            get enrich() {
+              return props.enrich;
+            },
+            get isSsrAbTest() {
+              return shouldRenderVariants();
+            }
+          });
+        }
+      })];
+    }
+  }), createComponent(content_default, mergeProps({}, {
+    get content() {
+      return defaultContent();
+    },
+    get classNameProp() {
+      return `variant-${props.content?.id}`;
+    },
+    showContent: true,
+    get model() {
+      return props.model;
+    },
+    get data() {
+      return props.data;
+    },
+    get context() {
+      return props.context;
+    },
+    get apiKey() {
+      return props.apiKey;
+    },
+    get apiVersion() {
+      return props.apiVersion;
+    },
+    get customComponents() {
+      return props.customComponents;
+    },
+    get canTrack() {
+      return props.canTrack;
+    },
+    get locale() {
+      return props.locale;
+    },
+    get includeRefs() {
+      return props.includeRefs;
+    },
+    get enrich() {
+      return props.enrich;
+    },
+    get isSsrAbTest() {
+      return shouldRenderVariants();
+    }
+  }))];
+}
+var content_variants_default = ContentVariants;
+
+// src/blocks/symbol/symbol.helpers.js
+var __defProp17 = Object.defineProperty;
+var __getOwnPropSymbols17 = Object.getOwnPropertySymbols;
+var __hasOwnProp17 = Object.prototype.hasOwnProperty;
+var __propIsEnum17 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp17 = (obj, key, value) => key in obj ? __defProp17(obj, key, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __spreadValues17 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp17.call(b, prop))
+      __defNormalProp17(a, prop, b[prop]);
+  if (__getOwnPropSymbols17)
+    for (var prop of __getOwnPropSymbols17(b)) {
+      if (__propIsEnum17.call(b, prop))
+        __defNormalProp17(a, prop, b[prop]);
+    }
+  return a;
+};
+var __async6 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var fetchSymbolContent = (_0) => __async6(void 0, [_0], function* ({
+  builderContextValue,
+  symbol
+}) {
+  if ((symbol == null ? void 0 : symbol.model) && (builderContextValue == null ? void 0 : builderContextValue.apiKey)) {
+    return fetchOneEntry(__spreadValues17({
+      model: symbol.model,
+      apiKey: builderContextValue.apiKey,
+      apiVersion: builderContextValue.apiVersion
+    }, (symbol == null ? void 0 : symbol.entry) && {
+      query: {
+        id: symbol.entry
+      }
+    })).catch((err) => {
+      logger.error("Could not fetch symbol content: ", err);
+      return void 0;
+    });
+  }
+  return void 0;
+});
+
+// src/blocks/symbol/symbol.jsx
+var _tmpl$16 = /* @__PURE__ */ template(`<div>`);
+function Symbol(props) {
+  const [contentToUse, setContentToUse] = createSignal(props.symbol?.content);
+  function className() {
+    return [...[props.attributes.class], "builder-symbol", props.symbol?.inline ? "builder-inline-symbol" : void 0, props.symbol?.dynamic || props.dynamic ? "builder-dynamic-symbol" : void 0].filter(Boolean).join(" ");
+  }
+  function setContent() {
+    if (contentToUse())
+      return;
+    fetchSymbolContent({
+      symbol: props.symbol,
+      builderContextValue: props.builderContext
+    }).then((newContent) => {
+      if (newContent) {
+        setContentToUse(newContent);
+      }
+    });
+  }
+  onMount(() => {
+    setContent();
+  });
+  function onUpdateFn_0() {
+    setContent();
+  }
+  createEffect(on(() => [props.symbol], onUpdateFn_0));
+  return (() => {
+    const _el$ = _tmpl$16();
+    spread(_el$, mergeProps({
+      get ["class"]() {
+        return className();
+      }
+    }, {}, () => props.attributes, {}), false, true);
+    insert(_el$, createComponent(content_variants_default, {
+      __isNestedRender: true,
+      get apiVersion() {
+        return props.builderContext.apiVersion;
+      },
+      get apiKey() {
+        return props.builderContext.apiKey;
+      },
+      get context() {
+        return props.builderContext.context;
+      },
+      get customComponents() {
+        return Object.values(props.builderComponents);
+      },
+      get data() {
+        return {
+          ...props.symbol?.data,
+          ...props.builderContext.localState,
+          ...contentToUse()?.data?.state
+        };
+      },
+      get model() {
+        return props.symbol?.model;
+      },
+      get content() {
+        return contentToUse();
+      }
+    }));
+    return _el$;
+  })();
+}
+var symbol_default = Symbol;
+
+// src/index-helpers/blocks-exports.js
+var RenderBlocks = blocks_default;
+var RenderContent = content_variants_default;
+
+// src/functions/set-editor-settings.js
+var settings = {};
+function setEditorSettings(newSettings) {
+  if (isBrowser()) {
+    Object.assign(settings, newSettings);
+    const message = {
+      type: "builder.settingsChange",
+      data: settings
+    };
+    parent.postMessage(message, "*");
+  }
+}
+
+// src/functions/fetch-builder-props.js
+var __defProp18 = Object.defineProperty;
+var __defProps12 = Object.defineProperties;
+var __getOwnPropDescs12 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols18 = Object.getOwnPropertySymbols;
+var __hasOwnProp18 = Object.prototype.hasOwnProperty;
+var __propIsEnum18 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp18 = (obj, key, value) => key in obj ? __defProp18(obj, key, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __spreadValues18 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp18.call(b, prop))
+      __defNormalProp18(a, prop, b[prop]);
+  if (__getOwnPropSymbols18)
+    for (var prop of __getOwnPropSymbols18(b)) {
+      if (__propIsEnum18.call(b, prop))
+        __defNormalProp18(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps12 = (a, b) => __defProps12(a, __getOwnPropDescs12(b));
+var __async7 = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+var fetchBuilderProps = (_args) => __async7(void 0, null, function* () {
+  var _a, _b, _c;
+  const urlPath = _args.path || ((_a = _args.url) == null ? void 0 : _a.pathname) || ((_b = _args.userAttributes) == null ? void 0 : _b.urlPath);
+  const getContentArgs = __spreadProps12(__spreadValues18({}, _args), {
+    apiKey: _args.apiKey,
+    model: _args.model || "page",
+    userAttributes: __spreadValues18(__spreadValues18({}, _args.userAttributes), urlPath ? {
+      urlPath
+    } : {}),
+    options: getBuilderSearchParams(_args.searchParams || ((_c = _args.url) == null ? void 0 : _c.searchParams) || _args.options)
+  });
+  return {
+    apiKey: getContentArgs.apiKey,
+    model: getContentArgs.model,
+    content: yield fetchOneEntry(getContentArgs)
+  };
+});
+
+export { blocks_default as Blocks, button_default as Button, columns_default as Columns, content_variants_default as Content, fragment_default as Fragment, image_default as Image, RenderBlocks, RenderContent, section_default as Section, symbol_default as Symbol, text_default as Text, video_default as Video, _processContentResult, createRegisterComponentMessage, fetchBuilderProps, fetchEntries, fetchOneEntry, getAllContent, getBuilderSearchParams, getContent, isEditing, isPreviewing, register, setEditorSettings, track };