@fragmentsx/definition 0.0.1

package/dist/index.cjs.js

@@ -0,0 +1,1135 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createConstants = (...constants) => {
+  return constants.reduce((acc, constant) => {
+    acc[constant] = constant;
+    return acc;
+  }, {});
+};
+const nodes = createConstants(
+  "Fragment",
+  "FragmentInstance",
+  "Instance",
+  "Breakpoint",
+  "Frame",
+  "Image",
+  "Text",
+  "SolidPaintStyle",
+  "CssLink",
+  "Variable",
+  "ComputedValue",
+  "TransformValue"
+);
+const fragmentGrowingMode = createConstants("auto", "fill");
+const borderType = createConstants("None", "Solid", "Dashed", "Dotted");
+const linkTarget = createConstants("_blank");
+const paintMode = createConstants("None", "Solid", "Image");
+const imagePaintScaleModes = createConstants(
+  "Fill",
+  "Fit",
+  "Crop",
+  "Tile"
+);
+const constrain = createConstants(
+  "Min",
+  "Center",
+  "Max",
+  "Stretch",
+  "Scale"
+);
+const positionType = createConstants("absolute", "relative");
+const sizing = createConstants("Fixed", "Hug", "Fill", "Relative");
+const layerMode = createConstants("none", "flex");
+const layerDirection = createConstants("vertical", "horizontal");
+const layerAlign = createConstants("start", "center", "end");
+const layerDistribute = createConstants(
+  "start",
+  "center",
+  "end",
+  "space-between",
+  "space-around"
+);
+const textTransform = createConstants(
+  "none",
+  "uppercase",
+  "lowercase",
+  "capitalize"
+);
+const textDecorations = createConstants(
+  "none",
+  "underline",
+  "line-through"
+);
+const effectType = createConstants("loop", "appear", "hover", "tap");
+const effectName = createConstants(
+  "fade",
+  "slide",
+  "bounce",
+  "wiggle",
+  "increase"
+);
+const variableType = createConstants(
+  "String",
+  "Boolean",
+  "Array",
+  "Color",
+  "ComponentInstance",
+  "Date",
+  "Enum",
+  "Number",
+  "Object"
+);
+const whiteSpace = createConstants(
+  "normal",
+  "nowrap",
+  "pre",
+  "pre-wrap",
+  "pre-line",
+  "break-spaces"
+);
+const overflow = createConstants("visible", "hidden", "scroll");
+const variableTransforms = createConstants(
+  "convert",
+  "exists",
+  "equals",
+  "startWith",
+  "endWith",
+  "contains",
+  "dateBefore",
+  "dateAfter",
+  "dateBetween",
+  "feature",
+  "notFeature",
+  "gt",
+  // Greater than
+  "gte",
+  // Greater than or equals
+  "lt",
+  // Less than
+  "lte",
+  // Less than or equals,
+  "convertFromBoolean",
+  "negative"
+);
+const renderTarget = createConstants("canvas", "document");
+const renderMode = createConstants("viewport", "parent", "fixed");
+const index = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  borderType,
+  constrain,
+  createConstants,
+  effectName,
+  effectType,
+  fragmentGrowingMode,
+  imagePaintScaleModes,
+  layerAlign,
+  layerDirection,
+  layerDistribute,
+  layerMode,
+  linkTarget,
+  nodes,
+  overflow,
+  paintMode,
+  positionType,
+  renderMode,
+  renderTarget,
+  sizing,
+  textDecorations,
+  textTransform,
+  variableTransforms,
+  variableType,
+  whiteSpace
+}, Symbol.toStringTag, { value: "Module" }));
+var store;
+// @__NO_SIDE_EFFECTS__
+function getGlobalConfig(config2) {
+  return {
+    lang: (config2 == null ? void 0 : config2.lang) ?? (store == null ? void 0 : store.lang),
+    message: config2 == null ? void 0 : config2.message,
+    abortEarly: (config2 == null ? void 0 : config2.abortEarly) ?? (store == null ? void 0 : store.abortEarly),
+    abortPipeEarly: (config2 == null ? void 0 : config2.abortPipeEarly) ?? (store == null ? void 0 : store.abortPipeEarly)
+  };
+}
+var store2;
+// @__NO_SIDE_EFFECTS__
+function getGlobalMessage(lang) {
+  return store2 == null ? void 0 : store2.get(lang);
+}
+var store3;
+// @__NO_SIDE_EFFECTS__
+function getSchemaMessage(lang) {
+  return store3 == null ? void 0 : store3.get(lang);
+}
+var store4;
+// @__NO_SIDE_EFFECTS__
+function getSpecificMessage(reference, lang) {
+  var _a;
+  return (_a = store4 == null ? void 0 : store4.get(reference)) == null ? void 0 : _a.get(lang);
+}
+// @__NO_SIDE_EFFECTS__
+function _stringify(input) {
+  var _a, _b;
+  const type = typeof input;
+  if (type === "string") {
+    return `"${input}"`;
+  }
+  if (type === "number" || type === "bigint" || type === "boolean") {
+    return `${input}`;
+  }
+  if (type === "object" || type === "function") {
+    return (input && ((_b = (_a = Object.getPrototypeOf(input)) == null ? void 0 : _a.constructor) == null ? void 0 : _b.name)) ?? "null";
+  }
+  return type;
+}
+function _addIssue(context, label, dataset, config2, other) {
+  const input = other && "input" in other ? other.input : dataset.value;
+  const expected = (other == null ? void 0 : other.expected) ?? context.expects ?? null;
+  const received = (other == null ? void 0 : other.received) ?? /* @__PURE__ */ _stringify(input);
+  const issue = {
+    kind: context.kind,
+    type: context.type,
+    input,
+    expected,
+    received,
+    message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
+    requirement: context.requirement,
+    path: other == null ? void 0 : other.path,
+    issues: other == null ? void 0 : other.issues,
+    lang: config2.lang,
+    abortEarly: config2.abortEarly,
+    abortPipeEarly: config2.abortPipeEarly
+  };
+  const isSchema = context.kind === "schema";
+  const message = (other == null ? void 0 : other.message) ?? context.message ?? /* @__PURE__ */ getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? /* @__PURE__ */ getSchemaMessage(issue.lang) : null) ?? config2.message ?? /* @__PURE__ */ getGlobalMessage(issue.lang);
+  if (message !== void 0) {
+    issue.message = typeof message === "function" ? (
+      // @ts-expect-error
+      message(issue)
+    ) : message;
+  }
+  if (isSchema) {
+    dataset.typed = false;
+  }
+  if (dataset.issues) {
+    dataset.issues.push(issue);
+  } else {
+    dataset.issues = [issue];
+  }
+}
+// @__NO_SIDE_EFFECTS__
+function _getStandardProps(context) {
+  return {
+    version: 1,
+    vendor: "valibot",
+    validate(value2) {
+      return context["~run"]({ value: value2 }, /* @__PURE__ */ getGlobalConfig());
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function _isValidObjectKey(object2, key) {
+  return Object.hasOwn(object2, key) && key !== "__proto__" && key !== "prototype" && key !== "constructor";
+}
+// @__NO_SIDE_EFFECTS__
+function _joinExpects(values2, separator) {
+  const list = [...new Set(values2)];
+  if (list.length > 1) {
+    return `(${list.join(` ${separator} `)})`;
+  }
+  return list[0] ?? "never";
+}
+// @__NO_SIDE_EFFECTS__
+function isOfKind(kind, object2) {
+  return object2.kind === kind;
+}
+var ValiError = class extends Error {
+  /**
+   * Creates a Valibot error with useful information.
+   *
+   * @param issues The error issues.
+   */
+  constructor(issues) {
+    super(issues[0].message);
+    this.name = "ValiError";
+    this.issues = issues;
+  }
+};
+// @__NO_SIDE_EFFECTS__
+function check(requirement, message) {
+  return {
+    kind: "validation",
+    type: "check",
+    reference: check,
+    async: false,
+    expects: null,
+    requirement,
+    message,
+    "~run"(dataset, config2) {
+      if (dataset.typed && !this.requirement(dataset.value)) {
+        _addIssue(this, "input", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function maxValue(requirement, message) {
+  return {
+    kind: "validation",
+    type: "max_value",
+    reference: maxValue,
+    async: false,
+    expects: `<=${requirement instanceof Date ? requirement.toJSON() : /* @__PURE__ */ _stringify(requirement)}`,
+    requirement,
+    message,
+    "~run"(dataset, config2) {
+      if (dataset.typed && !(dataset.value <= this.requirement)) {
+        _addIssue(this, "value", dataset, config2, {
+          received: dataset.value instanceof Date ? dataset.value.toJSON() : /* @__PURE__ */ _stringify(dataset.value)
+        });
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function metadata(metadata_) {
+  return {
+    kind: "metadata",
+    type: "metadata",
+    reference: metadata,
+    metadata: metadata_
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function minValue(requirement, message) {
+  return {
+    kind: "validation",
+    type: "min_value",
+    reference: minValue,
+    async: false,
+    expects: `>=${requirement instanceof Date ? requirement.toJSON() : /* @__PURE__ */ _stringify(requirement)}`,
+    requirement,
+    message,
+    "~run"(dataset, config2) {
+      if (dataset.typed && !(dataset.value >= this.requirement)) {
+        _addIssue(this, "value", dataset, config2, {
+          received: dataset.value instanceof Date ? dataset.value.toJSON() : /* @__PURE__ */ _stringify(dataset.value)
+        });
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function getFallback(schema, dataset, config2) {
+  return typeof schema.fallback === "function" ? (
+    // @ts-expect-error
+    schema.fallback(dataset, config2)
+  ) : (
+    // @ts-expect-error
+    schema.fallback
+  );
+}
+// @__NO_SIDE_EFFECTS__
+function getDefault(schema, dataset, config2) {
+  return typeof schema.default === "function" ? (
+    // @ts-expect-error
+    schema.default(dataset, config2)
+  ) : (
+    // @ts-expect-error
+    schema.default
+  );
+}
+// @__NO_SIDE_EFFECTS__
+function array(item, message) {
+  return {
+    kind: "schema",
+    type: "array",
+    reference: array,
+    expects: "Array",
+    async: false,
+    item,
+    message,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      var _a;
+      const input = dataset.value;
+      if (Array.isArray(input)) {
+        dataset.typed = true;
+        dataset.value = [];
+        for (let key = 0; key < input.length; key++) {
+          const value2 = input[key];
+          const itemDataset = this.item["~run"]({ value: value2 }, config2);
+          if (itemDataset.issues) {
+            const pathItem = {
+              type: "array",
+              origin: "value",
+              input,
+              key,
+              value: value2
+            };
+            for (const issue of itemDataset.issues) {
+              if (issue.path) {
+                issue.path.unshift(pathItem);
+              } else {
+                issue.path = [pathItem];
+              }
+              (_a = dataset.issues) == null ? void 0 : _a.push(issue);
+            }
+            if (!dataset.issues) {
+              dataset.issues = itemDataset.issues;
+            }
+            if (config2.abortEarly) {
+              dataset.typed = false;
+              break;
+            }
+          }
+          if (!itemDataset.typed) {
+            dataset.typed = false;
+          }
+          dataset.value.push(itemDataset.value);
+        }
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function boolean(message) {
+  return {
+    kind: "schema",
+    type: "boolean",
+    reference: boolean,
+    expects: "boolean",
+    async: false,
+    message,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      if (typeof dataset.value === "boolean") {
+        dataset.typed = true;
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function enum_(enum__, message) {
+  const options = [];
+  for (const key in enum__) {
+    if (`${+key}` !== key || typeof enum__[key] !== "string" || !Object.is(enum__[enum__[key]], +key)) {
+      options.push(enum__[key]);
+    }
+  }
+  return {
+    kind: "schema",
+    type: "enum",
+    reference: enum_,
+    expects: /* @__PURE__ */ _joinExpects(options.map(_stringify), "|"),
+    async: false,
+    enum: enum__,
+    options,
+    message,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      if (this.options.includes(dataset.value)) {
+        dataset.typed = true;
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function literal(literal_, message) {
+  return {
+    kind: "schema",
+    type: "literal",
+    reference: literal,
+    expects: /* @__PURE__ */ _stringify(literal_),
+    async: false,
+    literal: literal_,
+    message,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      if (dataset.value === this.literal) {
+        dataset.typed = true;
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function number(message) {
+  return {
+    kind: "schema",
+    type: "number",
+    reference: number,
+    expects: "number",
+    async: false,
+    message,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      if (typeof dataset.value === "number" && !isNaN(dataset.value)) {
+        dataset.typed = true;
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function object(entries, message) {
+  return {
+    kind: "schema",
+    type: "object",
+    reference: object,
+    expects: "Object",
+    async: false,
+    entries,
+    message,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      var _a;
+      const input = dataset.value;
+      if (input && typeof input === "object") {
+        dataset.typed = true;
+        dataset.value = {};
+        for (const key in this.entries) {
+          const valueSchema = this.entries[key];
+          if (key in input || (valueSchema.type === "exact_optional" || valueSchema.type === "optional" || valueSchema.type === "nullish") && // @ts-expect-error
+          valueSchema.default !== void 0) {
+            const value2 = key in input ? (
+              // @ts-expect-error
+              input[key]
+            ) : /* @__PURE__ */ getDefault(valueSchema);
+            const valueDataset = valueSchema["~run"]({ value: value2 }, config2);
+            if (valueDataset.issues) {
+              const pathItem = {
+                type: "object",
+                origin: "value",
+                input,
+                key,
+                value: value2
+              };
+              for (const issue of valueDataset.issues) {
+                if (issue.path) {
+                  issue.path.unshift(pathItem);
+                } else {
+                  issue.path = [pathItem];
+                }
+                (_a = dataset.issues) == null ? void 0 : _a.push(issue);
+              }
+              if (!dataset.issues) {
+                dataset.issues = valueDataset.issues;
+              }
+              if (config2.abortEarly) {
+                dataset.typed = false;
+                break;
+              }
+            }
+            if (!valueDataset.typed) {
+              dataset.typed = false;
+            }
+            dataset.value[key] = valueDataset.value;
+          } else if (valueSchema.fallback !== void 0) {
+            dataset.value[key] = /* @__PURE__ */ getFallback(valueSchema);
+          } else if (valueSchema.type !== "exact_optional" && valueSchema.type !== "optional" && valueSchema.type !== "nullish") {
+            _addIssue(this, "key", dataset, config2, {
+              input: void 0,
+              expected: `"${key}"`,
+              path: [
+                {
+                  type: "object",
+                  origin: "key",
+                  input,
+                  key,
+                  // @ts-expect-error
+                  value: input[key]
+                }
+              ]
+            });
+            if (config2.abortEarly) {
+              break;
+            }
+          }
+        }
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function optional(wrapped, default_) {
+  return {
+    kind: "schema",
+    type: "optional",
+    reference: optional,
+    expects: `(${wrapped.expects} | undefined)`,
+    async: false,
+    wrapped,
+    default: default_,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      if (dataset.value === void 0) {
+        if (this.default !== void 0) {
+          dataset.value = /* @__PURE__ */ getDefault(this, dataset, config2);
+        }
+        if (dataset.value === void 0) {
+          dataset.typed = true;
+          return dataset;
+        }
+      }
+      return this.wrapped["~run"](dataset, config2);
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function picklist(options, message) {
+  return {
+    kind: "schema",
+    type: "picklist",
+    reference: picklist,
+    expects: /* @__PURE__ */ _joinExpects(options.map(_stringify), "|"),
+    async: false,
+    options,
+    message,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      if (this.options.includes(dataset.value)) {
+        dataset.typed = true;
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function record(key, value2, message) {
+  return {
+    kind: "schema",
+    type: "record",
+    reference: record,
+    expects: "Object",
+    async: false,
+    key,
+    value: value2,
+    message,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      var _a, _b;
+      const input = dataset.value;
+      if (input && typeof input === "object") {
+        dataset.typed = true;
+        dataset.value = {};
+        for (const entryKey in input) {
+          if (/* @__PURE__ */ _isValidObjectKey(input, entryKey)) {
+            const entryValue = input[entryKey];
+            const keyDataset = this.key["~run"]({ value: entryKey }, config2);
+            if (keyDataset.issues) {
+              const pathItem = {
+                type: "object",
+                origin: "key",
+                input,
+                key: entryKey,
+                value: entryValue
+              };
+              for (const issue of keyDataset.issues) {
+                issue.path = [pathItem];
+                (_a = dataset.issues) == null ? void 0 : _a.push(issue);
+              }
+              if (!dataset.issues) {
+                dataset.issues = keyDataset.issues;
+              }
+              if (config2.abortEarly) {
+                dataset.typed = false;
+                break;
+              }
+            }
+            const valueDataset = this.value["~run"](
+              { value: entryValue },
+              config2
+            );
+            if (valueDataset.issues) {
+              const pathItem = {
+                type: "object",
+                origin: "value",
+                input,
+                key: entryKey,
+                value: entryValue
+              };
+              for (const issue of valueDataset.issues) {
+                if (issue.path) {
+                  issue.path.unshift(pathItem);
+                } else {
+                  issue.path = [pathItem];
+                }
+                (_b = dataset.issues) == null ? void 0 : _b.push(issue);
+              }
+              if (!dataset.issues) {
+                dataset.issues = valueDataset.issues;
+              }
+              if (config2.abortEarly) {
+                dataset.typed = false;
+                break;
+              }
+            }
+            if (!keyDataset.typed || !valueDataset.typed) {
+              dataset.typed = false;
+            }
+            if (keyDataset.typed) {
+              dataset.value[keyDataset.value] = valueDataset.value;
+            }
+          }
+        }
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function string(message) {
+  return {
+    kind: "schema",
+    type: "string",
+    reference: string,
+    expects: "string",
+    async: false,
+    message,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      if (typeof dataset.value === "string") {
+        dataset.typed = true;
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function _subIssues(datasets) {
+  let issues;
+  if (datasets) {
+    for (const dataset of datasets) {
+      if (issues) {
+        issues.push(...dataset.issues);
+      } else {
+        issues = dataset.issues;
+      }
+    }
+  }
+  return issues;
+}
+// @__NO_SIDE_EFFECTS__
+function union(options, message) {
+  return {
+    kind: "schema",
+    type: "union",
+    reference: union,
+    expects: /* @__PURE__ */ _joinExpects(
+      options.map((option) => option.expects),
+      "|"
+    ),
+    async: false,
+    options,
+    message,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      let validDataset;
+      let typedDatasets;
+      let untypedDatasets;
+      for (const schema of this.options) {
+        const optionDataset = schema["~run"]({ value: dataset.value }, config2);
+        if (optionDataset.typed) {
+          if (optionDataset.issues) {
+            if (typedDatasets) {
+              typedDatasets.push(optionDataset);
+            } else {
+              typedDatasets = [optionDataset];
+            }
+          } else {
+            validDataset = optionDataset;
+            break;
+          }
+        } else {
+          if (untypedDatasets) {
+            untypedDatasets.push(optionDataset);
+          } else {
+            untypedDatasets = [optionDataset];
+          }
+        }
+      }
+      if (validDataset) {
+        return validDataset;
+      }
+      if (typedDatasets) {
+        if (typedDatasets.length === 1) {
+          return typedDatasets[0];
+        }
+        _addIssue(this, "type", dataset, config2, {
+          issues: /* @__PURE__ */ _subIssues(typedDatasets)
+        });
+        dataset.typed = true;
+      } else if ((untypedDatasets == null ? void 0 : untypedDatasets.length) === 1) {
+        return untypedDatasets[0];
+      } else {
+        _addIssue(this, "type", dataset, config2, {
+          issues: /* @__PURE__ */ _subIssues(untypedDatasets)
+        });
+      }
+      return dataset;
+    }
+  };
+}
+function parse(schema, input, config2) {
+  const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config2));
+  if (dataset.issues) {
+    throw new ValiError(dataset.issues);
+  }
+  return dataset.value;
+}
+// @__NO_SIDE_EFFECTS__
+function pipe(...pipe2) {
+  return {
+    ...pipe2[0],
+    pipe: pipe2,
+    get "~standard"() {
+      return /* @__PURE__ */ _getStandardProps(this);
+    },
+    "~run"(dataset, config2) {
+      for (const item of pipe2) {
+        if (item.kind !== "metadata") {
+          if (dataset.issues && (item.kind === "schema" || item.kind === "transformation")) {
+            dataset.typed = false;
+            break;
+          }
+          if (!dataset.issues || !config2.abortEarly && !config2.abortPipeEarly) {
+            dataset = item["~run"](dataset, config2);
+          }
+        }
+      }
+      return dataset;
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function safeParse(schema, input, config2) {
+  const dataset = schema["~run"]({ value: input }, /* @__PURE__ */ getGlobalConfig(config2));
+  return {
+    typed: dataset.typed,
+    success: !dataset.issues,
+    output: dataset.value,
+    issues: dataset.issues
+  };
+}
+const linkValidator = /* @__PURE__ */ check(
+  (value) => {
+    var _a, _b;
+    return !!value && ((_b = (_a = value == null ? void 0 : value.split) == null ? void 0 : _a.call(value, ":")) == null ? void 0 : _b.length) === 2;
+  }
+);
+const getMetadata = (schema) => {
+  var _a;
+  const pipelines = (schema == null ? void 0 : schema.pipe) ?? [];
+  return ((_a = pipelines == null ? void 0 : pipelines.find((pipe2) => /* @__PURE__ */ isOfKind("metadata", pipe2))) == null ? void 0 : _a.metadata) ?? null;
+};
+const layerField = (schema, meta) => {
+  const modifiedSchema = (meta == null ? void 0 : meta.variable) ? /* @__PURE__ */ union([schema, /* @__PURE__ */ pipe(/* @__PURE__ */ string(), linkValidator)]) : schema;
+  return /* @__PURE__ */ pipe(/* @__PURE__ */ optional(modifiedSchema), /* @__PURE__ */ metadata(meta ?? {}));
+};
+const ChildrenSchema = /* @__PURE__ */ object({
+  children: layerField(/* @__PURE__ */ array(/* @__PURE__ */ string()), {
+    fallback: [],
+    overridable: false
+  })
+});
+const GraphFieldSchema = /* @__PURE__ */ object({
+  _id: /* @__PURE__ */ union([/* @__PURE__ */ string(), /* @__PURE__ */ number()]),
+  _type: /* @__PURE__ */ picklist(Object.keys(nodes))
+});
+const OverridesSchema = /* @__PURE__ */ object({
+  overrides: layerField(/* @__PURE__ */ array(/* @__PURE__ */ string()), { overridable: false })
+});
+const PositionSchema = /* @__PURE__ */ object({
+  position: layerField(/* @__PURE__ */ enum_(Object.keys(positionType)), {
+    fallback: positionType.absolute
+  }),
+  top: layerField(/* @__PURE__ */ number(), { fallback: 0 }),
+  left: layerField(/* @__PURE__ */ number(), { fallback: 0 })
+});
+const SceneSchema = /* @__PURE__ */ object({
+  opacity: layerField(/* @__PURE__ */ pipe(/* @__PURE__ */ number(), /* @__PURE__ */ minValue(0), /* @__PURE__ */ maxValue(1)), {
+    fallback: 1,
+    variable: true
+  }),
+  visible: layerField(/* @__PURE__ */ boolean(), { fallback: true, variable: true }),
+  zIndex: layerField(/* @__PURE__ */ number(), { fallback: -1 }),
+  borderRadius: layerField(/* @__PURE__ */ string(), { fallback: "0px" }),
+  overflow: layerField(/* @__PURE__ */ picklist(Object.keys(overflow)), {
+    fallback: overflow.hidden
+  })
+});
+const FillSchema = /* @__PURE__ */ object({
+  fillType: layerField(/* @__PURE__ */ picklist(Object.keys(paintMode)), {
+    fallback: paintMode.None
+  }),
+  solidFill: layerField(/* @__PURE__ */ string(), { fallback: "#fff" })
+});
+const BorderSchema = /* @__PURE__ */ object({
+  borderType: layerField(/* @__PURE__ */ picklist(Object.keys(borderType)), {
+    fallback: borderType.None
+  }),
+  borderWidth: layerField(/* @__PURE__ */ pipe(/* @__PURE__ */ number(), /* @__PURE__ */ minValue(0)), { fallback: 0 }),
+  borderColor: layerField(/* @__PURE__ */ string(), { fallback: "#fff" })
+});
+const SizeSchema = /* @__PURE__ */ object({
+  widthType: layerField(/* @__PURE__ */ picklist(Object.keys(sizing)), {
+    fallback: sizing.Fixed
+  }),
+  heightType: layerField(/* @__PURE__ */ picklist(Object.keys(sizing)), {
+    fallback: sizing.Fixed
+  }),
+  width: layerField(/* @__PURE__ */ pipe(/* @__PURE__ */ number(), /* @__PURE__ */ minValue(0)), { fallback: 0 }),
+  height: layerField(/* @__PURE__ */ pipe(/* @__PURE__ */ number(), /* @__PURE__ */ minValue(0)), { fallback: 0 }),
+  aspectRatio: layerField(/* @__PURE__ */ number(), { fallback: -1 })
+});
+const LayerSchema = /* @__PURE__ */ object({
+  layerMode: layerField(/* @__PURE__ */ picklist(Object.keys(layerMode)), {
+    fallback: layerMode.none
+  }),
+  layerAlign: layerField(/* @__PURE__ */ picklist(Object.keys(layerAlign)), {
+    fallback: layerAlign.start
+  }),
+  layerDirection: layerField(/* @__PURE__ */ picklist(Object.keys(layerDirection)), {
+    fallback: layerDirection.horizontal
+  }),
+  layerDistribute: layerField(/* @__PURE__ */ picklist(Object.keys(layerDistribute)), {
+    fallback: layerDistribute.start
+  }),
+  layerWrap: layerField(/* @__PURE__ */ boolean(), { fallback: false }),
+  layerGap: layerField(/* @__PURE__ */ pipe(/* @__PURE__ */ number(), /* @__PURE__ */ minValue(0)), { fallback: 0 }),
+  padding: layerField(/* @__PURE__ */ string(), { fallback: "0px" })
+});
+const FrameSchema = /* @__PURE__ */ pipe(
+  /* @__PURE__ */ object({
+    name: layerField(/* @__PURE__ */ string(), { fallback: "Frame", overridable: false }),
+    isBreakpoint: layerField(/* @__PURE__ */ boolean(), {
+      fallback: false,
+      overridable: false
+    }),
+    isPrimary: layerField(/* @__PURE__ */ boolean(), { fallback: false, overridable: false }),
+    threshold: layerField(/* @__PURE__ */ pipe(/* @__PURE__ */ number(), /* @__PURE__ */ minValue(0)), {
+      fallback: 320,
+      overridable: false
+    }),
+    ...ChildrenSchema.entries,
+    ...GraphFieldSchema.entries,
+    ...OverridesSchema.entries,
+    ...PositionSchema.entries,
+    ...SceneSchema.entries,
+    ...FillSchema.entries,
+    ...BorderSchema.entries,
+    ...SizeSchema.entries,
+    ...LayerSchema.entries
+  })
+);
+const TextSchema = /* @__PURE__ */ object({
+  name: layerField(/* @__PURE__ */ string(), { fallback: "Text", overridable: false }),
+  content: layerField(/* @__PURE__ */ string(), {
+    fallback: ""
+  }),
+  variableContent: layerField(/* @__PURE__ */ string(), { fallback: null, variable: true }),
+  attributes: layerField(
+    /* @__PURE__ */ object({
+      fontSize: layerField(/* @__PURE__ */ string(), { fallback: "14px" }),
+      color: layerField(/* @__PURE__ */ string(), { fallback: "#000" }),
+      lineHeight: layerField(/* @__PURE__ */ string(), { fallback: "14px" })
+    }),
+    { fallback: {} }
+  ),
+  ...GraphFieldSchema.entries,
+  ...OverridesSchema.entries,
+  ...PositionSchema.entries,
+  ...SceneSchema.entries,
+  ...SizeSchema.entries
+});
+const FragmentSchema = /* @__PURE__ */ object({
+  name: layerField(/* @__PURE__ */ string(), { fallback: "Fragment", overridable: false }),
+  horizontalGrow: layerField(/* @__PURE__ */ enum_(Object.keys(fragmentGrowingMode)), {
+    fallback: fragmentGrowingMode.auto,
+    overridable: false
+  }),
+  verticalGrow: layerField(/* @__PURE__ */ enum_(Object.keys(fragmentGrowingMode)), {
+    fallback: fragmentGrowingMode.auto,
+    overridable: false
+  }),
+  properties: layerField(/* @__PURE__ */ array(/* @__PURE__ */ string()), {
+    fallback: [],
+    overridable: false
+  }),
+  ...GraphFieldSchema.entries,
+  ...ChildrenSchema.entries
+});
+const InstanceSchema = /* @__PURE__ */ object({
+  name: layerField(/* @__PURE__ */ string(), { fallback: "Instance", overridable: false }),
+  fragment: layerField(/* @__PURE__ */ string()),
+  props: layerField(
+    /* @__PURE__ */ record(/* @__PURE__ */ string(), /* @__PURE__ */ union([/* @__PURE__ */ string(), /* @__PURE__ */ number(), /* @__PURE__ */ boolean()])),
+    {
+      fallback: {}
+    }
+  ),
+  ...GraphFieldSchema.entries,
+  ...OverridesSchema.entries,
+  ...PositionSchema.entries,
+  ...SizeSchema.entries,
+  ...SceneSchema.entries
+});
+const NumberVariableSchema = /* @__PURE__ */ object({
+  name: layerField(/* @__PURE__ */ string(), {
+    fallback: "Number",
+    overridable: false
+  }),
+  type: layerField(/* @__PURE__ */ literal(variableType.Number), {
+    fallback: variableType.Number
+  }),
+  defaultValue: layerField(/* @__PURE__ */ number(), { fallback: 0 }),
+  required: layerField(/* @__PURE__ */ boolean(), { fallback: false }),
+  min: layerField(/* @__PURE__ */ number(), { fallback: 1 }),
+  max: layerField(/* @__PURE__ */ number(), { fallback: 100 }),
+  step: layerField(/* @__PURE__ */ number(), { fallback: 1 }),
+  displayStepper: layerField(/* @__PURE__ */ boolean(), { fallback: true }),
+  ...GraphFieldSchema.entries
+});
+const BooleanVariableSchema = /* @__PURE__ */ object({
+  name: layerField(/* @__PURE__ */ string(), {
+    fallback: "Boolean",
+    overridable: false
+  }),
+  type: layerField(/* @__PURE__ */ literal(variableType.Boolean), {
+    fallback: variableType.Boolean
+  }),
+  defaultValue: layerField(/* @__PURE__ */ boolean(), { fallback: false }),
+  required: layerField(/* @__PURE__ */ boolean(), { fallback: false }),
+  ...GraphFieldSchema.entries
+});
+const ColorVariableSchema = /* @__PURE__ */ object({
+  name: layerField(/* @__PURE__ */ string(), {
+    fallback: "String",
+    overridable: false
+  }),
+  type: layerField(/* @__PURE__ */ literal(variableType.Color), {
+    fallback: variableType.Color
+  }),
+  // TODO Add color validator
+  defaultValue: layerField(/* @__PURE__ */ string(), { fallback: "#000" }),
+  required: layerField(/* @__PURE__ */ boolean(), { fallback: false }),
+  ...GraphFieldSchema.entries
+});
+const StringVariableSchema = /* @__PURE__ */ object({
+  name: layerField(/* @__PURE__ */ string(), {
+    fallback: "String",
+    overridable: false
+  }),
+  type: layerField(/* @__PURE__ */ literal(variableType.String), {
+    fallback: variableType.String
+  }),
+  defaultValue: layerField(/* @__PURE__ */ string(), { fallback: "" }),
+  required: layerField(/* @__PURE__ */ boolean(), { fallback: false }),
+  placeholder: layerField(/* @__PURE__ */ string(), { fallback: "" }),
+  isTextarea: layerField(/* @__PURE__ */ boolean(), { fallback: false }),
+  ...GraphFieldSchema.entries
+});
+const getLayerSchema = (layer) => {
+  if (!(layer == null ? void 0 : layer._type)) return null;
+  if ((layer == null ? void 0 : layer._type) === nodes.Frame) return FrameSchema;
+  if ((layer == null ? void 0 : layer._type) === nodes.Text) return TextSchema;
+  if ((layer == null ? void 0 : layer._type) === nodes.Fragment) return FragmentSchema;
+  if ((layer == null ? void 0 : layer._type) === nodes.Instance) return InstanceSchema;
+  if (layer._type === nodes.Variable) {
+    const types = {
+      [variableType.Number]: NumberVariableSchema,
+      [variableType.Boolean]: BooleanVariableSchema,
+      [variableType.String]: StringVariableSchema,
+      [variableType.Color]: ColorVariableSchema
+    };
+    if (layer.type in types) {
+      return types[layer.type];
+    }
+  }
+};
+const normalizeLayer = (schema, rawLayer, options) => {
+  try {
+    if (!rawLayer) return null;
+    const withFallback = (options == null ? void 0 : options.withFallback) ?? true;
+    const overrideTarget = options == null ? void 0 : options.overrideTarget;
+    const parsedLayer = parse(schema, rawLayer);
+    return Object.fromEntries(
+      Object.entries(schema.entries).map(([key, schemaEntity]) => {
+        const schemaMeta = getMetadata(schemaEntity);
+        const fallback = withFallback ? schemaMeta == null ? void 0 : schemaMeta.fallback : null;
+        const overrideValue = (schemaMeta == null ? void 0 : schemaMeta.overridable) !== false && overrideTarget ? overrideTarget == null ? void 0 : overrideTarget[key] : null;
+        return [key, parsedLayer[key] ?? overrideValue ?? fallback];
+      })
+    );
+  } catch (e) {
+    console.error(e);
+    return null;
+  }
+};
+const getNormalizeLayer = (layer, overrider) => {
+  if (!layer) return null;
+  const schema = getLayerSchema(layer);
+  if (!schema) return null;
+  return normalizeLayer(schema, layer, {
+    overrideTarget: overrider
+  });
+};
+const isValidLayerField = (layer, field, value) => {
+  var _a, _b;
+  const schema = getLayerSchema(layer);
+  if (schema && ((_a = schema == null ? void 0 : schema.entries) == null ? void 0 : _a[field])) {
+    const { success } = /* @__PURE__ */ safeParse((_b = schema.entries) == null ? void 0 : _b[field], value);
+    return success;
+  }
+  return false;
+};
+exports.definition = index;
+exports.getNormalizeLayer = getNormalizeLayer;
+exports.isValidLayerField = isValidLayerField;