@valbuild/core 0.100.0 → 0.101.0

package/dist/{index-202e48a3.cjs.dev.js → index-3e2d700e.cjs.dev.js}

@@ -5454,6 +5454,647 @@ var datetime = function datetime(options) {
   return new DateTimeSchema(options);
 };
 
+/**
+ * Parsing / formatting of the CSS color strings stored by `s.color()`.
+ *
+ * Colors are stored as plain CSS strings so that they can be used directly in
+ * `style` attributes and CSS custom properties. The schema decides which family
+ * (`hex`, `rgb`, `hsl` or `oklch`) the string is written in, this module does
+ * the conversion between them.
+ *
+ * All colors are sRGB: `oklch` is only used as an output notation, so any
+ * `oklch` value that falls outside the sRGB gamut is clipped when converted
+ * back to the other formats.
+ */
+
+var COLOR_FORMATS = ["hex", "rgb", "hsl", "oklch"];
+var DEFAULT_COLOR_FORMAT = "hsl";
+
+/**
+ * A color, normalized to sRGB.
+ *
+ * `r`, `g` and `b` are 0-255 (not rounded), `a` is 0-1.
+ */
+
+/**
+ * Which color notation a string uses, or `null` if it is not a notation we
+ * recognize. This looks at the syntax only: `detectColorFormat` says nothing
+ * about whether the value actually parses (`hsl(nope)` is still `"hsl"`).
+ */
+function detectColorFormat(value) {
+  var trimmed = value.trim().toLowerCase();
+  if (trimmed.startsWith("#")) {
+    return "hex";
+  }
+  if (trimmed.startsWith("rgb(") || trimmed.startsWith("rgba(")) {
+    return "rgb";
+  }
+  if (trimmed.startsWith("hsl(") || trimmed.startsWith("hsla(")) {
+    return "hsl";
+  }
+  if (trimmed.startsWith("oklch(")) {
+    return "oklch";
+  }
+  return null;
+}
+function clamp(value, min, max) {
+  if (Number.isNaN(value)) {
+    return min;
+  }
+  return Math.min(max, Math.max(min, value));
+}
+
+/**
+ * Splits the inside of a CSS color function into components.
+ *
+ * Handles both the legacy comma syntax (`rgb(1, 2, 3, 0.5)`) and the modern
+ * space syntax (`rgb(1 2 3 / 0.5)`), returning the alpha (if any) separately.
+ */
+function splitComponents(args) {
+  var slashParts = args.split("/");
+  if (slashParts.length > 2) {
+    return null;
+  }
+  var alpha = slashParts.length === 2 ? slashParts[1].trim() : null;
+  var head = slashParts[0].trim();
+  if (head === "") {
+    return null;
+  }
+  var components;
+  if (head.includes(",")) {
+    if (alpha !== null) {
+      // Mixing the comma and the slash syntax is not valid CSS
+      return null;
+    }
+    components = head.split(",").map(function (part) {
+      return part.trim();
+    });
+    if (components.length === 4) {
+      alpha = components[3];
+      components = components.slice(0, 3);
+    }
+  } else {
+    components = head.split(/\s+/);
+  }
+  if (components.length !== 3 || components.some(function (part) {
+    return part === "";
+  })) {
+    return null;
+  }
+  if (alpha === "") {
+    return null;
+  }
+  return {
+    components: components,
+    alpha: alpha
+  };
+}
+function parseNumber(value) {
+  if (!/^[+-]?(\d+\.?\d*|\.\d+)$/.test(value)) {
+    return null;
+  }
+  var parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+/**
+ * A `<number>` or a `<percentage>`, where 100% maps to `percentageBasis`.
+ */
+function parseNumberOrPercentage(value, percentageBasis) {
+  if (value.endsWith("%")) {
+    var percentage = parseNumber(value.slice(0, -1));
+    return percentage === null ? null : percentage / 100 * percentageBasis;
+  }
+  return parseNumber(value);
+}
+function parsePercentage(value) {
+  if (!value.endsWith("%")) {
+    return null;
+  }
+  return parseNumber(value.slice(0, -1));
+}
+function parseAlpha(value) {
+  if (value === null) {
+    return 1;
+  }
+  if (value === "none") {
+    return 0;
+  }
+  var parsed = parseNumberOrPercentage(value, 1);
+  return parsed === null ? null : clamp(parsed, 0, 1);
+}
+function parseHue(value) {
+  var match = /^([+-]?(?:\d+\.?\d*|\.\d+))(deg|grad|rad|turn)?$/.exec(value);
+  if (!match) {
+    return null;
+  }
+  var amount = Number(match[1]);
+  switch (match[2]) {
+    case "grad":
+      return amount / 400 * 360;
+    case "rad":
+      return amount * 180 / Math.PI;
+    case "turn":
+      return amount * 360;
+    default:
+      return amount;
+  }
+}
+function normalizeHue(hue) {
+  var wrapped = hue % 360;
+  return wrapped < 0 ? wrapped + 360 : wrapped;
+}
+function parseHex(value) {
+  var hex = value.slice(1);
+  if (!/^[0-9a-f]+$/i.test(hex)) {
+    return null;
+  }
+  var expand = function expand(_char) {
+    return parseInt(_char + _char, 16);
+  };
+  var pair = function pair(index) {
+    return parseInt(hex.slice(index, index + 2), 16);
+  };
+  if (hex.length === 3 || hex.length === 4) {
+    return {
+      r: expand(hex[0]),
+      g: expand(hex[1]),
+      b: expand(hex[2]),
+      a: hex.length === 4 ? expand(hex[3]) / 255 : 1
+    };
+  }
+  if (hex.length === 6 || hex.length === 8) {
+    return {
+      r: pair(0),
+      g: pair(2),
+      b: pair(4),
+      a: hex.length === 8 ? pair(6) / 255 : 1
+    };
+  }
+  return null;
+}
+function extractFunctionArgs(value, name) {
+  if (!value.startsWith(name + "(") || !value.endsWith(")")) {
+    return null;
+  }
+  return value.slice(name.length + 1, -1);
+}
+function parseRgb(value) {
+  var _extractFunctionArgs;
+  var args = (_extractFunctionArgs = extractFunctionArgs(value, "rgba")) !== null && _extractFunctionArgs !== void 0 ? _extractFunctionArgs : extractFunctionArgs(value, "rgb");
+  if (args === null) {
+    return null;
+  }
+  var split = splitComponents(args);
+  if (!split) {
+    return null;
+  }
+  var channels = split.components.map(function (component) {
+    return component === "none" ? 0 : parseNumberOrPercentage(component, 255);
+  });
+  var alpha = parseAlpha(split.alpha);
+  if (channels.some(function (channel) {
+    return channel === null;
+  }) || alpha === null) {
+    return null;
+  }
+  return {
+    r: clamp(channels[0], 0, 255),
+    g: clamp(channels[1], 0, 255),
+    b: clamp(channels[2], 0, 255),
+    a: alpha
+  };
+}
+function parseHsl(value) {
+  var _extractFunctionArgs2, _parsePercentage, _parsePercentage2;
+  var args = (_extractFunctionArgs2 = extractFunctionArgs(value, "hsla")) !== null && _extractFunctionArgs2 !== void 0 ? _extractFunctionArgs2 : extractFunctionArgs(value, "hsl");
+  if (args === null) {
+    return null;
+  }
+  var split = splitComponents(args);
+  if (!split) {
+    return null;
+  }
+  var _split$components = _slicedToArray(split.components, 3),
+    rawHue = _split$components[0],
+    rawSaturation = _split$components[1],
+    rawLightness = _split$components[2];
+  var hue = rawHue === "none" ? 0 : parseHue(rawHue);
+  // CSS requires percentages for s/l in hsl(), but the modern syntax also
+  // allows bare numbers, so accept both.
+  var saturation = rawSaturation === "none" ? 0 : (_parsePercentage = parsePercentage(rawSaturation)) !== null && _parsePercentage !== void 0 ? _parsePercentage : parseNumber(rawSaturation);
+  var lightness = rawLightness === "none" ? 0 : (_parsePercentage2 = parsePercentage(rawLightness)) !== null && _parsePercentage2 !== void 0 ? _parsePercentage2 : parseNumber(rawLightness);
+  var alpha = parseAlpha(split.alpha);
+  if (hue === null || saturation === null || lightness === null || alpha === null) {
+    return null;
+  }
+  return _objectSpread2(_objectSpread2({}, hslToRgb(normalizeHue(hue), clamp(saturation, 0, 100), clamp(lightness, 0, 100))), {}, {
+    a: alpha
+  });
+}
+function parseOklch(value) {
+  var args = extractFunctionArgs(value, "oklch");
+  if (args === null) {
+    return null;
+  }
+  var split = splitComponents(args);
+  if (!split) {
+    return null;
+  }
+  var _split$components2 = _slicedToArray(split.components, 3),
+    rawLightness = _split$components2[0],
+    rawChroma = _split$components2[1],
+    rawHue = _split$components2[2];
+  // Lightness is a <number> in 0-1 or a <percentage>, chroma is a <number>
+  // where 0.4 is roughly the maximum, or a <percentage> where 100% = 0.4.
+  var lightness = rawLightness === "none" ? 0 : parseNumberOrPercentage(rawLightness, 1);
+  var chroma = rawChroma === "none" ? 0 : parseNumberOrPercentage(rawChroma, 0.4);
+  var hue = rawHue === "none" ? 0 : parseHue(rawHue);
+  var alpha = parseAlpha(split.alpha);
+  if (lightness === null || chroma === null || hue === null || alpha === null) {
+    return null;
+  }
+  return _objectSpread2(_objectSpread2({}, oklchToRgb(clamp(lightness, 0, 1), Math.max(0, chroma), normalizeHue(hue))), {}, {
+    a: alpha
+  });
+}
+
+/**
+ * Parses a CSS color string into sRGB channels.
+ *
+ * Accepts hex (3, 4, 6 and 8 digits), `rgb()` / `rgba()`, `hsl()` / `hsla()`
+ * and `oklch()`, in both the legacy comma and the modern space syntax. Returns
+ * `null` if the value is not a color we can parse - notably: named colors
+ * (`red`), `color()`, `lab()` and `color-mix()` are not supported.
+ */
+function parseColor(value) {
+  var normalized = value.trim().toLowerCase();
+  if (normalized === "") {
+    return null;
+  }
+  switch (detectColorFormat(normalized)) {
+    case "hex":
+      return parseHex(normalized);
+    case "rgb":
+      return parseRgb(normalized);
+    case "hsl":
+      return parseHsl(normalized);
+    case "oklch":
+      return parseOklch(normalized);
+    default:
+      return null;
+  }
+}
+
+/**
+ * Rounds to at most `decimals` decimals, without trailing zeros.
+ */
+function round(value, decimals) {
+  var factor = Math.pow(10, decimals);
+  // `|| 0` normalizes -0 to 0
+  return Math.round(value * factor) / factor || 0;
+}
+function toHexPair(value) {
+  return clamp(Math.round(value), 0, 255).toString(16).padStart(2, "0");
+}
+function rgbToHsl(r, g, b) {
+  var red = r / 255;
+  var green = g / 255;
+  var blue = b / 255;
+  var max = Math.max(red, green, blue);
+  var min = Math.min(red, green, blue);
+  var delta = max - min;
+  var l = (max + min) / 2;
+  if (delta === 0) {
+    return {
+      h: 0,
+      s: 0,
+      l: l * 100
+    };
+  }
+  var s = delta / (1 - Math.abs(2 * l - 1));
+  var h;
+  if (max === red) {
+    h = (green - blue) / delta % 6;
+  } else if (max === green) {
+    h = (blue - red) / delta + 2;
+  } else {
+    h = (red - green) / delta + 4;
+  }
+  return {
+    h: normalizeHue(h * 60),
+    s: s * 100,
+    l: l * 100
+  };
+}
+function hslToRgb(h, s, l) {
+  var saturation = s / 100;
+  var lightness = l / 100;
+  var c = (1 - Math.abs(2 * lightness - 1)) * saturation;
+  var hPrime = normalizeHue(h) / 60;
+  var x = c * (1 - Math.abs(hPrime % 2 - 1));
+  var m = lightness - c / 2;
+  var rgb;
+  if (hPrime < 1) {
+    rgb = [c, x, 0];
+  } else if (hPrime < 2) {
+    rgb = [x, c, 0];
+  } else if (hPrime < 3) {
+    rgb = [0, c, x];
+  } else if (hPrime < 4) {
+    rgb = [0, x, c];
+  } else if (hPrime < 5) {
+    rgb = [x, 0, c];
+  } else {
+    rgb = [c, 0, x];
+  }
+  return {
+    r: (rgb[0] + m) * 255,
+    g: (rgb[1] + m) * 255,
+    b: (rgb[2] + m) * 255
+  };
+}
+function srgbToLinear(channel) {
+  var c = channel / 255;
+  return c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+}
+function linearToSrgb(channel) {
+  var c = channel <= 0.0031308 ? channel * 12.92 : 1.055 * Math.pow(channel, 1 / 2.4) - 0.055;
+  return clamp(c * 255, 0, 255);
+}
+
+/**
+ * sRGB to Oklch, using Björn Ottosson's Oklab matrices.
+ */
+function rgbToOklch(r, g, b) {
+  var lr = srgbToLinear(r);
+  var lg = srgbToLinear(g);
+  var lb = srgbToLinear(b);
+  var _long = Math.cbrt(0.4122214708 * lr + 0.5363325363 * lg + 0.0514459929 * lb);
+  var medium = Math.cbrt(0.2119034982 * lr + 0.6806995451 * lg + 0.1073969566 * lb);
+  var _short = Math.cbrt(0.0883024619 * lr + 0.2817188376 * lg + 0.6299787005 * lb);
+  var lightness = 0.2104542553 * _long + 0.793617785 * medium - 0.0040720468 * _short;
+  var a = 1.9779984951 * _long - 2.428592205 * medium + 0.4505937099 * _short;
+  var bComponent = 0.0259040371 * _long + 0.7827717662 * medium - 0.808675766 * _short;
+  var chroma = Math.sqrt(a * a + bComponent * bComponent);
+  // Achromatic colors have an undefined hue: report 0 rather than the noise
+  // that atan2 of two near-zero numbers produces.
+  var hue = chroma < 1e-6 ? 0 : normalizeHue(Math.atan2(bComponent, a) * 180 / Math.PI);
+  return {
+    l: clamp(lightness, 0, 1),
+    c: chroma,
+    h: hue
+  };
+}
+
+/**
+ * Oklch to sRGB. Out of gamut colors are clipped per channel.
+ */
+function oklchToRgb(l, c, h) {
+  var hueRadians = normalizeHue(h) * Math.PI / 180;
+  var a = c * Math.cos(hueRadians);
+  var bComponent = c * Math.sin(hueRadians);
+  var _long2 = Math.pow(l + 0.3963377774 * a + 0.2158037573 * bComponent, 3);
+  var medium = Math.pow(l - 0.1055613458 * a - 0.0638541728 * bComponent, 3);
+  var _short2 = Math.pow(l - 0.0894841775 * a - 1.291485548 * bComponent, 3);
+  return {
+    r: linearToSrgb(4.0767416621 * _long2 - 3.3077115913 * medium + 0.2309699292 * _short2),
+    g: linearToSrgb(-1.2684380046 * _long2 + 2.6097574011 * medium - 0.3413193965 * _short2),
+    b: linearToSrgb(-0.0041960863 * _long2 - 0.7034186147 * medium + 1.707614701 * _short2)
+  };
+}
+
+/**
+ * Serializes a color to the canonical string of the given format.
+ *
+ * The modern, space separated CSS syntax is used for the color functions
+ * (`rgb(255 0 0 / 0.5)`). Alpha is only included when it is not fully opaque.
+ */
+function formatColor(color, format) {
+  var alpha = clamp(color.a, 0, 1);
+  var alphaSuffix = alpha >= 1 ? "" : " / ".concat(round(alpha, 4));
+  switch (format) {
+    case "hex":
+      {
+        var hex = "#".concat(toHexPair(color.r)).concat(toHexPair(color.g)).concat(toHexPair(color.b));
+        return alpha >= 1 ? hex : "".concat(hex).concat(toHexPair(alpha * 255));
+      }
+    case "rgb":
+      {
+        var r = clamp(Math.round(color.r), 0, 255);
+        var g = clamp(Math.round(color.g), 0, 255);
+        var b = clamp(Math.round(color.b), 0, 255);
+        return "rgb(".concat(r, " ").concat(g, " ").concat(b).concat(alphaSuffix, ")");
+      }
+    case "hsl":
+      {
+        var _rgbToHsl = rgbToHsl(color.r, color.g, color.b),
+          h = _rgbToHsl.h,
+          s = _rgbToHsl.s,
+          l = _rgbToHsl.l;
+        return "hsl(".concat(round(h, 2), " ").concat(round(s, 2), "% ").concat(round(l, 2), "%").concat(alphaSuffix, ")");
+      }
+    case "oklch":
+      {
+        var _rgbToOklch = rgbToOklch(color.r, color.g, color.b),
+          _l = _rgbToOklch.l,
+          c = _rgbToOklch.c,
+          _h = _rgbToOklch.h;
+        return "oklch(".concat(round(_l, 4), " ").concat(round(c, 4), " ").concat(round(_h, 2)).concat(alphaSuffix, ")");
+      }
+  }
+}
+
+/**
+ * Converts a color string to the canonical string of the given format, or
+ * `null` if the input cannot be parsed.
+ */
+function convertColor(value, format) {
+  var parsed = parseColor(value);
+  if (parsed === null) {
+    return null;
+  }
+  return formatColor(parsed, format);
+}
+
+/**
+ * `#rrggbb`, which is what `<input type="color">` uses as its value.
+ */
+function colorToHex(color) {
+  return "#".concat(toHexPair(color.r)).concat(toHexPair(color.g)).concat(toHexPair(color.b));
+}
+
+/**
+ * An example of the canonical output of each format, used in error messages so
+ * that the expected syntax is obvious from the error alone.
+ */
+var FORMAT_EXAMPLES = {
+  hex: "#3b82f6",
+  rgb: "rgb(59 130 246)",
+  hsl: "hsl(217.22 91.22% 59.8%)",
+  oklch: "oklch(0.6231 0.188 259.81)"
+};
+var ColorSchema = /*#__PURE__*/function (_Schema) {
+  function ColorSchema(options) {
+    var _this;
+    var opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    var customValidateFunctions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+    var isReadonly = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+    var isHidden = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
+    var description = arguments.length > 5 ? arguments[5] : undefined;
+    _classCallCheck(this, ColorSchema);
+    _this = _callSuper(this, ColorSchema);
+    _this.options = options;
+    _this.opt = opt;
+    _this.customValidateFunctions = customValidateFunctions;
+    _this.isReadonly = isReadonly;
+    _this.isHidden = isHidden;
+    _this.description = description;
+    return _this;
+  }
+  _inherits(ColorSchema, _Schema);
+  return _createClass(ColorSchema, [{
+    key: "describe",
+    value: function describe(description) {
+      return new ColorSchema(this.options, this.opt, this.customValidateFunctions, this.isReadonly, this.isHidden, description !== null && description !== void 0 ? description : undefined);
+    }
+  }, {
+    key: "validate",
+    value: function validate(validationFunction) {
+      return new ColorSchema(this.options, this.opt, [].concat(_toConsumableArray(this.customValidateFunctions), [validationFunction]), this.isReadonly, this.isHidden, this.description);
+    }
+  }, {
+    key: "executeCustomValidateAt",
+    value: function executeCustomValidateAt(path, src) {
+      return this.executeCustomValidateFunctions(src, this.customValidateFunctions, {
+        path: path
+      });
+    }
+  }, {
+    key: "executeValidate",
+    value: function executeValidate(path, src) {
+      var _this$options$format, _this$options;
+      var errors = this.executeCustomValidateFunctions(src, this.customValidateFunctions, {
+        path: path
+      });
+      if (this.opt && (src === null || src === undefined)) {
+        return errors.length > 0 ? _defineProperty({}, path, errors) : false;
+      }
+      if (typeof src !== "string") {
+        errors.push({
+          message: "Expected 'string', got '".concat(_typeof(src), "'"),
+          value: src
+        });
+        return _defineProperty({}, path, errors);
+      }
+      var expectedFormat = (_this$options$format = (_this$options = this.options) === null || _this$options === void 0 ? void 0 : _this$options.format) !== null && _this$options$format !== void 0 ? _this$options$format : DEFAULT_COLOR_FORMAT;
+      var parsed = parseColor(src);
+      if (parsed === null) {
+        errors.push({
+          message: "Invalid color: '".concat(src, "'. Expected a CSS color in the '").concat(expectedFormat, "' format (e.g. '").concat(FORMAT_EXAMPLES[expectedFormat], "')"),
+          value: src
+        });
+      } else {
+        var _this$options3;
+        var actualFormat = detectColorFormat(src);
+        if (actualFormat !== expectedFormat) {
+          var _this$options2;
+          // Drop alpha from the SUGGESTION when alpha is not enabled, the same way
+          // the field's commit does. Keeping it would suggest a value that fails
+          // the alpha check immediately below, so following the advice would not
+          // clear the error.
+          var suggestion = formatColor((_this$options2 = this.options) !== null && _this$options2 !== void 0 && _this$options2.alpha ? parsed : _objectSpread2(_objectSpread2({}, parsed), {}, {
+            a: 1
+          }), expectedFormat);
+          errors.push({
+            message: "Expected a color in the '".concat(expectedFormat, "' format (e.g. '").concat(FORMAT_EXAMPLES[expectedFormat], "'), got '").concat(src, "'. Did you mean '").concat(suggestion, "'?"),
+            value: src
+          });
+        }
+        if (!((_this$options3 = this.options) !== null && _this$options3 !== void 0 && _this$options3.alpha) && parsed.a < 1) {
+          errors.push({
+            message: "Color '".concat(src, "' has an alpha channel, but alpha is not enabled. Use s.color({ alpha: true }) to allow transparency"),
+            value: src
+          });
+        }
+      }
+      if (errors.length > 0) {
+        return _defineProperty({}, path, errors);
+      }
+      return false;
+    }
+  }, {
+    key: "executeAssert",
+    value: function executeAssert(path, src) {
+      if (this.opt && src === null) {
+        return {
+          success: true,
+          data: src
+        };
+      }
+      if (src === null) {
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "Expected 'string', got 'null'",
+            typeError: true
+          }])
+        };
+      }
+      if (typeof src !== "string") {
+        return {
+          success: false,
+          errors: _defineProperty({}, path, [{
+            message: "Expected 'string', got '".concat(_typeof(src), "'"),
+            typeError: true
+          }])
+        };
+      }
+      return {
+        success: true,
+        data: src
+      };
+    }
+  }, {
+    key: "nullable",
+    value: function nullable() {
+      return new ColorSchema(this.options, true, [], this.isReadonly, this.isHidden, this.description);
+    }
+  }, {
+    key: "readonly",
+    value: function readonly() {
+      return new ColorSchema(this.options, this.opt, this.customValidateFunctions, true, this.isHidden, this.description);
+    }
+  }, {
+    key: "hidden",
+    value: function hidden() {
+      return new ColorSchema(this.options, this.opt, this.customValidateFunctions, this.isReadonly, true, this.description);
+    }
+  }, {
+    key: "executeSerialize",
+    value: function executeSerialize() {
+      var _this$customValidateF;
+      return {
+        type: "color",
+        opt: this.opt,
+        options: this.options,
+        customValidate: this.customValidateFunctions && ((_this$customValidateF = this.customValidateFunctions) === null || _this$customValidateF === void 0 ? void 0 : _this$customValidateF.length) > 0,
+        readonly: this.isReadonly,
+        hidden: this.isHidden,
+        description: this.description
+      };
+    }
+  }, {
+    key: "executeRender",
+    value: function executeRender() {
+      return {};
+    }
+  }]);
+}(Schema);
+var color = function color(options) {
+  return new ColorSchema(options);
+};
+
 function router(router, keyOrItem, maybeItem) {
   if (maybeItem) {
     return new RecordSchema(maybeItem, false, [], router, keyOrItem);
@@ -5543,6 +6184,7 @@ function initSchema() {
     files: files,
     date: date,
     datetime: datetime,
+    color: color,
     route: route,
     router: router,
     images: images
@@ -7265,6 +7907,8 @@ function deserializeSchemaImpl(serialized) {
       return new DateSchema(serialized.options, serialized.opt, [], false, false, serialized.description);
     case "dateTime":
       return new DateTimeSchema(serialized.options, serialized.opt, [], false, false, serialized.description);
+    case "color":
+      return new ColorSchema(serialized.options, serialized.opt, [], false, false, serialized.description);
     default:
       {
         var exhaustiveCheck = serialized;
@@ -7551,6 +8195,13 @@ var Internal = {
   joinModuleFilePathAndModulePath: joinModuleFilePathAndModulePath,
   nextAppRouter: nextAppRouter,
   externalPageRouter: externalPageRouter,
+  color: {
+    parseColor: parseColor,
+    formatColor: formatColor,
+    convertColor: convertColor,
+    detectColorFormat: detectColorFormat,
+    colorToHex: colorToHex
+  },
   remote: {
     createRemoteRef: createRemoteRef,
     getValidationBasis: getValidationBasis,
@@ -7633,7 +8284,10 @@ function tryJsonParse(str) {
 
 exports.ArraySchema = ArraySchema;
 exports.BooleanSchema = BooleanSchema;
+exports.COLOR_FORMATS = COLOR_FORMATS;
+exports.ColorSchema = ColorSchema;
 exports.DEFAULT_APP_HOST = DEFAULT_APP_HOST;
+exports.DEFAULT_COLOR_FORMAT = DEFAULT_COLOR_FORMAT;
 exports.DEFAULT_CONTENT_HOST = DEFAULT_CONTENT_HOST;
 exports.DEFAULT_VAL_REMOTE_HOST = DEFAULT_VAL_REMOTE_HOST;
 exports.DateSchema = DateSchema;