@builder.io/sdk-solid 0.5.9 → 0.6.0

package/lib/browser/index.jsx

@@ -0,0 +1,4374 @@
+// src/blocks/button/button.jsx
+import { Show } from "solid-js";
+import { css } from "solid-styled-components";
+function Button(props) {
+  return <Show
+    fallback={<button
+      class={props.attributes.class + " " + css({
+        all: "unset"
+      })}
+      {...{}}
+      {...props.attributes}
+      style={props.attributes.style}
+    >{props.text}</button>}
+    when={props.link}
+  ><a
+    role="button"
+    {...{}}
+    {...props.attributes}
+    href={props.link}
+    target={props.openLinkInNewTab ? "_blank" : void 0}
+  >{props.text}</a></Show>;
+}
+var button_default = Button;
+
+// src/blocks/columns/columns.jsx
+import { Show as Show7, For as For4, createSignal as createSignal6 } from "solid-js";
+import { css as css3 } from "solid-styled-components";
+
+// src/components/blocks/blocks.jsx
+import { useContext, Show as Show6, For as For3 } from "solid-js";
+
+// src/components/block/components/block-styles.jsx
+import { Show as Show2, createSignal } from "solid-js";
+
+// 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;
+  }
+};
+
+// src/components/inlined-styles.jsx
+function InlinedStyles(props) {
+  return <style innerHTML={props.styles} id={props.id} />;
+}
+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 <Show2 when={TARGET !== "reactNative" && css5() && canShowBlock()}><Inlined_styles_default styles={css5()} /></Show2>;
+}
+var Block_styles_default = BlockStyles;
+
+// src/components/block/block.jsx
+import { Show as Show5, For as For2, createSignal as createSignal4 } from "solid-js";
+
+// 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 SHOW_WARNINGS = false;
+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)) {
+      if (SHOW_WARNINGS) {
+      }
+      return acc;
+    }
+    if (propertiesThatMustBeNumber.has(key) && typeof propertyValue !== "number") {
+      if (SHOW_WARNINGS) {
+      }
+      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;
+};
+
+// src/components/block/components/repeated-block.jsx
+import { createSignal as createSignal2 } from "solid-js";
+
+// src/context/builder.context.js
+import { createContext } from "solid-js";
+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] = createSignal2(props.repeatContext);
+  return <stdin_default.Provider value={store()}><Block_default
+    block={props.block}
+    context={store()}
+    registeredComponents={props.registeredComponents}
+  /></stdin_default.Provider>;
+}
+var Repeated_block_default = RepeatedBlock;
+
+// src/components/block/components/component-ref/component-ref.jsx
+import { Show as Show3, For, createSignal as createSignal3 } from "solid-js";
+import { Dynamic as Dynamic2 } from "solid-js/web";
+
+// src/components/block/components/interactive-element.jsx
+import { Dynamic } from "solid-js/web";
+
+// 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 <Dynamic
+    {...props.wrapperProps}
+    attributes={{
+      ...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
+      })
+    }}
+    component={props.Wrapper}
+  >{props.children}</Dynamic>;
+}
+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] = createSignal3(
+    props.isInteractive ? interactive_element_default : props.componentRef
+  );
+  return <Show3 when={props.componentRef}><Dynamic2
+    {...getWrapperProps({
+      componentOptions: props.componentOptions,
+      builderBlock: props.builderBlock,
+      context: props.context,
+      componentRef: props.componentRef,
+      includeBlockProps: props.includeBlockProps,
+      isInteractive: props.isInteractive,
+      contextValue: props.context
+    })}
+    component={Wrapper()}
+  >
+    <For each={props.blockChildren}>{(child, _index) => {
+      const index = _index();
+      return <Block_default
+        key={"block-" + child.id}
+        block={child}
+        context={props.context}
+        registeredComponents={props.registeredComponents}
+      />;
+    }}</For>
+    <For each={props.blockChildren}>{(child, _index) => {
+      const index = _index();
+      return <Block_styles_default
+        key={"block-style-" + child.id}
+        block={child}
+        context={props.context}
+      />;
+    }}</For>
+  </Dynamic2></Show3>;
+}
+var Component_ref_default = ComponentRef;
+
+// src/components/block/components/block-wrapper.jsx
+import { Show as Show4 } from "solid-js";
+import { Dynamic as Dynamic3 } from "solid-js/web";
+function BlockWrapper(props) {
+  return <Show4
+    fallback={<Dynamic3
+      {...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
+      })}
+      component={props.Wrapper}
+    />}
+    when={props.hasChildren}
+  ><Dynamic3
+    {...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
+    })}
+    component={props.Wrapper}
+  >{props.children}</Dynamic3></Show4>;
+}
+var Block_wrapper_default = BlockWrapper;
+
+// src/components/block/block.jsx
+function Block(props) {
+  const [childrenContext, setChildrenContext] = createSignal4(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 <Show5 when={canShowBlock()}><Show5
+    fallback={<Component_ref_default {...componentRefProps()} />}
+    when={!blockComponent()?.noWrap}
+  >
+    <Show5 when={isEmptyHtmlElement(Tag())}><Block_wrapper_default
+      Wrapper={Tag()}
+      block={processedBlock()}
+      context={props.context}
+      hasChildren={false}
+    /></Show5>
+    <Show5 when={!isEmptyHtmlElement(Tag()) && repeatItem()}><For2 each={repeatItem()}>{(data, _index) => {
+      const index = _index();
+      return <Repeated_block_default
+        key={index}
+        repeatContext={data.context}
+        block={data.block}
+        registeredComponents={props.registeredComponents}
+      />;
+    }}</For2></Show5>
+    <Show5 when={!isEmptyHtmlElement(Tag()) && !repeatItem()}><Block_wrapper_default
+      Wrapper={Tag()}
+      block={processedBlock()}
+      context={props.context}
+      hasChildren={true}
+    >
+      <Component_ref_default {...componentRefProps()} />
+      <For2 each={childrenWithoutParentComponent()}>{(child, _index) => {
+        const index = _index();
+        return <Block
+          key={"block-" + child.id}
+          block={child}
+          context={childrenContext()}
+          registeredComponents={props.registeredComponents}
+        />;
+      }}</For2>
+      <For2 each={childrenWithoutParentComponent()}>{(child, _index) => {
+        const index = _index();
+        return <Block_styles_default
+          key={"block-style-" + child.id}
+          block={child}
+          context={childrenContext()}
+        />;
+      }}</For2>
+    </Block_wrapper_default></Show5>
+  </Show5></Show5>;
+}
+var Block_default = Block;
+
+// src/components/blocks/blocks-wrapper.jsx
+import { createSignal as createSignal5 } from "solid-js";
+import { css as css2 } from "solid-styled-components";
+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 <div
+    class={className() + " " + css2({
+      display: "flex",
+      flexDirection: "column",
+      alignItems: "stretch"
+    })}
+    builder-path={props.path}
+    builder-parent-id={props.parent}
+    {...{}}
+    style={props.styleProp}
+    onClick={(event) => onClick()}
+    onMouseEnter={(event) => onMouseEnter()}
+    onKeyPress={(event) => onClick()}
+  >{props.children}</div>;
+}
+var Blocks_wrapper_default = BlocksWrapper;
+
+// src/context/components.context.js
+import { createContext as createContext2 } from "solid-js";
+var stdin_default2 = createContext2({ registeredComponents: {} });
+
+// src/components/blocks/blocks.jsx
+function Blocks(props) {
+  const builderContext = useContext(stdin_default);
+  const componentsContext = useContext(stdin_default2);
+  return <Blocks_wrapper_default
+    blocks={props.blocks}
+    parent={props.parent}
+    path={props.path}
+    styleProp={props.styleProp}
+  >
+    <Show6 when={props.blocks}><For3 each={props.blocks}>{(block, _index) => {
+      const index = _index();
+      return <Block_default
+        key={"render-block-" + block.id}
+        block={block}
+        context={props.context || builderContext}
+        registeredComponents={props.registeredComponents || componentsContext.registeredComponents}
+      />;
+    }}</For3></Show6>
+    <Show6 when={props.blocks}><For3 each={props.blocks}>{(block, _index) => {
+      const index = _index();
+      return <Block_styles_default
+        key={"block-style-" + block.id}
+        block={block}
+        context={props.context || builderContext}
+      />;
+    }}</For3></Show6>
+  </Blocks_wrapper_default>;
+}
+var Blocks_default = Blocks;
+
+// src/blocks/columns/columns.jsx
+function Columns(props) {
+  const [gutterSize, setGutterSize] = createSignal6(
+    typeof props.space === "number" ? props.space || 0 : 20
+  );
+  const [cols, setCols] = createSignal6(props.columns || []);
+  const [stackAt, setStackAt] = createSignal6(props.stackColumnsAt || "tablet");
+  const [flexDir, setFlexDir] = createSignal6(
+    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 <div
+    class={`builder-columns ${props.builderBlock.id}-breakpoints ` + css3({
+      display: "flex",
+      lineHeight: "normal"
+    })}
+    style={columnsCssVars()}
+    {...{}}
+  >
+    <Show7 when={TARGET !== "reactNative"}><Inlined_styles_default styles={columnsStyles()} /></Show7>
+    <For4 each={props.columns}>{(column, _index) => {
+      const index = _index();
+      return <div
+        class={"builder-column " + css3({
+          display: "flex",
+          flexDirection: "column",
+          alignItems: "stretch"
+        })}
+        style={columnCssVars(index)}
+        {...{}}
+        key={index}
+      ><Blocks_default
+        path={`component.options.columns.${index}.blocks`}
+        parent={props.builderBlock.id}
+        styleProp={{
+          flexGrow: "1"
+        }}
+        context={props.builderContext}
+        registeredComponents={props.builderComponents}
+        blocks={column.blocks}
+      /></div>;
+    }}</For4>
+  </div>;
+}
+var columns_default = Columns;
+
+// src/blocks/fragment/fragment.jsx
+function FragmentComponent(props) {
+  return <span>{props.children}</span>;
+}
+var fragment_default = FragmentComponent;
+
+// src/blocks/image/image.jsx
+import { Show as Show8, createSignal as createSignal7 } from "solid-js";
+import { css as css4 } from "solid-styled-components";
+
+// 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
+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 <>
+    <picture>
+      <Show8 when={webpSrcSet()}><source type="image/webp" srcset={webpSrcSet()} /></Show8>
+      <img
+        class={"builder-image" + (props.className ? " " + props.className : "") + " " + css4({
+          opacity: "1",
+          transition: "opacity 0.2s ease-in-out"
+        })}
+        loading="lazy"
+        alt={props.altText}
+        role={props.altText ? "presentation" : void 0}
+        style={{
+          "object-position": props.backgroundPosition || "center",
+          "object-fit": props.backgroundSize || "cover",
+          ...aspectRatioCss()
+        }}
+        src={props.image}
+        srcset={srcSetToUse()}
+        sizes={props.sizes}
+      />
+    </picture>
+    <Show8
+      when={props.aspectRatio && !(props.builderBlock?.children?.length && props.fitContent)}
+    ><div
+      class={"builder-image-sizer " + css4({
+        width: "100%",
+        pointerEvents: "none",
+        fontSize: "0"
+      })}
+      style={{
+        "padding-top": props.aspectRatio * 100 + "%"
+      }}
+    /></Show8>
+    <Show8 when={props.builderBlock?.children?.length && props.fitContent}>{props.children}</Show8>
+    <Show8 when={!props.fitContent && props.children}><div
+      class={css4({
+        display: "flex",
+        flexDirection: "column",
+        alignItems: "stretch",
+        position: "absolute",
+        top: "0",
+        left: "0",
+        width: "100%",
+        height: "100%"
+      })}
+    >{props.children}</div></Show8>
+  </>;
+}
+var image_default = Image;
+
+// src/blocks/section/section.jsx
+function SectionComponent(props) {
+  return <section
+    {...{}}
+    {...props.attributes}
+    style={{
+      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"
+    }}
+  >{props.children}</section>;
+}
+var section_default = SectionComponent;
+
+// src/blocks/symbol/symbol.jsx
+import { onMount as onMount4, on as on3, createEffect as createEffect3, createSignal as createSignal15 } from "solid-js";
+
+// src/components/content-variants/content-variants.jsx
+import { Show as Show11, For as For5, onMount as onMount3, createSignal as createSignal14 } from "solid-js";
+
+// 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/components/content/content.jsx
+import { Show as Show10, createSignal as createSignal13 } from "solid-js";
+
+// 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"
+  }
+};
+
+// src/blocks/text/text.jsx
+function Text(props) {
+  return <span
+    class="builder-text"
+    innerHTML={props.text?.toString() || ""}
+    style={{
+      outline: "none"
+    }}
+  />;
+}
+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
+  }]
+};
+
+// src/blocks/video/video.jsx
+import { createSignal as createSignal8 } from "solid-js";
+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 <video
+    {...spreadProps()}
+    preload={props.preload || "metadata"}
+    style={{
+      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
+    }}
+    src={props.video || "no-src"}
+    poster={props.posterImage}
+  />;
+}
+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/embed.jsx
+import { on, createEffect, createSignal as createSignal9 } from "solid-js";
+
+// 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
+function Embed(props) {
+  const [scriptsInserted, setScriptsInserted] = createSignal9([]);
+  const [scriptsRun, setScriptsRun] = createSignal9([]);
+  const [ranInitFn, setRanInitFn] = createSignal9(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 <div class="builder-embed" ref={elem} innerHTML={props.content} />;
+}
+var embed_default = Embed;
+
+// src/blocks/img/img.jsx
+function ImgComponent(props) {
+  return <img
+    style={{
+      "object-fit": props.backgroundSize || "cover",
+      "object-position": props.backgroundPosition || "center"
+    }}
+    key={isEditing() && props.imgSrc || "default-key"}
+    alt={props.altText}
+    src={props.imgSrc || props.image}
+    {...{}}
+    {...props.attributes}
+  />;
+}
+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
+};
+
+// src/blocks/custom-code/custom-code.jsx
+import { onMount, createSignal as createSignal10 } from "solid-js";
+function CustomCode(props) {
+  const [scriptsInserted, setScriptsInserted] = createSignal10([]);
+  const [scriptsRun, setScriptsRun] = createSignal10([]);
+  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 <div
+    class={"builder-custom-code" + (props.replaceNodes ? " replace-nodes" : "")}
+    ref={elem}
+    innerHTML={props.code}
+  />;
+}
+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.jsx
+import { createSignal as createSignal11 } from "solid-js";
+
+// 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] = createSignal11(
+    `
+${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 <Inlined_styles_default styles={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/components/content/components/enable-editor.jsx
+import { Show as Show9, onMount as onMount2, on as on2, createEffect as createEffect2, createSignal as createSignal12 } from "solid-js";
+
+// 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.0";
+
+// 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) {
+      const previewContent = getPreviewContent(url.searchParams);
+      newResults.push(previewContent || 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
+function EnableEditor(props) {
+  const [canTrackToUse, setCanTrackToUse] = createSignal12(
+    checkIsDefined(props.canTrack) ? props.canTrack : true
+  );
+  const [forceReRenderCount, setForceReRenderCount] = createSignal12(0);
+  const [lastUpdated, setLastUpdated] = createSignal12(0);
+  const [shouldSendResetCookie, setShouldSendResetCookie] = createSignal12(false);
+  const [httpReqsData, setHttpReqsData] = createSignal12({});
+  const [clicked, setClicked] = createSignal12(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;
+  onMount2(() => {
+    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);
+    }
+  }
+  createEffect2(on2(() => [props.content], onUpdateFn_0));
+  function onUpdateFn_1() {
+  }
+  createEffect2(on2(() => [shouldSendResetCookie()], onUpdateFn_1));
+  function onUpdateFn_2() {
+    evaluateJsCode();
+  }
+  createEffect2(
+    on2(
+      () => [
+        props.builderContextSignal.content?.data?.jsCode,
+        props.builderContextSignal.rootState
+      ],
+      onUpdateFn_2
+    )
+  );
+  function onUpdateFn_3() {
+    runHttpRequests();
+  }
+  createEffect2(
+    on2(
+      () => [props.builderContextSignal.content?.data?.httpRequests],
+      onUpdateFn_3
+    )
+  );
+  function onUpdateFn_4() {
+    emitStateUpdate();
+  }
+  createEffect2(on2(() => [props.builderContextSignal.rootState], onUpdateFn_4));
+  return <stdin_default.Provider value={props.builderContextSignal}><Show9 when={props.builderContextSignal.content}><div
+    class={props.classNameProp}
+    key={forceReRenderCount()}
+    ref={elementRef}
+    onClick={(event) => onClick(event)}
+    builder-content-id={props.builderContextSignal.content?.id}
+    builder-model={props.model}
+    {...{}}
+    {...props.showContent ? {} : {
+      hidden: true,
+      "aria-hidden": true
+    }}
+  >{props.children}</div></Show9></stdin_default.Provider>;
+}
+var Enable_editor_default = EnableEditor;
+
+// src/components/inlined-script.jsx
+function InlinedScript(props) {
+  return <script innerHTML={props.scriptStr} id={props.id} />;
+}
+var Inlined_script_default = InlinedScript;
+
+// src/components/content/content.jsx
+function ContentComponent(props) {
+  const [scriptStr, setScriptStr] = createSignal13(
+    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] = createSignal13(
+    [
+      ...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] = createSignal13({
+    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 <stdin_default2.Provider
+    value={{
+      registeredComponents: registeredComponents()
+    }}
+  ><Enable_editor_default
+    content={props.content}
+    model={props.model}
+    context={props.context}
+    apiKey={props.apiKey}
+    canTrack={props.canTrack}
+    locale={props.locale}
+    includeRefs={props.includeRefs}
+    enrich={props.enrich}
+    classNameProp={props.classNameProp}
+    showContent={props.showContent}
+    builderContextSignal={builderContextSignal()}
+    {...{
+      setBuilderContextSignal
+    }}
+  >
+    <Show10 when={props.isSsrAbTest}><Inlined_script_default scriptStr={scriptStr()} /></Show10>
+    <Show10 when={TARGET !== "reactNative"}><Styles_default
+      contentId={builderContextSignal().content?.id}
+      cssCode={builderContextSignal().content?.data?.cssCode}
+      customFonts={builderContextSignal().content?.data?.customFonts}
+    /></Show10>
+    <Blocks_default
+      blocks={builderContextSignal().content?.data?.blocks}
+      context={builderContextSignal()}
+      registeredComponents={registeredComponents()}
+    />
+  </Enable_editor_default></stdin_default2.Provider>;
+}
+var Content_default = ContentComponent;
+
+// src/components/content-variants/content-variants.jsx
+function ContentVariants(props) {
+  const [shouldRenderVariants, setShouldRenderVariants] = createSignal14(
+    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)
+    });
+  }
+  onMount3(() => {
+  });
+  return <>
+    <Show11 when={!props.__isNestedRender && TARGET !== "reactNative"}><Inlined_script_default scriptStr={getScriptString()} /></Show11>
+    <Show11 when={shouldRenderVariants()}>
+      <Inlined_styles_default
+        id={`variants-styles-${props.content?.id}`}
+        styles={hideVariantsStyleString()}
+      />
+      <Inlined_script_default scriptStr={variantScriptStr()} />
+      <For5 each={getVariants(props.content)}>{(variant, _index) => {
+        const index = _index();
+        return <Content_default
+          key={variant.testVariationId}
+          content={variant}
+          showContent={false}
+          classNameProp={void 0}
+          model={props.model}
+          data={props.data}
+          context={props.context}
+          apiKey={props.apiKey}
+          apiVersion={props.apiVersion}
+          customComponents={props.customComponents}
+          canTrack={props.canTrack}
+          locale={props.locale}
+          includeRefs={props.includeRefs}
+          enrich={props.enrich}
+          isSsrAbTest={shouldRenderVariants()}
+        />;
+      }}</For5>
+    </Show11>
+    <Content_default
+      {...{}}
+      content={defaultContent()}
+      classNameProp={`variant-${props.content?.id}`}
+      showContent={true}
+      model={props.model}
+      data={props.data}
+      context={props.context}
+      apiKey={props.apiKey}
+      apiVersion={props.apiVersion}
+      customComponents={props.customComponents}
+      canTrack={props.canTrack}
+      locale={props.locale}
+      includeRefs={props.includeRefs}
+      enrich={props.enrich}
+      isSsrAbTest={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
+function Symbol(props) {
+  const [contentToUse, setContentToUse] = createSignal15(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);
+      }
+    });
+  }
+  onMount4(() => {
+    setContent();
+  });
+  function onUpdateFn_0() {
+    setContent();
+  }
+  createEffect3(on3(() => [props.symbol], onUpdateFn_0));
+  return <div class={className()} {...{}} {...props.attributes} {...{}}><Content_variants_default
+    __isNestedRender={true}
+    apiVersion={props.builderContext.apiVersion}
+    apiKey={props.builderContext.apiKey}
+    context={props.builderContext.context}
+    customComponents={Object.values(props.builderComponents)}
+    data={{
+      ...props.symbol?.data,
+      ...props.builderContext.localState,
+      ...contentToUse()?.data?.state
+    }}
+    model={props.symbol?.model}
+    content={contentToUse()}
+  /></div>;
+}
+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
+};