@makeswift/prop-controllers 0.2.0-canary.0 → 0.2.0

package/dist/index.cjs

@@ -20,6 +20,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  Backgrounds: () => Backgrounds,
   Border: () => Border,
   BorderPropControllerFormat: () => BorderPropControllerFormat,
   BorderRadius: () => BorderRadius,
@@ -31,6 +32,9 @@ __export(src_exports, {
   Font: () => Font,
   GapX: () => GapX,
   GapY: () => GapY,
+  Grid: () => Grid,
+  Image: () => Image,
+  Images: () => Images,
   Link: () => Link,
   Margin: () => Margin,
   MarginPropControllerFormat: () => MarginPropControllerFormat,
@@ -50,17 +54,23 @@ __export(src_exports, {
   Video: () => Video,
   Width: () => Width,
   WidthPropControllerFormat: () => WidthPropControllerFormat,
+  backgroundsPropControllerDataSchema: () => backgroundsPropControllerDataSchema,
   borderPropControllerDataSchema: () => borderPropControllerDataSchema,
   borderRadiusPropControllerDataSchema: () => borderRadiusPropControllerDataSchema,
   checkboxPropControllerDataSchema: () => checkboxPropControllerDataSchema,
+  copyBackgroundsPropControllerData: () => copyBackgroundsPropControllerData,
   copyBorderPropControllerData: () => copyBorderPropControllerData,
   copyElementIDPropControllerData: () => copyElementIDPropControllerData,
+  copyGridPropControllerData: () => copyGridPropControllerData,
+  copyImagePropControllerData: () => copyImagePropControllerData,
+  copyImagesPropControllerData: () => copyImagesPropControllerData,
   copyLinkPropControllerData: () => copyLinkPropControllerData,
   copyNavigationLinksPropControllerData: () => copyNavigationLinksPropControllerData,
   copyResponsiveColorPropControllerData: () => copyResponsiveColorPropControllerData,
   copyShadowsPropControllerData: () => copyShadowsPropControllerData,
   copyTableFormFieldsPropControllerData: () => copyTableFormFieldsPropControllerData,
   copyTablePropControllerData: () => copyTablePropControllerData,
+  createBackgroundsPropControllerDataFromResponsiveBackgroundsData: () => createBackgroundsPropControllerDataFromResponsiveBackgroundsData,
   createBorderPropControllerDataFromResponsiveBorderData: () => createBorderPropControllerDataFromResponsiveBorderData,
   createBorderRadiusPropControllerDataFromResponsiveBorderRadiusData: () => createBorderRadiusPropControllerDataFromResponsiveBorderRadiusData,
   createCheckboxPropControllerDataFromBoolean: () => createCheckboxPropControllerDataFromBoolean,
@@ -69,6 +79,9 @@ __export(src_exports, {
   createFontPropControllerDataFromResponsiveFontData: () => createFontPropControllerDataFromResponsiveFontData,
   createGapXPropControllerDataFromResponsiveGapData: () => createGapXPropControllerDataFromResponsiveGapData,
   createGapYPropControllerDataFromResponsiveGapData: () => createGapYPropControllerDataFromResponsiveGapData,
+  createGridPropControllerDataFromGridData: () => createGridPropControllerDataFromGridData,
+  createImagePropControllerDataFromImageData: () => createImagePropControllerDataFromImageData,
+  createImagesPropControllerDataFromImagesData: () => createImagesPropControllerDataFromImagesData,
   createLinkPropControllerDataFromLinkData: () => createLinkPropControllerDataFromLinkData,
   createMarginPropControllerDataFromResponsiveMarginData: () => createMarginPropControllerDataFromResponsiveMarginData,
   createNavigationLinksPropControllerDataFromNavigationLinksData: () => createNavigationLinksPropControllerDataFromNavigationLinksData,
@@ -84,11 +97,17 @@ __export(src_exports, {
   createTextStylePropControllerDataFromResponsiveTextStyleData: () => createTextStylePropControllerDataFromResponsiveTextStyleData,
   createVideoPropControllerDataFromVideoData: () => createVideoPropControllerDataFromVideoData,
   createWidthPropControllerDataFromResponsiveLengthData: () => createWidthPropControllerDataFromResponsiveLengthData,
+  dataSchema: () => dataSchema,
   datePropControllerDataSchema: () => datePropControllerDataSchema,
+  elementDataSchema: () => elementDataSchema,
   elementIDPropControllerDataSchema: () => elementIDPropControllerDataSchema,
+  elementSchema: () => elementSchema,
   fontPropControllerDataSchema: () => fontPropControllerDataSchema,
   gapXPropControllerDataSchema: () => gapXPropControllerDataSchema,
   gapYPropControllerDataSchema: () => gapYPropControllerDataSchema,
+  getBackgroundsPropControllerDataResponsiveBackgroundsData: () => getBackgroundsPropControllerDataResponsiveBackgroundsData,
+  getBackgroundsPropControllerFileIds: () => getBackgroundsPropControllerFileIds,
+  getBackgroundsPropControllerSwatchIds: () => getBackgroundsPropControllerSwatchIds,
   getBorderPropControllerDataResponsiveBorderData: () => getBorderPropControllerDataResponsiveBorderData,
   getBorderPropControllerDataSwatchIds: () => getBorderPropControllerDataSwatchIds,
   getBorderRadiusPropControllerDataResponsiveBorderRadiusData: () => getBorderRadiusPropControllerDataResponsiveBorderRadiusData,
@@ -98,6 +117,13 @@ __export(src_exports, {
   getFontPropControllerDataResponsiveFontData: () => getFontPropControllerDataResponsiveFontData,
   getGapXPropControllerDataResponsiveGapData: () => getGapXPropControllerDataResponsiveGapData,
   getGapYPropControllerDataResponsiveGapData: () => getGapYPropControllerDataResponsiveGapData,
+  getGridPropControllerDataGridData: () => getGridPropControllerDataGridData,
+  getGridPropControllerElementChildren: () => getGridPropControllerElementChildren,
+  getGridPropControllerGetElementPath: () => getGridPropControllerGetElementPath,
+  getImagePropControllerDataImageData: () => getImagePropControllerDataImageData,
+  getImagePropControllerFileIds: () => getImagePropControllerFileIds,
+  getImagesPropControllerDataImagesData: () => getImagesPropControllerDataImagesData,
+  getImagesPropControllerFileIds: () => getImagesPropControllerFileIds,
   getLinkPropControllerDataLinkData: () => getLinkPropControllerDataLinkData,
   getLinkPropControllerPageIds: () => getLinkPropControllerPageIds,
   getMarginPropControllerDataResponsiveMarginData: () => getMarginPropControllerDataResponsiveMarginData,
@@ -119,9 +145,13 @@ __export(src_exports, {
   getTextStylePropControllerDataResponsiveTextStyleData: () => getTextStylePropControllerDataResponsiveTextStyleData,
   getVideoPropControllerDataVideoData: () => getVideoPropControllerDataVideoData,
   getWidthPropControllerDataResponsiveLengthData: () => getWidthPropControllerDataResponsiveLengthData,
+  gridPropControllerDataSchema: () => gridPropControllerDataSchema,
+  imagePropControllerDataSchema: () => imagePropControllerDataSchema,
+  imagesPropControllerDataSchema: () => imagesPropControllerDataSchema,
   linkDataSchema: () => linkDataSchema,
   linkPropControllerDataSchema: () => linkPropControllerDataSchema,
   marginPropControllerDataSchema: () => marginPropControllerDataSchema,
+  mergeGridPropControllerTranslatedData: () => mergeGridPropControllerTranslatedData,
   navigationLinksPropControllerDataSchema: () => navigationLinksPropControllerDataSchema,
   numberPropControllerDataSchema: () => numberPropControllerDataSchema,
   paddingPropControllerDataSchema: () => paddingPropControllerDataSchema,
@@ -140,6 +170,7 @@ module.exports = __toCommonJS(src_exports);
 // src/prop-controllers.ts
 var import_zod = require("zod");
 var Types = {
+  Backgrounds: "Backgrounds",
   Border: "Border",
   BorderRadius: "BorderRadius",
   Checkbox: "Checkbox",
@@ -148,6 +179,9 @@ var Types = {
   Font: "Font",
   GapX: "GapX",
   GapY: "GapY",
+  Grid: "Grid",
+  Image: "Image",
+  Images: "Images",
   Link: "Link",
   Margin: "Margin",
   NavigationLinks: "NavigationLinks",
@@ -174,8 +208,24 @@ function createDeviceOverrideSchema(schema) {
 function createResponsiveValueSchema(schema) {
   return import_zod.z.array(createDeviceOverrideSchema(schema));
 }
+var dataSchema = import_zod.z.any();
+var elementDataSchema = import_zod.z.object({
+  type: import_zod.z.string(),
+  key: import_zod.z.string(),
+  props: import_zod.z.record(dataSchema)
+});
+var elementReferenceSchema = import_zod.z.object({
+  type: import_zod.z.literal("reference"),
+  key: import_zod.z.string(),
+  value: import_zod.z.string()
+});
+var elementSchema = import_zod.z.union([
+  elementDataSchema,
+  elementReferenceSchema
+]);
 
-// src/border/border.ts
+// src/backgrounds/backgrounds.ts
+var import_zod3 = require("zod");
 var import_ts_pattern = require("ts-pattern");
 
 // src/data.ts
@@ -193,18 +243,287 @@ var gapDataSchema = import_zod2.z.object({
   unit: import_zod2.z.literal("px")
 });
 var responsiveGapDataSchema = createResponsiveValueSchema(gapDataSchema);
+var fileIdSchema = import_zod2.z.string();
+var imageDataV0Schema = fileIdSchema;
+var imageDataV1MakeswiftFileSchema = import_zod2.z.object({
+  version: import_zod2.z.literal(1),
+  type: import_zod2.z.literal("makeswift-file"),
+  id: import_zod2.z.string()
+});
+var imageDataV1ExternalFileSchema = import_zod2.z.object({
+  version: import_zod2.z.literal(1),
+  type: import_zod2.z.literal("external-file"),
+  url: import_zod2.z.string(),
+  width: import_zod2.z.number().nullable().optional(),
+  height: import_zod2.z.number().nullable().optional()
+});
+var imageDataV1Schema = import_zod2.z.union([
+  imageDataV1MakeswiftFileSchema,
+  imageDataV1ExternalFileSchema
+]);
+var imageDataSchema = import_zod2.z.union([imageDataV0Schema, imageDataV1Schema]);
+
+// src/backgrounds/backgrounds.ts
+var colorBackgroundDataSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("color"),
+  id: import_zod3.z.string(),
+  payload: colorDataSchema.nullable()
+});
+var gradientStopDataSchema = import_zod3.z.object({
+  id: import_zod3.z.string(),
+  location: import_zod3.z.number(),
+  color: colorDataSchema.nullable()
+});
+var gradientDataSchema = import_zod3.z.object({
+  angle: import_zod3.z.number().optional(),
+  isRadial: import_zod3.z.boolean().optional(),
+  stops: import_zod3.z.array(gradientStopDataSchema)
+});
+var gradientBackgroundDataSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("gradient"),
+  id: import_zod3.z.string(),
+  payload: gradientDataSchema
+});
+var backgroundImagePositionDataSchema = import_zod3.z.object({
+  x: import_zod3.z.number(),
+  y: import_zod3.z.number()
+});
+var backgroundSizeDataSchema = import_zod3.z.union([
+  import_zod3.z.literal("cover"),
+  import_zod3.z.literal("contain"),
+  import_zod3.z.literal("auto")
+]);
+var backgroundImageRepeatDataSchema = import_zod3.z.union([
+  import_zod3.z.literal("no-repeat"),
+  import_zod3.z.literal("repeat-x"),
+  import_zod3.z.literal("repeat-y"),
+  import_zod3.z.literal("repeat")
+]);
+var backgroundImageV0DataSchema = import_zod3.z.object({
+  imageId: imageDataV0Schema,
+  position: backgroundImagePositionDataSchema,
+  size: backgroundSizeDataSchema.optional(),
+  repeat: backgroundImageRepeatDataSchema.optional(),
+  opacity: import_zod3.z.number().optional(),
+  parallax: import_zod3.z.number().optional(),
+  priority: import_zod3.z.boolean().optional()
+});
+var backgroundImageV1DataSchema = import_zod3.z.object({
+  version: import_zod3.z.literal(1),
+  image: imageDataV1Schema,
+  position: backgroundImagePositionDataSchema,
+  size: backgroundSizeDataSchema.optional(),
+  repeat: backgroundImageRepeatDataSchema.optional(),
+  opacity: import_zod3.z.number().optional(),
+  parallax: import_zod3.z.number().optional(),
+  priority: import_zod3.z.boolean().optional()
+});
+var backgroundImageDataSchema = import_zod3.z.union([
+  backgroundImageV0DataSchema,
+  backgroundImageV1DataSchema
+]);
+var imageBackgroundV0DataSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("image"),
+  id: import_zod3.z.string(),
+  payload: backgroundImageV0DataSchema
+});
+var imageBackgroundV1DataSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("image-v1"),
+  id: import_zod3.z.string(),
+  payload: backgroundImageV1DataSchema
+});
+var imageBackgroundDataSchema = import_zod3.z.union([
+  imageBackgroundV0DataSchema,
+  imageBackgroundV1DataSchema
+]);
+var backgroundVideoAspectRatioDataSchema = import_zod3.z.union([
+  import_zod3.z.literal("wide"),
+  import_zod3.z.literal("standard")
+]);
+var backgroundVideoDataSchema = import_zod3.z.object({
+  url: import_zod3.z.string().optional(),
+  maskColor: colorDataSchema.nullable().optional(),
+  opacity: import_zod3.z.number().optional(),
+  zoom: import_zod3.z.number().optional(),
+  aspectRatio: backgroundVideoAspectRatioDataSchema.optional(),
+  parallax: import_zod3.z.number().optional()
+});
+var videoBackgroundDataSchema = import_zod3.z.object({
+  type: import_zod3.z.literal("video"),
+  id: import_zod3.z.string(),
+  payload: backgroundVideoDataSchema
+});
+var backgroundDataSchema = import_zod3.z.union([
+  colorBackgroundDataSchema,
+  gradientBackgroundDataSchema,
+  imageBackgroundDataSchema,
+  videoBackgroundDataSchema
+]);
+var responsiveBackgroundsDataSchema = createResponsiveValueSchema(
+  import_zod3.z.array(backgroundDataSchema)
+);
+var backgroundsPropControllerDataV1Schema = responsiveBackgroundsDataSchema;
+var BackgroundsPropControllerDataV2Type = "prop-controllers::backgrounds::v2";
+var backgroundsPropControllerDataV2Schema = import_zod3.z.object({
+  [ControlDataTypeKey]: import_zod3.z.literal(BackgroundsPropControllerDataV2Type),
+  value: responsiveBackgroundsDataSchema
+});
+var backgroundsPropControllerDataSchema = import_zod3.z.union([
+  backgroundsPropControllerDataV1Schema,
+  backgroundsPropControllerDataV2Schema
+]);
+function Backgrounds(options = {}) {
+  return { type: Types.Backgrounds, version: 2, options };
+}
+function getBackgroundsPropControllerDataResponsiveBackgroundsData(data) {
+  return (0, import_ts_pattern.match)(data).with(
+    { [ControlDataTypeKey]: BackgroundsPropControllerDataV2Type },
+    (v2) => v2.value
+  ).otherwise((v0) => v0);
+}
+function createBackgroundsPropControllerDataFromResponsiveBackgroundsData(data, definition) {
+  return (0, import_ts_pattern.match)(definition).with(
+    { version: 2 },
+    () => ({
+      [ControlDataTypeKey]: BackgroundsPropControllerDataV2Type,
+      value: data
+    })
+  ).otherwise(() => data);
+}
+function getBackgroundsPropControllerFileIds(data) {
+  const value = getBackgroundsPropControllerDataResponsiveBackgroundsData(data);
+  return value?.flatMap((override) => override.value).flatMap((backgroundItem) => {
+    return (0, import_ts_pattern.match)(backgroundItem).with(
+      {
+        type: "image-v1",
+        payload: { image: { type: "makeswift-file" } }
+      },
+      (item) => [item.payload.image.id]
+    ).with({ type: "image", payload: { imageId: import_ts_pattern.P.string } }, (item) => [
+      item.payload.imageId
+    ]).otherwise(() => []);
+  }) ?? [];
+}
+function getBackgroundsPropControllerSwatchIds(data) {
+  const value = getBackgroundsPropControllerDataResponsiveBackgroundsData(data);
+  return value?.flatMap((override) => override.value).flatMap((backgroundItem) => {
+    switch (backgroundItem.type) {
+      case "color":
+        return backgroundItem.payload?.swatchId == null ? [] : [backgroundItem.payload.swatchId];
+      case "gradient":
+        return backgroundItem.payload.stops.flatMap(
+          (stop) => stop.color == null ? [] : stop.color.swatchId
+        );
+      default:
+        return [];
+    }
+  }) ?? [];
+}
+function copyResponsiveBackgroundsData(descriptor, data, context) {
+  if (data == null)
+    return data;
+  return data.map((override) => ({
+    ...override,
+    value: override.value.map((backgroundItem) => {
+      return (0, import_ts_pattern.match)([descriptor, backgroundItem]).with([import_ts_pattern.P.any, { type: "color" }], ([, item]) => {
+        return {
+          ...item,
+          payload: item.payload === null ? null : {
+            ...item.payload,
+            swatchId: context.replacementContext.swatchIds.get(
+              item.payload.swatchId
+            ) ?? item.payload.swatchId
+          }
+        };
+      }).with([import_ts_pattern.P.any, { type: "gradient" }], ([, item]) => {
+        return {
+          ...item,
+          payload: {
+            ...item.payload,
+            stops: item.payload.stops.map((stop) => ({
+              ...stop,
+              color: stop.color == null ? null : {
+                ...stop.color,
+                swatchId: context.replacementContext.swatchIds.get(
+                  stop.color.swatchId
+                ) ?? stop.color.swatchId
+              }
+            }))
+          }
+        };
+      }).with(
+        [
+          { version: import_ts_pattern.P.when((v) => v >= 1) },
+          {
+            type: "image-v1",
+            payload: {
+              version: 1,
+              image: { type: "makeswift-file" }
+            }
+          }
+        ],
+        ([, item]) => {
+          return {
+            ...item,
+            payload: {
+              ...item.payload,
+              image: {
+                ...item.payload.image,
+                id: context.replacementContext.fileIds.get(
+                  item.payload.image.id
+                ) ?? item.payload.image.id
+              }
+            }
+          };
+        }
+      ).with(
+        [import_ts_pattern.P.any, { type: "image", payload: { imageId: import_ts_pattern.P.string } }],
+        ([, item]) => {
+          return {
+            ...item,
+            payload: {
+              ...item.payload,
+              imageId: context.replacementContext.fileIds.get(
+                item.payload.imageId
+              ) ?? item.payload.imageId
+            }
+          };
+        }
+      ).otherwise(() => backgroundItem);
+    })
+  }));
+}
+function copyBackgroundsPropControllerData(descriptor, data, context) {
+  return (0, import_ts_pattern.match)(data).with(void 0, () => void 0).with(
+    { [ControlDataTypeKey]: BackgroundsPropControllerDataV2Type },
+    (v1) => {
+      const value = copyResponsiveBackgroundsData(
+        descriptor,
+        v1.value,
+        context
+      );
+      if (value == null)
+        return void 0;
+      return {
+        [ControlDataTypeKey]: BackgroundsPropControllerDataV2Type,
+        value
+      };
+    }
+  ).otherwise((v0) => copyResponsiveBackgroundsData(descriptor, v0, context));
+}
 
 // src/border/border.ts
-var import_zod3 = require("zod");
-var borderSideDataSchema = import_zod3.z.object({
-  width: import_zod3.z.number().nullable().optional(),
-  style: import_zod3.z.enum(["dashed", "dotted", "solid"]),
+var import_ts_pattern2 = require("ts-pattern");
+var import_zod4 = require("zod");
+var borderSideDataSchema = import_zod4.z.object({
+  width: import_zod4.z.number().nullable().optional(),
+  style: import_zod4.z.enum(["dashed", "dotted", "solid"]),
   color: colorDataSchema.nullable().optional()
 }).transform((v) => ({
   ...v,
   width: v.width
 }));
-var borderDataSchema = import_zod3.z.object({
+var borderDataSchema = import_zod4.z.object({
   borderTop: borderSideDataSchema.nullable().optional(),
   borderRight: borderSideDataSchema.nullable().optional(),
   borderBottom: borderSideDataSchema.nullable().optional(),
@@ -218,11 +537,11 @@ var borderDataSchema = import_zod3.z.object({
 var responsiveBorderDataSchema = createResponsiveValueSchema(borderDataSchema);
 var borderPropControllerDataV0Schema = responsiveBorderDataSchema;
 var BorderPropControllerDataV1Type = "prop-controllers::border::v1";
-var borderPropControllerDataV1Schema = import_zod3.z.object({
-  [ControlDataTypeKey]: import_zod3.z.literal(BorderPropControllerDataV1Type),
+var borderPropControllerDataV1Schema = import_zod4.z.object({
+  [ControlDataTypeKey]: import_zod4.z.literal(BorderPropControllerDataV1Type),
   value: responsiveBorderDataSchema
 });
-var borderPropControllerDataSchema = import_zod3.z.union([
+var borderPropControllerDataSchema = import_zod4.z.union([
   borderPropControllerDataV0Schema,
   borderPropControllerDataV1Schema
 ]);
@@ -235,13 +554,13 @@ function Border(options = {}) {
 }
 Border.Format = BorderPropControllerFormat;
 function getBorderPropControllerDataResponsiveBorderData(data) {
-  return (0, import_ts_pattern.match)(data).with(
+  return (0, import_ts_pattern2.match)(data).with(
     { [ControlDataTypeKey]: BorderPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createBorderPropControllerDataFromResponsiveBorderData(definition, responsiveBorderData) {
-  return (0, import_ts_pattern.match)(definition).with(
+  return (0, import_ts_pattern2.match)(definition).with(
     { version: 1 },
     () => ({
       [ControlDataTypeKey]: BorderPropControllerDataV1Type,
@@ -293,7 +612,7 @@ function copyResponsiveBorderData(data, context) {
   }
 }
 function copyBorderPropControllerData(data, context) {
-  return (0, import_ts_pattern.match)(data).with(void 0, () => void 0).with(
+  return (0, import_ts_pattern2.match)(data).with(void 0, () => void 0).with(
     { [ControlDataTypeKey]: BorderPropControllerDataV1Type },
     (v1) => ({
       [ControlDataTypeKey]: BorderPropControllerDataV1Type,
@@ -303,9 +622,9 @@ function copyBorderPropControllerData(data, context) {
 }
 
 // src/border-radius/border-radius.ts
-var import_zod4 = require("zod");
-var import_ts_pattern2 = require("ts-pattern");
-var borderRadiusDataSchema = import_zod4.z.object({
+var import_zod5 = require("zod");
+var import_ts_pattern3 = require("ts-pattern");
+var borderRadiusDataSchema = import_zod5.z.object({
   borderTopLeftRadius: lengthDataSchema.nullable().optional(),
   borderTopRightRadius: lengthDataSchema.nullable().optional(),
   borderBottomLeftRadius: lengthDataSchema.nullable().optional(),
@@ -316,11 +635,11 @@ var responsiveBorderRadiusDataSchema = createResponsiveValueSchema(
 );
 var borderRadiusPropControllerDataV0Schema = responsiveBorderRadiusDataSchema;
 var BorderRadiusPropControllerDataV1Type = "prop-controllers::border-radius::v1";
-var borderRadiusPropControllerDataV1Schema = import_zod4.z.object({
-  [ControlDataTypeKey]: import_zod4.z.literal(BorderRadiusPropControllerDataV1Type),
+var borderRadiusPropControllerDataV1Schema = import_zod5.z.object({
+  [ControlDataTypeKey]: import_zod5.z.literal(BorderRadiusPropControllerDataV1Type),
   value: responsiveBorderRadiusDataSchema
 });
-var borderRadiusPropControllerDataSchema = import_zod4.z.union([
+var borderRadiusPropControllerDataSchema = import_zod5.z.union([
   borderRadiusPropControllerDataV0Schema,
   borderRadiusPropControllerDataV1Schema
 ]);
@@ -333,13 +652,13 @@ function BorderRadius(options = {}) {
 }
 BorderRadius.Format = BorderRadiusPropControllerFormat;
 function getBorderRadiusPropControllerDataResponsiveBorderRadiusData(data) {
-  return (0, import_ts_pattern2.match)(data).with(
+  return (0, import_ts_pattern3.match)(data).with(
     { [ControlDataTypeKey]: BorderRadiusPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createBorderRadiusPropControllerDataFromResponsiveBorderRadiusData(definition, responsiveBorderRadiusData) {
-  return (0, import_ts_pattern2.match)(definition).with(
+  return (0, import_ts_pattern3.match)(definition).with(
     { version: 1 },
     () => ({
       [ControlDataTypeKey]: BorderRadiusPropControllerDataV1Type,
@@ -349,15 +668,15 @@ function createBorderRadiusPropControllerDataFromResponsiveBorderRadiusData(defi
 }
 
 // src/checkbox/checkbox.ts
-var import_zod5 = require("zod");
-var import_ts_pattern3 = require("ts-pattern");
-var checkboxPropControllerDataV0Schema = import_zod5.z.boolean();
+var import_zod6 = require("zod");
+var import_ts_pattern4 = require("ts-pattern");
+var checkboxPropControllerDataV0Schema = import_zod6.z.boolean();
 var CheckboxPropControllerDataV1Type = "prop-controllers::checkbox::v1";
-var checkboxPropControllerDataV1Schema = import_zod5.z.object({
-  [ControlDataTypeKey]: import_zod5.z.literal(CheckboxPropControllerDataV1Type),
-  value: import_zod5.z.boolean()
+var checkboxPropControllerDataV1Schema = import_zod6.z.object({
+  [ControlDataTypeKey]: import_zod6.z.literal(CheckboxPropControllerDataV1Type),
+  value: import_zod6.z.boolean()
 });
-var checkboxPropControllerDataSchema = import_zod5.z.union([
+var checkboxPropControllerDataSchema = import_zod6.z.union([
   checkboxPropControllerDataV0Schema,
   checkboxPropControllerDataV1Schema
 ]);
@@ -365,15 +684,15 @@ function Checkbox(options) {
   return { type: Types.Checkbox, version: 1, options };
 }
 function getCheckboxPropControllerDataBoolean(data) {
-  return (0, import_ts_pattern3.match)(data).with(
+  return (0, import_ts_pattern4.match)(data).with(
     { [ControlDataTypeKey]: CheckboxPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createCheckboxPropControllerDataFromBoolean(value, definition) {
-  return (0, import_ts_pattern3.match)(definition).with(
+  return (0, import_ts_pattern4.match)(definition).with(
     { version: 1 },
-    import_ts_pattern3.P.nullish,
+    import_ts_pattern4.P.nullish,
     () => ({
       [ControlDataTypeKey]: CheckboxPropControllerDataV1Type,
       value
@@ -382,15 +701,15 @@ function createCheckboxPropControllerDataFromBoolean(value, definition) {
 }
 
 // src/date/date.ts
-var import_zod6 = require("zod");
-var import_ts_pattern4 = require("ts-pattern");
-var datePropControllerDataV0Schema = import_zod6.z.string();
+var import_zod7 = require("zod");
+var import_ts_pattern5 = require("ts-pattern");
+var datePropControllerDataV0Schema = import_zod7.z.string();
 var DatePropControllerDataV1Type = "prop-controllers::date::v1";
-var datePropControllerDataV1Schema = import_zod6.z.object({
-  [ControlDataTypeKey]: import_zod6.z.literal(DatePropControllerDataV1Type),
-  value: import_zod6.z.string()
+var datePropControllerDataV1Schema = import_zod7.z.object({
+  [ControlDataTypeKey]: import_zod7.z.literal(DatePropControllerDataV1Type),
+  value: import_zod7.z.string()
 });
-var datePropControllerDataSchema = import_zod6.z.union([
+var datePropControllerDataSchema = import_zod7.z.union([
   datePropControllerDataV0Schema,
   datePropControllerDataV1Schema
 ]);
@@ -398,15 +717,15 @@ function Date(options = {}) {
   return { type: Types.Date, version: 1, options };
 }
 function getDatePropControllerDataString(data) {
-  return (0, import_ts_pattern4.match)(data).with(
+  return (0, import_ts_pattern5.match)(data).with(
     { [ControlDataTypeKey]: DatePropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createDatePropControllerDataFromString(value, definition) {
-  return (0, import_ts_pattern4.match)(definition).with(
+  return (0, import_ts_pattern5.match)(definition).with(
     { version: 1 },
-    import_ts_pattern4.P.nullish,
+    import_ts_pattern5.P.nullish,
     () => ({
       [ControlDataTypeKey]: DatePropControllerDataV1Type,
       value
@@ -415,16 +734,16 @@ function createDatePropControllerDataFromString(value, definition) {
 }
 
 // src/element-id/element-id.ts
-var import_zod7 = require("zod");
-var import_ts_pattern5 = require("ts-pattern");
-var elementIDSchema = import_zod7.z.string();
+var import_zod8 = require("zod");
+var import_ts_pattern6 = require("ts-pattern");
+var elementIDSchema = import_zod8.z.string();
 var elementIDPropControllerDataV0Schema = elementIDSchema;
 var ElementIDPropControllerDataV1Type = "prop-controllers::element-id::v1";
-var elementIDPropControllerDataV1Schema = import_zod7.z.object({
-  [ControlDataTypeKey]: import_zod7.z.literal(ElementIDPropControllerDataV1Type),
+var elementIDPropControllerDataV1Schema = import_zod8.z.object({
+  [ControlDataTypeKey]: import_zod8.z.literal(ElementIDPropControllerDataV1Type),
   value: elementIDSchema
 });
-var elementIDPropControllerDataSchema = import_zod7.z.union([
+var elementIDPropControllerDataSchema = import_zod8.z.union([
   elementIDPropControllerDataV0Schema,
   elementIDPropControllerDataV1Schema
 ]);
@@ -432,15 +751,15 @@ function ElementID(options = {}) {
   return { type: Types.ElementID, version: 1, options };
 }
 function getElementIDPropControllerDataElementID(data) {
-  return (0, import_ts_pattern5.match)(data).with(
+  return (0, import_ts_pattern6.match)(data).with(
     { [ControlDataTypeKey]: ElementIDPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createElementIDPropControllerDataFromElementID(value, definition) {
-  return (0, import_ts_pattern5.match)(definition).with(
+  return (0, import_ts_pattern6.match)(definition).with(
     { version: 1 },
-    import_ts_pattern5.P.nullish,
+    import_ts_pattern6.P.nullish,
     () => ({
       [ControlDataTypeKey]: ElementIDPropControllerDataV1Type,
       value
@@ -456,7 +775,7 @@ function copyElementID(data, context) {
   return data;
 }
 function copyElementIDPropControllerData(data, context) {
-  return (0, import_ts_pattern5.match)(data).with(void 0, () => void 0).with({ [ControlDataTypeKey]: ElementIDPropControllerDataV1Type }, (v1) => {
+  return (0, import_ts_pattern6.match)(data).with(void 0, () => void 0).with({ [ControlDataTypeKey]: ElementIDPropControllerDataV1Type }, (v1) => {
     const value = copyElementID(v1.value, context);
     if (value == null)
       return void 0;
@@ -468,17 +787,17 @@ function copyElementIDPropControllerData(data, context) {
 }
 
 // src/font/font.ts
-var import_ts_pattern6 = require("ts-pattern");
-var import_zod8 = require("zod");
-var fontDataSchema = import_zod8.z.string();
+var import_ts_pattern7 = require("ts-pattern");
+var import_zod9 = require("zod");
+var fontDataSchema = import_zod9.z.string();
 var responsiveFontDataSchema = createResponsiveValueSchema(fontDataSchema);
 var fontPropControllerDataV0Schema = responsiveFontDataSchema;
 var FontPropControllerDataV1Type = "prop-controllers::font::v1";
-var fontPropControllerDataV1Schema = import_zod8.z.object({
-  [ControlDataTypeKey]: import_zod8.z.literal(FontPropControllerDataV1Type),
+var fontPropControllerDataV1Schema = import_zod9.z.object({
+  [ControlDataTypeKey]: import_zod9.z.literal(FontPropControllerDataV1Type),
   value: responsiveFontDataSchema
 });
-var fontPropControllerDataSchema = import_zod8.z.union([
+var fontPropControllerDataSchema = import_zod9.z.union([
   fontPropControllerDataV0Schema,
   fontPropControllerDataV1Schema
 ]);
@@ -486,15 +805,15 @@ function Font(options = {}) {
   return { type: Types.Font, version: 1, options };
 }
 function getFontPropControllerDataResponsiveFontData(data) {
-  return (0, import_ts_pattern6.match)(data).with(
+  return (0, import_ts_pattern7.match)(data).with(
     { [ControlDataTypeKey]: FontPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createFontPropControllerDataFromResponsiveFontData(responsiveFontData, definition) {
-  return (0, import_ts_pattern6.match)(definition).with(
+  return (0, import_ts_pattern7.match)(definition).with(
     { version: 1 },
-    import_ts_pattern6.P.nullish,
+    import_ts_pattern7.P.nullish,
     () => ({
       [ControlDataTypeKey]: FontPropControllerDataV1Type,
       value: responsiveFontData
@@ -503,15 +822,15 @@ function createFontPropControllerDataFromResponsiveFontData(responsiveFontData,
 }
 
 // src/gap-x/gap-x.ts
-var import_ts_pattern7 = require("ts-pattern");
-var import_zod9 = require("zod");
+var import_ts_pattern8 = require("ts-pattern");
+var import_zod10 = require("zod");
 var gapXPropControllerDataV0Schema = responsiveGapDataSchema;
 var GapXPropControllerDataV1Type = "prop-controllers::gap-x::v1";
-var gapXPropControllerDataV1Schema = import_zod9.z.object({
-  [ControlDataTypeKey]: import_zod9.z.literal(GapXPropControllerDataV1Type),
+var gapXPropControllerDataV1Schema = import_zod10.z.object({
+  [ControlDataTypeKey]: import_zod10.z.literal(GapXPropControllerDataV1Type),
   value: responsiveGapDataSchema
 });
-var gapXPropControllerDataSchema = import_zod9.z.union([
+var gapXPropControllerDataSchema = import_zod10.z.union([
   gapXPropControllerDataV0Schema,
   gapXPropControllerDataV1Schema
 ]);
@@ -519,13 +838,13 @@ function GapX(options = {}) {
   return { type: Types.GapX, version: 1, options };
 }
 function getGapXPropControllerDataResponsiveGapData(data) {
-  return (0, import_ts_pattern7.match)(data).with(
+  return (0, import_ts_pattern8.match)(data).with(
     { [ControlDataTypeKey]: GapXPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createGapXPropControllerDataFromResponsiveGapData(responsiveGapData, definition) {
-  return (0, import_ts_pattern7.match)(definition).with(
+  return (0, import_ts_pattern8.match)(definition).with(
     { version: 1 },
     () => ({
       [ControlDataTypeKey]: GapXPropControllerDataV1Type,
@@ -535,15 +854,15 @@ function createGapXPropControllerDataFromResponsiveGapData(responsiveGapData, de
 }
 
 // src/gap-y/gap-y.ts
-var import_ts_pattern8 = require("ts-pattern");
-var import_zod10 = require("zod");
+var import_ts_pattern9 = require("ts-pattern");
+var import_zod11 = require("zod");
 var gapYPropControllerDataV0Schema = responsiveGapDataSchema;
 var GapYPropControllerDataV1Type = "prop-controllers::gap-y::v1";
-var gapYPropControllerDataV1Schema = import_zod10.z.object({
-  [ControlDataTypeKey]: import_zod10.z.literal(GapYPropControllerDataV1Type),
+var gapYPropControllerDataV1Schema = import_zod11.z.object({
+  [ControlDataTypeKey]: import_zod11.z.literal(GapYPropControllerDataV1Type),
   value: responsiveGapDataSchema
 });
-var gapYPropControllerDataSchema = import_zod10.z.union([
+var gapYPropControllerDataSchema = import_zod11.z.union([
   gapYPropControllerDataV0Schema,
   gapYPropControllerDataV1Schema
 ]);
@@ -551,13 +870,13 @@ function GapY(options = {}) {
   return { type: Types.GapY, version: 1, options };
 }
 function getGapYPropControllerDataResponsiveGapData(data) {
-  return (0, import_ts_pattern8.match)(data).with(
+  return (0, import_ts_pattern9.match)(data).with(
     { [ControlDataTypeKey]: GapYPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createGapYPropControllerDataFromResponsiveGapData(responsiveGapData, definition) {
-  return (0, import_ts_pattern8.match)(definition).with(
+  return (0, import_ts_pattern9.match)(definition).with(
     { version: 1 },
     () => ({
       [ControlDataTypeKey]: GapYPropControllerDataV1Type,
@@ -566,58 +885,204 @@ function createGapYPropControllerDataFromResponsiveGapData(responsiveGapData, de
   ).otherwise(() => responsiveGapData);
 }
 
+// src/grid/grid.ts
+var import_zod12 = require("zod");
+var import_ts_pattern10 = require("ts-pattern");
+var gridColumnSchema = import_zod12.z.object({
+  count: import_zod12.z.number(),
+  spans: import_zod12.z.array(import_zod12.z.array(import_zod12.z.number()))
+});
+var gridDataSchema = import_zod12.z.object({
+  elements: import_zod12.z.array(elementSchema),
+  columns: createResponsiveValueSchema(gridColumnSchema)
+});
+var gridPropControllerDataV0Schema = gridDataSchema;
+var GridPropControllerDataV1Type = "prop-controllers::grid::v1";
+var gridPropControllerDataV1Schema = import_zod12.z.object({
+  [ControlDataTypeKey]: import_zod12.z.literal(GridPropControllerDataV1Type),
+  value: gridDataSchema
+});
+var gridPropControllerDataSchema = import_zod12.z.union([
+  gridPropControllerDataV0Schema,
+  gridPropControllerDataV1Schema
+]);
+function Grid(options = {}) {
+  return { type: Types.Grid, version: 1, options };
+}
+function getGridPropControllerDataGridData(data) {
+  return (0, import_ts_pattern10.match)(data).with(
+    { [ControlDataTypeKey]: GridPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createGridPropControllerDataFromGridData(value, definition) {
+  return (0, import_ts_pattern10.match)(definition).with(
+    { version: 1 },
+    import_ts_pattern10.P.nullish,
+    () => ({
+      [ControlDataTypeKey]: GridPropControllerDataV1Type,
+      value
+    })
+  ).otherwise(() => value);
+}
+function mergeGridDataTranslatedData(data, context) {
+  return {
+    ...data,
+    elements: data.elements.map(
+      (element) => context.mergeTranslatedData(element)
+    )
+  };
+}
+function mergeGridPropControllerTranslatedData(data, context) {
+  return (0, import_ts_pattern10.match)(data).with(
+    { [ControlDataTypeKey]: GridPropControllerDataV1Type },
+    (v1) => ({
+      [ControlDataTypeKey]: GridPropControllerDataV1Type,
+      value: mergeGridDataTranslatedData(v1.value, context)
+    })
+  ).otherwise((v0) => mergeGridDataTranslatedData(v0, context));
+}
+function getGridPropControllerElementChildren(data) {
+  return getGridPropControllerDataGridData(data)?.elements ?? [];
+}
+function copyGridData(data, context) {
+  return {
+    ...data,
+    elements: data.elements.map((element) => context.copyElement(element))
+  };
+}
+function copyGridPropControllerData(data, context) {
+  return (0, import_ts_pattern10.match)(data).with(void 0, () => void 0).with(
+    { [ControlDataTypeKey]: GridPropControllerDataV1Type },
+    (v1) => ({
+      [ControlDataTypeKey]: GridPropControllerDataV1Type,
+      value: copyGridData(v1.value, context)
+    })
+  ).otherwise((v0) => copyGridData(v0, context));
+}
+function getGridPropControllerGetElementPath(data, elementKey) {
+  const value = getGridPropControllerDataGridData(data);
+  const idx = value?.elements.findIndex((element) => element.key === elementKey) ?? -1;
+  if (idx === -1)
+    return null;
+  return (0, import_ts_pattern10.match)(data).with({ [ControlDataTypeKey]: GridPropControllerDataV1Type }, (_v1) => [
+    "value",
+    "elements",
+    idx
+  ]).otherwise((_v0) => ["elements", idx]);
+}
+
+// src/image/image.ts
+var import_zod13 = require("zod");
+var import_ts_pattern11 = require("ts-pattern");
+var imagePropControllerDataV0Schema = imageDataV0Schema;
+var imagePropControllerDataV1Schema = imageDataSchema;
+var ImagePropControllerDataV2Type = "prop-controllers::image::v2";
+var imagePropControllerDataV2Schema = import_zod13.z.object({
+  [ControlDataTypeKey]: import_zod13.z.literal(ImagePropControllerDataV2Type),
+  value: imagePropControllerDataV1Schema
+});
+var imagePropControllerDataSchema = import_zod13.z.union([
+  imagePropControllerDataV0Schema,
+  imagePropControllerDataV1Schema,
+  imagePropControllerDataV2Schema
+]);
+function Image(options = {}) {
+  return { type: Types.Image, version: 2, options };
+}
+function getImagePropControllerDataImageData(data) {
+  return (0, import_ts_pattern11.match)(data).with(
+    { [ControlDataTypeKey]: ImagePropControllerDataV2Type },
+    (v2) => v2.value
+  ).otherwise((v0) => v0);
+}
+function createImagePropControllerDataFromImageData(data, definition) {
+  return (0, import_ts_pattern11.match)(definition).with(
+    { version: 2 },
+    () => ({
+      [ControlDataTypeKey]: ImagePropControllerDataV2Type,
+      value: data
+    })
+  ).otherwise(() => data);
+}
+function getImagePropControllerFileIds(data) {
+  const value = getImagePropControllerDataImageData(data);
+  return (0, import_ts_pattern11.match)(value).with(void 0, () => []).with(import_ts_pattern11.P.string, (v) => [v]).with({ type: "makeswift-file", version: 1 }, (v) => [v.id]).with({ type: "external-file", version: 1 }, () => []).exhaustive();
+}
+function copyImageData(data, context) {
+  return (0, import_ts_pattern11.match)(data).with(import_ts_pattern11.P.string, (v) => context.replacementContext.fileIds.get(v) ?? v).with({ type: "makeswift-file", version: 1 }, (v) => ({
+    ...v,
+    id: context.replacementContext.fileIds.get(v.id) ?? v.id
+  })).otherwise((v) => v);
+}
+function copyImagePropControllerData(data, context) {
+  return (0, import_ts_pattern11.match)(data).with(void 0, () => void 0).with({ [ControlDataTypeKey]: ImagePropControllerDataV2Type }, (v1) => {
+    const value = copyImageData(v1.value, context);
+    if (value == null)
+      return void 0;
+    return {
+      [ControlDataTypeKey]: ImagePropControllerDataV2Type,
+      value
+    };
+  }).otherwise((v0) => copyImageData(v0, context));
+}
+
+// src/images/images.ts
+var import_zod15 = require("zod");
+var import_ts_pattern13 = require("ts-pattern");
+
 // src/link/link.ts
-var import_ts_pattern9 = require("ts-pattern");
-var import_zod11 = require("zod");
-var openPageLinkSchema = import_zod11.z.object({
-  type: import_zod11.z.literal("OPEN_PAGE"),
-  payload: import_zod11.z.object({
-    pageId: import_zod11.z.string().nullable().optional(),
-    openInNewTab: import_zod11.z.boolean()
+var import_ts_pattern12 = require("ts-pattern");
+var import_zod14 = require("zod");
+var openPageLinkSchema = import_zod14.z.object({
+  type: import_zod14.z.literal("OPEN_PAGE"),
+  payload: import_zod14.z.object({
+    pageId: import_zod14.z.string().nullable().optional(),
+    openInNewTab: import_zod14.z.boolean()
   }).transform((v) => ({
     pageId: v.pageId,
     ...v
   }))
 });
-var openURLLinkSchema = import_zod11.z.object({
-  type: import_zod11.z.literal("OPEN_URL"),
-  payload: import_zod11.z.object({
-    url: import_zod11.z.string(),
-    openInNewTab: import_zod11.z.boolean()
+var openURLLinkSchema = import_zod14.z.object({
+  type: import_zod14.z.literal("OPEN_URL"),
+  payload: import_zod14.z.object({
+    url: import_zod14.z.string(),
+    openInNewTab: import_zod14.z.boolean()
   })
 });
-var sendEmailLinkSchema = import_zod11.z.object({
-  type: import_zod11.z.literal("SEND_EMAIL"),
-  payload: import_zod11.z.object({
-    to: import_zod11.z.string(),
-    subject: import_zod11.z.string().optional(),
-    body: import_zod11.z.string().optional()
+var sendEmailLinkSchema = import_zod14.z.object({
+  type: import_zod14.z.literal("SEND_EMAIL"),
+  payload: import_zod14.z.object({
+    to: import_zod14.z.string(),
+    subject: import_zod14.z.string().optional(),
+    body: import_zod14.z.string().optional()
   })
 });
-var callPhoneLinkSchema = import_zod11.z.object({
-  type: import_zod11.z.literal("CALL_PHONE"),
-  payload: import_zod11.z.object({
-    phoneNumber: import_zod11.z.string()
+var callPhoneLinkSchema = import_zod14.z.object({
+  type: import_zod14.z.literal("CALL_PHONE"),
+  payload: import_zod14.z.object({
+    phoneNumber: import_zod14.z.string()
   })
 });
-var scrollToElementLinkSchema = import_zod11.z.object({
-  type: import_zod11.z.literal("SCROLL_TO_ELEMENT"),
-  payload: import_zod11.z.object({
-    elementIdConfig: import_zod11.z.object({
-      elementKey: import_zod11.z.string(),
-      propName: import_zod11.z.string()
+var scrollToElementLinkSchema = import_zod14.z.object({
+  type: import_zod14.z.literal("SCROLL_TO_ELEMENT"),
+  payload: import_zod14.z.object({
+    elementIdConfig: import_zod14.z.object({
+      elementKey: import_zod14.z.string(),
+      propName: import_zod14.z.string()
     }).nullable().optional(),
-    block: import_zod11.z.union([
-      import_zod11.z.literal("start"),
-      import_zod11.z.literal("center"),
-      import_zod11.z.literal("end")
+    block: import_zod14.z.union([
+      import_zod14.z.literal("start"),
+      import_zod14.z.literal("center"),
+      import_zod14.z.literal("end")
     ])
   }).transform((v) => ({
     elementIdConfig: v.elementIdConfig,
     ...v
   }))
 });
-var linkDataSchema = import_zod11.z.union([
+var linkDataSchema = import_zod14.z.union([
   openPageLinkSchema,
   openURLLinkSchema,
   sendEmailLinkSchema,
@@ -626,11 +1091,11 @@ var linkDataSchema = import_zod11.z.union([
 ]);
 var linkPropControllerDataV0Schema = linkDataSchema;
 var LinkPropControllerDataV1Type = "prop-controllers::link::v1";
-var linkPropControllerDataV1Schema = import_zod11.z.object({
-  [ControlDataTypeKey]: import_zod11.z.literal(LinkPropControllerDataV1Type),
+var linkPropControllerDataV1Schema = import_zod14.z.object({
+  [ControlDataTypeKey]: import_zod14.z.literal(LinkPropControllerDataV1Type),
   value: linkDataSchema
 });
-var linkPropControllerDataSchema = import_zod11.z.union([
+var linkPropControllerDataSchema = import_zod14.z.union([
   linkPropControllerDataV0Schema,
   linkPropControllerDataV1Schema
 ]);
@@ -638,13 +1103,13 @@ function Link(options = {}) {
   return { type: Types.Link, version: 1, options };
 }
 function getLinkPropControllerDataLinkData(data) {
-  return (0, import_ts_pattern9.match)(data).with(
+  return (0, import_ts_pattern12.match)(data).with(
     { [ControlDataTypeKey]: LinkPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createLinkPropControllerDataFromLinkData(value, definition) {
-  return (0, import_ts_pattern9.match)(definition).with(
+  return (0, import_ts_pattern12.match)(definition).with(
     { version: 1 },
     () => ({
       [ControlDataTypeKey]: LinkPropControllerDataV1Type,
@@ -707,23 +1172,125 @@ function copyLinkPropControllerData(data, context) {
   const value = copyLinkData(getLinkPropControllerDataLinkData(data), context);
   if (value == null)
     return value;
-  return (0, import_ts_pattern9.match)(data).with({ [ControlDataTypeKey]: LinkPropControllerDataV1Type }, (v1) => ({
+  return (0, import_ts_pattern12.match)(data).with({ [ControlDataTypeKey]: LinkPropControllerDataV1Type }, (v1) => ({
     ...v1,
     value
   })).otherwise((_) => value);
 }
 
+// src/images/images.ts
+var imagesDataV0ItemSchema = import_zod15.z.object({
+  key: import_zod15.z.string(),
+  props: import_zod15.z.object({
+    link: linkDataSchema.optional(),
+    file: imageDataV0Schema.optional(),
+    altText: import_zod15.z.string().optional()
+  })
+});
+var imagesDataV0Schema = import_zod15.z.array(imagesDataV0ItemSchema);
+var imagesDataV1ItemSchema = import_zod15.z.object({
+  key: import_zod15.z.string(),
+  version: import_zod15.z.literal(1),
+  props: import_zod15.z.object({
+    link: linkDataSchema.optional(),
+    file: imageDataV1Schema.optional(),
+    altText: import_zod15.z.string().optional()
+  })
+});
+var imagesDataItemSchema = import_zod15.z.union([
+  imagesDataV0ItemSchema,
+  imagesDataV1ItemSchema
+]);
+var imagesDataSchema = import_zod15.z.array(imagesDataItemSchema);
+var imagesPropControllerDataV0Schema = import_zod15.z.array(imagesDataV0ItemSchema);
+var imagesPropControllerDataV1Schema = imagesDataSchema;
+var ImagesPropControllerDataV2Type = "prop-controllers::images::v2";
+var imagesPropControllerDataV2Schema = import_zod15.z.object({
+  [ControlDataTypeKey]: import_zod15.z.literal(ImagesPropControllerDataV2Type),
+  value: imagesPropControllerDataV1Schema
+});
+var imagesPropControllerDataSchema = import_zod15.z.union([
+  imagesPropControllerDataV0Schema,
+  imagesPropControllerDataV1Schema,
+  imagesPropControllerDataV2Schema
+]);
+function Images(options = {}) {
+  return { type: Types.Images, version: 2, options };
+}
+function getImagesPropControllerDataImagesData(data) {
+  return (0, import_ts_pattern13.match)(data).with(
+    { [ControlDataTypeKey]: ImagesPropControllerDataV2Type },
+    (v2) => v2.value
+  ).otherwise((v0) => v0);
+}
+function createImagesPropControllerDataFromImagesData(data, definition) {
+  return (0, import_ts_pattern13.match)(definition).with(
+    { version: 2 },
+    () => ({
+      [ControlDataTypeKey]: ImagesPropControllerDataV2Type,
+      value: data
+    })
+  ).otherwise(() => data);
+}
+function getImagesPropControllerFileIds(data) {
+  const value = getImagesPropControllerDataImagesData(data);
+  return value?.flatMap(
+    (item) => (0, import_ts_pattern13.match)(item.props.file).with(import_ts_pattern13.P.string, (f) => [f]).with({ type: "makeswift-file", version: 1 }, (f) => [f.id]).with({ type: "external-file", version: 1 }, () => []).with(import_ts_pattern13.P.nullish, () => []).otherwise(() => [])
+  ) ?? [];
+}
+function copyImagesData(data, context) {
+  if (data == null)
+    return data;
+  return data.map(copyImagesPanelItem);
+  function copyImagesPanelItem(imagesPanelItem) {
+    if ("version" in imagesPanelItem) {
+      return {
+        ...imagesPanelItem,
+        props: {
+          ...imagesPanelItem.props,
+          file: (0, import_ts_pattern13.match)(imagesPanelItem.props.file).with({ type: "makeswift-file", version: 1 }, (f) => ({
+            ...f,
+            id: context.replacementContext.fileIds.get(f.id) ?? f.id
+          })).otherwise((f) => f)
+        }
+      };
+    } else {
+      return {
+        ...imagesPanelItem,
+        props: {
+          ...imagesPanelItem.props,
+          file: (0, import_ts_pattern13.match)(imagesPanelItem.props.file).with(
+            import_ts_pattern13.P.string,
+            (f) => context.replacementContext.fileIds.get(f) ?? f
+          ).otherwise((f) => f)
+        }
+      };
+    }
+  }
+}
+function copyImagesPropControllerData(data, context) {
+  return (0, import_ts_pattern13.match)(data).with(void 0, () => void 0).with({ [ControlDataTypeKey]: ImagesPropControllerDataV2Type }, (v1) => {
+    const value = copyImagesData(v1.value, context);
+    if (value == null)
+      return void 0;
+    return {
+      [ControlDataTypeKey]: ImagesPropControllerDataV2Type,
+      value
+    };
+  }).otherwise((v0) => copyImagesData(v0, context));
+}
+
 // src/margin/margin.ts
-var import_ts_pattern10 = require("ts-pattern");
-var import_zod12 = require("zod");
-var marginSideDataSchema = import_zod12.z.union([
-  import_zod12.z.object({
-    value: import_zod12.z.number(),
-    unit: import_zod12.z.literal("px")
+var import_ts_pattern14 = require("ts-pattern");
+var import_zod16 = require("zod");
+var marginSideDataSchema = import_zod16.z.union([
+  import_zod16.z.object({
+    value: import_zod16.z.number(),
+    unit: import_zod16.z.literal("px")
   }),
-  import_zod12.z.literal("auto")
+  import_zod16.z.literal("auto")
 ]);
-var marginDataSchema = import_zod12.z.object({
+var marginDataSchema = import_zod16.z.object({
   marginTop: marginSideDataSchema.nullable().optional(),
   marginRight: marginSideDataSchema.nullable().optional(),
   marginBottom: marginSideDataSchema.nullable().optional(),
@@ -737,11 +1304,11 @@ var marginDataSchema = import_zod12.z.object({
 var responsiveMarginDataSchema = createResponsiveValueSchema(marginDataSchema);
 var marginPropControllerDataV0Schema = responsiveMarginDataSchema;
 var MarginPropControllerDataV1Type = "prop-controllers::margin::v1";
-var marginPropControllerDataV1Schema = import_zod12.z.object({
-  [ControlDataTypeKey]: import_zod12.z.literal(MarginPropControllerDataV1Type),
+var marginPropControllerDataV1Schema = import_zod16.z.object({
+  [ControlDataTypeKey]: import_zod16.z.literal(MarginPropControllerDataV1Type),
   value: responsiveMarginDataSchema
 });
-var marginPropControllerDataSchema = import_zod12.z.union([
+var marginPropControllerDataSchema = import_zod16.z.union([
   marginPropControllerDataV0Schema,
   marginPropControllerDataV1Schema
 ]);
@@ -754,15 +1321,15 @@ function Margin(options = {}) {
 }
 Margin.Format = MarginPropControllerFormat;
 function getMarginPropControllerDataResponsiveMarginData(data) {
-  return (0, import_ts_pattern10.match)(data).with(
+  return (0, import_ts_pattern14.match)(data).with(
     { [ControlDataTypeKey]: MarginPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createMarginPropControllerDataFromResponsiveMarginData(responsiveMarginData, definition) {
-  return (0, import_ts_pattern10.match)(definition).with(
+  return (0, import_ts_pattern14.match)(definition).with(
     { version: 1 },
-    import_ts_pattern10.P.nullish,
+    import_ts_pattern14.P.nullish,
     () => ({
       [ControlDataTypeKey]: MarginPropControllerDataV1Type,
       value: responsiveMarginData
@@ -771,22 +1338,22 @@ function createMarginPropControllerDataFromResponsiveMarginData(responsiveMargin
 }
 
 // src/navigation-links/navigation-links.ts
-var import_ts_pattern13 = require("ts-pattern");
-var import_zod15 = require("zod");
+var import_ts_pattern17 = require("ts-pattern");
+var import_zod19 = require("zod");
 
 // src/text-style/text-style.ts
-var import_ts_pattern11 = require("ts-pattern");
-var import_zod13 = require("zod");
-var textStyleDataSchema = import_zod13.z.object({
-  fontFamily: import_zod13.z.string().optional().nullable(),
-  letterSpacing: import_zod13.z.number().optional().nullable(),
-  fontSize: import_zod13.z.object({
-    value: import_zod13.z.number(),
-    unit: import_zod13.z.literal("px")
+var import_ts_pattern15 = require("ts-pattern");
+var import_zod17 = require("zod");
+var textStyleDataSchema = import_zod17.z.object({
+  fontFamily: import_zod17.z.string().optional().nullable(),
+  letterSpacing: import_zod17.z.number().optional().nullable(),
+  fontSize: import_zod17.z.object({
+    value: import_zod17.z.number(),
+    unit: import_zod17.z.literal("px")
   }).optional().nullable(),
-  fontWeight: import_zod13.z.number().optional().nullable(),
-  textTransform: import_zod13.z.array(import_zod13.z.literal("uppercase")),
-  fontStyle: import_zod13.z.array(import_zod13.z.literal("italic"))
+  fontWeight: import_zod17.z.number().optional().nullable(),
+  textTransform: import_zod17.z.array(import_zod17.z.literal("uppercase")),
+  fontStyle: import_zod17.z.array(import_zod17.z.literal("italic"))
 }).transform((v) => ({
   ...v,
   letterSpacing: v.letterSpacing,
@@ -798,11 +1365,11 @@ var textStyleDataSchema = import_zod13.z.object({
 var responsiveTextStyleDataSchema = createResponsiveValueSchema(textStyleDataSchema);
 var textStylePropControllerDataV0Schema = responsiveTextStyleDataSchema;
 var TextStylePropControllerDataV1Type = "prop-controllers::text-style::v1";
-var textStylePropControllerDataV1Schema = import_zod13.z.object({
-  [ControlDataTypeKey]: import_zod13.z.literal(TextStylePropControllerDataV1Type),
+var textStylePropControllerDataV1Schema = import_zod17.z.object({
+  [ControlDataTypeKey]: import_zod17.z.literal(TextStylePropControllerDataV1Type),
   value: responsiveTextStyleDataSchema
 });
-var textStylePropControllerDataSchema = import_zod13.z.union([
+var textStylePropControllerDataSchema = import_zod17.z.union([
   textStylePropControllerDataV0Schema,
   textStylePropControllerDataV1Schema
 ]);
@@ -810,13 +1377,13 @@ function TextStyle(options = {}) {
   return { type: Types.TextStyle, version: 1, options };
 }
 function getTextStylePropControllerDataResponsiveTextStyleData(data) {
-  return (0, import_ts_pattern11.match)(data).with(
+  return (0, import_ts_pattern15.match)(data).with(
     { [ControlDataTypeKey]: TextStylePropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createTextStylePropControllerDataFromResponsiveTextStyleData(responsiveTextStyleData, definition) {
-  return (0, import_ts_pattern11.match)(definition).with(
+  return (0, import_ts_pattern15.match)(definition).with(
     { version: 1 },
     () => ({
       [ControlDataTypeKey]: TextStylePropControllerDataV1Type,
@@ -826,16 +1393,16 @@ function createTextStylePropControllerDataFromResponsiveTextStyleData(responsive
 }
 
 // src/responsive-color.ts
-var import_zod14 = require("zod");
-var import_ts_pattern12 = require("ts-pattern");
+var import_zod18 = require("zod");
+var import_ts_pattern16 = require("ts-pattern");
 var responsiveColorDataSchema = createResponsiveValueSchema(colorDataSchema);
 var responsiveColorPropControllerDataV0Schema = responsiveColorDataSchema;
 var ResponsiveColorPropControllerDataV1Type = "prop-controllers::responsive-color::v1";
-var responsiveColorPropControllerDataV1Schema = import_zod14.z.object({
-  [ControlDataTypeKey]: import_zod14.z.literal(ResponsiveColorPropControllerDataV1Type),
+var responsiveColorPropControllerDataV1Schema = import_zod18.z.object({
+  [ControlDataTypeKey]: import_zod18.z.literal(ResponsiveColorPropControllerDataV1Type),
   value: responsiveColorDataSchema
 });
-var responsiveColorPropControllerDataSchema = import_zod14.z.union([
+var responsiveColorPropControllerDataSchema = import_zod18.z.union([
   responsiveColorPropControllerDataV0Schema,
   responsiveColorPropControllerDataV1Schema
 ]);
@@ -843,13 +1410,13 @@ function ResponsiveColor(options = {}) {
   return { type: Types.ResponsiveColor, version: 1, options };
 }
 function getResponsiveColorPropControllerDataResponsiveColorData(data) {
-  return (0, import_ts_pattern12.match)(data).with(
+  return (0, import_ts_pattern16.match)(data).with(
     { [ControlDataTypeKey]: ResponsiveColorPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createResponsiveColorPropControllerDataFromResponsiveColorData(definition, responsiveColorData) {
-  return (0, import_ts_pattern12.match)(definition).with(
+  return (0, import_ts_pattern16.match)(definition).with(
     { version: 1 },
     () => ({
       [ControlDataTypeKey]: ResponsiveColorPropControllerDataV1Type,
@@ -880,7 +1447,7 @@ function copyResponsiveColorData(data, context) {
   }
 }
 function copyResponsiveColorPropControllerData(data, context) {
-  return (0, import_ts_pattern12.match)(data).with(void 0, () => void 0).with(
+  return (0, import_ts_pattern16.match)(data).with(void 0, () => void 0).with(
     { [ControlDataTypeKey]: ResponsiveColorPropControllerDataV1Type },
     (v1) => ({
       [ControlDataTypeKey]: ResponsiveColorPropControllerDataV1Type,
@@ -890,7 +1457,7 @@ function copyResponsiveColorPropControllerData(data, context) {
 }
 
 // src/navigation-links/navigation-links.ts
-var buttonVariantSchema = import_zod15.z.enum([
+var buttonVariantSchema = import_zod19.z.enum([
   "flat",
   "outline",
   "shadow",
@@ -899,13 +1466,13 @@ var buttonVariantSchema = import_zod15.z.enum([
   "bubbly",
   "skewed"
 ]);
-var buttonShapeSchema = import_zod15.z.enum(["pill", "rounded", "square"]);
-var buttonSizeSchema = import_zod15.z.enum(["small", "medium", "large"]);
-var navigationButtonSchema = import_zod15.z.object({
-  id: import_zod15.z.string(),
-  type: import_zod15.z.literal("button"),
-  payload: import_zod15.z.object({
-    label: import_zod15.z.string(),
+var buttonShapeSchema = import_zod19.z.enum(["pill", "rounded", "square"]);
+var buttonSizeSchema = import_zod19.z.enum(["small", "medium", "large"]);
+var navigationButtonSchema = import_zod19.z.object({
+  id: import_zod19.z.string(),
+  type: import_zod19.z.literal("button"),
+  payload: import_zod19.z.object({
+    label: import_zod19.z.string(),
     link: linkDataSchema.optional(),
     variant: createResponsiveValueSchema(buttonVariantSchema).optional(),
     shape: createResponsiveValueSchema(buttonShapeSchema).optional(),
@@ -915,28 +1482,28 @@ var navigationButtonSchema = import_zod15.z.object({
     textStyle: createResponsiveValueSchema(textStyleDataSchema).optional()
   })
 });
-var navigationDropdownCaretTypeSchema = import_zod15.z.union([
-  import_zod15.z.literal("caret"),
-  import_zod15.z.literal("plus"),
-  import_zod15.z.literal("arrow-down"),
-  import_zod15.z.literal("chevron-down")
+var navigationDropdownCaretTypeSchema = import_zod19.z.union([
+  import_zod19.z.literal("caret"),
+  import_zod19.z.literal("plus"),
+  import_zod19.z.literal("arrow-down"),
+  import_zod19.z.literal("chevron-down")
 ]);
-var navigationDropdownLinkSchema = import_zod15.z.object({
-  id: import_zod15.z.string(),
-  payload: import_zod15.z.object({
-    label: import_zod15.z.string(),
+var navigationDropdownLinkSchema = import_zod19.z.object({
+  id: import_zod19.z.string(),
+  payload: import_zod19.z.object({
+    label: import_zod19.z.string(),
     link: linkDataSchema.optional(),
     color: createResponsiveValueSchema(colorDataSchema).optional(),
     textStyle: createResponsiveValueSchema(textStyleDataSchema).optional()
   })
 });
-var navigationDropdownSchema = import_zod15.z.object({
-  id: import_zod15.z.string(),
-  type: import_zod15.z.literal("dropdown"),
-  payload: import_zod15.z.object({
-    label: import_zod15.z.string(),
+var navigationDropdownSchema = import_zod19.z.object({
+  id: import_zod19.z.string(),
+  type: import_zod19.z.literal("dropdown"),
+  payload: import_zod19.z.object({
+    label: import_zod19.z.string(),
     caret: navigationDropdownCaretTypeSchema.optional(),
-    links: import_zod15.z.array(navigationDropdownLinkSchema).optional(),
+    links: import_zod19.z.array(navigationDropdownLinkSchema).optional(),
     variant: createResponsiveValueSchema(buttonVariantSchema).optional(),
     shape: createResponsiveValueSchema(buttonShapeSchema).optional(),
     size: createResponsiveValueSchema(buttonSizeSchema).optional(),
@@ -945,16 +1512,16 @@ var navigationDropdownSchema = import_zod15.z.object({
     textStyle: createResponsiveValueSchema(textStyleDataSchema).optional()
   })
 });
-var navigationLinksDataSchema = import_zod15.z.array(
-  import_zod15.z.union([navigationButtonSchema, navigationDropdownSchema])
+var navigationLinksDataSchema = import_zod19.z.array(
+  import_zod19.z.union([navigationButtonSchema, navigationDropdownSchema])
 );
 var navigationLinksPropControllerDataV0Schema = navigationLinksDataSchema;
 var NavigationLinksPropControllerDataV1Type = "prop-controllers::navigation-links::v1";
-var navigationLinksPropControllerDataV1Schema = import_zod15.z.object({
-  [ControlDataTypeKey]: import_zod15.z.literal(NavigationLinksPropControllerDataV1Type),
+var navigationLinksPropControllerDataV1Schema = import_zod19.z.object({
+  [ControlDataTypeKey]: import_zod19.z.literal(NavigationLinksPropControllerDataV1Type),
   value: navigationLinksDataSchema
 });
-var navigationLinksPropControllerDataSchema = import_zod15.z.union([
+var navigationLinksPropControllerDataSchema = import_zod19.z.union([
   navigationLinksPropControllerDataV0Schema,
   navigationLinksPropControllerDataV1Schema
 ]);
@@ -962,13 +1529,13 @@ function NavigationLinks(options = {}) {
   return { type: Types.NavigationLinks, version: 1, options };
 }
 function getNavigationLinksPropControllerDataNavigationLinksData(data) {
-  return (0, import_ts_pattern13.match)(data).with(
+  return (0, import_ts_pattern17.match)(data).with(
     { [ControlDataTypeKey]: NavigationLinksPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createNavigationLinksPropControllerDataFromNavigationLinksData(navigationLinksData, definition) {
-  return (0, import_ts_pattern13.match)(definition).with(
+  return (0, import_ts_pattern17.match)(definition).with(
     { version: 1 },
     () => ({
       [ControlDataTypeKey]: NavigationLinksPropControllerDataV1Type,
@@ -1059,7 +1626,7 @@ function copyNavigationLinksData(data, context) {
   });
 }
 function copyNavigationLinksPropControllerData(data, context) {
-  return (0, import_ts_pattern13.match)(data).with(void 0, () => void 0).with(
+  return (0, import_ts_pattern17.match)(data).with(void 0, () => void 0).with(
     { [ControlDataTypeKey]: NavigationLinksPropControllerDataV1Type },
     (v1) => ({
       [ControlDataTypeKey]: NavigationLinksPropControllerDataV1Type,
@@ -1069,15 +1636,15 @@ function copyNavigationLinksPropControllerData(data, context) {
 }
 
 // src/number.ts
-var import_zod16 = require("zod");
-var import_ts_pattern14 = require("ts-pattern");
-var numberPropControllerDataV0Schema = import_zod16.z.number();
+var import_zod20 = require("zod");
+var import_ts_pattern18 = require("ts-pattern");
+var numberPropControllerDataV0Schema = import_zod20.z.number();
 var NumberPropControllerDataV1Type = "prop-controllers::number::v1";
-var numberPropControllerDataV1Schema = import_zod16.z.object({
-  [ControlDataTypeKey]: import_zod16.z.literal(NumberPropControllerDataV1Type),
-  value: import_zod16.z.number()
+var numberPropControllerDataV1Schema = import_zod20.z.object({
+  [ControlDataTypeKey]: import_zod20.z.literal(NumberPropControllerDataV1Type),
+  value: import_zod20.z.number()
 });
-var numberPropControllerDataSchema = import_zod16.z.union([
+var numberPropControllerDataSchema = import_zod20.z.union([
   numberPropControllerDataV0Schema,
   numberPropControllerDataV1Schema
 ]);
@@ -1085,15 +1652,15 @@ function Number(options = {}) {
   return { type: Types.Number, version: 1, options };
 }
 function getNumberPropControllerDataNumber(data) {
-  return (0, import_ts_pattern14.match)(data).with(
+  return (0, import_ts_pattern18.match)(data).with(
     { [ControlDataTypeKey]: NumberPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createNumberPropControllerDataFromNumber(value, definition) {
-  return (0, import_ts_pattern14.match)(definition).with(
+  return (0, import_ts_pattern18.match)(definition).with(
     { version: 1 },
-    import_ts_pattern14.P.nullish,
+    import_ts_pattern18.P.nullish,
     () => ({
       [ControlDataTypeKey]: NumberPropControllerDataV1Type,
       value
@@ -1102,13 +1669,13 @@ function createNumberPropControllerDataFromNumber(value, definition) {
 }
 
 // src/padding/padding.ts
-var import_ts_pattern15 = require("ts-pattern");
-var import_zod17 = require("zod");
-var paddingSideDataSchema = import_zod17.z.object({
-  value: import_zod17.z.number(),
-  unit: import_zod17.z.literal("px")
+var import_ts_pattern19 = require("ts-pattern");
+var import_zod21 = require("zod");
+var paddingSideDataSchema = import_zod21.z.object({
+  value: import_zod21.z.number(),
+  unit: import_zod21.z.literal("px")
 });
-var paddingDataSchema = import_zod17.z.object({
+var paddingDataSchema = import_zod21.z.object({
   paddingTop: paddingSideDataSchema.nullable().optional(),
   paddingRight: paddingSideDataSchema.nullable().optional(),
   paddingBottom: paddingSideDataSchema.nullable().optional(),
@@ -1122,11 +1689,11 @@ var paddingDataSchema = import_zod17.z.object({
 var responsivePaddingDataSchema = createResponsiveValueSchema(paddingDataSchema);
 var paddingPropControllerDataV0Schema = responsivePaddingDataSchema;
 var PaddingPropControllerDataV1Type = "prop-controllers::padding::v1";
-var paddingPropControllerDataV1Schema = import_zod17.z.object({
-  [ControlDataTypeKey]: import_zod17.z.literal(PaddingPropControllerDataV1Type),
+var paddingPropControllerDataV1Schema = import_zod21.z.object({
+  [ControlDataTypeKey]: import_zod21.z.literal(PaddingPropControllerDataV1Type),
   value: responsivePaddingDataSchema
 });
-var paddingPropControllerDataSchema = import_zod17.z.union([
+var paddingPropControllerDataSchema = import_zod21.z.union([
   paddingPropControllerDataV0Schema,
   paddingPropControllerDataV1Schema
 ]);
@@ -1139,15 +1706,15 @@ function Padding(options = {}) {
 }
 Padding.Format = PaddingPropControllerFormat;
 function getPaddingPropControllerDataResponsivePaddingData(data) {
-  return (0, import_ts_pattern15.match)(data).with(
+  return (0, import_ts_pattern19.match)(data).with(
     { [ControlDataTypeKey]: PaddingPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createPaddingPropControllerDataFromResponsivePaddingData(responsivePaddingData, definition) {
-  return (0, import_ts_pattern15.match)(definition).with(
+  return (0, import_ts_pattern19.match)(definition).with(
     { version: 1 },
-    import_ts_pattern15.P.nullish,
+    import_ts_pattern19.P.nullish,
     () => ({
       [ControlDataTypeKey]: PaddingPropControllerDataV1Type,
       value: responsivePaddingData
@@ -1156,16 +1723,16 @@ function createPaddingPropControllerDataFromResponsivePaddingData(responsivePadd
 }
 
 // src/responsive-length.ts
-var import_zod18 = require("zod");
-var import_ts_pattern16 = require("ts-pattern");
+var import_zod22 = require("zod");
+var import_ts_pattern20 = require("ts-pattern");
 var responsiveLengthDataSchema = createResponsiveValueSchema(lengthDataSchema);
 var responsiveLengthPropControllerDataV0Schema = responsiveLengthDataSchema;
 var ResponsiveLengthPropControllerDataV1Type = "prop-controllers::responsive-length::v1";
-var responsiveLengthPropControllerDataV1Schema = import_zod18.z.object({
-  [ControlDataTypeKey]: import_zod18.z.literal(ResponsiveLengthPropControllerDataV1Type),
+var responsiveLengthPropControllerDataV1Schema = import_zod22.z.object({
+  [ControlDataTypeKey]: import_zod22.z.literal(ResponsiveLengthPropControllerDataV1Type),
   value: responsiveLengthDataSchema
 });
-var responsiveLengthPropControllerDataSchema = import_zod18.z.union([
+var responsiveLengthPropControllerDataSchema = import_zod22.z.union([
   responsiveLengthPropControllerDataV0Schema,
   responsiveLengthPropControllerDataV1Schema
 ]);
@@ -1173,13 +1740,13 @@ function ResponsiveLength(options = {}) {
   return { type: Types.ResponsiveLength, version: 1, options };
 }
 function getResponsiveLengthPropControllerDataResponsiveLengthData(data) {
-  return (0, import_ts_pattern16.match)(data).with(
+  return (0, import_ts_pattern20.match)(data).with(
     { [ControlDataTypeKey]: ResponsiveLengthPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createResponsiveLengthPropControllerDataFromResponsiveLengthData(definition, responsiveLengthData) {
-  return (0, import_ts_pattern16.match)(definition).with(
+  return (0, import_ts_pattern20.match)(definition).with(
     { version: 1 },
     () => ({
       [ControlDataTypeKey]: ResponsiveLengthPropControllerDataV1Type,
@@ -1189,30 +1756,30 @@ function createResponsiveLengthPropControllerDataFromResponsiveLengthData(defini
 }
 
 // src/shadows.ts
-var import_ts_pattern17 = require("ts-pattern");
-var import_zod19 = require("zod");
-var shadowDataSchema = import_zod19.z.object({
+var import_ts_pattern21 = require("ts-pattern");
+var import_zod23 = require("zod");
+var shadowDataSchema = import_zod23.z.object({
   color: colorDataSchema.nullable().optional(),
-  blurRadius: import_zod19.z.number().optional(),
-  spreadRadius: import_zod19.z.number().optional(),
-  offsetX: import_zod19.z.number().optional(),
-  offsetY: import_zod19.z.number().optional(),
-  inset: import_zod19.z.boolean().optional()
-});
-var shadowsDataSchema = import_zod19.z.array(
-  import_zod19.z.object({
-    id: import_zod19.z.string(),
+  blurRadius: import_zod23.z.number().optional(),
+  spreadRadius: import_zod23.z.number().optional(),
+  offsetX: import_zod23.z.number().optional(),
+  offsetY: import_zod23.z.number().optional(),
+  inset: import_zod23.z.boolean().optional()
+});
+var shadowsDataSchema = import_zod23.z.array(
+  import_zod23.z.object({
+    id: import_zod23.z.string(),
     payload: shadowDataSchema
   })
 );
 var responsiveShadowsDataSchema = createResponsiveValueSchema(shadowsDataSchema);
 var shadowsPropControllerDataV0Schema = responsiveShadowsDataSchema;
 var ShadowsPropControllerDataV1Type = "prop-controllers::shadows::v1";
-var shadowsPropControllerDataV1Schema = import_zod19.z.object({
-  [ControlDataTypeKey]: import_zod19.z.literal(ShadowsPropControllerDataV1Type),
+var shadowsPropControllerDataV1Schema = import_zod23.z.object({
+  [ControlDataTypeKey]: import_zod23.z.literal(ShadowsPropControllerDataV1Type),
   value: responsiveShadowsDataSchema
 });
-var shadowsPropControllerDataSchema = import_zod19.z.union([
+var shadowsPropControllerDataSchema = import_zod23.z.union([
   shadowsPropControllerDataV0Schema,
   shadowsPropControllerDataV1Schema
 ]);
@@ -1225,13 +1792,13 @@ function Shadows(options = {}) {
 }
 Shadows.Format = ShadowsPropControllerFormat;
 function getShadowsPropControllerDataResponsiveShadowsData(data) {
-  return (0, import_ts_pattern17.match)(data).with(
+  return (0, import_ts_pattern21.match)(data).with(
     { [ControlDataTypeKey]: ShadowsPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createShadowsPropControllerDataFromResponsiveShadowsData(definition, responsiveShadowsData) {
-  return (0, import_ts_pattern17.match)(definition).with(
+  return (0, import_ts_pattern21.match)(definition).with(
     { version: 1 },
     () => ({
       [ControlDataTypeKey]: ShadowsPropControllerDataV1Type,
@@ -1265,7 +1832,7 @@ function copyResponsiveShadowsData(data, context) {
   }));
 }
 function copyShadowsPropControllerData(data, context) {
-  return (0, import_ts_pattern17.match)(data).with(void 0, () => void 0).with(
+  return (0, import_ts_pattern21.match)(data).with(void 0, () => void 0).with(
     { [ControlDataTypeKey]: ShadowsPropControllerDataV1Type },
     (v1) => ({
       [ControlDataTypeKey]: ShadowsPropControllerDataV1Type,
@@ -1275,16 +1842,16 @@ function copyShadowsPropControllerData(data, context) {
 }
 
 // src/table/table.ts
-var import_zod20 = require("zod");
-var import_ts_pattern18 = require("ts-pattern");
-var tableIdSchema = import_zod20.z.string();
+var import_zod24 = require("zod");
+var import_ts_pattern22 = require("ts-pattern");
+var tableIdSchema = import_zod24.z.string();
 var tablePropControllerDataV0Schema = tableIdSchema;
 var TablePropControllerDataV1Type = "prop-controllers::table::v1";
-var tablePropControllerDataV1Schema = import_zod20.z.object({
-  [ControlDataTypeKey]: import_zod20.z.literal(TablePropControllerDataV1Type),
+var tablePropControllerDataV1Schema = import_zod24.z.object({
+  [ControlDataTypeKey]: import_zod24.z.literal(TablePropControllerDataV1Type),
   value: tableIdSchema
 });
-var tablePropControllerDataSchema = import_zod20.z.union([
+var tablePropControllerDataSchema = import_zod24.z.union([
   tablePropControllerDataV0Schema,
   tablePropControllerDataV1Schema
 ]);
@@ -1292,15 +1859,15 @@ function Table(options = {}) {
   return { type: Types.Table, version: 1, options };
 }
 function getTablePropControllerDataTableId(data) {
-  return (0, import_ts_pattern18.match)(data).with(
+  return (0, import_ts_pattern22.match)(data).with(
     { [ControlDataTypeKey]: TablePropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createTablePropControllerDataFromTableId(value, definition) {
-  return (0, import_ts_pattern18.match)(definition).with(
+  return (0, import_ts_pattern22.match)(definition).with(
     { version: 1 },
-    import_ts_pattern18.P.nullish,
+    import_ts_pattern22.P.nullish,
     () => ({
       [ControlDataTypeKey]: TablePropControllerDataV1Type,
       value
@@ -1313,7 +1880,7 @@ function copyTableId(data, context) {
   return context.replacementContext.tableIds.get(data) ?? data;
 }
 function copyTablePropControllerData(data, context) {
-  return (0, import_ts_pattern18.match)(data).with(void 0, () => void 0).with(
+  return (0, import_ts_pattern22.match)(data).with(void 0, () => void 0).with(
     { [ControlDataTypeKey]: TablePropControllerDataV1Type },
     (v1) => ({
       [ControlDataTypeKey]: TablePropControllerDataV1Type,
@@ -1327,36 +1894,36 @@ function getTablePropControllerDataTableIds(data) {
 }
 
 // src/table-form-fields/table-form-fields.ts
-var import_zod21 = require("zod");
-var import_ts_pattern19 = require("ts-pattern");
-var tableFormFieldSchema = import_zod21.z.object({
-  id: import_zod21.z.string(),
-  tableColumnId: import_zod21.z.string(),
-  label: import_zod21.z.string().optional(),
-  placeholder: import_zod21.z.string().optional(),
-  defaultValue: import_zod21.z.union([import_zod21.z.string(), import_zod21.z.boolean(), import_zod21.z.array(import_zod21.z.string())]).optional(),
-  required: import_zod21.z.boolean().optional(),
-  hidden: import_zod21.z.boolean().optional(),
-  type: import_zod21.z.union([import_zod21.z.literal("select"), import_zod21.z.literal("radio")]).optional(),
-  hideLabel: import_zod21.z.boolean().optional(),
-  autofill: import_zod21.z.boolean().optional()
-});
-var tableFormFieldsDataSchema = import_zod21.z.object({
-  fields: import_zod21.z.array(tableFormFieldSchema),
+var import_zod25 = require("zod");
+var import_ts_pattern23 = require("ts-pattern");
+var tableFormFieldSchema = import_zod25.z.object({
+  id: import_zod25.z.string(),
+  tableColumnId: import_zod25.z.string(),
+  label: import_zod25.z.string().optional(),
+  placeholder: import_zod25.z.string().optional(),
+  defaultValue: import_zod25.z.union([import_zod25.z.string(), import_zod25.z.boolean(), import_zod25.z.array(import_zod25.z.string())]).optional(),
+  required: import_zod25.z.boolean().optional(),
+  hidden: import_zod25.z.boolean().optional(),
+  type: import_zod25.z.union([import_zod25.z.literal("select"), import_zod25.z.literal("radio")]).optional(),
+  hideLabel: import_zod25.z.boolean().optional(),
+  autofill: import_zod25.z.boolean().optional()
+});
+var tableFormFieldsDataSchema = import_zod25.z.object({
+  fields: import_zod25.z.array(tableFormFieldSchema),
   grid: createResponsiveValueSchema(
-    import_zod21.z.object({
-      count: import_zod21.z.number(),
-      spans: import_zod21.z.array(import_zod21.z.array(import_zod21.z.number()))
+    import_zod25.z.object({
+      count: import_zod25.z.number(),
+      spans: import_zod25.z.array(import_zod25.z.array(import_zod25.z.number()))
     })
   )
 });
 var tableFormFieldsPropControllerDataV0Schema = tableFormFieldsDataSchema;
 var TableFormFieldsPropControllerDataV1Type = "prop-controllers::table-form-fields::v1";
-var tableFormFieldsPropControllerDataV1Schema = import_zod21.z.object({
-  [ControlDataTypeKey]: import_zod21.z.literal(TableFormFieldsPropControllerDataV1Type),
+var tableFormFieldsPropControllerDataV1Schema = import_zod25.z.object({
+  [ControlDataTypeKey]: import_zod25.z.literal(TableFormFieldsPropControllerDataV1Type),
   value: tableFormFieldsDataSchema
 });
-var tableFormFieldsPropControllerDataSchema = import_zod21.z.union([
+var tableFormFieldsPropControllerDataSchema = import_zod25.z.union([
   tableFormFieldsPropControllerDataV0Schema,
   tableFormFieldsPropControllerDataV1Schema
 ]);
@@ -1364,15 +1931,15 @@ function TableFormFields(options = {}) {
   return { type: Types.TableFormFields, version: 1, options };
 }
 function getTableFormFieldsPropControllerDataTableFormFieldsData(data) {
-  return (0, import_ts_pattern19.match)(data).with(
+  return (0, import_ts_pattern23.match)(data).with(
     { [ControlDataTypeKey]: TableFormFieldsPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createTableFormFieldsPropControllerDataFromTableFormFieldsData(value, definition) {
-  return (0, import_ts_pattern19.match)(definition).with(
+  return (0, import_ts_pattern23.match)(definition).with(
     { version: 1 },
-    import_ts_pattern19.P.nullish,
+    import_ts_pattern23.P.nullish,
     () => ({
       [ControlDataTypeKey]: TableFormFieldsPropControllerDataV1Type,
       value
@@ -1391,7 +1958,7 @@ function copyTableFormFieldsData(data, context) {
   };
 }
 function copyTableFormFieldsPropControllerData(data, context) {
-  return (0, import_ts_pattern19.match)(data).with(void 0, () => void 0).with(
+  return (0, import_ts_pattern23.match)(data).with(void 0, () => void 0).with(
     { [ControlDataTypeKey]: TableFormFieldsPropControllerDataV1Type },
     (v1) => ({
       [ControlDataTypeKey]: TableFormFieldsPropControllerDataV1Type,
@@ -1401,15 +1968,15 @@ function copyTableFormFieldsPropControllerData(data, context) {
 }
 
 // src/text-area/text-area.ts
-var import_zod22 = require("zod");
-var import_ts_pattern20 = require("ts-pattern");
-var textAreaPropControllerDataV0Schema = import_zod22.z.string();
+var import_zod26 = require("zod");
+var import_ts_pattern24 = require("ts-pattern");
+var textAreaPropControllerDataV0Schema = import_zod26.z.string();
 var TextAreaPropControllerDataV1Type = "prop-controllers::text-area::v1";
-var textAreaPropControllerDataV1Schema = import_zod22.z.object({
-  [ControlDataTypeKey]: import_zod22.z.literal(TextAreaPropControllerDataV1Type),
-  value: import_zod22.z.string()
+var textAreaPropControllerDataV1Schema = import_zod26.z.object({
+  [ControlDataTypeKey]: import_zod26.z.literal(TextAreaPropControllerDataV1Type),
+  value: import_zod26.z.string()
 });
-var textAreaPropControllerDataSchema = import_zod22.z.union([
+var textAreaPropControllerDataSchema = import_zod26.z.union([
   textAreaPropControllerDataV0Schema,
   textAreaPropControllerDataV1Schema
 ]);
@@ -1417,13 +1984,13 @@ function TextArea(options = {}) {
   return { type: Types.TextArea, version: 1, options };
 }
 function getTextAreaPropControllerDataString(data) {
-  return (0, import_ts_pattern20.match)(data).with(
+  return (0, import_ts_pattern24.match)(data).with(
     { [ControlDataTypeKey]: TextAreaPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createTextAreaPropControllerDataFromString(value, definition) {
-  return (0, import_ts_pattern20.match)(definition).with(
+  return (0, import_ts_pattern24.match)(definition).with(
     { version: 1 },
     () => ({
       [ControlDataTypeKey]: TextAreaPropControllerDataV1Type,
@@ -1433,15 +2000,15 @@ function createTextAreaPropControllerDataFromString(value, definition) {
 }
 
 // src/width/width.ts
-var import_ts_pattern21 = require("ts-pattern");
-var import_zod23 = require("zod");
+var import_ts_pattern25 = require("ts-pattern");
+var import_zod27 = require("zod");
 var widthPropControllerDataV0Schema = responsiveLengthDataSchema;
 var WidthPropControllerDataV1Type = "prop-controllers::width::v1";
-var widthPropControllerDataV1Schema = import_zod23.z.object({
-  [ControlDataTypeKey]: import_zod23.z.literal(WidthPropControllerDataV1Type),
+var widthPropControllerDataV1Schema = import_zod27.z.object({
+  [ControlDataTypeKey]: import_zod27.z.literal(WidthPropControllerDataV1Type),
   value: responsiveLengthDataSchema
 });
-var widthPropControllerDataSchema = import_zod23.z.union([
+var widthPropControllerDataSchema = import_zod27.z.union([
   widthPropControllerDataV0Schema,
   widthPropControllerDataV1Schema
 ]);
@@ -1454,15 +2021,15 @@ function Width(options = {}) {
 }
 Width.Format = WidthPropControllerFormat;
 function getWidthPropControllerDataResponsiveLengthData(data) {
-  return (0, import_ts_pattern21.match)(data).with(
+  return (0, import_ts_pattern25.match)(data).with(
     { [ControlDataTypeKey]: WidthPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createWidthPropControllerDataFromResponsiveLengthData(responsiveLengthData, definition) {
-  return (0, import_ts_pattern21.match)(definition).with(
+  return (0, import_ts_pattern25.match)(definition).with(
     { version: 1 },
-    import_ts_pattern21.P.nullish,
+    import_ts_pattern25.P.nullish,
     () => ({
       [ControlDataTypeKey]: WidthPropControllerDataV1Type,
       value: responsiveLengthData
@@ -1471,22 +2038,22 @@ function createWidthPropControllerDataFromResponsiveLengthData(responsiveLengthD
 }
 
 // src/video/video.ts
-var import_zod24 = require("zod");
-var import_ts_pattern22 = require("ts-pattern");
-var videoDataSchema = import_zod24.z.object({
-  url: import_zod24.z.string().optional(),
-  muted: import_zod24.z.boolean().optional(),
-  playing: import_zod24.z.boolean().optional(),
-  loop: import_zod24.z.boolean().optional(),
-  controls: import_zod24.z.boolean().optional()
+var import_zod28 = require("zod");
+var import_ts_pattern26 = require("ts-pattern");
+var videoDataSchema = import_zod28.z.object({
+  url: import_zod28.z.string().optional(),
+  muted: import_zod28.z.boolean().optional(),
+  playing: import_zod28.z.boolean().optional(),
+  loop: import_zod28.z.boolean().optional(),
+  controls: import_zod28.z.boolean().optional()
 });
 var videoPropControllerDataV0Schema = videoDataSchema;
 var VideoPropControllerDataV1Type = "prop-controllers::video::v1";
-var videoPropControllerDataV1Schema = import_zod24.z.object({
-  [ControlDataTypeKey]: import_zod24.z.literal(VideoPropControllerDataV1Type),
+var videoPropControllerDataV1Schema = import_zod28.z.object({
+  [ControlDataTypeKey]: import_zod28.z.literal(VideoPropControllerDataV1Type),
   value: videoDataSchema
 });
-var videoPropControllerDataSchema = import_zod24.z.union([
+var videoPropControllerDataSchema = import_zod28.z.union([
   videoPropControllerDataV1Schema,
   videoPropControllerDataV0Schema
 ]);
@@ -1494,15 +2061,15 @@ function Video(options = {}) {
   return { type: Types.Video, version: 1, options };
 }
 function getVideoPropControllerDataVideoData(data) {
-  return (0, import_ts_pattern22.match)(data).with(
+  return (0, import_ts_pattern26.match)(data).with(
     { [ControlDataTypeKey]: VideoPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createVideoPropControllerDataFromVideoData(value, definition) {
-  return (0, import_ts_pattern22.match)(definition).with(
+  return (0, import_ts_pattern26.match)(definition).with(
     { version: 1 },
-    import_ts_pattern22.P.nullish,
+    import_ts_pattern26.P.nullish,
     () => ({
       [ControlDataTypeKey]: VideoPropControllerDataV1Type,
       value
@@ -1511,6 +2078,7 @@ function createVideoPropControllerDataFromVideoData(value, definition) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  Backgrounds,
   Border,
   BorderPropControllerFormat,
   BorderRadius,
@@ -1522,6 +2090,9 @@ function createVideoPropControllerDataFromVideoData(value, definition) {
   Font,
   GapX,
   GapY,
+  Grid,
+  Image,
+  Images,
   Link,
   Margin,
   MarginPropControllerFormat,
@@ -1541,17 +2112,23 @@ function createVideoPropControllerDataFromVideoData(value, definition) {
   Video,
   Width,
   WidthPropControllerFormat,
+  backgroundsPropControllerDataSchema,
   borderPropControllerDataSchema,
   borderRadiusPropControllerDataSchema,
   checkboxPropControllerDataSchema,
+  copyBackgroundsPropControllerData,
   copyBorderPropControllerData,
   copyElementIDPropControllerData,
+  copyGridPropControllerData,
+  copyImagePropControllerData,
+  copyImagesPropControllerData,
   copyLinkPropControllerData,
   copyNavigationLinksPropControllerData,
   copyResponsiveColorPropControllerData,
   copyShadowsPropControllerData,
   copyTableFormFieldsPropControllerData,
   copyTablePropControllerData,
+  createBackgroundsPropControllerDataFromResponsiveBackgroundsData,
   createBorderPropControllerDataFromResponsiveBorderData,
   createBorderRadiusPropControllerDataFromResponsiveBorderRadiusData,
   createCheckboxPropControllerDataFromBoolean,
@@ -1560,6 +2137,9 @@ function createVideoPropControllerDataFromVideoData(value, definition) {
   createFontPropControllerDataFromResponsiveFontData,
   createGapXPropControllerDataFromResponsiveGapData,
   createGapYPropControllerDataFromResponsiveGapData,
+  createGridPropControllerDataFromGridData,
+  createImagePropControllerDataFromImageData,
+  createImagesPropControllerDataFromImagesData,
   createLinkPropControllerDataFromLinkData,
   createMarginPropControllerDataFromResponsiveMarginData,
   createNavigationLinksPropControllerDataFromNavigationLinksData,
@@ -1575,11 +2155,17 @@ function createVideoPropControllerDataFromVideoData(value, definition) {
   createTextStylePropControllerDataFromResponsiveTextStyleData,
   createVideoPropControllerDataFromVideoData,
   createWidthPropControllerDataFromResponsiveLengthData,
+  dataSchema,
   datePropControllerDataSchema,
+  elementDataSchema,
   elementIDPropControllerDataSchema,
+  elementSchema,
   fontPropControllerDataSchema,
   gapXPropControllerDataSchema,
   gapYPropControllerDataSchema,
+  getBackgroundsPropControllerDataResponsiveBackgroundsData,
+  getBackgroundsPropControllerFileIds,
+  getBackgroundsPropControllerSwatchIds,
   getBorderPropControllerDataResponsiveBorderData,
   getBorderPropControllerDataSwatchIds,
   getBorderRadiusPropControllerDataResponsiveBorderRadiusData,
@@ -1589,6 +2175,13 @@ function createVideoPropControllerDataFromVideoData(value, definition) {
   getFontPropControllerDataResponsiveFontData,
   getGapXPropControllerDataResponsiveGapData,
   getGapYPropControllerDataResponsiveGapData,
+  getGridPropControllerDataGridData,
+  getGridPropControllerElementChildren,
+  getGridPropControllerGetElementPath,
+  getImagePropControllerDataImageData,
+  getImagePropControllerFileIds,
+  getImagesPropControllerDataImagesData,
+  getImagesPropControllerFileIds,
   getLinkPropControllerDataLinkData,
   getLinkPropControllerPageIds,
   getMarginPropControllerDataResponsiveMarginData,
@@ -1610,9 +2203,13 @@ function createVideoPropControllerDataFromVideoData(value, definition) {
   getTextStylePropControllerDataResponsiveTextStyleData,
   getVideoPropControllerDataVideoData,
   getWidthPropControllerDataResponsiveLengthData,
+  gridPropControllerDataSchema,
+  imagePropControllerDataSchema,
+  imagesPropControllerDataSchema,
   linkDataSchema,
   linkPropControllerDataSchema,
   marginPropControllerDataSchema,
+  mergeGridPropControllerTranslatedData,
   navigationLinksPropControllerDataSchema,
   numberPropControllerDataSchema,
   paddingPropControllerDataSchema,