@builder.io/sdk-qwik 0.0.6 → 0.0.9

package/lib/index.qwik.mjs

@@ -0,0 +1,2521 @@
+import { createContext, componentQrl, inlinedQrl, useContextProvider, useStore, useStylesScopedQrl, useContext, Host, useLexicalScope, Slot, Fragment as Fragment$2, useRef, useWatchQrl, useHostElement, useClientEffectQrl, _useMutableProps, useCleanupQrl } from "@builder.io/qwik";
+import { jsx, Fragment as Fragment$1, jsxs } from "@builder.io/qwik/jsx-runtime";
+const TARGET = "qwik";
+function isBrowser() {
+  return typeof window !== "undefined" && typeof document !== "undefined";
+}
+const 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) {
+      console.debug("Could not postmessage", err);
+    }
+  }
+}
+const 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"
+        }
+      ]
+    ]
+  });
+};
+const setupBrowserForEditing = () => {
+  var _a;
+  if (isBrowser()) {
+    (_a = window.parent) == null || _a.postMessage({
+      type: "builder.sdkInfo",
+      data: {
+        target: TARGET,
+        supportsPatchUpdates: false
+      }
+    }, "*");
+    window.addEventListener("message", ({ data }) => {
+      var _a2, _b;
+      if (data)
+        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 || _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 || _a3.postMessage({
+                  type: "builder.evaluateResult",
+                  data: {
+                    id,
+                    result: finalResult
+                  }
+                }, "*");
+              }).catch(console.error);
+            else
+              (_b = window.parent) == null || _b.postMessage({
+                type: "builder.evaluateResult",
+                data: {
+                  result,
+                  id
+                }
+              }, "*");
+            break;
+          }
+        }
+    });
+  }
+};
+var stdin_default = createContext("Builder");
+function isIframe() {
+  return isBrowser() && window.self !== window.top;
+}
+function isEditing() {
+  return isIframe() && window.location.search.indexOf("builder.frameEditing=") !== -1;
+}
+const SIZES = {
+  small: {
+    min: 320,
+    default: 321,
+    max: 640
+  },
+  medium: {
+    min: 641,
+    default: 642,
+    max: 991
+  },
+  large: {
+    min: 990,
+    default: 991,
+    max: 1200
+  }
+};
+const getMaxWidthQueryForSize = (size) => `@media (max-width: ${SIZES[size].max}px)`;
+function evaluate({ code, context, state, event }) {
+  if (code === "") {
+    console.warn("Skipping evaluation of empty code block.");
+    return;
+  }
+  const builder = {
+    isEditing: isEditing(),
+    isBrowser: isBrowser(),
+    isServer: !isBrowser()
+  };
+  const useReturn = !(code.includes(";") || code.includes(" return ") || code.trim().startsWith("return "));
+  const useCode = useReturn ? `return (${code});` : code;
+  try {
+    return new Function("builder", "Builder", "state", "context", "event", useCode)(builder, builder, state, context, event);
+  } catch (e) {
+    console.warn("Builder custom code error: ", e);
+  }
+}
+const 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;
+};
+function transformBlock(block) {
+  return block;
+}
+var __defProp$7 = Object.defineProperty;
+var __defProps$5 = Object.defineProperties;
+var __getOwnPropDescs$5 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$7 = Object.getOwnPropertySymbols;
+var __hasOwnProp$7 = Object.prototype.hasOwnProperty;
+var __propIsEnum$7 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __spreadValues$7 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$7.call(b, prop))
+      __defNormalProp$7(a, prop, b[prop]);
+  if (__getOwnPropSymbols$7) {
+    for (var prop of __getOwnPropSymbols$7(b))
+      if (__propIsEnum$7.call(b, prop))
+        __defNormalProp$7(a, prop, b[prop]);
+  }
+  return a;
+};
+var __spreadProps$5 = (a, b) => __defProps$5(a, __getOwnPropDescs$5(b));
+const evaluateBindings = ({ block, context, state }) => {
+  if (!block.bindings)
+    return block;
+  const copied = __spreadProps$5(__spreadValues$7({}, block), {
+    properties: __spreadValues$7({}, block.properties),
+    actions: __spreadValues$7({}, block.actions)
+  });
+  for (const binding in block.bindings) {
+    const expression = block.bindings[binding];
+    const value = evaluate({
+      code: expression,
+      state,
+      context
+    });
+    set(copied, binding, value);
+  }
+  return copied;
+};
+function getProcessedBlock(options) {
+  const { state, context } = options;
+  const block = transformBlock(options.block);
+  if (evaluateBindings)
+    return evaluateBindings({
+      block,
+      state,
+      context
+    });
+  else
+    return block;
+}
+const camelToKebabCase = (string) => string.replace(/([a-z0-9]|(?=[A-Z]))([A-Z])/g, "$1-$2").toLowerCase();
+const convertStyleMaptoCSS = (style) => {
+  const cssProps = Object.entries(style).map(([key, value]) => {
+    if (typeof value === "string")
+      return `${camelToKebabCase(key)}: ${value};`;
+  });
+  return cssProps.join("\n");
+};
+const RenderInlinedStyles = /* @__PURE__ */ componentQrl(inlinedQrl((props) => {
+  const state = {};
+  return /* @__PURE__ */ jsx(Fragment$1, {
+    children: /* @__PURE__ */ jsx(state.tagName, {
+      children: props.styles
+    })
+  });
+}, "RenderInlinedStyles_component_0sD5UmyM3Rg"));
+const RenderInlinedStyles$1 = RenderInlinedStyles;
+const useBlock$1 = function useBlock(props, state) {
+  return getProcessedBlock({
+    block: props.block,
+    state: props.context.state,
+    context: props.context.context,
+    evaluateBindings: true
+  });
+};
+const css = function css2(props, state) {
+  const styles = useBlock$1(props).responsiveStyles;
+  const largeStyles = styles?.large;
+  const mediumStyles = styles?.medium;
+  const smallStyles = styles?.small;
+  return `
+        ${largeStyles ? `.${useBlock$1(props).id} {${convertStyleMaptoCSS(largeStyles)}}` : ""}
+        ${mediumStyles ? `${getMaxWidthQueryForSize("medium")} {
+              .${useBlock$1(props).id} {${convertStyleMaptoCSS(mediumStyles)}}
+            }` : ""}
+        ${smallStyles ? `${getMaxWidthQueryForSize("small")} {
+              .${useBlock$1(props).id} {${convertStyleMaptoCSS(smallStyles)}}
+            }` : ""}
+      }`;
+};
+const BlockStyles = (props) => {
+  return /* @__PURE__ */ jsx(Fragment$1, {
+    children: TARGET === "vue2" || TARGET === "vue3" || TARGET === "svelte" ? /* @__PURE__ */ jsx(RenderInlinedStyles$1, {
+      styles: css(props)
+    }) : null
+  });
+};
+const BlockStyles$1 = BlockStyles;
+function capitalizeFirstLetter(string) {
+  return string.charAt(0).toUpperCase() + string.slice(1);
+}
+const getEventHandlerName = (key) => `on${capitalizeFirstLetter(key)}`;
+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];
+    obj[getEventHandlerName(key)] = (event) => evaluate({
+      code: value,
+      context: options.context,
+      state: options.state,
+      event
+    });
+  }
+  return obj;
+}
+var __defProp$6 = Object.defineProperty;
+var __defProps$4 = Object.defineProperties;
+var __getOwnPropDescs$4 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$6 = Object.getOwnPropertySymbols;
+var __hasOwnProp$6 = Object.prototype.hasOwnProperty;
+var __propIsEnum$6 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __spreadValues$6 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$6.call(b, prop))
+      __defNormalProp$6(a, prop, b[prop]);
+  if (__getOwnPropSymbols$6) {
+    for (var prop of __getOwnPropSymbols$6(b))
+      if (__propIsEnum$6.call(b, prop))
+        __defNormalProp$6(a, prop, b[prop]);
+  }
+  return a;
+};
+var __spreadProps$4 = (a, b) => __defProps$4(a, __getOwnPropDescs$4(b));
+function getBlockComponentOptions(block) {
+  var _a;
+  return __spreadProps$4(__spreadValues$6(__spreadValues$6({}, (_a = block.component) == null ? void 0 : _a.options), block.options), {
+    builderBlock: block
+  });
+}
+var __defProp$5 = Object.defineProperty;
+var __defProps$3 = Object.defineProperties;
+var __getOwnPropDescs$3 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$5 = Object.getOwnPropertySymbols;
+var __hasOwnProp$5 = Object.prototype.hasOwnProperty;
+var __propIsEnum$5 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __spreadValues$5 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$5.call(b, prop))
+      __defNormalProp$5(a, prop, b[prop]);
+  if (__getOwnPropSymbols$5) {
+    for (var prop of __getOwnPropSymbols$5(b))
+      if (__propIsEnum$5.call(b, prop))
+        __defNormalProp$5(a, prop, b[prop]);
+  }
+  return a;
+};
+var __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
+function getBlockProperties(block) {
+  var _a;
+  return __spreadProps$3(__spreadValues$5({}, block.properties), {
+    "builder-id": block.id,
+    class: [
+      block.id,
+      "builder-block",
+      block.class,
+      (_a = block.properties) == null ? void 0 : _a.class
+    ].filter(Boolean).join(" ")
+  });
+}
+const convertStyleObject = (obj) => {
+  return obj;
+};
+const sanitizeBlockStyles = (_styles) => {
+};
+var __defProp$4 = Object.defineProperty;
+var __getOwnPropSymbols$4 = Object.getOwnPropertySymbols;
+var __hasOwnProp$4 = Object.prototype.hasOwnProperty;
+var __propIsEnum$4 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __spreadValues$4 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$4.call(b, prop))
+      __defNormalProp$4(a, prop, b[prop]);
+  if (__getOwnPropSymbols$4) {
+    for (var prop of __getOwnPropSymbols$4(b))
+      if (__propIsEnum$4.call(b, prop))
+        __defNormalProp$4(a, prop, b[prop]);
+  }
+  return a;
+};
+function getBlockStyles(block) {
+  var _a, _b, _c, _d, _e;
+  const styles = __spreadValues$4(__spreadValues$4({}, convertStyleObject((_a = block.responsiveStyles) == null ? void 0 : _a.large)), block.styles);
+  if ((_b = block.responsiveStyles) == null ? void 0 : _b.medium)
+    styles[getMaxWidthQueryForSize("medium")] = convertStyleObject((_c = block.responsiveStyles) == null ? void 0 : _c.medium);
+  if ((_d = block.responsiveStyles) == null ? void 0 : _d.small)
+    styles[getMaxWidthQueryForSize("small")] = convertStyleObject((_e = block.responsiveStyles) == null ? void 0 : _e.small);
+  sanitizeBlockStyles();
+  return styles;
+}
+function getBlockTag(block) {
+  return block.tagName || "div";
+}
+const EMPTY_HTML_ELEMENTS = [
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "keygen",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+];
+const isEmptyHtmlElement = (tagName3) => {
+  return typeof tagName3 === "string" && EMPTY_HTML_ELEMENTS.includes(tagName3.toLowerCase());
+};
+const RenderComponent = (props) => {
+  return /* @__PURE__ */ jsx(Fragment$1, {
+    children: props.componentRef ? /* @__PURE__ */ jsxs(props.componentRef, {
+      ...props.componentOptions,
+      children: [
+        (props.blockChildren || []).map((child) => {
+          return /* @__PURE__ */ jsx(RenderBlock$1, {
+            block: child,
+            context: props.context
+          }, "render-block-" + child.id);
+        }),
+        (props.blockChildren || []).map((child) => {
+          return /* @__PURE__ */ jsx(BlockStyles$1, {
+            block: child,
+            context: props.context
+          }, "block-style-" + child.id);
+        })
+      ]
+    }) : null
+  });
+};
+const RenderComponent$1 = RenderComponent;
+const RenderRepeatedBlock = /* @__PURE__ */ componentQrl(inlinedQrl((props) => {
+  useContextProvider(stdin_default, useStore({
+    content: (() => {
+      return props.repeatContext.content;
+    })(),
+    state: (() => {
+      return props.repeatContext.state;
+    })(),
+    context: (() => {
+      return props.repeatContext.context;
+    })(),
+    apiKey: (() => {
+      return props.repeatContext.apiKey;
+    })(),
+    registeredComponents: (() => {
+      return props.repeatContext.registeredComponents;
+    })()
+  }));
+  return /* @__PURE__ */ jsx(RenderBlock$1, {
+    block: props.block,
+    context: props.context
+  });
+}, "RenderRepeatedBlock_component_fV0PdmPN990"));
+const RenderRepeatedBlock$1 = RenderRepeatedBlock;
+const component = function component2(props, state) {
+  const componentName = getProcessedBlock({
+    block: props.block,
+    state: props.context.state,
+    context: props.context.context,
+    evaluateBindings: false
+  }).component?.name;
+  if (!componentName)
+    return null;
+  const ref = props.context.registeredComponents[componentName];
+  if (!ref) {
+    console.warn(`
+          Could not find a registered component named "${componentName}". 
+          If you registered it, is the file that registered it imported by the file that needs to render it?`);
+    return void 0;
+  } else
+    return ref;
+};
+const componentInfo$9 = function componentInfo(props, state) {
+  if (component(props)) {
+    const { component: _, ...info } = component(props);
+    return info;
+  } else
+    return void 0;
+};
+const componentRef = function componentRef2(props, state) {
+  return component(props)?.component;
+};
+const tagName = function tagName2(props, state) {
+  return getBlockTag(useBlock2(props));
+};
+const useBlock2 = function useBlock3(props, state) {
+  return repeatItemData(props) ? props.block : getProcessedBlock({
+    block: props.block,
+    state: props.context.state,
+    context: props.context.context,
+    evaluateBindings: true
+  });
+};
+const attributes = function attributes2(props, state) {
+  return {
+    ...getBlockProperties(useBlock2(props)),
+    ...getBlockActions({
+      block: useBlock2(props),
+      state: props.context.state,
+      context: props.context.context
+    }),
+    style: getBlockStyles(useBlock2(props))
+  };
+};
+const shouldWrap = function shouldWrap2(props, state) {
+  return !componentInfo$9(props)?.noWrap;
+};
+const componentOptions = function componentOptions2(props, state) {
+  return {
+    ...getBlockComponentOptions(useBlock2(props)),
+    ...shouldWrap(props) ? {} : {
+      attributes: attributes(props)
+    }
+  };
+};
+const renderComponentProps = function renderComponentProps2(props, state) {
+  return {
+    blockChildren: children(props),
+    componentRef: componentRef(props),
+    componentOptions: componentOptions(props)
+  };
+};
+const children = function children2(props, state) {
+  return useBlock2(props).children ?? [];
+};
+const childrenWithoutParentComponent = function childrenWithoutParentComponent2(props, state) {
+  const shouldRenderChildrenOutsideRef = !componentRef(props) && !repeatItemData(props);
+  return shouldRenderChildrenOutsideRef ? children(props) : [];
+};
+const repeatItemData = function repeatItemData2(props, state) {
+  const { repeat, ...blockWithoutRepeat } = props.block;
+  if (!repeat?.collection)
+    return void 0;
+  const itemsArray = evaluate({
+    code: repeat.collection,
+    state: props.context.state,
+    context: props.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: {
+        ...props.context,
+        state: {
+          ...props.context.state,
+          $index: index,
+          $item: item,
+          [itemNameToUse]: item,
+          [`$${itemNameToUse}Index`]: index
+        }
+      },
+      block: blockWithoutRepeat
+    })
+  );
+  return repeatArray;
+};
+const RenderBlock = (props) => {
+  const state = {};
+  state.tagName = tagName(props);
+  return /* @__PURE__ */ jsx(Fragment$1, {
+    children: shouldWrap(props) ? !isEmptyHtmlElement(tagName(props)) ? /* @__PURE__ */ jsxs(state.tagName, {
+      ...attributes(props),
+      children: [
+        repeatItemData(props) ? (repeatItemData(props) || []).map((data, index) => {
+          return /* @__PURE__ */ jsx(RenderRepeatedBlock$1, {
+            repeatContext: data.context,
+            block: data.block
+          }, index);
+        }) : null,
+        !repeatItemData(props) ? /* @__PURE__ */ jsx(RenderComponent$1, {
+          ...renderComponentProps(props)
+        }) : null,
+        (childrenWithoutParentComponent(props) || []).map((child) => {
+          return /* @__PURE__ */ jsx(RenderBlock, {
+            block: child,
+            context: props.context
+          }, "render-block-" + child.id);
+        }),
+        (childrenWithoutParentComponent(props) || []).map((child) => {
+          return /* @__PURE__ */ jsx(BlockStyles$1, {
+            block: child,
+            context: props.context
+          }, "block-style-" + child.id);
+        })
+      ]
+    }) : /* @__PURE__ */ jsx(state.tagName, {
+      ...attributes(props)
+    }) : /* @__PURE__ */ jsx(RenderComponent$1, {
+      ...renderComponentProps(props),
+      context: props.context
+    })
+  });
+};
+const RenderBlock$1 = RenderBlock;
+const className = function className2(props, state, builderContext) {
+  return "builder-blocks" + (!props.blocks?.length ? " no-blocks" : "");
+};
+const onClick$1 = function onClick(props, state, builderContext) {
+  if (isEditing() && !props.blocks?.length)
+    window.parent?.postMessage({
+      type: "builder.clickEmptyBlocks",
+      data: {
+        parentElementId: props.parent,
+        dataPath: props.path
+      }
+    }, "*");
+};
+const onMouseEnter = function onMouseEnter2(props, state, builderContext) {
+  if (isEditing() && !props.blocks?.length)
+    window.parent?.postMessage({
+      type: "builder.hoverEmptyBlocks",
+      data: {
+        parentElementId: props.parent,
+        dataPath: props.path
+      }
+    }, "*");
+};
+const RenderBlocks = /* @__PURE__ */ componentQrl(inlinedQrl((props) => {
+  useStylesScopedQrl(inlinedQrl(STYLES$2, "RenderBlocks_component_useStylesScoped_QNti2s7juQc"));
+  const builderContext = useContext(stdin_default);
+  const state = {};
+  return /* @__PURE__ */ jsx(Host, {
+    class: className(props) + " div-RenderBlocks",
+    "builder-path": props.path,
+    "builder-parent-id": props.parent,
+    dataSet: {
+      class: className(props)
+    },
+    onClick$: inlinedQrl((event) => {
+      const [builderContext2, props2, state2] = useLexicalScope();
+      return onClick$1(props2);
+    }, "RenderBlocks_component_Host_onClick_81ErKSpyspw", [
+      builderContext,
+      props,
+      state
+    ]),
+    onMouseEnter$: inlinedQrl((event) => {
+      const [builderContext2, props2, state2] = useLexicalScope();
+      return onMouseEnter(props2);
+    }, "RenderBlocks_component_Host_onMouseEnter_h6rWG6KLkHE", [
+      builderContext,
+      props,
+      state
+    ]),
+    children: /* @__PURE__ */ jsxs(Fragment$1, {
+      children: [
+        props.blocks ? (props.blocks || []).map((block) => {
+          return /* @__PURE__ */ jsx(RenderBlock$1, {
+            block,
+            context: builderContext
+          }, "render-block-" + block.id);
+        }) : null,
+        props.blocks ? (props.blocks || []).map((block) => {
+          return /* @__PURE__ */ jsx(BlockStyles$1, {
+            block,
+            context: builderContext
+          }, "block-style-" + block.id);
+        }) : null
+      ]
+    })
+  });
+}, "RenderBlocks_component_SXGwmVyEM0s"), {
+  tagName: "div"
+});
+const RenderBlocks$1 = RenderBlocks;
+const STYLES$2 = `.div-RenderBlocks { 
+display: flex;
+flex-direction: column;
+align-items: stretch; }`;
+const getGutterSize = function getGutterSize2(props, state) {
+  return typeof props.space === "number" ? props.space || 0 : 20;
+};
+const getColumns = function getColumns2(props, state) {
+  return props.columns || [];
+};
+const getWidth = function getWidth2(props, state, index) {
+  const columns = getColumns(props);
+  return columns[index]?.width || 100 / columns.length;
+};
+const getColumnCssWidth = function getColumnCssWidth2(props, state, index) {
+  const columns = getColumns(props);
+  const gutterSize = getGutterSize(props);
+  const subtractWidth = gutterSize * (columns.length - 1) / columns.length;
+  return `calc(${getWidth(props, state, index)}% - ${subtractWidth}px)`;
+};
+const maybeApplyForTablet = function maybeApplyForTablet2(props, state, prop) {
+  const _stackColumnsAt = props.stackColumnsAt || "tablet";
+  return _stackColumnsAt === "tablet" ? prop : "inherit";
+};
+const columnsCssVars = function columnsCssVars2(props, state) {
+  const flexDir = props.stackColumnsAt === "never" ? "inherit" : props.reverseColumnsWhenStacked ? "column-reverse" : "column";
+  return {
+    "--flex-dir": flexDir,
+    "--flex-dir-tablet": maybeApplyForTablet(props, state, flexDir)
+  };
+};
+const columnCssVars = function columnCssVars2(props, state) {
+  const width = "100%";
+  const marginLeft = "0";
+  return {
+    "--column-width": width,
+    "--column-margin-left": marginLeft,
+    "--column-width-tablet": maybeApplyForTablet(props, state, width),
+    "--column-margin-left-tablet": maybeApplyForTablet(props, state, marginLeft)
+  };
+};
+const Columns = /* @__PURE__ */ componentQrl(inlinedQrl((props) => {
+  useStylesScopedQrl(inlinedQrl(STYLES$1, "Columns_component_useStylesScoped_704fWXyHORo"));
+  const state = {};
+  return /* @__PURE__ */ jsx(Host, {
+    class: "builder-columns div-Columns",
+    style: columnsCssVars(props, state),
+    children: (props.columns || []).map((column, index) => {
+      return /* @__PURE__ */ jsx("div", {
+        class: "builder-column div-Columns-2",
+        style: {
+          width: getColumnCssWidth(props, state, index),
+          marginLeft: `${index === 0 ? 0 : getGutterSize(props)}px`,
+          ...columnCssVars(props, state)
+        },
+        children: /* @__PURE__ */ jsx(RenderBlocks$1, {
+          blocks: column.blocks
+        })
+      }, index);
+    })
+  });
+}, "Columns_component_0PeVQGTMczc"), {
+  tagName: "div"
+});
+const Columns$1 = Columns;
+const STYLES$1 = `.div-Columns { 
+display: flex;
+align-items: stretch;
+line-height: normal; }@media (max-width: 999px) { .div-Columns { 
+flex-direction: var(--flex-dir-tablet); } }@media (max-width: 639px) { .div-Columns { 
+flex-direction: var(--flex-dir); } }.div-Columns-2 { 
+flex-grow: 1; }@media (max-width: 999px) { .div-Columns-2 { 
+width: var(--column-width-tablet) !important;
+margin-left: var(--column-margin-left-tablet) !important; } }@media (max-width: 639px) { .div-Columns-2 { 
+width: var(--column-width) !important;
+margin-left: var(--column-margin-left) !important; } }`;
+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;
+}
+const srcSetToUse = function srcSetToUse2(props, state) {
+  const imageToUse = props.image || props.src;
+  const url = imageToUse;
+  if (!url || !(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])) {
+      console.debug("Removed given srcset");
+      return getSrcSet(url);
+    }
+  } else if (props.image && !props.srcset)
+    return getSrcSet(url);
+  return getSrcSet(url);
+};
+const webpSrcSet = function webpSrcSet2(props, state) {
+  if (srcSetToUse(props)?.match(/builder\.io/) && !props.noWebp)
+    return srcSetToUse(props).replace(/\?/g, "?format=webp&");
+  else
+    return "";
+};
+const Image = /* @__PURE__ */ componentQrl(inlinedQrl((props) => {
+  useStylesScopedQrl(inlinedQrl(STYLES, "Image_component_useStylesScoped_gRbO7w7SeZA"));
+  return /* @__PURE__ */ jsx(Host, {
+    class: "div-Image",
+    children: /* @__PURE__ */ jsxs(Fragment$1, {
+      children: [
+        /* @__PURE__ */ jsxs("picture", {
+          children: [
+            webpSrcSet(props) ? /* @__PURE__ */ jsx("source", {
+              type: "image/webp",
+              srcset: webpSrcSet(props)
+            }) : null,
+            /* @__PURE__ */ jsx("img", {
+              loading: "lazy",
+              alt: props.altText,
+              role: props.altText ? "presentation" : void 0,
+              style: {
+                objectPosition: props.backgroundSize || "center",
+                objectFit: props.backgroundSize || "cover"
+              },
+              class: "builder-image" + (props.className ? " " + props.className : "") + " img-Image",
+              src: props.image,
+              srcset: srcSetToUse(props),
+              sizes: props.sizes
+            }),
+            /* @__PURE__ */ jsx("source", {
+              srcset: srcSetToUse(props)
+            })
+          ]
+        }),
+        props.aspectRatio && !(props.fitContent && props.builderBlock?.children?.length) ? /* @__PURE__ */ jsx("div", {
+          class: "builder-image-sizer div-Image-2",
+          style: {
+            paddingTop: props.aspectRatio * 100 + "%"
+          }
+        }) : null,
+        props.builderBlock?.children?.length && props.fitContent ? /* @__PURE__ */ jsx(Slot, {}) : null,
+        !props.fitContent ? /* @__PURE__ */ jsx("div", {
+          class: "div-Image-3",
+          children: /* @__PURE__ */ jsx(Slot, {})
+        }) : null
+      ]
+    })
+  });
+}, "Image_component_y3S3Zox9wEo"), {
+  tagName: "div"
+});
+const Image$1 = Image;
+const STYLES = `.div-Image { 
+position: relative; }.img-Image { 
+opacity: 1;
+transition: opacity 0.2s ease-in-out;
+position: absolute;
+height: 100%;
+width: 100%;
+top: 0px;
+left: 0px; }.div-Image-2 { 
+width: 100%;
+pointer-events: none;
+font-size: 0; }.div-Image-3 { 
+display: flex;
+flex-direction: column;
+align-items: stretch;
+position: absolute;
+top: 0;
+left: 0;
+width: 100%;
+height: 100%; }`;
+const Text = /* @__PURE__ */ componentQrl(inlinedQrl((props) => {
+  return /* @__PURE__ */ jsx(Host, {
+    class: "builder-text",
+    dangerouslySetInnerHTML: props.text
+  });
+}, "Text_component_ci0NVEdoK0Q"), {
+  tagName: "div"
+});
+const Text$1 = Text;
+const videoProps = function videoProps2(props, state) {
+  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
+    } : {}
+  };
+};
+const Video = /* @__PURE__ */ componentQrl(inlinedQrl((props) => {
+  return /* @__PURE__ */ jsx(Host, {
+    ...videoProps(props),
+    style: {
+      width: "100%",
+      height: "100%",
+      ...props.attributes?.style,
+      objectFit: props.fit,
+      objectPosition: props.position,
+      borderRadius: 1
+    },
+    src: props.video || "no-src",
+    poster: props.posterImage
+  });
+}, "Video_component_O5sPuWlrTvk"), {
+  tagName: "video"
+});
+const Video$1 = Video;
+const Button = /* @__PURE__ */ componentQrl(inlinedQrl((props) => {
+  return /* @__PURE__ */ jsx(Fragment$2, {
+    children: props.link ? /* @__PURE__ */ jsx("a", {
+      role: "button",
+      ...props.attributes,
+      href: props.link,
+      target: props.openLinkInNewTab ? "_blank" : void 0,
+      children: props.text
+    }) : /* @__PURE__ */ jsx("span", {
+      ...props.attributes,
+      children: props.text
+    })
+  });
+}, "Button_component_FtjCELjtKF4"));
+const Button$1 = Button;
+const componentInfo$8 = {
+  name: "Core:Button",
+  builtIn: true,
+  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
+};
+function markSerializable(fn) {
+  fn.__qwik_serializable__ = true;
+  return fn;
+}
+const componentInfo$7 = {
+  name: "Columns",
+  builtIn: 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: markSerializable((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
+    }
+  ]
+};
+const componentInfo$6 = {
+  name: "Fragment",
+  static: true,
+  hidden: true,
+  builtIn: true,
+  canHaveChildren: true,
+  noWrap: true
+};
+const FragmentComponent = /* @__PURE__ */ componentQrl(inlinedQrl((props) => {
+  return /* @__PURE__ */ jsx(Host, {
+    children: /* @__PURE__ */ jsx(Slot, {})
+  });
+}, "FragmentComponent_component_FJmqlA66Rjg"), {
+  tagName: "span"
+});
+const Fragment = FragmentComponent;
+const componentInfo$5 = {
+  name: "Image",
+  static: true,
+  builtIn: 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%2Fpwgjf0RoYWbdnJSbpBAjXNRMe9F2%2Ffb27a7c790324294af8be1c35fe30f4d",
+      onChange: markSerializable((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) => {
+              console.warn("Image load failed", event.error);
+              reject(event.error);
+            });
+            img.src = url;
+            setTimeout(() => {
+              if (!loaded)
+                reject(new Error("Image load timed out"));
+            }, timeout);
+          });
+        }
+        function round(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", round(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
+    }
+  ]
+};
+const componentInfo$4 = {
+  name: "Core:Section",
+  static: true,
+  builtIn: 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>"
+        }
+      }
+    }
+  ]
+};
+const SectionComponent = /* @__PURE__ */ componentQrl(inlinedQrl((props) => {
+  return /* @__PURE__ */ jsx(Host, {
+    ...props.attributes,
+    style: (() => {
+      props.maxWidth && typeof props.maxWidth === "number" ? props.maxWidth : void 0;
+    })(),
+    children: /* @__PURE__ */ jsx(Slot, {})
+  });
+}, "SectionComponent_component_m1CcjCwgHug"), {
+  tagName: "section"
+});
+const Section = SectionComponent;
+const componentInfo$3 = {
+  name: "Symbol",
+  noWrap: true,
+  static: true,
+  builtIn: 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"
+    }
+  ]
+};
+const componentInfo$2 = {
+  name: "Text",
+  static: true,
+  builtIn: 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"
+  }
+};
+const componentInfo$1 = {
+  name: "Video",
+  canHaveChildren: true,
+  builtIn: 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: "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
+    }
+  ]
+};
+const componentInfo2 = {
+  name: "Embed",
+  static: true,
+  builtIn: true,
+  inputs: [
+    {
+      name: "url",
+      type: "url",
+      required: true,
+      defaultValue: "",
+      helperText: "e.g. enter a youtube url, google map, etc",
+      onChange: markSerializable((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
+    }
+  ]
+};
+const SCRIPT_MIME_TYPES = [
+  "text/javascript",
+  "application/javascript",
+  "application/ecmascript"
+];
+const isJsScript = (script) => SCRIPT_MIME_TYPES.includes(script.type);
+const findAndRunScripts = function findAndRunScripts2(props, state, elem) {
+  const scripts = elem.getElementsByTagName("script");
+  for (let i = 0; i < scripts.length; i++) {
+    const script = scripts[i];
+    if (script.src && !state.scriptsInserted.includes(script.src)) {
+      state.scriptsInserted.push(script.src);
+      const newScript = document.createElement("script");
+      newScript.async = true;
+      newScript.src = script.src;
+      document.head.appendChild(newScript);
+    } else if (isJsScript(script) && !state.scriptsRun.includes(script.innerText))
+      try {
+        state.scriptsRun.push(script.innerText);
+        new Function(script.innerText)();
+      } catch (error) {
+        console.warn("`Embed`: Error running script:", error);
+      }
+  }
+};
+const Embed = /* @__PURE__ */ componentQrl(inlinedQrl((props) => {
+  const elem = useRef();
+  const state = useStore({
+    scriptsInserted: [],
+    scriptsRun: [],
+    ranInitFn: false
+  });
+  useWatchQrl(inlinedQrl(({ track: track2 }) => {
+    const [elem2, props2, state2] = useLexicalScope();
+    state2 && track2(state2, "ranInitFn");
+    if (elem2 && !state2.ranInitFn) {
+      state2.ranInitFn = true;
+      findAndRunScripts(props2, state2, elem2);
+    }
+  }, "Embed_component_useWatch_XE41s3iNuto", [
+    elem,
+    props,
+    state
+  ]));
+  return /* @__PURE__ */ jsx(Host, {
+    class: "builder-embed",
+    ref: elem,
+    dangerouslySetInnerHTML: props.content
+  });
+}, "Embed_component_CP6B8Y76ylw"), {
+  tagName: "div"
+});
+const embed = Embed;
+var __defProp$3 = Object.defineProperty;
+var __getOwnPropSymbols$3 = Object.getOwnPropertySymbols;
+var __hasOwnProp$3 = Object.prototype.hasOwnProperty;
+var __propIsEnum$3 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __spreadValues$3 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$3.call(b, prop))
+      __defNormalProp$3(a, prop, b[prop]);
+  if (__getOwnPropSymbols$3) {
+    for (var prop of __getOwnPropSymbols$3(b))
+      if (__propIsEnum$3.call(b, prop))
+        __defNormalProp$3(a, prop, b[prop]);
+  }
+  return a;
+};
+const getDefaultRegisteredComponents = () => [
+  __spreadValues$3({
+    component: Columns$1
+  }, componentInfo$7),
+  __spreadValues$3({
+    component: Image$1
+  }, componentInfo$5),
+  __spreadValues$3({
+    component: Text$1
+  }, componentInfo$2),
+  __spreadValues$3({
+    component: Video$1
+  }, componentInfo$1),
+  __spreadValues$3({
+    component: Symbol$2
+  }, componentInfo$3),
+  __spreadValues$3({
+    component: Button$1
+  }, componentInfo$8),
+  __spreadValues$3({
+    component: Section
+  }, componentInfo$4),
+  __spreadValues$3({
+    component: Fragment
+  }, componentInfo$6),
+  __spreadValues$3({
+    component: embed
+  }, componentInfo2)
+];
+var __defProp$2 = Object.defineProperty;
+var __defProps$2 = Object.defineProperties;
+var __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
+var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
+var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __spreadValues$2 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$2.call(b, prop))
+      __defNormalProp$2(a, prop, b[prop]);
+  if (__getOwnPropSymbols$2) {
+    for (var prop of __getOwnPropSymbols$2(b))
+      if (__propIsEnum$2.call(b, prop))
+        __defNormalProp$2(a, prop, b[prop]);
+  }
+  return a;
+};
+var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(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 ? __spreadValues$2(__spreadValues$2({}, acc), flatten(value, newPath, separator)) : __spreadProps$2(__spreadValues$2({}, acc), {
+      [newPath]: value
+    });
+  }, {});
+}
+const BUILDER_SEARCHPARAMS_PREFIX = "builder.";
+const convertSearchParamsToQueryObject = (searchParams) => {
+  const options = {};
+  searchParams.forEach((value, key) => {
+    options[key] = value;
+  });
+  return options;
+};
+const getBuilderSearchParams = (options) => {
+  const newOptions = {};
+  Object.keys(options).forEach((key) => {
+    if (key.startsWith(BUILDER_SEARCHPARAMS_PREFIX)) {
+      const trimmedKey = key.replace(BUILDER_SEARCHPARAMS_PREFIX, "");
+      newOptions[trimmedKey] = options[key];
+    }
+  });
+  return newOptions;
+};
+const getBuilderSearchParamsFromWindow = () => {
+  if (!isBrowser())
+    return {};
+  const searchParams = new URLSearchParams(window.location.search);
+  return getBuilderSearchParams(convertSearchParamsToQueryObject(searchParams));
+};
+const normalizeSearchParams = (searchParams) => searchParams instanceof URLSearchParams ? convertSearchParamsToQueryObject(searchParams) : searchParams;
+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 null;
+}
+var __async$1 = (__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());
+  });
+};
+function getFetch() {
+  return __async$1(this, null, function* () {
+    const globalFetch = getGlobalThis().fetch;
+    if (typeof globalFetch === "undefined" && typeof global !== "undefined") {
+      const nodeFetch = import("./index.97024df8.js").then(
+        (d) => d.default
+      );
+      return nodeFetch.default || nodeFetch;
+    }
+    return globalFetch.default || globalFetch;
+  });
+}
+const handleABTesting = (item, testGroups) => {
+  if (item.variations && Object.keys(item.variations).length) {
+    const testGroup = item.id ? testGroups[item.id] : void 0;
+    const variationValue = testGroup ? item.variations[testGroup] : void 0;
+    if (testGroup && variationValue) {
+      item.data = variationValue.data;
+      item.testVariationId = variationValue.id;
+      item.testVariationName = variationValue.name;
+    } else {
+      let n = 0;
+      const random = Math.random();
+      let set2 = false;
+      for (const id in item.variations) {
+        const variation = item.variations[id];
+        const testRatio = variation.testRatio;
+        n += testRatio;
+        if (random < n) {
+          const variationName = variation.name || (variation.id === item.id ? "Default variation" : "");
+          set2 = true;
+          Object.assign(item, {
+            data: variation.data,
+            testVariationId: variation.id,
+            testVariationName: variationName
+          });
+        }
+      }
+      if (!set2)
+        Object.assign(item, {
+          testVariationId: item.id,
+          testVariationName: "Default"
+        });
+    }
+  }
+};
+var __defProp$1 = Object.defineProperty;
+var __defProps$1 = Object.defineProperties;
+var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, {
+  enumerable: true,
+  configurable: true,
+  writable: true,
+  value
+}) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1) {
+    for (var prop of __getOwnPropSymbols$1(b))
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+  }
+  return a;
+};
+var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
+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());
+  });
+};
+const fetch$ = getFetch();
+function getContent(options) {
+  return __async(this, null, function* () {
+    return (yield getAllContent(__spreadProps$1(__spreadValues$1({}, options), {
+      limit: 1
+    }))).results[0] || null;
+  });
+}
+const generateContentUrl = (options) => {
+  const { limit = 1, userAttributes, query, noTraverse = false, model, apiKey } = options;
+  const url = new URL(`https://cdn.builder.io/api/v2/content/${model}?apiKey=${apiKey}&limit=${limit}&noTraverse=${noTraverse}`);
+  const queryOptions = __spreadValues$1(__spreadValues$1({}, 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;
+};
+function getAllContent(options) {
+  return __async(this, null, function* () {
+    const url = generateContentUrl(options);
+    const fetch2 = yield fetch$;
+    const content = yield fetch2(url.href).then(
+      (res) => res.json()
+    );
+    if (options.testGroups)
+      for (const item of content.results)
+        handleABTesting(item, options.testGroups);
+    return content;
+  });
+}
+function isPreviewing() {
+  if (!isBrowser())
+    return false;
+  if (isEditing())
+    return false;
+  return Boolean(location.search.indexOf("builder.preview=") !== -1);
+}
+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 __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols) {
+    for (var prop of __getOwnPropSymbols(source))
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+  }
+  return target;
+};
+const components = [];
+function registerComponent(component3, info) {
+  components.push(__spreadValues({
+    component: component3
+  }, info));
+  console.warn("registerComponent is deprecated. Use the `customComponents` prop in RenderContent instead to provide your custom components to the builder SDK.");
+  return component3;
+}
+const createRegisterComponentMessage = (_a) => {
+  var info = __objRest(_a, [
+    "component"
+  ]);
+  return {
+    type: "builder.registerComponent",
+    data: prepareComponentInfoToSend(info)
+  };
+};
+const fastClone = (obj) => JSON.parse(JSON.stringify(obj));
+const serializeValue = (value) => typeof value === "function" ? serializeFn(value) : fastClone(value);
+const serializeFn = (fnValue) => {
+  const fnStr = fnValue.toString().trim();
+  const appendFunction = !fnStr.startsWith("function") && !fnStr.startsWith("(");
+  return `return (${appendFunction ? "function " : ""}${fnStr}).apply(this, arguments)`;
+};
+const prepareComponentInfoToSend = (_c) => {
+  var { inputs } = _c, info = __objRest(_c, [
+    "inputs"
+  ]);
+  return __spreadProps(__spreadValues({}, fastClone(info)), {
+    inputs: inputs == null ? void 0 : inputs.map(
+      (input) => Object.entries(input).reduce(
+        (acc, [key, value]) => __spreadProps(__spreadValues({}, acc), {
+          [key]: serializeValue(value)
+        }),
+        {}
+      )
+    )
+  });
+};
+function track(event, properties) {
+  if (isEditing())
+    return;
+  if (!(isBrowser() || TARGET === "reactNative"))
+    return;
+  return fetch(`https://builder.io/api/v1/track`, {
+    method: "POST",
+    body: JSON.stringify({
+      events: [
+        {
+          type: event,
+          data: properties
+        }
+      ]
+    }),
+    headers: {
+      "content-type": "application/json"
+    },
+    mode: "cors"
+  });
+}
+const getCssFromFont = function getCssFromFont2(props, state, font) {
+  const family = font.family + (font.kind && !font.kind.includes("#") ? ", " + font.kind : "");
+  const name = family.split(",")[0];
+  const url = font.fileUrl ?? font?.files?.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;
+};
+const getFontCss = function getFontCss2(props, state, { customFonts }) {
+  return customFonts?.map(
+    (font) => getCssFromFont(props, state, font)
+  )?.join(" ") || "";
+};
+const injectedStyles = function injectedStyles2(props, state) {
+  return `
+${props.cssCode || ""}
+${getFontCss(props, state, {
+    customFonts: props.customFonts
+  })}`;
+};
+const RenderContentStyles = /* @__PURE__ */ componentQrl(inlinedQrl((props) => {
+  const state = {};
+  return /* @__PURE__ */ jsx(RenderInlinedStyles$1, {
+    styles: injectedStyles(props, state)
+  });
+}, "RenderContentStyles_component_32XAr483K2o"));
+const RenderContentStyles$1 = RenderContentStyles;
+const useContent = function useContent2(props, state) {
+  const mergedContent = {
+    ...props.content,
+    ...state.overrideContent,
+    data: {
+      ...props.content?.data,
+      ...props.data,
+      ...state.overrideContent?.data
+    }
+  };
+  return mergedContent;
+};
+const contentState = function contentState2(props, state) {
+  return {
+    ...props.content?.data?.state,
+    ...props.data,
+    ...state.overrideState
+  };
+};
+const contextContext = function contextContext2(props, state) {
+  return props.context || {};
+};
+const allRegisteredComponents = function allRegisteredComponents2(props, state) {
+  const allComponentsArray = [
+    ...getDefaultRegisteredComponents(),
+    ...components,
+    ...props.customComponents || []
+  ];
+  const allComponents = allComponentsArray.reduce(
+    (acc, curr) => ({
+      ...acc,
+      [curr.name]: curr
+    }),
+    {}
+  );
+  return allComponents;
+};
+const processMessage = function processMessage2(props, state, event) {
+  const { data } = event;
+  if (data)
+    switch (data.type) {
+      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)
+          state.overrideContent = contentData;
+        break;
+      }
+    }
+};
+const evaluateJsCode = function evaluateJsCode2(props, state) {
+  const jsCode = useContent(props, state)?.data?.jsCode;
+  if (jsCode)
+    evaluate({
+      code: jsCode,
+      context: contextContext(props),
+      state: contentState(props, state)
+    });
+};
+const httpReqsData = function httpReqsData2(props, state) {
+  return {};
+};
+const onClick2 = function onClick3(props, state, _event) {
+  if (useContent(props, state) && props.canTrack !== false)
+    track("click", {
+      contentId: useContent(props, state).id
+    });
+};
+const evalExpression = function evalExpression2(props, state, expression) {
+  return expression.replace(
+    /{{([^}]+)}}/g,
+    (_match, group) => evaluate({
+      code: group,
+      context: contextContext(props),
+      state: contentState(props, state)
+    })
+  );
+};
+const handleRequest = function handleRequest2(props, state, { url, key }) {
+  const fetchAndSetState = async () => {
+    const fetch2 = await getFetch();
+    const response = await fetch2(url);
+    const json = await response.json();
+    const newOverrideState = {
+      ...state.overrideState,
+      [key]: json
+    };
+    state.overrideState = newOverrideState;
+  };
+  fetchAndSetState();
+};
+const runHttpRequests = function runHttpRequests2(props, state) {
+  const requests = useContent(props, state)?.data?.httpRequests ?? {};
+  Object.entries(requests).forEach(([key, url]) => {
+    if (url && (!httpReqsData()[key] || isEditing())) {
+      const evaluatedUrl = evalExpression(props, state, url);
+      handleRequest(props, state, {
+        url: evaluatedUrl,
+        key
+      });
+    }
+  });
+};
+const emitStateUpdate = function emitStateUpdate2(props, state) {
+  if (isEditing())
+    window.dispatchEvent(new CustomEvent("builder:component:stateChange", {
+      detail: {
+        state: contentState(props, state),
+        ref: {
+          name: props.model
+        }
+      }
+    }));
+};
+const shouldRenderContentStyles = function shouldRenderContentStyles2(props, state) {
+  return Boolean((useContent(props, state)?.data?.cssCode || useContent(props, state)?.data?.customFonts?.length) && TARGET !== "reactNative");
+};
+const RenderContent = /* @__PURE__ */ componentQrl(inlinedQrl((props) => {
+  const hostElement = useHostElement();
+  const state = useStore({
+    forceReRenderCount: 0,
+    overrideContent: null,
+    update: 0,
+    overrideState: {}
+  });
+  useContextProvider(stdin_default, useStore({
+    content: (() => {
+      return useContent(props, state);
+    })(),
+    state: (() => {
+      return contentState(props, state);
+    })(),
+    context: (() => {
+      return contextContext(props);
+    })(),
+    apiKey: (() => {
+      return props.apiKey;
+    })(),
+    registeredComponents: (() => {
+      return allRegisteredComponents(props);
+    })()
+  }));
+  useClientEffectQrl(inlinedQrl(() => {
+    const [hostElement2, props2, state2] = useLexicalScope();
+    if (isBrowser()) {
+      if (isEditing()) {
+        state2.forceReRenderCount++;
+        _useMutableProps(hostElement2, true);
+        registerInsertMenu();
+        setupBrowserForEditing();
+        Object.values(allRegisteredComponents(props2)).forEach((registeredComponent) => {
+          const message = createRegisterComponentMessage(registeredComponent);
+          window.parent?.postMessage(message, "*");
+        });
+        window.addEventListener("message", processMessage.bind(null, props2, state2));
+        window.addEventListener("builder:component:stateChangeListenerActivated", emitStateUpdate.bind(null, props2, state2));
+      }
+      if (useContent(props2, state2) && props2.canTrack !== false)
+        track("impression", {
+          contentId: useContent(props2, state2).id
+        });
+      if (isPreviewing()) {
+        const searchParams = new URL(location.href).searchParams;
+        if (props2.model && searchParams.get("builder.preview") === props2.model) {
+          const previewApiKey = searchParams.get("apiKey") || searchParams.get("builder.space");
+          if (previewApiKey)
+            getContent({
+              model: props2.model,
+              apiKey: previewApiKey
+            }).then((content) => {
+              if (content)
+                state2.overrideContent = content;
+            });
+        }
+      }
+      evaluateJsCode(props2, state2);
+      runHttpRequests(props2, state2);
+      emitStateUpdate(props2, state2);
+    }
+  }, "RenderContent_component_useClientEffect_ntruwSC9lSo", [
+    hostElement,
+    props,
+    state
+  ]));
+  useWatchQrl(inlinedQrl(({ track: track1 }) => {
+    const [props2, state2] = useLexicalScope();
+    state2.useContent?.data && track1(state2.useContent?.data, "jsCode");
+    evaluateJsCode(props2, state2);
+  }, "RenderContent_component_useWatch_1P0ujLQOmzc", [
+    props,
+    state
+  ]));
+  useWatchQrl(inlinedQrl(({ track: track2 }) => {
+    const [props2, state2] = useLexicalScope();
+    state2.useContent?.data && track2(state2.useContent?.data, "httpRequests");
+    runHttpRequests(props2, state2);
+  }, "RenderContent_component_useWatch_1_0hAcn4V2AZw", [
+    props,
+    state
+  ]));
+  useWatchQrl(inlinedQrl(({ track: track3 }) => {
+    const [props2, state2] = useLexicalScope();
+    state2 && track3(state2, "contentState");
+    emitStateUpdate(props2, state2);
+  }, "RenderContent_component_useWatch_2_t2n8zpl4mRs", [
+    props,
+    state
+  ]));
+  useCleanupQrl(inlinedQrl(() => {
+    const [props2, state2] = useLexicalScope();
+    if (isBrowser()) {
+      window.removeEventListener("message", processMessage.bind(null, props2, state2));
+      window.removeEventListener("builder:component:stateChangeListenerActivated", emitStateUpdate.bind(null, props2, state2));
+    }
+  }, "RenderContent_component_useCleanup_sGf1npb03WA", [
+    props,
+    state
+  ]));
+  return /* @__PURE__ */ jsx(Fragment$1, {
+    children: useContent(props, state) ? /* @__PURE__ */ jsxs("div", {
+      onClick$: inlinedQrl((event) => {
+        const [props2, state2] = useLexicalScope();
+        return onClick2(props2, state2);
+      }, "RenderContent_component__Fragment_div_onClick_76e3rL00UYE", [
+        props,
+        state
+      ]),
+      "builder-content-id": useContent(props, state)?.id,
+      children: [
+        shouldRenderContentStyles(props, state) ? /* @__PURE__ */ jsx(RenderContentStyles$1, {
+          cssCode: useContent(props, state)?.data?.cssCode,
+          customFonts: useContent(props, state)?.data?.customFonts
+        }) : null,
+        /* @__PURE__ */ jsx(RenderBlocks$1, {
+          blocks: useContent(props, state)?.data?.blocks
+        }, state.forceReRenderCount)
+      ]
+    }) : null
+  });
+}, "RenderContent_component_I00xF3zGD1I"));
+const RenderContent$1 = RenderContent;
+const Symbol$1 = /* @__PURE__ */ componentQrl(inlinedQrl((props) => {
+  const builderContext = useContext(stdin_default);
+  const state = useStore({
+    className: "builder-symbol",
+    content: null
+  });
+  useClientEffectQrl(inlinedQrl(() => {
+    const [props2, state2] = useLexicalScope();
+    state2.content = props2.symbol?.content;
+  }, "Symbol_component_useClientEffect_nexfMR52XGY", [
+    props,
+    state
+  ]));
+  useWatchQrl(inlinedQrl(({ track: track2 }) => {
+    const [builderContext2, props2, state2] = useLexicalScope();
+    props2.symbol && track2(props2.symbol, "content");
+    props2.symbol && track2(props2.symbol, "model");
+    props2.symbol && track2(props2.symbol, "entry");
+    state2 && track2(state2, "content");
+    const symbolToUse = props2.symbol;
+    if (symbolToUse && !symbolToUse.content && !state2.content && symbolToUse.model)
+      getContent({
+        model: symbolToUse.model,
+        apiKey: builderContext2.apiKey,
+        query: {
+          id: symbolToUse.entry
+        }
+      }).then((response) => {
+        state2.content = response;
+      });
+  }, "Symbol_component_useWatch_cKXWtr2eEjY", [
+    builderContext,
+    props,
+    state
+  ]));
+  return /* @__PURE__ */ jsx(Host, {
+    ...props.attributes,
+    dataSet: {
+      class: state.className
+    },
+    class: state.className,
+    children: /* @__PURE__ */ jsx(RenderContent$1, {
+      apiKey: builderContext.apiKey,
+      context: builderContext.context,
+      customComponents: Object.values(builderContext.registeredComponents),
+      data: {
+        ...props.symbol?.data,
+        ...builderContext.state,
+        ...props.symbol?.content?.data?.state
+      },
+      model: props.symbol?.model,
+      content: state.content
+    })
+  });
+}, "Symbol_component_Dn8mGpai87I"), {
+  tagName: "div"
+});
+const Symbol$2 = Symbol$1;
+const settings = {};
+function setEditorSettings(newSettings) {
+  if (isBrowser()) {
+    Object.assign(settings, newSettings);
+    const message = {
+      type: "builder.settingsChange",
+      data: settings
+    };
+    parent.postMessage(message, "*");
+  }
+}
+export {
+  Button$1 as Button,
+  Columns$1 as Columns,
+  Fragment,
+  Image$1 as Image,
+  RenderBlocks$1 as RenderBlocks,
+  RenderContent$1 as RenderContent,
+  Section,
+  Symbol$2 as Symbol,
+  Text$1 as Text,
+  Video$1 as Video,
+  components,
+  convertSearchParamsToQueryObject,
+  createRegisterComponentMessage,
+  generateContentUrl,
+  getAllContent,
+  getBuilderSearchParams,
+  getBuilderSearchParamsFromWindow,
+  getContent,
+  isEditing,
+  isPreviewing,
+  normalizeSearchParams,
+  register,
+  registerComponent,
+  setEditorSettings
+};