@makeswift/prop-controllers 0.3.0-canary.0 → 0.3.0-canary.2

package/dist/index.cjs

@@ -48,10 +48,13 @@ __export(src_exports, {
   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,
@@ -95,9 +98,11 @@ __export(src_exports, {
   createResponsiveLengthPropControllerDataFromResponsiveLengthData: () => createResponsiveLengthPropControllerDataFromResponsiveLengthData,
   createResponsiveValueSchema: () => createResponsiveValueSchema,
   createShadowsPropControllerDataFromResponsiveShadowsData: () => createShadowsPropControllerDataFromResponsiveShadowsData,
+  createSocialLinksPropControllerDataFromSocialLinksData: () => createSocialLinksPropControllerDataFromSocialLinksData,
   createTableFormFieldsPropControllerDataFromTableFormFieldsData: () => createTableFormFieldsPropControllerDataFromTableFormFieldsData,
   createTablePropControllerDataFromTableId: () => createTablePropControllerDataFromTableId,
   createTextAreaPropControllerDataFromString: () => createTextAreaPropControllerDataFromString,
+  createTextInputPropControllerDataFromString: () => createTextInputPropControllerDataFromString,
   createTextStylePropControllerDataFromResponsiveTextStyleData: () => createTextStylePropControllerDataFromResponsiveTextStyleData,
   createVideoPropControllerDataFromVideoData: () => createVideoPropControllerDataFromVideoData,
   createWidthPropControllerDataFromResponsiveLengthData: () => createWidthPropControllerDataFromResponsiveLengthData,
@@ -141,10 +146,13 @@ __export(src_exports, {
   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,
@@ -167,10 +175,13 @@ __export(src_exports, {
   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,
@@ -205,7 +216,10 @@ var Types = {
   ResponsiveColor: "ResponsiveColor",
   ResponsiveLength: "ResponsiveLength",
   ResponsiveNumber: "ResponsiveNumber",
+  ResponsiveOpacity: "ResponsiveOpacity",
+  SocialLinks: "SocialLinks",
   TextArea: "TextArea",
+  TextInput: "TextInput",
   Table: "Table",
   TableFormFields: "TableFormFields",
   TextStyle: "TextStyle",
@@ -341,114 +355,128 @@ var ResponsiveNumber = versionedPropDef()(Types.ResponsiveNumber, responsiveNumb
   dataKey: "prop-controllers::responsive-number::v1"
 });
 
-// src/backgrounds/backgrounds.ts
+// 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_zod4.z.object({
-  type: import_zod4.z.literal("color"),
-  id: import_zod4.z.string(),
+var colorBackgroundDataSchema = import_zod5.z.object({
+  type: import_zod5.z.literal("color"),
+  id: import_zod5.z.string(),
   payload: colorDataSchema.nullable()
 });
-var gradientStopDataSchema = import_zod4.z.object({
-  id: import_zod4.z.string(),
-  location: import_zod4.z.number(),
+var gradientStopDataSchema = import_zod5.z.object({
+  id: import_zod5.z.string(),
+  location: import_zod5.z.number(),
   color: colorDataSchema.nullable()
 });
-var gradientDataSchema = import_zod4.z.object({
-  angle: import_zod4.z.number().optional(),
-  isRadial: import_zod4.z.boolean().optional(),
-  stops: import_zod4.z.array(gradientStopDataSchema)
+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_zod4.z.object({
-  type: import_zod4.z.literal("gradient"),
-  id: import_zod4.z.string(),
+var gradientBackgroundDataSchema = import_zod5.z.object({
+  type: import_zod5.z.literal("gradient"),
+  id: import_zod5.z.string(),
   payload: gradientDataSchema
 });
-var backgroundImagePositionDataSchema = import_zod4.z.object({
-  x: import_zod4.z.number(),
-  y: import_zod4.z.number()
+var backgroundImagePositionDataSchema = import_zod5.z.object({
+  x: import_zod5.z.number(),
+  y: import_zod5.z.number()
 });
-var backgroundSizeDataSchema = import_zod4.z.union([
-  import_zod4.z.literal("cover"),
-  import_zod4.z.literal("contain"),
-  import_zod4.z.literal("auto")
+var backgroundSizeDataSchema = import_zod5.z.union([
+  import_zod5.z.literal("cover"),
+  import_zod5.z.literal("contain"),
+  import_zod5.z.literal("auto")
 ]);
-var backgroundImageRepeatDataSchema = import_zod4.z.union([
-  import_zod4.z.literal("no-repeat"),
-  import_zod4.z.literal("repeat-x"),
-  import_zod4.z.literal("repeat-y"),
-  import_zod4.z.literal("repeat")
+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_zod4.z.object({
+var backgroundImageV0DataSchema = import_zod5.z.object({
   imageId: imageDataV0Schema,
   position: backgroundImagePositionDataSchema,
   size: backgroundSizeDataSchema.optional(),
   repeat: backgroundImageRepeatDataSchema.optional(),
-  opacity: import_zod4.z.number().optional(),
-  parallax: import_zod4.z.number().optional(),
-  priority: import_zod4.z.boolean().optional()
+  opacity: import_zod5.z.number().optional(),
+  parallax: import_zod5.z.number().optional(),
+  priority: import_zod5.z.boolean().optional()
 });
-var backgroundImageV1DataSchema = import_zod4.z.object({
-  version: import_zod4.z.literal(1),
+var backgroundImageV1DataSchema = import_zod5.z.object({
+  version: import_zod5.z.literal(1),
   image: imageDataV1Schema,
   position: backgroundImagePositionDataSchema,
   size: backgroundSizeDataSchema.optional(),
   repeat: backgroundImageRepeatDataSchema.optional(),
-  opacity: import_zod4.z.number().optional(),
-  parallax: import_zod4.z.number().optional(),
-  priority: import_zod4.z.boolean().optional()
+  opacity: import_zod5.z.number().optional(),
+  parallax: import_zod5.z.number().optional(),
+  priority: import_zod5.z.boolean().optional()
 });
-var backgroundImageDataSchema = import_zod4.z.union([
+var backgroundImageDataSchema = import_zod5.z.union([
   backgroundImageV0DataSchema,
   backgroundImageV1DataSchema
 ]);
-var imageBackgroundV0DataSchema = import_zod4.z.object({
-  type: import_zod4.z.literal("image"),
-  id: import_zod4.z.string(),
+var imageBackgroundV0DataSchema = import_zod5.z.object({
+  type: import_zod5.z.literal("image"),
+  id: import_zod5.z.string(),
   payload: backgroundImageV0DataSchema
 });
-var imageBackgroundV1DataSchema = import_zod4.z.object({
-  type: import_zod4.z.literal("image-v1"),
-  id: import_zod4.z.string(),
+var imageBackgroundV1DataSchema = import_zod5.z.object({
+  type: import_zod5.z.literal("image-v1"),
+  id: import_zod5.z.string(),
   payload: backgroundImageV1DataSchema
 });
-var imageBackgroundDataSchema = import_zod4.z.union([
+var imageBackgroundDataSchema = import_zod5.z.union([
   imageBackgroundV0DataSchema,
   imageBackgroundV1DataSchema
 ]);
-var backgroundVideoAspectRatioDataSchema = import_zod4.z.union([
-  import_zod4.z.literal("wide"),
-  import_zod4.z.literal("standard")
+var backgroundVideoAspectRatioDataSchema = import_zod5.z.union([
+  import_zod5.z.literal("wide"),
+  import_zod5.z.literal("standard")
 ]);
-var backgroundVideoDataSchema = import_zod4.z.object({
-  url: import_zod4.z.string().optional(),
+var backgroundVideoDataSchema = import_zod5.z.object({
+  url: import_zod5.z.string().optional(),
   maskColor: colorDataSchema.nullable().optional(),
-  opacity: import_zod4.z.number().optional(),
-  zoom: import_zod4.z.number().optional(),
+  opacity: import_zod5.z.number().optional(),
+  zoom: import_zod5.z.number().optional(),
   aspectRatio: backgroundVideoAspectRatioDataSchema.optional(),
-  parallax: import_zod4.z.number().optional()
+  parallax: import_zod5.z.number().optional()
 });
-var videoBackgroundDataSchema = import_zod4.z.object({
-  type: import_zod4.z.literal("video"),
-  id: import_zod4.z.string(),
+var videoBackgroundDataSchema = import_zod5.z.object({
+  type: import_zod5.z.literal("video"),
+  id: import_zod5.z.string(),
   payload: backgroundVideoDataSchema
 });
-var backgroundDataSchema = import_zod4.z.union([
+var backgroundDataSchema = import_zod5.z.union([
   colorBackgroundDataSchema,
   gradientBackgroundDataSchema,
   imageBackgroundDataSchema,
   videoBackgroundDataSchema
 ]);
 var responsiveBackgroundsDataSchema = createResponsiveValueSchema(
-  import_zod4.z.array(backgroundDataSchema)
+  import_zod5.z.array(backgroundDataSchema)
 );
 var backgroundsPropControllerDataV1Schema = responsiveBackgroundsDataSchema;
 var BackgroundsPropControllerDataV2Type = "prop-controllers::backgrounds::v2";
-var backgroundsPropControllerDataV2Schema = import_zod4.z.object({
-  [ControlDataTypeKey]: import_zod4.z.literal(BackgroundsPropControllerDataV2Type),
+var backgroundsPropControllerDataV2Schema = import_zod5.z.object({
+  [ControlDataTypeKey]: import_zod5.z.literal(BackgroundsPropControllerDataV2Type),
   value: responsiveBackgroundsDataSchema
 });
-var backgroundsPropControllerDataSchema = import_zod4.z.union([
+var backgroundsPropControllerDataSchema = import_zod5.z.union([
   backgroundsPropControllerDataV1Schema,
   backgroundsPropControllerDataV2Schema
 ]);
@@ -594,16 +622,16 @@ function copyBackgroundsPropControllerData(descriptor, data, context) {
 
 // src/border/border.ts
 var import_ts_pattern3 = require("ts-pattern");
-var import_zod5 = require("zod");
-var borderSideDataSchema = import_zod5.z.object({
-  width: import_zod5.z.number().nullable().optional(),
-  style: import_zod5.z.enum(["dashed", "dotted", "solid"]),
+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_zod5.z.object({
+var borderDataSchema = import_zod6.z.object({
   borderTop: borderSideDataSchema.nullable().optional(),
   borderRight: borderSideDataSchema.nullable().optional(),
   borderBottom: borderSideDataSchema.nullable().optional(),
@@ -617,11 +645,11 @@ var borderDataSchema = import_zod5.z.object({
 var responsiveBorderDataSchema = createResponsiveValueSchema(borderDataSchema);
 var borderPropControllerDataV0Schema = responsiveBorderDataSchema;
 var BorderPropControllerDataV1Type = "prop-controllers::border::v1";
-var borderPropControllerDataV1Schema = import_zod5.z.object({
-  [ControlDataTypeKey]: import_zod5.z.literal(BorderPropControllerDataV1Type),
+var borderPropControllerDataV1Schema = import_zod6.z.object({
+  [ControlDataTypeKey]: import_zod6.z.literal(BorderPropControllerDataV1Type),
   value: responsiveBorderDataSchema
 });
-var borderPropControllerDataSchema = import_zod5.z.union([
+var borderPropControllerDataSchema = import_zod6.z.union([
   borderPropControllerDataV0Schema,
   borderPropControllerDataV1Schema
 ]);
@@ -702,9 +730,9 @@ function copyBorderPropControllerData(data, context) {
 }
 
 // src/border-radius/border-radius.ts
-var import_zod6 = require("zod");
+var import_zod7 = require("zod");
 var import_ts_pattern4 = require("ts-pattern");
-var borderRadiusDataSchema = import_zod6.z.object({
+var borderRadiusDataSchema = import_zod7.z.object({
   borderTopLeftRadius: lengthDataSchema.nullable().optional(),
   borderTopRightRadius: lengthDataSchema.nullable().optional(),
   borderBottomLeftRadius: lengthDataSchema.nullable().optional(),
@@ -715,11 +743,11 @@ var responsiveBorderRadiusDataSchema = createResponsiveValueSchema(
 );
 var borderRadiusPropControllerDataV0Schema = responsiveBorderRadiusDataSchema;
 var BorderRadiusPropControllerDataV1Type = "prop-controllers::border-radius::v1";
-var borderRadiusPropControllerDataV1Schema = import_zod6.z.object({
-  [ControlDataTypeKey]: import_zod6.z.literal(BorderRadiusPropControllerDataV1Type),
+var borderRadiusPropControllerDataV1Schema = import_zod7.z.object({
+  [ControlDataTypeKey]: import_zod7.z.literal(BorderRadiusPropControllerDataV1Type),
   value: responsiveBorderRadiusDataSchema
 });
-var borderRadiusPropControllerDataSchema = import_zod6.z.union([
+var borderRadiusPropControllerDataSchema = import_zod7.z.union([
   borderRadiusPropControllerDataV0Schema,
   borderRadiusPropControllerDataV1Schema
 ]);
@@ -748,15 +776,15 @@ function createBorderRadiusPropControllerDataFromResponsiveBorderRadiusData(defi
 }
 
 // src/checkbox/checkbox.ts
-var import_zod7 = require("zod");
+var import_zod8 = require("zod");
 var import_ts_pattern5 = require("ts-pattern");
-var checkboxPropControllerDataV0Schema = import_zod7.z.boolean();
+var checkboxPropControllerDataV0Schema = import_zod8.z.boolean();
 var CheckboxPropControllerDataV1Type = "prop-controllers::checkbox::v1";
-var checkboxPropControllerDataV1Schema = import_zod7.z.object({
-  [ControlDataTypeKey]: import_zod7.z.literal(CheckboxPropControllerDataV1Type),
-  value: import_zod7.z.boolean()
+var checkboxPropControllerDataV1Schema = import_zod8.z.object({
+  [ControlDataTypeKey]: import_zod8.z.literal(CheckboxPropControllerDataV1Type),
+  value: import_zod8.z.boolean()
 });
-var checkboxPropControllerDataSchema = import_zod7.z.union([
+var checkboxPropControllerDataSchema = import_zod8.z.union([
   checkboxPropControllerDataV0Schema,
   checkboxPropControllerDataV1Schema
 ]);
@@ -781,15 +809,15 @@ function createCheckboxPropControllerDataFromBoolean(value, definition) {
 }
 
 // src/date/date.ts
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
 var import_ts_pattern6 = require("ts-pattern");
-var datePropControllerDataV0Schema = import_zod8.z.string();
+var datePropControllerDataV0Schema = import_zod9.z.string();
 var DatePropControllerDataV1Type = "prop-controllers::date::v1";
-var datePropControllerDataV1Schema = import_zod8.z.object({
-  [ControlDataTypeKey]: import_zod8.z.literal(DatePropControllerDataV1Type),
-  value: import_zod8.z.string()
+var datePropControllerDataV1Schema = import_zod9.z.object({
+  [ControlDataTypeKey]: import_zod9.z.literal(DatePropControllerDataV1Type),
+  value: import_zod9.z.string()
 });
-var datePropControllerDataSchema = import_zod8.z.union([
+var datePropControllerDataSchema = import_zod9.z.union([
   datePropControllerDataV0Schema,
   datePropControllerDataV1Schema
 ]);
@@ -814,16 +842,16 @@ function createDatePropControllerDataFromString(value, definition) {
 }
 
 // src/element-id/element-id.ts
-var import_zod9 = require("zod");
+var import_zod10 = require("zod");
 var import_ts_pattern7 = require("ts-pattern");
-var elementIDSchema = import_zod9.z.string();
+var elementIDSchema = import_zod10.z.string();
 var elementIDPropControllerDataV0Schema = elementIDSchema;
 var ElementIDPropControllerDataV1Type = "prop-controllers::element-id::v1";
-var elementIDPropControllerDataV1Schema = import_zod9.z.object({
-  [ControlDataTypeKey]: import_zod9.z.literal(ElementIDPropControllerDataV1Type),
+var elementIDPropControllerDataV1Schema = import_zod10.z.object({
+  [ControlDataTypeKey]: import_zod10.z.literal(ElementIDPropControllerDataV1Type),
   value: elementIDSchema
 });
-var elementIDPropControllerDataSchema = import_zod9.z.union([
+var elementIDPropControllerDataSchema = import_zod10.z.union([
   elementIDPropControllerDataV0Schema,
   elementIDPropControllerDataV1Schema
 ]);
@@ -868,16 +896,16 @@ function copyElementIDPropControllerData(data, context) {
 
 // src/font/font.ts
 var import_ts_pattern8 = require("ts-pattern");
-var import_zod10 = require("zod");
-var fontDataSchema = import_zod10.z.string();
+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_zod10.z.object({
-  [ControlDataTypeKey]: import_zod10.z.literal(FontPropControllerDataV1Type),
+var fontPropControllerDataV1Schema = import_zod11.z.object({
+  [ControlDataTypeKey]: import_zod11.z.literal(FontPropControllerDataV1Type),
   value: responsiveFontDataSchema
 });
-var fontPropControllerDataSchema = import_zod10.z.union([
+var fontPropControllerDataSchema = import_zod11.z.union([
   fontPropControllerDataV0Schema,
   fontPropControllerDataV1Schema
 ]);
@@ -903,14 +931,14 @@ function createFontPropControllerDataFromResponsiveFontData(responsiveFontData,
 
 // src/gap-y/gap-y.ts
 var import_ts_pattern9 = require("ts-pattern");
-var import_zod11 = require("zod");
+var import_zod12 = require("zod");
 var gapYPropControllerDataV0Schema = responsiveGapDataSchema;
 var GapYPropControllerDataV1Type = "prop-controllers::gap-y::v1";
-var gapYPropControllerDataV1Schema = import_zod11.z.object({
-  [ControlDataTypeKey]: import_zod11.z.literal(GapYPropControllerDataV1Type),
+var gapYPropControllerDataV1Schema = import_zod12.z.object({
+  [ControlDataTypeKey]: import_zod12.z.literal(GapYPropControllerDataV1Type),
   value: responsiveGapDataSchema
 });
-var gapYPropControllerDataSchema = import_zod11.z.union([
+var gapYPropControllerDataSchema = import_zod12.z.union([
   gapYPropControllerDataV0Schema,
   gapYPropControllerDataV1Schema
 ]);
@@ -934,23 +962,23 @@ function createGapYPropControllerDataFromResponsiveGapData(responsiveGapData, de
 }
 
 // src/grid/grid.ts
-var import_zod12 = require("zod");
+var import_zod13 = require("zod");
 var import_ts_pattern10 = require("ts-pattern");
-var gridColumnSchema = import_zod12.z.object({
-  count: import_zod12.z.number(),
-  spans: import_zod12.z.array(import_zod12.z.array(import_zod12.z.number()))
+var 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_zod12.z.object({
-  elements: import_zod12.z.array(elementSchema),
+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_zod12.z.object({
-  [ControlDataTypeKey]: import_zod12.z.literal(GridPropControllerDataV1Type),
+var gridPropControllerDataV1Schema = import_zod13.z.object({
+  [ControlDataTypeKey]: import_zod13.z.literal(GridPropControllerDataV1Type),
   value: gridDataSchema
 });
-var gridPropControllerDataSchema = import_zod12.z.union([
+var gridPropControllerDataSchema = import_zod13.z.union([
   gridPropControllerDataV0Schema,
   gridPropControllerDataV1Schema
 ]);
@@ -1021,16 +1049,16 @@ function getGridPropControllerGetElementPath(data, elementKey) {
 }
 
 // src/image/image.ts
-var import_zod13 = require("zod");
+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_zod13.z.object({
-  [ControlDataTypeKey]: import_zod13.z.literal(ImagePropControllerDataV2Type),
+var imagePropControllerDataV2Schema = import_zod14.z.object({
+  [ControlDataTypeKey]: import_zod14.z.literal(ImagePropControllerDataV2Type),
   value: imagePropControllerDataV1Schema
 });
-var imagePropControllerDataSchema = import_zod13.z.union([
+var imagePropControllerDataSchema = import_zod14.z.union([
   imagePropControllerDataV0Schema,
   imagePropControllerDataV1Schema,
   imagePropControllerDataV2Schema
@@ -1076,61 +1104,61 @@ function copyImagePropControllerData(data, context) {
 }
 
 // src/images/images.ts
-var import_zod15 = require("zod");
+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_zod14 = require("zod");
-var openPageLinkSchema = import_zod14.z.object({
-  type: import_zod14.z.literal("OPEN_PAGE"),
-  payload: import_zod14.z.object({
-    pageId: import_zod14.z.string().nullable().optional(),
-    openInNewTab: import_zod14.z.boolean()
+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_zod14.z.object({
-  type: import_zod14.z.literal("OPEN_URL"),
-  payload: import_zod14.z.object({
-    url: import_zod14.z.string(),
-    openInNewTab: import_zod14.z.boolean()
+var 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_zod14.z.object({
-  type: import_zod14.z.literal("SEND_EMAIL"),
-  payload: import_zod14.z.object({
-    to: import_zod14.z.string(),
-    subject: import_zod14.z.string().optional(),
-    body: import_zod14.z.string().optional()
+var 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_zod14.z.object({
-  type: import_zod14.z.literal("CALL_PHONE"),
-  payload: import_zod14.z.object({
-    phoneNumber: import_zod14.z.string()
+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_zod14.z.object({
-  type: import_zod14.z.literal("SCROLL_TO_ELEMENT"),
-  payload: import_zod14.z.object({
-    elementIdConfig: import_zod14.z.object({
-      elementKey: import_zod14.z.string(),
-      propName: import_zod14.z.string()
+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_zod14.z.union([
-      import_zod14.z.literal("start"),
-      import_zod14.z.literal("center"),
-      import_zod14.z.literal("end")
+    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_zod14.z.union([
+var linkDataSchema = import_zod15.z.union([
   openPageLinkSchema,
   openURLLinkSchema,
   sendEmailLinkSchema,
@@ -1139,11 +1167,11 @@ var linkDataSchema = import_zod14.z.union([
 ]);
 var linkPropControllerDataV0Schema = linkDataSchema;
 var LinkPropControllerDataV1Type = "prop-controllers::link::v1";
-var linkPropControllerDataV1Schema = import_zod14.z.object({
-  [ControlDataTypeKey]: import_zod14.z.literal(LinkPropControllerDataV1Type),
+var linkPropControllerDataV1Schema = import_zod15.z.object({
+  [ControlDataTypeKey]: import_zod15.z.literal(LinkPropControllerDataV1Type),
   value: linkDataSchema
 });
-var linkPropControllerDataSchema = import_zod14.z.union([
+var linkPropControllerDataSchema = import_zod15.z.union([
   linkPropControllerDataV0Schema,
   linkPropControllerDataV1Schema
 ]);
@@ -1227,37 +1255,37 @@ function copyLinkPropControllerData(data, context) {
 }
 
 // src/images/images.ts
-var imagesDataV0ItemSchema = import_zod15.z.object({
-  key: import_zod15.z.string(),
-  props: import_zod15.z.object({
+var imagesDataV0ItemSchema = import_zod16.z.object({
+  key: import_zod16.z.string(),
+  props: import_zod16.z.object({
     link: linkDataSchema.optional(),
     file: imageDataV0Schema.optional(),
-    altText: import_zod15.z.string().optional()
+    altText: import_zod16.z.string().optional()
   })
 });
-var imagesDataV0Schema = import_zod15.z.array(imagesDataV0ItemSchema);
-var imagesDataV1ItemSchema = import_zod15.z.object({
-  key: import_zod15.z.string(),
-  version: import_zod15.z.literal(1),
-  props: import_zod15.z.object({
+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_zod15.z.string().optional()
+    altText: import_zod16.z.string().optional()
   })
 });
-var imagesDataItemSchema = import_zod15.z.union([
+var imagesDataItemSchema = import_zod16.z.union([
   imagesDataV0ItemSchema,
   imagesDataV1ItemSchema
 ]);
-var imagesDataSchema = import_zod15.z.array(imagesDataItemSchema);
-var imagesPropControllerDataV0Schema = import_zod15.z.array(imagesDataV0ItemSchema);
+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_zod15.z.object({
-  [ControlDataTypeKey]: import_zod15.z.literal(ImagesPropControllerDataV2Type),
+var imagesPropControllerDataV2Schema = import_zod16.z.object({
+  [ControlDataTypeKey]: import_zod16.z.literal(ImagesPropControllerDataV2Type),
   value: imagesPropControllerDataV1Schema
 });
-var imagesPropControllerDataSchema = import_zod15.z.union([
+var imagesPropControllerDataSchema = import_zod16.z.union([
   imagesPropControllerDataV0Schema,
   imagesPropControllerDataV1Schema,
   imagesPropControllerDataV2Schema
@@ -1330,15 +1358,15 @@ function copyImagesPropControllerData(data, context) {
 
 // src/margin/margin.ts
 var import_ts_pattern14 = require("ts-pattern");
-var import_zod16 = require("zod");
-var marginSideDataSchema = import_zod16.z.union([
-  import_zod16.z.object({
-    value: import_zod16.z.number(),
-    unit: import_zod16.z.literal("px")
+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_zod16.z.literal("auto")
+  import_zod17.z.literal("auto")
 ]);
-var marginDataSchema = import_zod16.z.object({
+var marginDataSchema = import_zod17.z.object({
   marginTop: marginSideDataSchema.nullable().optional(),
   marginRight: marginSideDataSchema.nullable().optional(),
   marginBottom: marginSideDataSchema.nullable().optional(),
@@ -1352,11 +1380,11 @@ var marginDataSchema = import_zod16.z.object({
 var responsiveMarginDataSchema = createResponsiveValueSchema(marginDataSchema);
 var marginPropControllerDataV0Schema = responsiveMarginDataSchema;
 var MarginPropControllerDataV1Type = "prop-controllers::margin::v1";
-var marginPropControllerDataV1Schema = import_zod16.z.object({
-  [ControlDataTypeKey]: import_zod16.z.literal(MarginPropControllerDataV1Type),
+var marginPropControllerDataV1Schema = import_zod17.z.object({
+  [ControlDataTypeKey]: import_zod17.z.literal(MarginPropControllerDataV1Type),
   value: responsiveMarginDataSchema
 });
-var marginPropControllerDataSchema = import_zod16.z.union([
+var marginPropControllerDataSchema = import_zod17.z.union([
   marginPropControllerDataV0Schema,
   marginPropControllerDataV1Schema
 ]);
@@ -1387,21 +1415,21 @@ function createMarginPropControllerDataFromResponsiveMarginData(responsiveMargin
 
 // src/navigation-links/navigation-links.ts
 var import_ts_pattern17 = require("ts-pattern");
-var import_zod19 = require("zod");
+var import_zod20 = require("zod");
 
 // src/text-style/text-style.ts
 var import_ts_pattern15 = require("ts-pattern");
-var import_zod17 = require("zod");
-var textStyleDataSchema = import_zod17.z.object({
-  fontFamily: import_zod17.z.string().optional().nullable(),
-  letterSpacing: import_zod17.z.number().optional().nullable(),
-  fontSize: import_zod17.z.object({
-    value: import_zod17.z.number(),
-    unit: import_zod17.z.literal("px")
+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_zod17.z.number().optional().nullable(),
-  textTransform: import_zod17.z.array(import_zod17.z.literal("uppercase")),
-  fontStyle: import_zod17.z.array(import_zod17.z.literal("italic"))
+  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,
@@ -1413,11 +1441,11 @@ var textStyleDataSchema = import_zod17.z.object({
 var responsiveTextStyleDataSchema = createResponsiveValueSchema(textStyleDataSchema);
 var textStylePropControllerDataV0Schema = responsiveTextStyleDataSchema;
 var TextStylePropControllerDataV1Type = "prop-controllers::text-style::v1";
-var textStylePropControllerDataV1Schema = import_zod17.z.object({
-  [ControlDataTypeKey]: import_zod17.z.literal(TextStylePropControllerDataV1Type),
+var textStylePropControllerDataV1Schema = import_zod18.z.object({
+  [ControlDataTypeKey]: import_zod18.z.literal(TextStylePropControllerDataV1Type),
   value: responsiveTextStyleDataSchema
 });
-var textStylePropControllerDataSchema = import_zod17.z.union([
+var textStylePropControllerDataSchema = import_zod18.z.union([
   textStylePropControllerDataV0Schema,
   textStylePropControllerDataV1Schema
 ]);
@@ -1441,16 +1469,16 @@ function createTextStylePropControllerDataFromResponsiveTextStyleData(responsive
 }
 
 // src/responsive-color.ts
-var import_zod18 = require("zod");
+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_zod18.z.object({
-  [ControlDataTypeKey]: import_zod18.z.literal(ResponsiveColorPropControllerDataV1Type),
+var responsiveColorPropControllerDataV1Schema = import_zod19.z.object({
+  [ControlDataTypeKey]: import_zod19.z.literal(ResponsiveColorPropControllerDataV1Type),
   value: responsiveColorDataSchema
 });
-var responsiveColorPropControllerDataSchema = import_zod18.z.union([
+var responsiveColorPropControllerDataSchema = import_zod19.z.union([
   responsiveColorPropControllerDataV0Schema,
   responsiveColorPropControllerDataV1Schema
 ]);
@@ -1505,7 +1533,7 @@ function copyResponsiveColorPropControllerData(data, context) {
 }
 
 // src/navigation-links/navigation-links.ts
-var buttonVariantSchema = import_zod19.z.enum([
+var buttonVariantSchema = import_zod20.z.enum([
   "flat",
   "outline",
   "shadow",
@@ -1514,13 +1542,13 @@ var buttonVariantSchema = import_zod19.z.enum([
   "bubbly",
   "skewed"
 ]);
-var buttonShapeSchema = import_zod19.z.enum(["pill", "rounded", "square"]);
-var buttonSizeSchema = import_zod19.z.enum(["small", "medium", "large"]);
-var navigationButtonSchema = import_zod19.z.object({
-  id: import_zod19.z.string(),
-  type: import_zod19.z.literal("button"),
-  payload: import_zod19.z.object({
-    label: import_zod19.z.string(),
+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(),
@@ -1530,28 +1558,28 @@ var navigationButtonSchema = import_zod19.z.object({
     textStyle: createResponsiveValueSchema(textStyleDataSchema).optional()
   })
 });
-var navigationDropdownCaretTypeSchema = import_zod19.z.union([
-  import_zod19.z.literal("caret"),
-  import_zod19.z.literal("plus"),
-  import_zod19.z.literal("arrow-down"),
-  import_zod19.z.literal("chevron-down")
+var 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_zod19.z.object({
-  id: import_zod19.z.string(),
-  payload: import_zod19.z.object({
-    label: import_zod19.z.string(),
+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_zod19.z.object({
-  id: import_zod19.z.string(),
-  type: import_zod19.z.literal("dropdown"),
-  payload: import_zod19.z.object({
-    label: import_zod19.z.string(),
+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_zod19.z.array(navigationDropdownLinkSchema).optional(),
+    links: import_zod20.z.array(navigationDropdownLinkSchema).optional(),
     variant: createResponsiveValueSchema(buttonVariantSchema).optional(),
     shape: createResponsiveValueSchema(buttonShapeSchema).optional(),
     size: createResponsiveValueSchema(buttonSizeSchema).optional(),
@@ -1560,16 +1588,16 @@ var navigationDropdownSchema = import_zod19.z.object({
     textStyle: createResponsiveValueSchema(textStyleDataSchema).optional()
   })
 });
-var navigationLinksDataSchema = import_zod19.z.array(
-  import_zod19.z.union([navigationButtonSchema, navigationDropdownSchema])
+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_zod19.z.object({
-  [ControlDataTypeKey]: import_zod19.z.literal(NavigationLinksPropControllerDataV1Type),
+var navigationLinksPropControllerDataV1Schema = import_zod20.z.object({
+  [ControlDataTypeKey]: import_zod20.z.literal(NavigationLinksPropControllerDataV1Type),
   value: navigationLinksDataSchema
 });
-var navigationLinksPropControllerDataSchema = import_zod19.z.union([
+var navigationLinksPropControllerDataSchema = import_zod20.z.union([
   navigationLinksPropControllerDataV0Schema,
   navigationLinksPropControllerDataV1Schema
 ]);
@@ -1684,15 +1712,15 @@ function copyNavigationLinksPropControllerData(data, context) {
 }
 
 // src/number.ts
-var import_zod20 = require("zod");
+var import_zod21 = require("zod");
 var import_ts_pattern18 = require("ts-pattern");
-var numberPropControllerDataV0Schema = import_zod20.z.number();
+var numberPropControllerDataV0Schema = import_zod21.z.number();
 var NumberPropControllerDataV1Type = "prop-controllers::number::v1";
-var numberPropControllerDataV1Schema = import_zod20.z.object({
-  [ControlDataTypeKey]: import_zod20.z.literal(NumberPropControllerDataV1Type),
-  value: import_zod20.z.number()
+var numberPropControllerDataV1Schema = import_zod21.z.object({
+  [ControlDataTypeKey]: import_zod21.z.literal(NumberPropControllerDataV1Type),
+  value: import_zod21.z.number()
 });
-var numberPropControllerDataSchema = import_zod20.z.union([
+var numberPropControllerDataSchema = import_zod21.z.union([
   numberPropControllerDataV0Schema,
   numberPropControllerDataV1Schema
 ]);
@@ -1718,12 +1746,12 @@ function createNumberPropControllerDataFromNumber(value, definition) {
 
 // src/padding/padding.ts
 var import_ts_pattern19 = require("ts-pattern");
-var import_zod21 = require("zod");
-var paddingSideDataSchema = import_zod21.z.object({
-  value: import_zod21.z.number(),
-  unit: import_zod21.z.literal("px")
+var import_zod22 = require("zod");
+var paddingSideDataSchema = import_zod22.z.object({
+  value: import_zod22.z.number(),
+  unit: import_zod22.z.literal("px")
 });
-var paddingDataSchema = import_zod21.z.object({
+var paddingDataSchema = import_zod22.z.object({
   paddingTop: paddingSideDataSchema.nullable().optional(),
   paddingRight: paddingSideDataSchema.nullable().optional(),
   paddingBottom: paddingSideDataSchema.nullable().optional(),
@@ -1737,11 +1765,11 @@ var paddingDataSchema = import_zod21.z.object({
 var responsivePaddingDataSchema = createResponsiveValueSchema(paddingDataSchema);
 var paddingPropControllerDataV0Schema = responsivePaddingDataSchema;
 var PaddingPropControllerDataV1Type = "prop-controllers::padding::v1";
-var paddingPropControllerDataV1Schema = import_zod21.z.object({
-  [ControlDataTypeKey]: import_zod21.z.literal(PaddingPropControllerDataV1Type),
+var paddingPropControllerDataV1Schema = import_zod22.z.object({
+  [ControlDataTypeKey]: import_zod22.z.literal(PaddingPropControllerDataV1Type),
   value: responsivePaddingDataSchema
 });
-var paddingPropControllerDataSchema = import_zod21.z.union([
+var paddingPropControllerDataSchema = import_zod22.z.union([
   paddingPropControllerDataV0Schema,
   paddingPropControllerDataV1Schema
 ]);
@@ -1771,16 +1799,16 @@ function createPaddingPropControllerDataFromResponsivePaddingData(responsivePadd
 }
 
 // src/responsive-length.ts
-var import_zod22 = require("zod");
+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_zod22.z.object({
-  [ControlDataTypeKey]: import_zod22.z.literal(ResponsiveLengthPropControllerDataV1Type),
+var responsiveLengthPropControllerDataV1Schema = import_zod23.z.object({
+  [ControlDataTypeKey]: import_zod23.z.literal(ResponsiveLengthPropControllerDataV1Type),
   value: responsiveLengthDataSchema
 });
-var responsiveLengthPropControllerDataSchema = import_zod22.z.union([
+var responsiveLengthPropControllerDataSchema = import_zod23.z.union([
   responsiveLengthPropControllerDataV0Schema,
   responsiveLengthPropControllerDataV1Schema
 ]);
@@ -1803,31 +1831,120 @@ function createResponsiveLengthPropControllerDataFromResponsiveLengthData(defini
   ).otherwise(() => responsiveLengthData);
 }
 
-// src/shadows.ts
+// src/social-links/social-links.ts
+var import_zod24 = require("zod");
 var import_ts_pattern21 = require("ts-pattern");
-var import_zod23 = require("zod");
-var shadowDataSchema = import_zod23.z.object({
+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_zod23.z.number().optional(),
-  spreadRadius: import_zod23.z.number().optional(),
-  offsetX: import_zod23.z.number().optional(),
-  offsetY: import_zod23.z.number().optional(),
-  inset: import_zod23.z.boolean().optional()
-});
-var shadowsDataSchema = import_zod23.z.array(
-  import_zod23.z.object({
-    id: import_zod23.z.string(),
+  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_zod23.z.object({
-  [ControlDataTypeKey]: import_zod23.z.literal(ShadowsPropControllerDataV1Type),
+var shadowsPropControllerDataV1Schema = import_zod25.z.object({
+  [ControlDataTypeKey]: import_zod25.z.literal(ShadowsPropControllerDataV1Type),
   value: responsiveShadowsDataSchema
 });
-var shadowsPropControllerDataSchema = import_zod23.z.union([
+var shadowsPropControllerDataSchema = import_zod25.z.union([
   shadowsPropControllerDataV0Schema,
   shadowsPropControllerDataV1Schema
 ]);
@@ -1840,13 +1957,13 @@ function Shadows(options = {}) {
 }
 Shadows.Format = ShadowsPropControllerFormat;
 function getShadowsPropControllerDataResponsiveShadowsData(data) {
-  return (0, import_ts_pattern21.match)(data).with(
+  return (0, import_ts_pattern22.match)(data).with(
     { [ControlDataTypeKey]: ShadowsPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createShadowsPropControllerDataFromResponsiveShadowsData(definition, responsiveShadowsData) {
-  return (0, import_ts_pattern21.match)(definition).with(
+  return (0, import_ts_pattern22.match)(definition).with(
     { version: 1 },
     () => ({
       [ControlDataTypeKey]: ShadowsPropControllerDataV1Type,
@@ -1880,7 +1997,7 @@ function copyResponsiveShadowsData(data, context) {
   }));
 }
 function copyShadowsPropControllerData(data, context) {
-  return (0, import_ts_pattern21.match)(data).with(void 0, () => void 0).with(
+  return (0, import_ts_pattern22.match)(data).with(void 0, () => void 0).with(
     { [ControlDataTypeKey]: ShadowsPropControllerDataV1Type },
     (v1) => ({
       [ControlDataTypeKey]: ShadowsPropControllerDataV1Type,
@@ -1890,16 +2007,16 @@ function copyShadowsPropControllerData(data, context) {
 }
 
 // src/table/table.ts
-var import_zod24 = require("zod");
-var import_ts_pattern22 = require("ts-pattern");
-var tableIdSchema = import_zod24.z.string();
+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_zod24.z.object({
-  [ControlDataTypeKey]: import_zod24.z.literal(TablePropControllerDataV1Type),
+var tablePropControllerDataV1Schema = import_zod26.z.object({
+  [ControlDataTypeKey]: import_zod26.z.literal(TablePropControllerDataV1Type),
   value: tableIdSchema
 });
-var tablePropControllerDataSchema = import_zod24.z.union([
+var tablePropControllerDataSchema = import_zod26.z.union([
   tablePropControllerDataV0Schema,
   tablePropControllerDataV1Schema
 ]);
@@ -1907,15 +2024,15 @@ function Table(options = {}) {
   return { type: Types.Table, version: 1, options };
 }
 function getTablePropControllerDataTableId(data) {
-  return (0, import_ts_pattern22.match)(data).with(
+  return (0, import_ts_pattern23.match)(data).with(
     { [ControlDataTypeKey]: TablePropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createTablePropControllerDataFromTableId(value, definition) {
-  return (0, import_ts_pattern22.match)(definition).with(
+  return (0, import_ts_pattern23.match)(definition).with(
     { version: 1 },
-    import_ts_pattern22.P.nullish,
+    import_ts_pattern23.P.nullish,
     () => ({
       [ControlDataTypeKey]: TablePropControllerDataV1Type,
       value
@@ -1928,7 +2045,7 @@ function copyTableId(data, context) {
   return context.replacementContext.tableIds.get(data) ?? data;
 }
 function copyTablePropControllerData(data, context) {
-  return (0, import_ts_pattern22.match)(data).with(void 0, () => void 0).with(
+  return (0, import_ts_pattern23.match)(data).with(void 0, () => void 0).with(
     { [ControlDataTypeKey]: TablePropControllerDataV1Type },
     (v1) => ({
       [ControlDataTypeKey]: TablePropControllerDataV1Type,
@@ -1942,36 +2059,36 @@ function getTablePropControllerDataTableIds(data) {
 }
 
 // src/table-form-fields/table-form-fields.ts
-var import_zod25 = require("zod");
-var import_ts_pattern23 = require("ts-pattern");
-var tableFormFieldSchema = import_zod25.z.object({
-  id: import_zod25.z.string(),
-  tableColumnId: import_zod25.z.string(),
-  label: import_zod25.z.string().optional(),
-  placeholder: import_zod25.z.string().optional(),
-  defaultValue: import_zod25.z.union([import_zod25.z.string(), import_zod25.z.boolean(), import_zod25.z.array(import_zod25.z.string())]).optional(),
-  required: import_zod25.z.boolean().optional(),
-  hidden: import_zod25.z.boolean().optional(),
-  type: import_zod25.z.union([import_zod25.z.literal("select"), import_zod25.z.literal("radio")]).optional(),
-  hideLabel: import_zod25.z.boolean().optional(),
-  autofill: import_zod25.z.boolean().optional()
-});
-var tableFormFieldsDataSchema = import_zod25.z.object({
-  fields: import_zod25.z.array(tableFormFieldSchema),
+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_zod25.z.object({
-      count: import_zod25.z.number(),
-      spans: import_zod25.z.array(import_zod25.z.array(import_zod25.z.number()))
+    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_zod25.z.object({
-  [ControlDataTypeKey]: import_zod25.z.literal(TableFormFieldsPropControllerDataV1Type),
+var tableFormFieldsPropControllerDataV1Schema = import_zod27.z.object({
+  [ControlDataTypeKey]: import_zod27.z.literal(TableFormFieldsPropControllerDataV1Type),
   value: tableFormFieldsDataSchema
 });
-var tableFormFieldsPropControllerDataSchema = import_zod25.z.union([
+var tableFormFieldsPropControllerDataSchema = import_zod27.z.union([
   tableFormFieldsPropControllerDataV0Schema,
   tableFormFieldsPropControllerDataV1Schema
 ]);
@@ -1979,15 +2096,15 @@ function TableFormFields(options = {}) {
   return { type: Types.TableFormFields, version: 1, options };
 }
 function getTableFormFieldsPropControllerDataTableFormFieldsData(data) {
-  return (0, import_ts_pattern23.match)(data).with(
+  return (0, import_ts_pattern24.match)(data).with(
     { [ControlDataTypeKey]: TableFormFieldsPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createTableFormFieldsPropControllerDataFromTableFormFieldsData(value, definition) {
-  return (0, import_ts_pattern23.match)(definition).with(
+  return (0, import_ts_pattern24.match)(definition).with(
     { version: 1 },
-    import_ts_pattern23.P.nullish,
+    import_ts_pattern24.P.nullish,
     () => ({
       [ControlDataTypeKey]: TableFormFieldsPropControllerDataV1Type,
       value
@@ -2006,7 +2123,7 @@ function copyTableFormFieldsData(data, context) {
   };
 }
 function copyTableFormFieldsPropControllerData(data, context) {
-  return (0, import_ts_pattern23.match)(data).with(void 0, () => void 0).with(
+  return (0, import_ts_pattern24.match)(data).with(void 0, () => void 0).with(
     { [ControlDataTypeKey]: TableFormFieldsPropControllerDataV1Type },
     (v1) => ({
       [ControlDataTypeKey]: TableFormFieldsPropControllerDataV1Type,
@@ -2016,15 +2133,15 @@ function copyTableFormFieldsPropControllerData(data, context) {
 }
 
 // src/text-area/text-area.ts
-var import_zod26 = require("zod");
-var import_ts_pattern24 = require("ts-pattern");
-var textAreaPropControllerDataV0Schema = import_zod26.z.string();
+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_zod26.z.object({
-  [ControlDataTypeKey]: import_zod26.z.literal(TextAreaPropControllerDataV1Type),
-  value: import_zod26.z.string()
+var textAreaPropControllerDataV1Schema = import_zod28.z.object({
+  [ControlDataTypeKey]: import_zod28.z.literal(TextAreaPropControllerDataV1Type),
+  value: import_zod28.z.string()
 });
-var textAreaPropControllerDataSchema = import_zod26.z.union([
+var textAreaPropControllerDataSchema = import_zod28.z.union([
   textAreaPropControllerDataV0Schema,
   textAreaPropControllerDataV1Schema
 ]);
@@ -2032,13 +2149,13 @@ function TextArea(options = {}) {
   return { type: Types.TextArea, version: 1, options };
 }
 function getTextAreaPropControllerDataString(data) {
-  return (0, import_ts_pattern24.match)(data).with(
+  return (0, import_ts_pattern25.match)(data).with(
     { [ControlDataTypeKey]: TextAreaPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createTextAreaPropControllerDataFromString(value, definition) {
-  return (0, import_ts_pattern24.match)(definition).with(
+  return (0, import_ts_pattern25.match)(definition).with(
     { version: 1 },
     () => ({
       [ControlDataTypeKey]: TextAreaPropControllerDataV1Type,
@@ -2047,16 +2164,48 @@ function createTextAreaPropControllerDataFromString(value, definition) {
   ).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_pattern25 = require("ts-pattern");
-var import_zod27 = require("zod");
+var import_ts_pattern27 = require("ts-pattern");
+var import_zod30 = require("zod");
 var widthPropControllerDataV0Schema = responsiveLengthDataSchema;
 var WidthPropControllerDataV1Type = "prop-controllers::width::v1";
-var widthPropControllerDataV1Schema = import_zod27.z.object({
-  [ControlDataTypeKey]: import_zod27.z.literal(WidthPropControllerDataV1Type),
+var widthPropControllerDataV1Schema = import_zod30.z.object({
+  [ControlDataTypeKey]: import_zod30.z.literal(WidthPropControllerDataV1Type),
   value: responsiveLengthDataSchema
 });
-var widthPropControllerDataSchema = import_zod27.z.union([
+var widthPropControllerDataSchema = import_zod30.z.union([
   widthPropControllerDataV0Schema,
   widthPropControllerDataV1Schema
 ]);
@@ -2069,15 +2218,15 @@ function Width(options = {}) {
 }
 Width.Format = WidthPropControllerFormat;
 function getWidthPropControllerDataResponsiveLengthData(data) {
-  return (0, import_ts_pattern25.match)(data).with(
+  return (0, import_ts_pattern27.match)(data).with(
     { [ControlDataTypeKey]: WidthPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createWidthPropControllerDataFromResponsiveLengthData(responsiveLengthData, definition) {
-  return (0, import_ts_pattern25.match)(definition).with(
+  return (0, import_ts_pattern27.match)(definition).with(
     { version: 1 },
-    import_ts_pattern25.P.nullish,
+    import_ts_pattern27.P.nullish,
     () => ({
       [ControlDataTypeKey]: WidthPropControllerDataV1Type,
       value: responsiveLengthData
@@ -2086,22 +2235,22 @@ function createWidthPropControllerDataFromResponsiveLengthData(responsiveLengthD
 }
 
 // src/video/video.ts
-var import_zod28 = require("zod");
-var import_ts_pattern26 = require("ts-pattern");
-var videoDataSchema = import_zod28.z.object({
-  url: import_zod28.z.string().optional(),
-  muted: import_zod28.z.boolean().optional(),
-  playing: import_zod28.z.boolean().optional(),
-  loop: import_zod28.z.boolean().optional(),
-  controls: import_zod28.z.boolean().optional()
+var 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_zod28.z.object({
-  [ControlDataTypeKey]: import_zod28.z.literal(VideoPropControllerDataV1Type),
+var videoPropControllerDataV1Schema = import_zod31.z.object({
+  [ControlDataTypeKey]: import_zod31.z.literal(VideoPropControllerDataV1Type),
   value: videoDataSchema
 });
-var videoPropControllerDataSchema = import_zod28.z.union([
+var videoPropControllerDataSchema = import_zod31.z.union([
   videoPropControllerDataV1Schema,
   videoPropControllerDataV0Schema
 ]);
@@ -2109,15 +2258,15 @@ function Video(options = {}) {
   return { type: Types.Video, version: 1, options };
 }
 function getVideoPropControllerDataVideoData(data) {
-  return (0, import_ts_pattern26.match)(data).with(
+  return (0, import_ts_pattern28.match)(data).with(
     { [ControlDataTypeKey]: VideoPropControllerDataV1Type },
     (v1) => v1.value
   ).otherwise((v0) => v0);
 }
 function createVideoPropControllerDataFromVideoData(value, definition) {
-  return (0, import_ts_pattern26.match)(definition).with(
+  return (0, import_ts_pattern28.match)(definition).with(
     { version: 1 },
-    import_ts_pattern26.P.nullish,
+    import_ts_pattern28.P.nullish,
     () => ({
       [ControlDataTypeKey]: VideoPropControllerDataV1Type,
       value
@@ -2154,10 +2303,13 @@ function createVideoPropControllerDataFromVideoData(value, definition) {
   ResponsiveLength,
   ResponsiveLengthPropControllerDataV1Type,
   ResponsiveNumber,
+  ResponsiveOpacity,
   Shadows,
+  SocialLinks,
   Table,
   TableFormFields,
   TextArea,
+  TextInput,
   TextStyle,
   Types,
   Video,
@@ -2201,9 +2353,11 @@ function createVideoPropControllerDataFromVideoData(value, definition) {
   createResponsiveLengthPropControllerDataFromResponsiveLengthData,
   createResponsiveValueSchema,
   createShadowsPropControllerDataFromResponsiveShadowsData,
+  createSocialLinksPropControllerDataFromSocialLinksData,
   createTableFormFieldsPropControllerDataFromTableFormFieldsData,
   createTablePropControllerDataFromTableId,
   createTextAreaPropControllerDataFromString,
+  createTextInputPropControllerDataFromString,
   createTextStylePropControllerDataFromResponsiveTextStyleData,
   createVideoPropControllerDataFromVideoData,
   createWidthPropControllerDataFromResponsiveLengthData,
@@ -2247,10 +2401,13 @@ function createVideoPropControllerDataFromVideoData(value, definition) {
   getResponsiveLengthPropControllerDataResponsiveLengthData,
   getShadowsPropControllerDataResponsiveShadowsData,
   getShadowsPropControllerDataSwatchIds,
+  getSocialLinkTypes,
+  getSocialLinksPropControllerDataSocialLinksData,
   getTableFormFieldsPropControllerDataTableFormFieldsData,
   getTablePropControllerDataTableId,
   getTablePropControllerDataTableIds,
   getTextAreaPropControllerDataString,
+  getTextInputPropControllerDataString,
   getTextStylePropControllerDataResponsiveTextStyleData,
   getVideoPropControllerDataVideoData,
   getWidthPropControllerDataResponsiveLengthData,
@@ -2273,10 +2430,13 @@ function createVideoPropControllerDataFromVideoData(value, definition) {
   responsiveGapDataSchema,
   responsiveLengthPropControllerDataSchema,
   responsiveNumberValueSchema,
+  responsiveOpacityValueSchema,
   shadowsPropControllerDataSchema,
+  socialLinksPropControllerDataSchema,
   tableFormFieldsPropControllerDataSchema,
   tablePropControllerDataSchema,
   textAreaPropControllerDataSchema,
+  textInputPropControllerDataSchema,
   textStylePropControllerDataSchema,
   versionedPropDef,
   videoPropControllerDataSchema,