@makeswift/prop-controllers 0.0.0-5b910bb-20240510191620

package/dist/index.cjs

@@ -0,0 +1,2444 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Backgrounds: () => Backgrounds,
+  BackgroundsPropControllerDataV2Type: () => BackgroundsPropControllerDataV2Type,
+  Border: () => Border,
+  BorderPropControllerFormat: () => BorderPropControllerFormat,
+  BorderRadius: () => BorderRadius,
+  BorderRadiusPropControllerFormat: () => BorderRadiusPropControllerFormat,
+  Checkbox: () => Checkbox,
+  ControlDataTypeKey: () => ControlDataTypeKey,
+  Date: () => Date,
+  ElementID: () => ElementID,
+  Font: () => Font,
+  GapX: () => GapX,
+  GapY: () => GapY,
+  Grid: () => Grid,
+  Image: () => Image,
+  Images: () => Images,
+  Link: () => Link,
+  Margin: () => Margin,
+  MarginPropControllerFormat: () => MarginPropControllerFormat,
+  NavigationLinks: () => NavigationLinks,
+  Number: () => Number,
+  Padding: () => Padding,
+  PaddingPropControllerFormat: () => PaddingPropControllerFormat,
+  PropDef: () => PropDef,
+  ResponsiveColor: () => ResponsiveColor,
+  ResponsiveLength: () => ResponsiveLength,
+  ResponsiveLengthPropControllerDataV1Type: () => ResponsiveLengthPropControllerDataV1Type,
+  ResponsiveNumber: () => ResponsiveNumber,
+  ResponsiveOpacity: () => ResponsiveOpacity,
+  Shadows: () => Shadows,
+  SocialLinks: () => SocialLinks,
+  Table: () => Table,
+  TableFormFields: () => TableFormFields,
+  TextArea: () => TextArea,
+  TextInput: () => TextInput,
+  TextStyle: () => TextStyle,
+  Types: () => Types,
+  Video: () => Video,
+  Width: () => Width,
+  WidthPropControllerFormat: () => WidthPropControllerFormat,
+  backgroundImageDataSchema: () => backgroundImageDataSchema,
+  backgroundsPropControllerDataSchema: () => backgroundsPropControllerDataSchema,
+  borderPropControllerDataSchema: () => borderPropControllerDataSchema,
+  borderRadiusPropControllerDataSchema: () => borderRadiusPropControllerDataSchema,
+  checkboxPropControllerDataSchema: () => checkboxPropControllerDataSchema,
+  colorDataSchema: () => colorDataSchema,
+  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,
+  createDatePropControllerDataFromString: () => createDatePropControllerDataFromString,
+  createElementIDPropControllerDataFromElementID: () => createElementIDPropControllerDataFromElementID,
+  createFontPropControllerDataFromResponsiveFontData: () => createFontPropControllerDataFromResponsiveFontData,
+  createGapYPropControllerDataFromResponsiveGapData: () => createGapYPropControllerDataFromResponsiveGapData,
+  createGridPropControllerDataFromGridData: () => createGridPropControllerDataFromGridData,
+  createImagePropControllerDataFromImageData: () => createImagePropControllerDataFromImageData,
+  createImagesPropControllerDataFromImagesData: () => createImagesPropControllerDataFromImagesData,
+  createLinkPropControllerDataFromLinkData: () => createLinkPropControllerDataFromLinkData,
+  createMarginPropControllerDataFromResponsiveMarginData: () => createMarginPropControllerDataFromResponsiveMarginData,
+  createNavigationLinksPropControllerDataFromNavigationLinksData: () => createNavigationLinksPropControllerDataFromNavigationLinksData,
+  createNumberPropControllerDataFromNumber: () => createNumberPropControllerDataFromNumber,
+  createPaddingPropControllerDataFromResponsivePaddingData: () => createPaddingPropControllerDataFromResponsivePaddingData,
+  createResponsiveColorPropControllerDataFromResponsiveColorData: () => createResponsiveColorPropControllerDataFromResponsiveColorData,
+  createResponsiveLengthPropControllerDataFromResponsiveLengthData: () => createResponsiveLengthPropControllerDataFromResponsiveLengthData,
+  createResponsiveValueSchema: () => createResponsiveValueSchema,
+  createShadowsPropControllerDataFromResponsiveShadowsData: () => createShadowsPropControllerDataFromResponsiveShadowsData,
+  createSocialLinksPropControllerDataFromSocialLinksData: () => createSocialLinksPropControllerDataFromSocialLinksData,
+  createTableFormFieldsPropControllerDataFromTableFormFieldsData: () => createTableFormFieldsPropControllerDataFromTableFormFieldsData,
+  createTablePropControllerDataFromTableId: () => createTablePropControllerDataFromTableId,
+  createTextAreaPropControllerDataFromString: () => createTextAreaPropControllerDataFromString,
+  createTextInputPropControllerDataFromString: () => createTextInputPropControllerDataFromString,
+  createTextStylePropControllerDataFromResponsiveTextStyleData: () => createTextStylePropControllerDataFromResponsiveTextStyleData,
+  createVideoPropControllerDataFromVideoData: () => createVideoPropControllerDataFromVideoData,
+  createWidthPropControllerDataFromResponsiveLengthData: () => createWidthPropControllerDataFromResponsiveLengthData,
+  dataSchema: () => dataSchema,
+  datePropControllerDataSchema: () => datePropControllerDataSchema,
+  elementDataSchema: () => elementDataSchema,
+  elementIDPropControllerDataSchema: () => elementIDPropControllerDataSchema,
+  elementSchema: () => elementSchema,
+  fontPropControllerDataSchema: () => fontPropControllerDataSchema,
+  gapDataSchema: () => gapDataSchema,
+  gapYPropControllerDataSchema: () => gapYPropControllerDataSchema,
+  getBackgroundsPropControllerDataResponsiveBackgroundsData: () => getBackgroundsPropControllerDataResponsiveBackgroundsData,
+  getBackgroundsPropControllerFileIds: () => getBackgroundsPropControllerFileIds,
+  getBackgroundsPropControllerSwatchIds: () => getBackgroundsPropControllerSwatchIds,
+  getBorderPropControllerDataResponsiveBorderData: () => getBorderPropControllerDataResponsiveBorderData,
+  getBorderPropControllerDataSwatchIds: () => getBorderPropControllerDataSwatchIds,
+  getBorderRadiusPropControllerDataResponsiveBorderRadiusData: () => getBorderRadiusPropControllerDataResponsiveBorderRadiusData,
+  getCheckboxPropControllerDataBoolean: () => getCheckboxPropControllerDataBoolean,
+  getDatePropControllerDataString: () => getDatePropControllerDataString,
+  getElementIDPropControllerDataElementID: () => getElementIDPropControllerDataElementID,
+  getFontPropControllerDataResponsiveFontData: () => getFontPropControllerDataResponsiveFontData,
+  getGapYPropControllerDataResponsiveGapData: () => getGapYPropControllerDataResponsiveGapData,
+  getGridPropControllerDataGridData: () => getGridPropControllerDataGridData,
+  getGridPropControllerElementChildren: () => getGridPropControllerElementChildren,
+  getGridPropControllerGetElementPath: () => getGridPropControllerGetElementPath,
+  getImagePropControllerDataImageData: () => getImagePropControllerDataImageData,
+  getImagePropControllerFileIds: () => getImagePropControllerFileIds,
+  getImagesPropControllerDataImagesData: () => getImagesPropControllerDataImagesData,
+  getImagesPropControllerFileIds: () => getImagesPropControllerFileIds,
+  getLinkPropControllerDataLinkData: () => getLinkPropControllerDataLinkData,
+  getLinkPropControllerPageIds: () => getLinkPropControllerPageIds,
+  getMarginPropControllerDataResponsiveMarginData: () => getMarginPropControllerDataResponsiveMarginData,
+  getNavigationLinksPropControllerDataNavigationLinksData: () => getNavigationLinksPropControllerDataNavigationLinksData,
+  getNavigationLinksPropControllerPageIds: () => getNavigationLinksPropControllerPageIds,
+  getNavigationLinksPropControllerSwatchIds: () => getNavigationLinksPropControllerSwatchIds,
+  getNumberPropControllerDataNumber: () => getNumberPropControllerDataNumber,
+  getPaddingPropControllerDataResponsivePaddingData: () => getPaddingPropControllerDataResponsivePaddingData,
+  getResponsiveColorDataSwatchIds: () => getResponsiveColorDataSwatchIds,
+  getResponsiveColorPropControllerDataResponsiveColorData: () => getResponsiveColorPropControllerDataResponsiveColorData,
+  getResponsiveColorPropControllerDataSawtchIds: () => getResponsiveColorPropControllerDataSawtchIds,
+  getResponsiveLengthPropControllerDataResponsiveLengthData: () => getResponsiveLengthPropControllerDataResponsiveLengthData,
+  getShadowsPropControllerDataResponsiveShadowsData: () => getShadowsPropControllerDataResponsiveShadowsData,
+  getShadowsPropControllerDataSwatchIds: () => getShadowsPropControllerDataSwatchIds,
+  getSocialLinkTypes: () => getSocialLinkTypes,
+  getSocialLinksPropControllerDataSocialLinksData: () => getSocialLinksPropControllerDataSocialLinksData,
+  getTableFormFieldsPropControllerDataTableFormFieldsData: () => getTableFormFieldsPropControllerDataTableFormFieldsData,
+  getTablePropControllerDataTableId: () => getTablePropControllerDataTableId,
+  getTablePropControllerDataTableIds: () => getTablePropControllerDataTableIds,
+  getTextAreaPropControllerDataString: () => getTextAreaPropControllerDataString,
+  getTextInputPropControllerDataString: () => getTextInputPropControllerDataString,
+  getTextStylePropControllerDataResponsiveTextStyleData: () => getTextStylePropControllerDataResponsiveTextStyleData,
+  getVideoPropControllerDataVideoData: () => getVideoPropControllerDataVideoData,
+  getWidthPropControllerDataResponsiveLengthData: () => getWidthPropControllerDataResponsiveLengthData,
+  gridPropControllerDataSchema: () => gridPropControllerDataSchema,
+  imageBackgroundDataSchema: () => imageBackgroundDataSchema,
+  imageDataSchema: () => imageDataSchema,
+  imageDataV0Schema: () => imageDataV0Schema,
+  imageDataV1Schema: () => imageDataV1Schema,
+  imagePropControllerDataSchema: () => imagePropControllerDataSchema,
+  imagesPropControllerDataSchema: () => imagesPropControllerDataSchema,
+  lengthDataSchema: () => lengthDataSchema,
+  linkDataSchema: () => linkDataSchema,
+  linkPropControllerDataSchema: () => linkPropControllerDataSchema,
+  marginPropControllerDataSchema: () => marginPropControllerDataSchema,
+  mergeGridPropControllerTranslatedData: () => mergeGridPropControllerTranslatedData,
+  navigationLinksPropControllerDataSchema: () => navigationLinksPropControllerDataSchema,
+  numberPropControllerDataSchema: () => numberPropControllerDataSchema,
+  paddingPropControllerDataSchema: () => paddingPropControllerDataSchema,
+  responsiveColorPropControllerDataSchema: () => responsiveColorPropControllerDataSchema,
+  responsiveGapDataSchema: () => responsiveGapDataSchema,
+  responsiveLengthPropControllerDataSchema: () => responsiveLengthPropControllerDataSchema,
+  responsiveNumberValueSchema: () => responsiveNumberValueSchema,
+  responsiveOpacityValueSchema: () => responsiveOpacityValueSchema,
+  shadowsPropControllerDataSchema: () => shadowsPropControllerDataSchema,
+  socialLinksPropControllerDataSchema: () => socialLinksPropControllerDataSchema,
+  tableFormFieldsPropControllerDataSchema: () => tableFormFieldsPropControllerDataSchema,
+  tablePropControllerDataSchema: () => tablePropControllerDataSchema,
+  textAreaPropControllerDataSchema: () => textAreaPropControllerDataSchema,
+  textInputPropControllerDataSchema: () => textInputPropControllerDataSchema,
+  textStylePropControllerDataSchema: () => textStylePropControllerDataSchema,
+  versionedPropDef: () => versionedPropDef,
+  videoPropControllerDataSchema: () => videoPropControllerDataSchema,
+  widthPropControllerDataSchema: () => widthPropControllerDataSchema
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/data.ts
+var import_zod2 = require("zod");
+
+// src/prop-controllers.ts
+var import_zod = require("zod");
+var Types = {
+  Backgrounds: "Backgrounds",
+  Border: "Border",
+  BorderRadius: "BorderRadius",
+  Checkbox: "Checkbox",
+  Date: "Date",
+  ElementID: "ElementID",
+  Font: "Font",
+  GapX: "GapX",
+  GapY: "GapY",
+  Grid: "Grid",
+  Image: "Image",
+  Images: "Images",
+  Link: "Link",
+  Margin: "Margin",
+  NavigationLinks: "NavigationLinks",
+  Padding: "Padding",
+  Number: "Number",
+  Shadows: "Shadows",
+  ResponsiveColor: "ResponsiveColor",
+  ResponsiveLength: "ResponsiveLength",
+  ResponsiveNumber: "ResponsiveNumber",
+  ResponsiveOpacity: "ResponsiveOpacity",
+  SocialLinks: "SocialLinks",
+  TextArea: "TextArea",
+  TextInput: "TextInput",
+  Table: "Table",
+  TableFormFields: "TableFormFields",
+  TextStyle: "TextStyle",
+  Width: "Width",
+  Video: "Video"
+};
+var ControlDataTypeKey = "@@makeswift/type";
+var deviceSchema = import_zod.z.string();
+function createDeviceOverrideSchema(schema) {
+  return import_zod.z.object({
+    deviceId: deviceSchema,
+    value: 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/data.ts
+var colorDataSchema = import_zod2.z.object({
+  swatchId: import_zod2.z.string(),
+  alpha: import_zod2.z.number()
+});
+var lengthDataSchema = import_zod2.z.object({
+  value: import_zod2.z.number(),
+  unit: import_zod2.z.union([import_zod2.z.literal("px"), import_zod2.z.literal("%")])
+});
+var gapDataSchema = import_zod2.z.object({
+  value: import_zod2.z.number(),
+  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]);
+var responsiveNumberValueSchema = createResponsiveValueSchema(
+  import_zod2.z.number()
+);
+
+// src/versioned.ts
+var import_ts_pattern = require("ts-pattern");
+var import_zod3 = require("zod");
+var PropDef = class extends Function {
+  __associated_types__;
+  _callable;
+  constructor() {
+    super("...args", "return this._callable.__call__(...args)");
+    this._callable = this.bind(this);
+    return this._callable;
+  }
+};
+var versionedPropDef = () => (type, valueSchema, discriminator) => {
+  const schemaV0 = valueSchema;
+  const schemaV1 = import_zod3.z.object({
+    [ControlDataTypeKey]: import_zod3.z.literal(discriminator.dataKey),
+    value: valueSchema
+  });
+  const schema = import_zod3.z.union([schemaV0, schemaV1]);
+  class Def extends PropDef {
+    schemaV0 = schemaV0;
+    schemaV1 = schemaV1;
+    schema = schema;
+    type = type;
+    discriminator = discriminator;
+    __call__(options) {
+      return {
+        type,
+        version: discriminator.version,
+        options: options ?? {}
+      };
+    }
+    fromPropData(propData) {
+      return (0, import_ts_pattern.match)(propData).with(
+        {
+          [ControlDataTypeKey]: discriminator.dataKey
+        },
+        (v1) => v1.value
+      ).otherwise((v0) => v0);
+    }
+    toPropData(data, descriptor) {
+      return (0, import_ts_pattern.match)(descriptor).with(
+        { version: discriminator.version },
+        () => ({
+          [ControlDataTypeKey]: discriminator.dataKey,
+          value: data
+        })
+      ).otherwise(() => data);
+    }
+  }
+  return new Def();
+};
+
+// src/gap-x/gap-x.ts
+var GapX = versionedPropDef()(Types.GapX, responsiveGapDataSchema, {
+  version: 1,
+  dataKey: "prop-controllers::gap-x::v1"
+});
+
+// src/responsive-number/responsive-number.ts
+var ResponsiveNumber = versionedPropDef()(Types.ResponsiveNumber, responsiveNumberValueSchema, {
+  version: 1,
+  dataKey: "prop-controllers::responsive-number::v1"
+});
+
+// src/responsive-opacity/responsive-opacity.ts
+var import_zod4 = require("zod");
+var responsiveOpacityValueSchema = createResponsiveValueSchema(
+  import_zod4.z.number()
+);
+var ResponsiveOpacity = versionedPropDef()(
+  Types.ResponsiveOpacity,
+  responsiveOpacityValueSchema,
+  {
+    version: 1,
+    dataKey: "prop-controllers::responsive-opacity::v1"
+  }
+);
+
+// src/backgrounds/backgrounds.ts
+var import_zod5 = require("zod");
+var import_ts_pattern2 = require("ts-pattern");
+var colorBackgroundDataSchema = import_zod5.z.object({
+  type: import_zod5.z.literal("color"),
+  id: import_zod5.z.string(),
+  payload: colorDataSchema.nullable()
+});
+var gradientStopDataSchema = import_zod5.z.object({
+  id: import_zod5.z.string(),
+  location: import_zod5.z.number(),
+  color: colorDataSchema.nullable()
+});
+var gradientDataSchema = import_zod5.z.object({
+  angle: import_zod5.z.number().optional(),
+  isRadial: import_zod5.z.boolean().optional(),
+  stops: import_zod5.z.array(gradientStopDataSchema)
+});
+var gradientBackgroundDataSchema = import_zod5.z.object({
+  type: import_zod5.z.literal("gradient"),
+  id: import_zod5.z.string(),
+  payload: gradientDataSchema
+});
+var backgroundImagePositionDataSchema = import_zod5.z.object({
+  x: import_zod5.z.number(),
+  y: import_zod5.z.number()
+});
+var backgroundSizeDataSchema = import_zod5.z.union([
+  import_zod5.z.literal("cover"),
+  import_zod5.z.literal("contain"),
+  import_zod5.z.literal("auto")
+]);
+var backgroundImageRepeatDataSchema = import_zod5.z.union([
+  import_zod5.z.literal("no-repeat"),
+  import_zod5.z.literal("repeat-x"),
+  import_zod5.z.literal("repeat-y"),
+  import_zod5.z.literal("repeat")
+]);
+var backgroundImageV0DataSchema = import_zod5.z.object({
+  imageId: imageDataV0Schema,
+  position: backgroundImagePositionDataSchema,
+  size: backgroundSizeDataSchema.optional(),
+  repeat: backgroundImageRepeatDataSchema.optional(),
+  opacity: import_zod5.z.number().optional(),
+  parallax: import_zod5.z.number().optional(),
+  priority: import_zod5.z.boolean().optional()
+});
+var backgroundImageV1DataSchema = import_zod5.z.object({
+  version: import_zod5.z.literal(1),
+  image: imageDataV1Schema,
+  position: backgroundImagePositionDataSchema,
+  size: backgroundSizeDataSchema.optional(),
+  repeat: backgroundImageRepeatDataSchema.optional(),
+  opacity: import_zod5.z.number().optional(),
+  parallax: import_zod5.z.number().optional(),
+  priority: import_zod5.z.boolean().optional()
+});
+var backgroundImageDataSchema = import_zod5.z.union([
+  backgroundImageV0DataSchema,
+  backgroundImageV1DataSchema
+]);
+var imageBackgroundV0DataSchema = import_zod5.z.object({
+  type: import_zod5.z.literal("image"),
+  id: import_zod5.z.string(),
+  payload: backgroundImageV0DataSchema
+});
+var imageBackgroundV1DataSchema = import_zod5.z.object({
+  type: import_zod5.z.literal("image-v1"),
+  id: import_zod5.z.string(),
+  payload: backgroundImageV1DataSchema
+});
+var imageBackgroundDataSchema = import_zod5.z.union([
+  imageBackgroundV0DataSchema,
+  imageBackgroundV1DataSchema
+]);
+var backgroundVideoAspectRatioDataSchema = import_zod5.z.union([
+  import_zod5.z.literal("wide"),
+  import_zod5.z.literal("standard")
+]);
+var backgroundVideoDataSchema = import_zod5.z.object({
+  url: import_zod5.z.string().optional(),
+  maskColor: colorDataSchema.nullable().optional(),
+  opacity: import_zod5.z.number().optional(),
+  zoom: import_zod5.z.number().optional(),
+  aspectRatio: backgroundVideoAspectRatioDataSchema.optional(),
+  parallax: import_zod5.z.number().optional()
+});
+var videoBackgroundDataSchema = import_zod5.z.object({
+  type: import_zod5.z.literal("video"),
+  id: import_zod5.z.string(),
+  payload: backgroundVideoDataSchema
+});
+var backgroundDataSchema = import_zod5.z.union([
+  colorBackgroundDataSchema,
+  gradientBackgroundDataSchema,
+  imageBackgroundDataSchema,
+  videoBackgroundDataSchema
+]);
+var responsiveBackgroundsDataSchema = createResponsiveValueSchema(
+  import_zod5.z.array(backgroundDataSchema)
+);
+var backgroundsPropControllerDataV1Schema = responsiveBackgroundsDataSchema;
+var BackgroundsPropControllerDataV2Type = "prop-controllers::backgrounds::v2";
+var backgroundsPropControllerDataV2Schema = import_zod5.z.object({
+  [ControlDataTypeKey]: import_zod5.z.literal(BackgroundsPropControllerDataV2Type),
+  value: responsiveBackgroundsDataSchema
+});
+var backgroundsPropControllerDataSchema = import_zod5.z.union([
+  backgroundsPropControllerDataV1Schema,
+  backgroundsPropControllerDataV2Schema
+]);
+function Backgrounds(options = {}) {
+  return { type: Types.Backgrounds, version: 2, options };
+}
+function getBackgroundsPropControllerDataResponsiveBackgroundsData(data) {
+  return (0, import_ts_pattern2.match)(data).with(
+    { [ControlDataTypeKey]: BackgroundsPropControllerDataV2Type },
+    (v2) => v2.value
+  ).otherwise((v0) => v0);
+}
+function createBackgroundsPropControllerDataFromResponsiveBackgroundsData(data, definition) {
+  return (0, import_ts_pattern2.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_pattern2.match)(backgroundItem).with(
+      {
+        type: "image-v1",
+        payload: { image: { type: "makeswift-file" } }
+      },
+      (item) => [item.payload.image.id]
+    ).with({ type: "image", payload: { imageId: import_ts_pattern2.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_pattern2.match)([descriptor, backgroundItem]).with([import_ts_pattern2.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_pattern2.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_pattern2.P.when((v) => 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_pattern2.P.any, { type: "image", payload: { imageId: import_ts_pattern2.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_pattern2.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_ts_pattern3 = require("ts-pattern");
+var import_zod6 = require("zod");
+var borderSideDataSchema = import_zod6.z.object({
+  width: import_zod6.z.number().nullable().optional(),
+  style: import_zod6.z.enum(["dashed", "dotted", "solid"]),
+  color: colorDataSchema.nullable().optional()
+}).transform((v) => ({
+  ...v,
+  width: v.width
+}));
+var borderDataSchema = import_zod6.z.object({
+  borderTop: borderSideDataSchema.nullable().optional(),
+  borderRight: borderSideDataSchema.nullable().optional(),
+  borderBottom: borderSideDataSchema.nullable().optional(),
+  borderLeft: borderSideDataSchema.nullable().optional()
+}).transform((v) => ({
+  borderTop: v.borderTop,
+  borderRight: v.borderRight,
+  borderBottom: v.borderBottom,
+  borderLeft: v.borderLeft
+}));
+var responsiveBorderDataSchema = createResponsiveValueSchema(borderDataSchema);
+var borderPropControllerDataV0Schema = responsiveBorderDataSchema;
+var BorderPropControllerDataV1Type = "prop-controllers::border::v1";
+var borderPropControllerDataV1Schema = import_zod6.z.object({
+  [ControlDataTypeKey]: import_zod6.z.literal(BorderPropControllerDataV1Type),
+  value: responsiveBorderDataSchema
+});
+var borderPropControllerDataSchema = import_zod6.z.union([
+  borderPropControllerDataV0Schema,
+  borderPropControllerDataV1Schema
+]);
+var BorderPropControllerFormat = {
+  ClassName: "makeswift::prop-controllers::border::format::class-name",
+  ResponsiveValue: "makeswift::prop-controllers::border::format::responsive-value"
+};
+function Border(options = {}) {
+  return { type: Types.Border, version: 1, options };
+}
+Border.Format = BorderPropControllerFormat;
+function getBorderPropControllerDataResponsiveBorderData(data) {
+  return (0, import_ts_pattern3.match)(data).with(
+    { [ControlDataTypeKey]: BorderPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createBorderPropControllerDataFromResponsiveBorderData(definition, responsiveBorderData) {
+  return (0, import_ts_pattern3.match)(definition).with(
+    { version: 1 },
+    () => ({
+      [ControlDataTypeKey]: BorderPropControllerDataV1Type,
+      value: responsiveBorderData
+    })
+  ).otherwise(() => responsiveBorderData);
+}
+function getBorderPropControllerDataSwatchIds(data) {
+  return getBorderPropControllerDataResponsiveBorderData(data)?.flatMap((override) => override.value).flatMap((borderValue) => {
+    return [
+      borderValue.borderTop?.color?.swatchId,
+      borderValue.borderRight?.color?.swatchId,
+      borderValue.borderBottom?.color?.swatchId,
+      borderValue.borderLeft?.color?.swatchId
+    ].filter(
+      (swatchId) => swatchId != null
+    );
+  }) ?? [];
+}
+function copyResponsiveBorderData(data, context) {
+  return data.map((override) => ({
+    ...override,
+    value: copyBorderValue(override.value)
+  }));
+  function copyBorderValue({
+    borderTop,
+    borderRight,
+    borderBottom,
+    borderLeft
+  }) {
+    return {
+      borderTop: borderTop && copyBorderSide(borderTop),
+      borderRight: borderRight && copyBorderSide(borderRight),
+      borderBottom: borderBottom && copyBorderSide(borderBottom),
+      borderLeft: borderLeft && copyBorderSide(borderLeft)
+    };
+  }
+  function copyBorderSide(borderSide) {
+    const { color } = borderSide;
+    if (color == null)
+      return borderSide;
+    return {
+      ...borderSide,
+      color: {
+        ...color,
+        swatchId: context.replacementContext.swatchIds.get(color.swatchId) ?? color.swatchId
+      }
+    };
+  }
+}
+function copyBorderPropControllerData(data, context) {
+  return (0, import_ts_pattern3.match)(data).with(void 0, () => void 0).with(
+    { [ControlDataTypeKey]: BorderPropControllerDataV1Type },
+    (v1) => ({
+      [ControlDataTypeKey]: BorderPropControllerDataV1Type,
+      value: copyResponsiveBorderData(v1.value, context)
+    })
+  ).otherwise((v0) => copyResponsiveBorderData(v0, context));
+}
+
+// src/border-radius/border-radius.ts
+var import_zod7 = require("zod");
+var import_ts_pattern4 = require("ts-pattern");
+var borderRadiusDataSchema = import_zod7.z.object({
+  borderTopLeftRadius: lengthDataSchema.nullable().optional(),
+  borderTopRightRadius: lengthDataSchema.nullable().optional(),
+  borderBottomLeftRadius: lengthDataSchema.nullable().optional(),
+  borderBottomRightRadius: lengthDataSchema.nullable().optional()
+});
+var responsiveBorderRadiusDataSchema = createResponsiveValueSchema(
+  borderRadiusDataSchema
+);
+var borderRadiusPropControllerDataV0Schema = responsiveBorderRadiusDataSchema;
+var BorderRadiusPropControllerDataV1Type = "prop-controllers::border-radius::v1";
+var borderRadiusPropControllerDataV1Schema = import_zod7.z.object({
+  [ControlDataTypeKey]: import_zod7.z.literal(BorderRadiusPropControllerDataV1Type),
+  value: responsiveBorderRadiusDataSchema
+});
+var borderRadiusPropControllerDataSchema = import_zod7.z.union([
+  borderRadiusPropControllerDataV0Schema,
+  borderRadiusPropControllerDataV1Schema
+]);
+var BorderRadiusPropControllerFormat = {
+  ClassName: "makeswift::prop-controllers::border-radius::format::class-name",
+  ResponsiveValue: "makeswift::prop-controllers::border-radius::format::responsive-value"
+};
+function BorderRadius(options = {}) {
+  return { type: Types.BorderRadius, version: 1, options };
+}
+BorderRadius.Format = BorderRadiusPropControllerFormat;
+function getBorderRadiusPropControllerDataResponsiveBorderRadiusData(data) {
+  return (0, import_ts_pattern4.match)(data).with(
+    { [ControlDataTypeKey]: BorderRadiusPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createBorderRadiusPropControllerDataFromResponsiveBorderRadiusData(definition, responsiveBorderRadiusData) {
+  return (0, import_ts_pattern4.match)(definition).with(
+    { version: 1 },
+    () => ({
+      [ControlDataTypeKey]: BorderRadiusPropControllerDataV1Type,
+      value: responsiveBorderRadiusData
+    })
+  ).otherwise(() => responsiveBorderRadiusData);
+}
+
+// src/checkbox/checkbox.ts
+var import_zod8 = require("zod");
+var import_ts_pattern5 = require("ts-pattern");
+var checkboxPropControllerDataV0Schema = import_zod8.z.boolean();
+var CheckboxPropControllerDataV1Type = "prop-controllers::checkbox::v1";
+var checkboxPropControllerDataV1Schema = import_zod8.z.object({
+  [ControlDataTypeKey]: import_zod8.z.literal(CheckboxPropControllerDataV1Type),
+  value: import_zod8.z.boolean()
+});
+var checkboxPropControllerDataSchema = import_zod8.z.union([
+  checkboxPropControllerDataV0Schema,
+  checkboxPropControllerDataV1Schema
+]);
+function Checkbox(options) {
+  return { type: Types.Checkbox, version: 1, options };
+}
+function getCheckboxPropControllerDataBoolean(data) {
+  return (0, import_ts_pattern5.match)(data).with(
+    { [ControlDataTypeKey]: CheckboxPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createCheckboxPropControllerDataFromBoolean(value, definition) {
+  return (0, import_ts_pattern5.match)(definition).with(
+    { version: 1 },
+    import_ts_pattern5.P.nullish,
+    () => ({
+      [ControlDataTypeKey]: CheckboxPropControllerDataV1Type,
+      value
+    })
+  ).otherwise(() => value);
+}
+
+// src/date/date.ts
+var import_zod9 = require("zod");
+var import_ts_pattern6 = require("ts-pattern");
+var datePropControllerDataV0Schema = import_zod9.z.string();
+var DatePropControllerDataV1Type = "prop-controllers::date::v1";
+var datePropControllerDataV1Schema = import_zod9.z.object({
+  [ControlDataTypeKey]: import_zod9.z.literal(DatePropControllerDataV1Type),
+  value: import_zod9.z.string()
+});
+var datePropControllerDataSchema = import_zod9.z.union([
+  datePropControllerDataV0Schema,
+  datePropControllerDataV1Schema
+]);
+function Date(options = {}) {
+  return { type: Types.Date, version: 1, options };
+}
+function getDatePropControllerDataString(data) {
+  return (0, import_ts_pattern6.match)(data).with(
+    { [ControlDataTypeKey]: DatePropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createDatePropControllerDataFromString(value, definition) {
+  return (0, import_ts_pattern6.match)(definition).with(
+    { version: 1 },
+    import_ts_pattern6.P.nullish,
+    () => ({
+      [ControlDataTypeKey]: DatePropControllerDataV1Type,
+      value
+    })
+  ).otherwise(() => value);
+}
+
+// src/element-id/element-id.ts
+var import_zod10 = require("zod");
+var import_ts_pattern7 = require("ts-pattern");
+var elementIDSchema = import_zod10.z.string();
+var elementIDPropControllerDataV0Schema = elementIDSchema;
+var ElementIDPropControllerDataV1Type = "prop-controllers::element-id::v1";
+var elementIDPropControllerDataV1Schema = import_zod10.z.object({
+  [ControlDataTypeKey]: import_zod10.z.literal(ElementIDPropControllerDataV1Type),
+  value: elementIDSchema
+});
+var elementIDPropControllerDataSchema = import_zod10.z.union([
+  elementIDPropControllerDataV0Schema,
+  elementIDPropControllerDataV1Schema
+]);
+function ElementID(options = {}) {
+  return { type: Types.ElementID, version: 1, options };
+}
+function getElementIDPropControllerDataElementID(data) {
+  return (0, import_ts_pattern7.match)(data).with(
+    { [ControlDataTypeKey]: ElementIDPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createElementIDPropControllerDataFromElementID(value, definition) {
+  return (0, import_ts_pattern7.match)(definition).with(
+    { version: 1 },
+    import_ts_pattern7.P.nullish,
+    () => ({
+      [ControlDataTypeKey]: ElementIDPropControllerDataV1Type,
+      value
+    })
+  ).otherwise(() => value);
+}
+function copyElementID(data, context) {
+  if (data == null)
+    return data;
+  if (context.replacementContext.elementHtmlIds.has(data))
+    return void 0;
+  context.replacementContext.elementHtmlIds.add(data);
+  return data;
+}
+function copyElementIDPropControllerData(data, context) {
+  return (0, import_ts_pattern7.match)(data).with(void 0, () => void 0).with({ [ControlDataTypeKey]: ElementIDPropControllerDataV1Type }, (v1) => {
+    const value = copyElementID(v1.value, context);
+    if (value == null)
+      return void 0;
+    return {
+      [ControlDataTypeKey]: ElementIDPropControllerDataV1Type,
+      value
+    };
+  }).otherwise((v0) => copyElementID(v0, context));
+}
+
+// src/font/font.ts
+var import_ts_pattern8 = require("ts-pattern");
+var import_zod11 = require("zod");
+var fontDataSchema = import_zod11.z.string();
+var responsiveFontDataSchema = createResponsiveValueSchema(fontDataSchema);
+var fontPropControllerDataV0Schema = responsiveFontDataSchema;
+var FontPropControllerDataV1Type = "prop-controllers::font::v1";
+var fontPropControllerDataV1Schema = import_zod11.z.object({
+  [ControlDataTypeKey]: import_zod11.z.literal(FontPropControllerDataV1Type),
+  value: responsiveFontDataSchema
+});
+var fontPropControllerDataSchema = import_zod11.z.union([
+  fontPropControllerDataV0Schema,
+  fontPropControllerDataV1Schema
+]);
+function Font(options = {}) {
+  return { type: Types.Font, version: 1, options };
+}
+function getFontPropControllerDataResponsiveFontData(data) {
+  return (0, import_ts_pattern8.match)(data).with(
+    { [ControlDataTypeKey]: FontPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createFontPropControllerDataFromResponsiveFontData(responsiveFontData, definition) {
+  return (0, import_ts_pattern8.match)(definition).with(
+    { version: 1 },
+    import_ts_pattern8.P.nullish,
+    () => ({
+      [ControlDataTypeKey]: FontPropControllerDataV1Type,
+      value: responsiveFontData
+    })
+  ).otherwise(() => responsiveFontData);
+}
+
+// src/gap-y/gap-y.ts
+var import_ts_pattern9 = require("ts-pattern");
+var import_zod12 = require("zod");
+var gapYPropControllerDataV0Schema = responsiveGapDataSchema;
+var GapYPropControllerDataV1Type = "prop-controllers::gap-y::v1";
+var gapYPropControllerDataV1Schema = import_zod12.z.object({
+  [ControlDataTypeKey]: import_zod12.z.literal(GapYPropControllerDataV1Type),
+  value: responsiveGapDataSchema
+});
+var gapYPropControllerDataSchema = import_zod12.z.union([
+  gapYPropControllerDataV0Schema,
+  gapYPropControllerDataV1Schema
+]);
+function GapY(options = {}) {
+  return { type: Types.GapY, version: 1, options };
+}
+function getGapYPropControllerDataResponsiveGapData(data) {
+  return (0, import_ts_pattern9.match)(data).with(
+    { [ControlDataTypeKey]: GapYPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createGapYPropControllerDataFromResponsiveGapData(responsiveGapData, definition) {
+  return (0, import_ts_pattern9.match)(definition).with(
+    { version: 1 },
+    () => ({
+      [ControlDataTypeKey]: GapYPropControllerDataV1Type,
+      value: responsiveGapData
+    })
+  ).otherwise(() => responsiveGapData);
+}
+
+// src/grid/grid.ts
+var import_zod13 = require("zod");
+var import_ts_pattern10 = require("ts-pattern");
+var gridColumnSchema = import_zod13.z.object({
+  count: import_zod13.z.number(),
+  spans: import_zod13.z.array(import_zod13.z.array(import_zod13.z.number()))
+});
+var gridDataSchema = import_zod13.z.object({
+  elements: import_zod13.z.array(elementSchema),
+  columns: createResponsiveValueSchema(gridColumnSchema)
+});
+var gridPropControllerDataV0Schema = gridDataSchema;
+var GridPropControllerDataV1Type = "prop-controllers::grid::v1";
+var gridPropControllerDataV1Schema = import_zod13.z.object({
+  [ControlDataTypeKey]: import_zod13.z.literal(GridPropControllerDataV1Type),
+  value: gridDataSchema
+});
+var gridPropControllerDataSchema = import_zod13.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_zod14 = require("zod");
+var import_ts_pattern11 = require("ts-pattern");
+var imagePropControllerDataV0Schema = imageDataV0Schema;
+var imagePropControllerDataV1Schema = imageDataSchema;
+var ImagePropControllerDataV2Type = "prop-controllers::image::v2";
+var imagePropControllerDataV2Schema = import_zod14.z.object({
+  [ControlDataTypeKey]: import_zod14.z.literal(ImagePropControllerDataV2Type),
+  value: imagePropControllerDataV1Schema
+});
+var imagePropControllerDataSchema = import_zod14.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_zod16 = require("zod");
+var import_ts_pattern13 = require("ts-pattern");
+
+// src/link/link.ts
+var import_ts_pattern12 = require("ts-pattern");
+var import_zod15 = require("zod");
+var openPageLinkSchema = import_zod15.z.object({
+  type: import_zod15.z.literal("OPEN_PAGE"),
+  payload: import_zod15.z.object({
+    pageId: import_zod15.z.string().nullable().optional(),
+    openInNewTab: import_zod15.z.boolean()
+  }).transform((v) => ({
+    pageId: v.pageId,
+    ...v
+  }))
+});
+var openURLLinkSchema = import_zod15.z.object({
+  type: import_zod15.z.literal("OPEN_URL"),
+  payload: import_zod15.z.object({
+    url: import_zod15.z.string(),
+    openInNewTab: import_zod15.z.boolean()
+  })
+});
+var sendEmailLinkSchema = import_zod15.z.object({
+  type: import_zod15.z.literal("SEND_EMAIL"),
+  payload: import_zod15.z.object({
+    to: import_zod15.z.string(),
+    subject: import_zod15.z.string().optional(),
+    body: import_zod15.z.string().optional()
+  })
+});
+var callPhoneLinkSchema = import_zod15.z.object({
+  type: import_zod15.z.literal("CALL_PHONE"),
+  payload: import_zod15.z.object({
+    phoneNumber: import_zod15.z.string()
+  })
+});
+var scrollToElementLinkSchema = import_zod15.z.object({
+  type: import_zod15.z.literal("SCROLL_TO_ELEMENT"),
+  payload: import_zod15.z.object({
+    elementIdConfig: import_zod15.z.object({
+      elementKey: import_zod15.z.string(),
+      propName: import_zod15.z.string()
+    }).nullable().optional(),
+    block: import_zod15.z.union([
+      import_zod15.z.literal("start"),
+      import_zod15.z.literal("center"),
+      import_zod15.z.literal("end")
+    ])
+  }).transform((v) => ({
+    elementIdConfig: v.elementIdConfig,
+    ...v
+  }))
+});
+var linkDataSchema = import_zod15.z.union([
+  openPageLinkSchema,
+  openURLLinkSchema,
+  sendEmailLinkSchema,
+  callPhoneLinkSchema,
+  scrollToElementLinkSchema
+]);
+var linkPropControllerDataV0Schema = linkDataSchema;
+var LinkPropControllerDataV1Type = "prop-controllers::link::v1";
+var linkPropControllerDataV1Schema = import_zod15.z.object({
+  [ControlDataTypeKey]: import_zod15.z.literal(LinkPropControllerDataV1Type),
+  value: linkDataSchema
+});
+var linkPropControllerDataSchema = import_zod15.z.union([
+  linkPropControllerDataV0Schema,
+  linkPropControllerDataV1Schema
+]);
+function Link(options = {}) {
+  return { type: Types.Link, version: 1, options };
+}
+function getLinkPropControllerDataLinkData(data) {
+  return (0, import_ts_pattern12.match)(data).with(
+    { [ControlDataTypeKey]: LinkPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createLinkPropControllerDataFromLinkData(value, definition) {
+  return (0, import_ts_pattern12.match)(definition).with(
+    { version: 1 },
+    () => ({
+      [ControlDataTypeKey]: LinkPropControllerDataV1Type,
+      value
+    })
+  ).otherwise(() => value);
+}
+function getLinkPropControllerPageIds(linkData) {
+  if (linkData == null)
+    return [];
+  const link = getLinkPropControllerDataLinkData(linkData);
+  switch (link.type) {
+    case "OPEN_PAGE":
+      return link.payload.pageId == null ? [] : [link.payload.pageId];
+    default:
+      return [];
+  }
+}
+function copyLinkData(data, context) {
+  let value = data;
+  switch (value?.type) {
+    case "OPEN_PAGE":
+      {
+        const pageId = value.payload.pageId;
+        if (pageId == null)
+          return value;
+        value = {
+          ...value,
+          payload: {
+            ...value.payload,
+            pageId: context.replacementContext.pageIds.get(pageId) ?? pageId
+          }
+        };
+      }
+      break;
+    case "SCROLL_TO_ELEMENT": {
+      const elementIdConfig = value.payload.elementIdConfig;
+      if (elementIdConfig == null)
+        return value;
+      value = {
+        ...value,
+        payload: {
+          ...value.payload,
+          elementIdConfig: {
+            ...elementIdConfig,
+            elementKey: context.replacementContext.elementKeys.get(
+              elementIdConfig.elementKey
+            ) ?? elementIdConfig.elementKey
+          }
+        }
+      };
+      break;
+    }
+  }
+  return value;
+}
+function copyLinkPropControllerData(data, context) {
+  if (data == null)
+    return data;
+  const value = copyLinkData(getLinkPropControllerDataLinkData(data), context);
+  if (value == null)
+    return value;
+  return (0, import_ts_pattern12.match)(data).with({ [ControlDataTypeKey]: LinkPropControllerDataV1Type }, (v1) => ({
+    ...v1,
+    value
+  })).otherwise((_) => value);
+}
+
+// src/images/images.ts
+var imagesDataV0ItemSchema = import_zod16.z.object({
+  key: import_zod16.z.string(),
+  props: import_zod16.z.object({
+    link: linkDataSchema.optional(),
+    file: imageDataV0Schema.optional(),
+    altText: import_zod16.z.string().optional()
+  })
+});
+var imagesDataV0Schema = import_zod16.z.array(imagesDataV0ItemSchema);
+var imagesDataV1ItemSchema = import_zod16.z.object({
+  key: import_zod16.z.string(),
+  version: import_zod16.z.literal(1),
+  props: import_zod16.z.object({
+    link: linkDataSchema.optional(),
+    file: imageDataV1Schema.optional(),
+    altText: import_zod16.z.string().optional()
+  })
+});
+var imagesDataItemSchema = import_zod16.z.union([
+  imagesDataV0ItemSchema,
+  imagesDataV1ItemSchema
+]);
+var imagesDataSchema = import_zod16.z.array(imagesDataItemSchema);
+var imagesPropControllerDataV0Schema = import_zod16.z.array(imagesDataV0ItemSchema);
+var imagesPropControllerDataV1Schema = imagesDataSchema;
+var ImagesPropControllerDataV2Type = "prop-controllers::images::v2";
+var imagesPropControllerDataV2Schema = import_zod16.z.object({
+  [ControlDataTypeKey]: import_zod16.z.literal(ImagesPropControllerDataV2Type),
+  value: imagesPropControllerDataV1Schema
+});
+var imagesPropControllerDataSchema = import_zod16.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_pattern14 = require("ts-pattern");
+var import_zod17 = require("zod");
+var marginSideDataSchema = import_zod17.z.union([
+  import_zod17.z.object({
+    value: import_zod17.z.number(),
+    unit: import_zod17.z.literal("px")
+  }),
+  import_zod17.z.literal("auto")
+]);
+var marginDataSchema = import_zod17.z.object({
+  marginTop: marginSideDataSchema.nullable().optional(),
+  marginRight: marginSideDataSchema.nullable().optional(),
+  marginBottom: marginSideDataSchema.nullable().optional(),
+  marginLeft: marginSideDataSchema.nullable().optional()
+}).transform((v) => ({
+  marginTop: v.marginTop,
+  marginRight: v.marginRight,
+  marginBottom: v.marginBottom,
+  marginLeft: v.marginLeft
+}));
+var responsiveMarginDataSchema = createResponsiveValueSchema(marginDataSchema);
+var marginPropControllerDataV0Schema = responsiveMarginDataSchema;
+var MarginPropControllerDataV1Type = "prop-controllers::margin::v1";
+var marginPropControllerDataV1Schema = import_zod17.z.object({
+  [ControlDataTypeKey]: import_zod17.z.literal(MarginPropControllerDataV1Type),
+  value: responsiveMarginDataSchema
+});
+var marginPropControllerDataSchema = import_zod17.z.union([
+  marginPropControllerDataV0Schema,
+  marginPropControllerDataV1Schema
+]);
+var MarginPropControllerFormat = {
+  ClassName: "makeswift::prop-controllers::margin::format::class-name",
+  ResponsiveValue: "makeswift::prop-controllers::margin::format::responsive-value"
+};
+function Margin(options = {}) {
+  return { type: Types.Margin, version: 1, options };
+}
+Margin.Format = MarginPropControllerFormat;
+function getMarginPropControllerDataResponsiveMarginData(data) {
+  return (0, import_ts_pattern14.match)(data).with(
+    { [ControlDataTypeKey]: MarginPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createMarginPropControllerDataFromResponsiveMarginData(responsiveMarginData, definition) {
+  return (0, import_ts_pattern14.match)(definition).with(
+    { version: 1 },
+    import_ts_pattern14.P.nullish,
+    () => ({
+      [ControlDataTypeKey]: MarginPropControllerDataV1Type,
+      value: responsiveMarginData
+    })
+  ).otherwise(() => responsiveMarginData);
+}
+
+// src/navigation-links/navigation-links.ts
+var import_ts_pattern17 = require("ts-pattern");
+var import_zod20 = require("zod");
+
+// src/text-style/text-style.ts
+var import_ts_pattern15 = require("ts-pattern");
+var import_zod18 = require("zod");
+var textStyleDataSchema = import_zod18.z.object({
+  fontFamily: import_zod18.z.string().optional().nullable(),
+  letterSpacing: import_zod18.z.number().optional().nullable(),
+  fontSize: import_zod18.z.object({
+    value: import_zod18.z.number(),
+    unit: import_zod18.z.literal("px")
+  }).optional().nullable(),
+  fontWeight: import_zod18.z.number().optional().nullable(),
+  textTransform: import_zod18.z.array(import_zod18.z.literal("uppercase")),
+  fontStyle: import_zod18.z.array(import_zod18.z.literal("italic"))
+}).transform((v) => ({
+  ...v,
+  letterSpacing: v.letterSpacing,
+  fontSize: v.fontSize,
+  fontWeight: v.fontWeight,
+  textTransform: v.textTransform,
+  fontStyle: v.fontStyle
+}));
+var responsiveTextStyleDataSchema = createResponsiveValueSchema(textStyleDataSchema);
+var textStylePropControllerDataV0Schema = responsiveTextStyleDataSchema;
+var TextStylePropControllerDataV1Type = "prop-controllers::text-style::v1";
+var textStylePropControllerDataV1Schema = import_zod18.z.object({
+  [ControlDataTypeKey]: import_zod18.z.literal(TextStylePropControllerDataV1Type),
+  value: responsiveTextStyleDataSchema
+});
+var textStylePropControllerDataSchema = import_zod18.z.union([
+  textStylePropControllerDataV0Schema,
+  textStylePropControllerDataV1Schema
+]);
+function TextStyle(options = {}) {
+  return { type: Types.TextStyle, version: 1, options };
+}
+function getTextStylePropControllerDataResponsiveTextStyleData(data) {
+  return (0, import_ts_pattern15.match)(data).with(
+    { [ControlDataTypeKey]: TextStylePropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createTextStylePropControllerDataFromResponsiveTextStyleData(responsiveTextStyleData, definition) {
+  return (0, import_ts_pattern15.match)(definition).with(
+    { version: 1 },
+    () => ({
+      [ControlDataTypeKey]: TextStylePropControllerDataV1Type,
+      value: responsiveTextStyleData
+    })
+  ).otherwise(() => responsiveTextStyleData);
+}
+
+// src/responsive-color.ts
+var import_zod19 = 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_zod19.z.object({
+  [ControlDataTypeKey]: import_zod19.z.literal(ResponsiveColorPropControllerDataV1Type),
+  value: responsiveColorDataSchema
+});
+var responsiveColorPropControllerDataSchema = import_zod19.z.union([
+  responsiveColorPropControllerDataV0Schema,
+  responsiveColorPropControllerDataV1Schema
+]);
+function ResponsiveColor(options = {}) {
+  return { type: Types.ResponsiveColor, version: 1, options };
+}
+function getResponsiveColorPropControllerDataResponsiveColorData(data) {
+  return (0, import_ts_pattern16.match)(data).with(
+    { [ControlDataTypeKey]: ResponsiveColorPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createResponsiveColorPropControllerDataFromResponsiveColorData(definition, responsiveColorData) {
+  return (0, import_ts_pattern16.match)(definition).with(
+    { version: 1 },
+    () => ({
+      [ControlDataTypeKey]: ResponsiveColorPropControllerDataV1Type,
+      value: responsiveColorData
+    })
+  ).otherwise(() => responsiveColorData);
+}
+function getResponsiveColorDataSwatchIds(data) {
+  return data.map((override) => override.value.swatchId);
+}
+function getResponsiveColorPropControllerDataSawtchIds(data) {
+  if (data == null)
+    return [];
+  return getResponsiveColorDataSwatchIds(
+    getResponsiveColorPropControllerDataResponsiveColorData(data)
+  );
+}
+function copyResponsiveColorData(data, context) {
+  return data.map((override) => ({
+    ...override,
+    value: copyColorValue(override.value)
+  }));
+  function copyColorValue(colorValue) {
+    return {
+      ...colorValue,
+      swatchId: context.replacementContext.swatchIds.get(colorValue.swatchId) ?? colorValue.swatchId
+    };
+  }
+}
+function copyResponsiveColorPropControllerData(data, context) {
+  return (0, import_ts_pattern16.match)(data).with(void 0, () => void 0).with(
+    { [ControlDataTypeKey]: ResponsiveColorPropControllerDataV1Type },
+    (v1) => ({
+      [ControlDataTypeKey]: ResponsiveColorPropControllerDataV1Type,
+      value: copyResponsiveColorData(v1.value, context)
+    })
+  ).otherwise((v0) => copyResponsiveColorData(v0, context));
+}
+
+// src/navigation-links/navigation-links.ts
+var buttonVariantSchema = import_zod20.z.enum([
+  "flat",
+  "outline",
+  "shadow",
+  "clear",
+  "blocky",
+  "bubbly",
+  "skewed"
+]);
+var buttonShapeSchema = import_zod20.z.enum(["pill", "rounded", "square"]);
+var buttonSizeSchema = import_zod20.z.enum(["small", "medium", "large"]);
+var navigationButtonSchema = import_zod20.z.object({
+  id: import_zod20.z.string(),
+  type: import_zod20.z.literal("button"),
+  payload: import_zod20.z.object({
+    label: import_zod20.z.string(),
+    link: linkDataSchema.optional(),
+    variant: createResponsiveValueSchema(buttonVariantSchema).optional(),
+    shape: createResponsiveValueSchema(buttonShapeSchema).optional(),
+    size: createResponsiveValueSchema(buttonSizeSchema).optional(),
+    textColor: createResponsiveValueSchema(colorDataSchema).optional(),
+    color: createResponsiveValueSchema(colorDataSchema).optional(),
+    textStyle: createResponsiveValueSchema(textStyleDataSchema).optional()
+  })
+});
+var navigationDropdownCaretTypeSchema = import_zod20.z.union([
+  import_zod20.z.literal("caret"),
+  import_zod20.z.literal("plus"),
+  import_zod20.z.literal("arrow-down"),
+  import_zod20.z.literal("chevron-down")
+]);
+var navigationDropdownLinkSchema = import_zod20.z.object({
+  id: import_zod20.z.string(),
+  payload: import_zod20.z.object({
+    label: import_zod20.z.string(),
+    link: linkDataSchema.optional(),
+    color: createResponsiveValueSchema(colorDataSchema).optional(),
+    textStyle: createResponsiveValueSchema(textStyleDataSchema).optional()
+  })
+});
+var navigationDropdownSchema = import_zod20.z.object({
+  id: import_zod20.z.string(),
+  type: import_zod20.z.literal("dropdown"),
+  payload: import_zod20.z.object({
+    label: import_zod20.z.string(),
+    caret: navigationDropdownCaretTypeSchema.optional(),
+    links: import_zod20.z.array(navigationDropdownLinkSchema).optional(),
+    variant: createResponsiveValueSchema(buttonVariantSchema).optional(),
+    shape: createResponsiveValueSchema(buttonShapeSchema).optional(),
+    size: createResponsiveValueSchema(buttonSizeSchema).optional(),
+    textColor: createResponsiveValueSchema(colorDataSchema).optional(),
+    color: createResponsiveValueSchema(colorDataSchema).optional(),
+    textStyle: createResponsiveValueSchema(textStyleDataSchema).optional()
+  })
+});
+var navigationLinksDataSchema = import_zod20.z.array(
+  import_zod20.z.union([navigationButtonSchema, navigationDropdownSchema])
+);
+var navigationLinksPropControllerDataV0Schema = navigationLinksDataSchema;
+var NavigationLinksPropControllerDataV1Type = "prop-controllers::navigation-links::v1";
+var navigationLinksPropControllerDataV1Schema = import_zod20.z.object({
+  [ControlDataTypeKey]: import_zod20.z.literal(NavigationLinksPropControllerDataV1Type),
+  value: navigationLinksDataSchema
+});
+var navigationLinksPropControllerDataSchema = import_zod20.z.union([
+  navigationLinksPropControllerDataV0Schema,
+  navigationLinksPropControllerDataV1Schema
+]);
+function NavigationLinks(options = {}) {
+  return { type: Types.NavigationLinks, version: 1, options };
+}
+function getNavigationLinksPropControllerDataNavigationLinksData(data) {
+  return (0, import_ts_pattern17.match)(data).with(
+    { [ControlDataTypeKey]: NavigationLinksPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createNavigationLinksPropControllerDataFromNavigationLinksData(navigationLinksData, definition) {
+  return (0, import_ts_pattern17.match)(definition).with(
+    { version: 1 },
+    () => ({
+      [ControlDataTypeKey]: NavigationLinksPropControllerDataV1Type,
+      value: navigationLinksData
+    })
+  ).otherwise(() => navigationLinksData);
+}
+function getNavigationLinksPropControllerPageIds(data) {
+  if (data == null)
+    return [];
+  const value = getNavigationLinksPropControllerDataNavigationLinksData(data);
+  return value?.flatMap((item) => {
+    switch (item.type) {
+      case "button": {
+        if (item.payload.link == null)
+          return [];
+        switch (item.payload.link.type) {
+          case "OPEN_PAGE":
+            return item.payload.link.payload.pageId == null ? [] : [item.payload.link.payload.pageId];
+          default:
+            return [];
+        }
+      }
+      case "dropdown": {
+        return item.payload.links?.flatMap((link) => {
+          if (link.payload.link == null)
+            return [];
+          switch (link.payload.link.type) {
+            case "OPEN_PAGE":
+              return link.payload.link.payload.pageId == null ? [] : [link.payload.link.payload.pageId];
+            default:
+              return [];
+          }
+        }) ?? [];
+      }
+    }
+  }) ?? [];
+}
+function getNavigationLinksPropControllerSwatchIds(data) {
+  if (data == null)
+    return [];
+  const value = getNavigationLinksPropControllerDataNavigationLinksData(data);
+  return value?.flatMap((item) => {
+    switch (item.type) {
+      case "button":
+      case "dropdown":
+        return [
+          ...item.payload.color?.map((override) => override.value).map((color) => color.swatchId) ?? [],
+          ...item.payload.textColor?.map((override) => override.value).map((color) => color.swatchId) ?? []
+        ];
+    }
+  }) ?? [];
+}
+function copyNavigationLinksData(data, context) {
+  return data?.map((item) => {
+    switch (item.type) {
+      case "button": {
+        const { color, link } = item.payload;
+        return {
+          ...item,
+          payload: {
+            ...item.payload,
+            link: copyLinkData(link, context),
+            color: color != null ? copyResponsiveColorData(color, context) : void 0
+          }
+        };
+      }
+      case "dropdown": {
+        const { color, links } = item.payload;
+        return {
+          ...item,
+          payload: {
+            ...item.payload,
+            links: links != null ? links.map((link) => ({
+              ...link,
+              payload: {
+                ...link.payload,
+                link: copyLinkData(link.payload.link, context)
+              }
+            })) : void 0,
+            color: color != null ? copyResponsiveColorData(color, context) : void 0
+          }
+        };
+      }
+      default:
+        return item;
+    }
+  });
+}
+function copyNavigationLinksPropControllerData(data, context) {
+  return (0, import_ts_pattern17.match)(data).with(void 0, () => void 0).with(
+    { [ControlDataTypeKey]: NavigationLinksPropControllerDataV1Type },
+    (v1) => ({
+      [ControlDataTypeKey]: NavigationLinksPropControllerDataV1Type,
+      value: copyNavigationLinksData(v1.value, context)
+    })
+  ).otherwise((v0) => copyNavigationLinksData(v0, context));
+}
+
+// src/number.ts
+var import_zod21 = require("zod");
+var import_ts_pattern18 = require("ts-pattern");
+var numberPropControllerDataV0Schema = import_zod21.z.number();
+var NumberPropControllerDataV1Type = "prop-controllers::number::v1";
+var numberPropControllerDataV1Schema = import_zod21.z.object({
+  [ControlDataTypeKey]: import_zod21.z.literal(NumberPropControllerDataV1Type),
+  value: import_zod21.z.number()
+});
+var numberPropControllerDataSchema = import_zod21.z.union([
+  numberPropControllerDataV0Schema,
+  numberPropControllerDataV1Schema
+]);
+function Number(options = {}) {
+  return { type: Types.Number, version: 1, options };
+}
+function getNumberPropControllerDataNumber(data) {
+  return (0, import_ts_pattern18.match)(data).with(
+    { [ControlDataTypeKey]: NumberPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createNumberPropControllerDataFromNumber(value, definition) {
+  return (0, import_ts_pattern18.match)(definition).with(
+    { version: 1 },
+    import_ts_pattern18.P.nullish,
+    () => ({
+      [ControlDataTypeKey]: NumberPropControllerDataV1Type,
+      value
+    })
+  ).otherwise(() => value);
+}
+
+// src/padding/padding.ts
+var import_ts_pattern19 = require("ts-pattern");
+var import_zod22 = require("zod");
+var paddingSideDataSchema = import_zod22.z.object({
+  value: import_zod22.z.number(),
+  unit: import_zod22.z.literal("px")
+});
+var paddingDataSchema = import_zod22.z.object({
+  paddingTop: paddingSideDataSchema.nullable().optional(),
+  paddingRight: paddingSideDataSchema.nullable().optional(),
+  paddingBottom: paddingSideDataSchema.nullable().optional(),
+  paddingLeft: paddingSideDataSchema.nullable().optional()
+}).transform((v) => ({
+  paddingTop: v.paddingTop,
+  paddingRight: v.paddingRight,
+  paddingBottom: v.paddingBottom,
+  paddingLeft: v.paddingLeft
+}));
+var responsivePaddingDataSchema = createResponsiveValueSchema(paddingDataSchema);
+var paddingPropControllerDataV0Schema = responsivePaddingDataSchema;
+var PaddingPropControllerDataV1Type = "prop-controllers::padding::v1";
+var paddingPropControllerDataV1Schema = import_zod22.z.object({
+  [ControlDataTypeKey]: import_zod22.z.literal(PaddingPropControllerDataV1Type),
+  value: responsivePaddingDataSchema
+});
+var paddingPropControllerDataSchema = import_zod22.z.union([
+  paddingPropControllerDataV0Schema,
+  paddingPropControllerDataV1Schema
+]);
+var PaddingPropControllerFormat = {
+  ClassName: "makeswift::prop-controllers::padding::format::class-name",
+  ResponsiveValue: "makeswift::prop-controllers::padding::format::responsive-value"
+};
+function Padding(options = {}) {
+  return { type: Types.Padding, version: 1, options };
+}
+Padding.Format = PaddingPropControllerFormat;
+function getPaddingPropControllerDataResponsivePaddingData(data) {
+  return (0, import_ts_pattern19.match)(data).with(
+    { [ControlDataTypeKey]: PaddingPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createPaddingPropControllerDataFromResponsivePaddingData(responsivePaddingData, definition) {
+  return (0, import_ts_pattern19.match)(definition).with(
+    { version: 1 },
+    import_ts_pattern19.P.nullish,
+    () => ({
+      [ControlDataTypeKey]: PaddingPropControllerDataV1Type,
+      value: responsivePaddingData
+    })
+  ).otherwise(() => responsivePaddingData);
+}
+
+// src/responsive-length.ts
+var import_zod23 = 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_zod23.z.object({
+  [ControlDataTypeKey]: import_zod23.z.literal(ResponsiveLengthPropControllerDataV1Type),
+  value: responsiveLengthDataSchema
+});
+var responsiveLengthPropControllerDataSchema = import_zod23.z.union([
+  responsiveLengthPropControllerDataV0Schema,
+  responsiveLengthPropControllerDataV1Schema
+]);
+function ResponsiveLength(options = {}) {
+  return { type: Types.ResponsiveLength, version: 1, options };
+}
+function getResponsiveLengthPropControllerDataResponsiveLengthData(data) {
+  return (0, import_ts_pattern20.match)(data).with(
+    { [ControlDataTypeKey]: ResponsiveLengthPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createResponsiveLengthPropControllerDataFromResponsiveLengthData(definition, responsiveLengthData) {
+  return (0, import_ts_pattern20.match)(definition).with(
+    { version: 1 },
+    () => ({
+      [ControlDataTypeKey]: ResponsiveLengthPropControllerDataV1Type,
+      value: responsiveLengthData
+    })
+  ).otherwise(() => responsiveLengthData);
+}
+
+// src/social-links/social-links.ts
+var import_zod24 = require("zod");
+var import_ts_pattern21 = require("ts-pattern");
+var socialLinkTypesV0 = [
+  "angellist",
+  "codepen",
+  "discord",
+  "dribbble",
+  "facebook",
+  "github",
+  "instagram",
+  "linkedin",
+  "medium",
+  "pinterest",
+  "reddit",
+  "rss",
+  "snapchat",
+  "soundcloud",
+  "spotify",
+  "telegram",
+  "tumblr",
+  "twitch",
+  "twitter",
+  "vimeo",
+  "whatsapp",
+  "yelp",
+  "youtube"
+];
+var socialLinkTypesV1 = [...socialLinkTypesV0, "x", "slack"];
+var socialLinkV0Schema = import_zod24.z.object({
+  type: import_zod24.z.enum(socialLinkTypesV0),
+  url: import_zod24.z.string()
+});
+var socialLinkV1Schema = import_zod24.z.object({
+  type: import_zod24.z.enum(socialLinkTypesV1),
+  url: import_zod24.z.string()
+});
+var socialLinksLinkV0Schema = import_zod24.z.object({
+  id: import_zod24.z.string(),
+  payload: socialLinkV0Schema
+});
+var socialLinksLinkV1Schema = import_zod24.z.object({
+  id: import_zod24.z.string(),
+  payload: socialLinkV1Schema
+});
+var socialLinksDataV0Schema = import_zod24.z.object({
+  links: import_zod24.z.array(socialLinksLinkV0Schema),
+  openInNewTab: import_zod24.z.boolean()
+});
+var socialLinksDataV1Schema = import_zod24.z.object({
+  links: import_zod24.z.array(socialLinksLinkV1Schema),
+  openInNewTab: import_zod24.z.boolean()
+});
+var socialLinksDataSchema = import_zod24.z.union([
+  socialLinksDataV0Schema,
+  socialLinksDataV1Schema
+]);
+var socialLinksPropControllerDataV1Schema = socialLinksDataSchema;
+var SocialLinksPropControllerDataV2Type = "prop-controllers::social-links::v2";
+var socialLinksPropControllerDataV2Schema = import_zod24.z.object({
+  [ControlDataTypeKey]: import_zod24.z.literal(SocialLinksPropControllerDataV2Type),
+  value: socialLinksDataSchema
+});
+var socialLinksPropControllerDataSchema = import_zod24.z.union([
+  socialLinksPropControllerDataV1Schema,
+  socialLinksPropControllerDataV2Schema
+]);
+function SocialLinks(options = {}) {
+  return { type: Types.SocialLinks, version: 2, options };
+}
+function getSocialLinkTypes(descriptor) {
+  return (0, import_ts_pattern21.match)(descriptor).with({ version: import_ts_pattern21.P.union(1, 2) }, () => socialLinkTypesV1).otherwise(() => socialLinkTypesV0);
+}
+function getSocialLinksPropControllerDataSocialLinksData(data) {
+  return (0, import_ts_pattern21.match)(data).with(
+    { [ControlDataTypeKey]: SocialLinksPropControllerDataV2Type },
+    (v2) => v2.value
+  ).otherwise((v0) => v0);
+}
+function createSocialLinksPropControllerDataFromSocialLinksData(data, definition) {
+  return (0, import_ts_pattern21.match)(definition).with(
+    { version: 2 },
+    () => ({
+      [ControlDataTypeKey]: SocialLinksPropControllerDataV2Type,
+      value: data
+    })
+  ).otherwise(() => data);
+}
+
+// src/shadows.ts
+var import_ts_pattern22 = require("ts-pattern");
+var import_zod25 = require("zod");
+var shadowDataSchema = import_zod25.z.object({
+  color: colorDataSchema.nullable().optional(),
+  blurRadius: import_zod25.z.number().optional(),
+  spreadRadius: import_zod25.z.number().optional(),
+  offsetX: import_zod25.z.number().optional(),
+  offsetY: import_zod25.z.number().optional(),
+  inset: import_zod25.z.boolean().optional()
+});
+var shadowsDataSchema = import_zod25.z.array(
+  import_zod25.z.object({
+    id: import_zod25.z.string(),
+    payload: shadowDataSchema
+  })
+);
+var responsiveShadowsDataSchema = createResponsiveValueSchema(shadowsDataSchema);
+var shadowsPropControllerDataV0Schema = responsiveShadowsDataSchema;
+var ShadowsPropControllerDataV1Type = "prop-controllers::shadows::v1";
+var shadowsPropControllerDataV1Schema = import_zod25.z.object({
+  [ControlDataTypeKey]: import_zod25.z.literal(ShadowsPropControllerDataV1Type),
+  value: responsiveShadowsDataSchema
+});
+var shadowsPropControllerDataSchema = import_zod25.z.union([
+  shadowsPropControllerDataV0Schema,
+  shadowsPropControllerDataV1Schema
+]);
+var ShadowsPropControllerFormat = {
+  ClassName: "makeswift::prop-controllers::shadows::format::class-name",
+  ResponsiveValue: "makeswift::prop-controllers::shadows::format::responsive-value"
+};
+function Shadows(options = {}) {
+  return { type: Types.Shadows, version: 1, options };
+}
+Shadows.Format = ShadowsPropControllerFormat;
+function getShadowsPropControllerDataResponsiveShadowsData(data) {
+  return (0, import_ts_pattern22.match)(data).with(
+    { [ControlDataTypeKey]: ShadowsPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createShadowsPropControllerDataFromResponsiveShadowsData(definition, responsiveShadowsData) {
+  return (0, import_ts_pattern22.match)(definition).with(
+    { version: 1 },
+    () => ({
+      [ControlDataTypeKey]: ShadowsPropControllerDataV1Type,
+      value: responsiveShadowsData
+    })
+  ).otherwise(() => responsiveShadowsData);
+}
+function getShadowsPropControllerDataSwatchIds(data) {
+  return getShadowsPropControllerDataResponsiveShadowsData(data)?.flatMap((override) => override.value).map((item) => item.payload.color?.swatchId).filter(
+    (swatchId) => swatchId != null
+  ) ?? [];
+}
+function copyResponsiveShadowsData(data, context) {
+  return data.map((override) => ({
+    ...override,
+    value: override.value.map((item) => {
+      const { color } = item.payload;
+      if (color == null)
+        return item;
+      return {
+        ...item,
+        payload: {
+          ...item.payload,
+          color: {
+            ...color,
+            swatchId: context.replacementContext.swatchIds.get(color.swatchId) ?? color.swatchId
+          }
+        }
+      };
+    })
+  }));
+}
+function copyShadowsPropControllerData(data, context) {
+  return (0, import_ts_pattern22.match)(data).with(void 0, () => void 0).with(
+    { [ControlDataTypeKey]: ShadowsPropControllerDataV1Type },
+    (v1) => ({
+      [ControlDataTypeKey]: ShadowsPropControllerDataV1Type,
+      value: copyResponsiveShadowsData(v1.value, context)
+    })
+  ).otherwise((v0) => copyResponsiveShadowsData(v0, context));
+}
+
+// src/table/table.ts
+var import_zod26 = require("zod");
+var import_ts_pattern23 = require("ts-pattern");
+var tableIdSchema = import_zod26.z.string();
+var tablePropControllerDataV0Schema = tableIdSchema;
+var TablePropControllerDataV1Type = "prop-controllers::table::v1";
+var tablePropControllerDataV1Schema = import_zod26.z.object({
+  [ControlDataTypeKey]: import_zod26.z.literal(TablePropControllerDataV1Type),
+  value: tableIdSchema
+});
+var tablePropControllerDataSchema = import_zod26.z.union([
+  tablePropControllerDataV0Schema,
+  tablePropControllerDataV1Schema
+]);
+function Table(options = {}) {
+  return { type: Types.Table, version: 1, options };
+}
+function getTablePropControllerDataTableId(data) {
+  return (0, import_ts_pattern23.match)(data).with(
+    { [ControlDataTypeKey]: TablePropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createTablePropControllerDataFromTableId(value, definition) {
+  return (0, import_ts_pattern23.match)(definition).with(
+    { version: 1 },
+    import_ts_pattern23.P.nullish,
+    () => ({
+      [ControlDataTypeKey]: TablePropControllerDataV1Type,
+      value
+    })
+  ).otherwise(() => value);
+}
+function copyTableId(data, context) {
+  if (data == null)
+    return data;
+  return context.replacementContext.tableIds.get(data) ?? data;
+}
+function copyTablePropControllerData(data, context) {
+  return (0, import_ts_pattern23.match)(data).with(void 0, () => void 0).with(
+    { [ControlDataTypeKey]: TablePropControllerDataV1Type },
+    (v1) => ({
+      [ControlDataTypeKey]: TablePropControllerDataV1Type,
+      value: copyTableId(v1.value, context)
+    })
+  ).otherwise((v0) => copyTableId(v0, context));
+}
+function getTablePropControllerDataTableIds(data) {
+  const value = getTablePropControllerDataTableId(data);
+  return value ? [value] : [];
+}
+
+// src/table-form-fields/table-form-fields.ts
+var import_zod27 = require("zod");
+var import_ts_pattern24 = require("ts-pattern");
+var tableFormFieldSchema = import_zod27.z.object({
+  id: import_zod27.z.string(),
+  tableColumnId: import_zod27.z.string(),
+  label: import_zod27.z.string().optional(),
+  placeholder: import_zod27.z.string().optional(),
+  defaultValue: import_zod27.z.union([import_zod27.z.string(), import_zod27.z.boolean(), import_zod27.z.array(import_zod27.z.string())]).optional(),
+  required: import_zod27.z.boolean().optional(),
+  hidden: import_zod27.z.boolean().optional(),
+  type: import_zod27.z.union([import_zod27.z.literal("select"), import_zod27.z.literal("radio")]).optional(),
+  hideLabel: import_zod27.z.boolean().optional(),
+  autofill: import_zod27.z.boolean().optional()
+});
+var tableFormFieldsDataSchema = import_zod27.z.object({
+  fields: import_zod27.z.array(tableFormFieldSchema),
+  grid: createResponsiveValueSchema(
+    import_zod27.z.object({
+      count: import_zod27.z.number(),
+      spans: import_zod27.z.array(import_zod27.z.array(import_zod27.z.number()))
+    })
+  )
+});
+var tableFormFieldsPropControllerDataV0Schema = tableFormFieldsDataSchema;
+var TableFormFieldsPropControllerDataV1Type = "prop-controllers::table-form-fields::v1";
+var tableFormFieldsPropControllerDataV1Schema = import_zod27.z.object({
+  [ControlDataTypeKey]: import_zod27.z.literal(TableFormFieldsPropControllerDataV1Type),
+  value: tableFormFieldsDataSchema
+});
+var tableFormFieldsPropControllerDataSchema = import_zod27.z.union([
+  tableFormFieldsPropControllerDataV0Schema,
+  tableFormFieldsPropControllerDataV1Schema
+]);
+function TableFormFields(options = {}) {
+  return { type: Types.TableFormFields, version: 1, options };
+}
+function getTableFormFieldsPropControllerDataTableFormFieldsData(data) {
+  return (0, import_ts_pattern24.match)(data).with(
+    { [ControlDataTypeKey]: TableFormFieldsPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createTableFormFieldsPropControllerDataFromTableFormFieldsData(value, definition) {
+  return (0, import_ts_pattern24.match)(definition).with(
+    { version: 1 },
+    import_ts_pattern24.P.nullish,
+    () => ({
+      [ControlDataTypeKey]: TableFormFieldsPropControllerDataV1Type,
+      value
+    })
+  ).otherwise(() => value);
+}
+function copyTableFormFieldsData(data, context) {
+  if (data == null)
+    return data;
+  return {
+    ...data,
+    fields: data.fields.map((field) => ({
+      ...field,
+      tableColumnId: context.replacementContext.tableColumnIds.get(field.tableColumnId) ?? field.tableColumnId
+    }))
+  };
+}
+function copyTableFormFieldsPropControllerData(data, context) {
+  return (0, import_ts_pattern24.match)(data).with(void 0, () => void 0).with(
+    { [ControlDataTypeKey]: TableFormFieldsPropControllerDataV1Type },
+    (v1) => ({
+      [ControlDataTypeKey]: TableFormFieldsPropControllerDataV1Type,
+      value: copyTableFormFieldsData(v1.value, context)
+    })
+  ).otherwise((v0) => copyTableFormFieldsData(v0, context));
+}
+
+// src/text-area/text-area.ts
+var import_zod28 = require("zod");
+var import_ts_pattern25 = require("ts-pattern");
+var textAreaPropControllerDataV0Schema = import_zod28.z.string();
+var TextAreaPropControllerDataV1Type = "prop-controllers::text-area::v1";
+var textAreaPropControllerDataV1Schema = import_zod28.z.object({
+  [ControlDataTypeKey]: import_zod28.z.literal(TextAreaPropControllerDataV1Type),
+  value: import_zod28.z.string()
+});
+var textAreaPropControllerDataSchema = import_zod28.z.union([
+  textAreaPropControllerDataV0Schema,
+  textAreaPropControllerDataV1Schema
+]);
+function TextArea(options = {}) {
+  return { type: Types.TextArea, version: 1, options };
+}
+function getTextAreaPropControllerDataString(data) {
+  return (0, import_ts_pattern25.match)(data).with(
+    { [ControlDataTypeKey]: TextAreaPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createTextAreaPropControllerDataFromString(value, definition) {
+  return (0, import_ts_pattern25.match)(definition).with(
+    { version: 1 },
+    () => ({
+      [ControlDataTypeKey]: TextAreaPropControllerDataV1Type,
+      value
+    })
+  ).otherwise(() => value);
+}
+
+// src/text-input/text-input.ts
+var import_zod29 = require("zod");
+var import_ts_pattern26 = require("ts-pattern");
+var textInputPropControllerDataV0Schema = import_zod29.z.string();
+var TextInputPropControllerDataV1Type = "prop-controllers::text-input::v1";
+var textInputPropControllerDataV1Schema = import_zod29.z.object({
+  [ControlDataTypeKey]: import_zod29.z.literal(TextInputPropControllerDataV1Type),
+  value: import_zod29.z.string()
+});
+var textInputPropControllerDataSchema = import_zod29.z.union([
+  textInputPropControllerDataV0Schema,
+  textInputPropControllerDataV1Schema
+]);
+function TextInput(options = {}) {
+  return { type: Types.TextInput, version: 1, options };
+}
+function getTextInputPropControllerDataString(data) {
+  return (0, import_ts_pattern26.match)(data).with(
+    { [ControlDataTypeKey]: TextInputPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createTextInputPropControllerDataFromString(value, definition) {
+  return (0, import_ts_pattern26.match)(definition).with(
+    { version: 1 },
+    () => ({
+      [ControlDataTypeKey]: TextInputPropControllerDataV1Type,
+      value
+    })
+  ).otherwise(() => value);
+}
+
+// src/width/width.ts
+var import_ts_pattern27 = require("ts-pattern");
+var import_zod30 = require("zod");
+var widthPropControllerDataV0Schema = responsiveLengthDataSchema;
+var WidthPropControllerDataV1Type = "prop-controllers::width::v1";
+var widthPropControllerDataV1Schema = import_zod30.z.object({
+  [ControlDataTypeKey]: import_zod30.z.literal(WidthPropControllerDataV1Type),
+  value: responsiveLengthDataSchema
+});
+var widthPropControllerDataSchema = import_zod30.z.union([
+  widthPropControllerDataV0Schema,
+  widthPropControllerDataV1Schema
+]);
+var WidthPropControllerFormat = {
+  ClassName: "makeswift::prop-controllers::width::format::class-name",
+  ResponsiveValue: "makeswift::prop-controllers::width::format::responsive-value"
+};
+function Width(options = {}) {
+  return { type: Types.Width, version: 1, options };
+}
+Width.Format = WidthPropControllerFormat;
+function getWidthPropControllerDataResponsiveLengthData(data) {
+  return (0, import_ts_pattern27.match)(data).with(
+    { [ControlDataTypeKey]: WidthPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createWidthPropControllerDataFromResponsiveLengthData(responsiveLengthData, definition) {
+  return (0, import_ts_pattern27.match)(definition).with(
+    { version: 1 },
+    import_ts_pattern27.P.nullish,
+    () => ({
+      [ControlDataTypeKey]: WidthPropControllerDataV1Type,
+      value: responsiveLengthData
+    })
+  ).otherwise(() => responsiveLengthData);
+}
+
+// src/video/video.ts
+var import_zod31 = require("zod");
+var import_ts_pattern28 = require("ts-pattern");
+var videoDataSchema = import_zod31.z.object({
+  url: import_zod31.z.string().optional(),
+  muted: import_zod31.z.boolean().optional(),
+  playing: import_zod31.z.boolean().optional(),
+  loop: import_zod31.z.boolean().optional(),
+  controls: import_zod31.z.boolean().optional()
+});
+var videoPropControllerDataV0Schema = videoDataSchema;
+var VideoPropControllerDataV1Type = "prop-controllers::video::v1";
+var videoPropControllerDataV1Schema = import_zod31.z.object({
+  [ControlDataTypeKey]: import_zod31.z.literal(VideoPropControllerDataV1Type),
+  value: videoDataSchema
+});
+var videoPropControllerDataSchema = import_zod31.z.union([
+  videoPropControllerDataV1Schema,
+  videoPropControllerDataV0Schema
+]);
+function Video(options = {}) {
+  return { type: Types.Video, version: 1, options };
+}
+function getVideoPropControllerDataVideoData(data) {
+  return (0, import_ts_pattern28.match)(data).with(
+    { [ControlDataTypeKey]: VideoPropControllerDataV1Type },
+    (v1) => v1.value
+  ).otherwise((v0) => v0);
+}
+function createVideoPropControllerDataFromVideoData(value, definition) {
+  return (0, import_ts_pattern28.match)(definition).with(
+    { version: 1 },
+    import_ts_pattern28.P.nullish,
+    () => ({
+      [ControlDataTypeKey]: VideoPropControllerDataV1Type,
+      value
+    })
+  ).otherwise(() => value);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Backgrounds,
+  BackgroundsPropControllerDataV2Type,
+  Border,
+  BorderPropControllerFormat,
+  BorderRadius,
+  BorderRadiusPropControllerFormat,
+  Checkbox,
+  ControlDataTypeKey,
+  Date,
+  ElementID,
+  Font,
+  GapX,
+  GapY,
+  Grid,
+  Image,
+  Images,
+  Link,
+  Margin,
+  MarginPropControllerFormat,
+  NavigationLinks,
+  Number,
+  Padding,
+  PaddingPropControllerFormat,
+  PropDef,
+  ResponsiveColor,
+  ResponsiveLength,
+  ResponsiveLengthPropControllerDataV1Type,
+  ResponsiveNumber,
+  ResponsiveOpacity,
+  Shadows,
+  SocialLinks,
+  Table,
+  TableFormFields,
+  TextArea,
+  TextInput,
+  TextStyle,
+  Types,
+  Video,
+  Width,
+  WidthPropControllerFormat,
+  backgroundImageDataSchema,
+  backgroundsPropControllerDataSchema,
+  borderPropControllerDataSchema,
+  borderRadiusPropControllerDataSchema,
+  checkboxPropControllerDataSchema,
+  colorDataSchema,
+  copyBackgroundsPropControllerData,
+  copyBorderPropControllerData,
+  copyElementIDPropControllerData,
+  copyGridPropControllerData,
+  copyImagePropControllerData,
+  copyImagesPropControllerData,
+  copyLinkPropControllerData,
+  copyNavigationLinksPropControllerData,
+  copyResponsiveColorPropControllerData,
+  copyShadowsPropControllerData,
+  copyTableFormFieldsPropControllerData,
+  copyTablePropControllerData,
+  createBackgroundsPropControllerDataFromResponsiveBackgroundsData,
+  createBorderPropControllerDataFromResponsiveBorderData,
+  createBorderRadiusPropControllerDataFromResponsiveBorderRadiusData,
+  createCheckboxPropControllerDataFromBoolean,
+  createDatePropControllerDataFromString,
+  createElementIDPropControllerDataFromElementID,
+  createFontPropControllerDataFromResponsiveFontData,
+  createGapYPropControllerDataFromResponsiveGapData,
+  createGridPropControllerDataFromGridData,
+  createImagePropControllerDataFromImageData,
+  createImagesPropControllerDataFromImagesData,
+  createLinkPropControllerDataFromLinkData,
+  createMarginPropControllerDataFromResponsiveMarginData,
+  createNavigationLinksPropControllerDataFromNavigationLinksData,
+  createNumberPropControllerDataFromNumber,
+  createPaddingPropControllerDataFromResponsivePaddingData,
+  createResponsiveColorPropControllerDataFromResponsiveColorData,
+  createResponsiveLengthPropControllerDataFromResponsiveLengthData,
+  createResponsiveValueSchema,
+  createShadowsPropControllerDataFromResponsiveShadowsData,
+  createSocialLinksPropControllerDataFromSocialLinksData,
+  createTableFormFieldsPropControllerDataFromTableFormFieldsData,
+  createTablePropControllerDataFromTableId,
+  createTextAreaPropControllerDataFromString,
+  createTextInputPropControllerDataFromString,
+  createTextStylePropControllerDataFromResponsiveTextStyleData,
+  createVideoPropControllerDataFromVideoData,
+  createWidthPropControllerDataFromResponsiveLengthData,
+  dataSchema,
+  datePropControllerDataSchema,
+  elementDataSchema,
+  elementIDPropControllerDataSchema,
+  elementSchema,
+  fontPropControllerDataSchema,
+  gapDataSchema,
+  gapYPropControllerDataSchema,
+  getBackgroundsPropControllerDataResponsiveBackgroundsData,
+  getBackgroundsPropControllerFileIds,
+  getBackgroundsPropControllerSwatchIds,
+  getBorderPropControllerDataResponsiveBorderData,
+  getBorderPropControllerDataSwatchIds,
+  getBorderRadiusPropControllerDataResponsiveBorderRadiusData,
+  getCheckboxPropControllerDataBoolean,
+  getDatePropControllerDataString,
+  getElementIDPropControllerDataElementID,
+  getFontPropControllerDataResponsiveFontData,
+  getGapYPropControllerDataResponsiveGapData,
+  getGridPropControllerDataGridData,
+  getGridPropControllerElementChildren,
+  getGridPropControllerGetElementPath,
+  getImagePropControllerDataImageData,
+  getImagePropControllerFileIds,
+  getImagesPropControllerDataImagesData,
+  getImagesPropControllerFileIds,
+  getLinkPropControllerDataLinkData,
+  getLinkPropControllerPageIds,
+  getMarginPropControllerDataResponsiveMarginData,
+  getNavigationLinksPropControllerDataNavigationLinksData,
+  getNavigationLinksPropControllerPageIds,
+  getNavigationLinksPropControllerSwatchIds,
+  getNumberPropControllerDataNumber,
+  getPaddingPropControllerDataResponsivePaddingData,
+  getResponsiveColorDataSwatchIds,
+  getResponsiveColorPropControllerDataResponsiveColorData,
+  getResponsiveColorPropControllerDataSawtchIds,
+  getResponsiveLengthPropControllerDataResponsiveLengthData,
+  getShadowsPropControllerDataResponsiveShadowsData,
+  getShadowsPropControllerDataSwatchIds,
+  getSocialLinkTypes,
+  getSocialLinksPropControllerDataSocialLinksData,
+  getTableFormFieldsPropControllerDataTableFormFieldsData,
+  getTablePropControllerDataTableId,
+  getTablePropControllerDataTableIds,
+  getTextAreaPropControllerDataString,
+  getTextInputPropControllerDataString,
+  getTextStylePropControllerDataResponsiveTextStyleData,
+  getVideoPropControllerDataVideoData,
+  getWidthPropControllerDataResponsiveLengthData,
+  gridPropControllerDataSchema,
+  imageBackgroundDataSchema,
+  imageDataSchema,
+  imageDataV0Schema,
+  imageDataV1Schema,
+  imagePropControllerDataSchema,
+  imagesPropControllerDataSchema,
+  lengthDataSchema,
+  linkDataSchema,
+  linkPropControllerDataSchema,
+  marginPropControllerDataSchema,
+  mergeGridPropControllerTranslatedData,
+  navigationLinksPropControllerDataSchema,
+  numberPropControllerDataSchema,
+  paddingPropControllerDataSchema,
+  responsiveColorPropControllerDataSchema,
+  responsiveGapDataSchema,
+  responsiveLengthPropControllerDataSchema,
+  responsiveNumberValueSchema,
+  responsiveOpacityValueSchema,
+  shadowsPropControllerDataSchema,
+  socialLinksPropControllerDataSchema,
+  tableFormFieldsPropControllerDataSchema,
+  tablePropControllerDataSchema,
+  textAreaPropControllerDataSchema,
+  textInputPropControllerDataSchema,
+  textStylePropControllerDataSchema,
+  versionedPropDef,
+  videoPropControllerDataSchema,
+  widthPropControllerDataSchema
+});