@design-edito/tools 0.2.15 → 0.2.16

package/chunks/chunk-IDXUS2IO.js

@@ -0,0 +1,296 @@
+import {
+  zod_default
+} from "./chunk-DZ2T5DTY.js";
+import {
+  toSharpColor,
+  toSharpInstance
+} from "./chunk-BKIF2ELV.js";
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  clamp
+} from "./chunk-OSAXBA7G.js";
+import {
+  isColor
+} from "./chunk-UG5EMKGN.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/images/format/index.ts
+var format_exports = {};
+__export(format_exports, {
+  format: () => format,
+  isFormatAvifOptions: () => isFormatAvifOptions,
+  isFormatCommonOptions: () => isFormatCommonOptions,
+  isFormatHeifOptions: () => isFormatHeifOptions,
+  isFormatJpgOptions: () => isFormatJpgOptions,
+  isFormatOptions: () => isFormatOptions,
+  isFormatPngOptions: () => isFormatPngOptions,
+  isFormatTiffOptions: () => isFormatTiffOptions,
+  isFormatWebpOptions: () => isFormatWebpOptions,
+  toAvif: () => toAvif,
+  toHeif: () => toHeif,
+  toHeight: () => toHeight,
+  toJpg: () => toJpg,
+  toPng: () => toPng,
+  toSharpAvifOptions: () => toSharpAvifOptions,
+  toSharpHeifOptions: () => toSharpHeifOptions,
+  toSharpJpegOptions: () => toSharpJpegOptions,
+  toSharpPngOptions: () => toSharpPngOptions,
+  toSharpResizeOptions: () => toSharpResizeOptions,
+  toSharpTiffOptions: () => toSharpTiffOptions,
+  toSharpWebpOptions: () => toSharpWebpOptions,
+  toTiff: () => toTiff,
+  toWebp: () => toWebp,
+  toWidth: () => toWidth
+});
+var formatCommonOptionsSchema = zod_default.object({
+  width: zod_default.number().optional(),
+  height: zod_default.number().optional(),
+  fit: zod_default.enum(["contain", "cover", "fill", "inside", "outside"]).optional(),
+  position: zod_default.union([zod_default.number(), zod_default.string()]).optional(),
+  background: zod_default.custom(isColor).optional(),
+  kernel: zod_default.enum(["nearest", "cubic", "mitchell", "lanczos2", "lanczos3", "mks2013", "mks2021"]).optional(),
+  withoutEnlargement: zod_default.boolean().optional(),
+  withoutReduction: zod_default.boolean().optional(),
+  fastShrinkOnLoad: zod_default.boolean().optional()
+});
+var formatJpgOptionsSchema = formatCommonOptionsSchema.extend({
+  type: zod_default.union([zod_default.literal("jpg"), zod_default.literal("jpeg")]),
+  quality: zod_default.number().optional(),
+  force: zod_default.boolean().optional(),
+  progressive: zod_default.boolean().optional(),
+  chromaSubsampling: zod_default.string().optional(),
+  trellisQuantisation: zod_default.boolean().optional(),
+  overshootDeringing: zod_default.boolean().optional(),
+  optimizeScans: zod_default.boolean().optional(),
+  optimizeCoding: zod_default.boolean().optional(),
+  quantizationTable: zod_default.number().optional(),
+  mozjpeg: zod_default.boolean().optional()
+});
+var formatPngOptionsSchema = formatCommonOptionsSchema.extend({
+  type: zod_default.literal("png"),
+  quality: zod_default.number().optional(),
+  force: zod_default.boolean().optional(),
+  progressive: zod_default.boolean().optional(),
+  compressionLevel: zod_default.number().min(0).max(9).optional(),
+  adaptiveFiltering: zod_default.boolean().optional(),
+  effort: zod_default.number().min(1).max(10).optional(),
+  palette: zod_default.boolean().optional(),
+  colors: zod_default.number().min(1).max(256).optional(),
+  dither: zod_default.number().min(0).max(1).optional()
+});
+var formatWebpOptionsSchema = formatCommonOptionsSchema.extend({
+  type: zod_default.literal("webp"),
+  quality: zod_default.number().optional(),
+  force: zod_default.boolean().optional(),
+  alphaQuality: zod_default.number().optional(),
+  lossless: zod_default.boolean().optional(),
+  nearLossless: zod_default.boolean().optional(),
+  smartSubsample: zod_default.boolean().optional(),
+  smartDeblock: zod_default.boolean().optional(),
+  effort: zod_default.number().optional(),
+  minSize: zod_default.boolean().optional(),
+  mixed: zod_default.boolean().optional(),
+  preset: zod_default.enum(["default", "picture", "photo", "drawing", "icon", "text"]).optional(),
+  loop: zod_default.number().optional(),
+  delay: zod_default.union([zod_default.number(), zod_default.array(zod_default.number())]).optional()
+});
+var formatAvifOptionsSchema = formatCommonOptionsSchema.extend({
+  type: zod_default.literal("avif"),
+  quality: zod_default.number().optional(),
+  force: zod_default.boolean().optional(),
+  lossless: zod_default.boolean().optional(),
+  effort: zod_default.number().optional(),
+  chromaSubsampling: zod_default.string().optional(),
+  bitdepth: zod_default.union([zod_default.literal(8), zod_default.literal(10), zod_default.literal(12)]).optional()
+});
+var formatTiffOptionsSchema = formatCommonOptionsSchema.extend({
+  type: zod_default.literal("tiff"),
+  quality: zod_default.number().optional(),
+  compression: zod_default.enum(["none", "jpeg", "deflate", "packbits", "ccittfax4", "lzw", "webp", "zstd", "jp2k"]).optional(),
+  force: zod_default.boolean().optional(),
+  predictor: zod_default.enum(["none", "horizontal", "float"]).optional(),
+  pyramid: zod_default.boolean().optional(),
+  tile: zod_default.boolean().optional(),
+  tileWidth: zod_default.number().optional(),
+  tileHeight: zod_default.number().optional(),
+  xres: zod_default.number().optional(),
+  yres: zod_default.number().optional(),
+  bitdepth: zod_default.union([zod_default.literal(1), zod_default.literal(2), zod_default.literal(4), zod_default.literal(8)]).optional(),
+  miniswhite: zod_default.boolean().optional(),
+  resolutionUnit: zod_default.enum(["inch", "cm"]).optional()
+});
+var formatHeifOptionsSchema = formatCommonOptionsSchema.extend({
+  type: zod_default.literal("heif"),
+  quality: zod_default.number().optional(),
+  force: zod_default.boolean().optional(),
+  compression: zod_default.enum(["av1", "hevc"]).optional(),
+  lossless: zod_default.boolean().optional(),
+  effort: zod_default.number().optional(),
+  chromaSubsampling: zod_default.string().optional(),
+  bitdepth: zod_default.union([zod_default.literal(8), zod_default.literal(10), zod_default.literal(12)]).optional()
+});
+var formatKeepOptionsSchema = formatCommonOptionsSchema;
+var formatOptionsSchema = zod_default.union([
+  formatJpgOptionsSchema,
+  formatPngOptionsSchema,
+  formatWebpOptionsSchema,
+  formatAvifOptionsSchema,
+  formatTiffOptionsSchema,
+  formatHeifOptionsSchema,
+  formatKeepOptionsSchema
+]);
+var isFormatCommonOptions = (options) => formatCommonOptionsSchema.safeParse(options).success;
+var isFormatJpgOptions = (options) => formatJpgOptionsSchema.safeParse(options).success;
+var isFormatPngOptions = (options) => formatPngOptionsSchema.safeParse(options).success;
+var isFormatWebpOptions = (options) => formatWebpOptionsSchema.safeParse(options).success;
+var isFormatAvifOptions = (options) => formatAvifOptionsSchema.safeParse(options).success;
+var isFormatTiffOptions = (options) => formatTiffOptionsSchema.safeParse(options).success;
+var isFormatHeifOptions = (options) => formatHeifOptionsSchema.safeParse(options).success;
+var isFormatOptions = (options) => formatOptionsSchema.safeParse(options).success;
+var toSharpResizeOptions = (options) => {
+  return {
+    width: options.width,
+    height: options.height,
+    fit: options.fit,
+    position: options.position,
+    background: options.background ? toSharpColor(options.background) : void 0,
+    kernel: options.kernel,
+    withoutEnlargement: options.withoutEnlargement,
+    withoutReduction: options.withoutReduction,
+    fastShrinkOnLoad: options.fastShrinkOnLoad
+  };
+};
+var toSharpJpegOptions = (options) => {
+  return {
+    quality: options.quality,
+    force: options.force,
+    progressive: options.progressive,
+    chromaSubsampling: options.chromaSubsampling,
+    trellisQuantisation: options.trellisQuantisation,
+    overshootDeringing: options.overshootDeringing,
+    optimizeScans: options.optimizeScans,
+    optimizeCoding: options.optimizeCoding,
+    quantizationTable: options.quantizationTable,
+    mozjpeg: options.mozjpeg
+  };
+};
+var toSharpPngOptions = (options) => {
+  return {
+    quality: options.quality,
+    force: options.force,
+    progressive: options.progressive,
+    compressionLevel: options.compressionLevel,
+    adaptiveFiltering: options.adaptiveFiltering,
+    effort: options.effort,
+    palette: options.palette,
+    colors: options.colors,
+    dither: options.dither
+  };
+};
+var toSharpWebpOptions = (options) => {
+  return {
+    quality: options.quality,
+    loop: options.loop,
+    delay: options.delay,
+    force: options.force,
+    alphaQuality: options.alphaQuality,
+    lossless: options.lossless,
+    nearLossless: options.nearLossless,
+    smartSubsample: options.smartSubsample,
+    smartDeblock: options.smartDeblock,
+    effort: options.effort,
+    minSize: options.minSize,
+    mixed: options.mixed,
+    preset: options.preset
+  };
+};
+var toSharpAvifOptions = (options) => {
+  return {
+    force: options.force,
+    quality: options.quality,
+    lossless: options.lossless,
+    effort: options.effort,
+    chromaSubsampling: options.chromaSubsampling,
+    bitdepth: options.bitdepth
+  };
+};
+var toSharpTiffOptions = (options) => {
+  return {
+    force: options.force,
+    quality: options.quality,
+    compression: options.compression,
+    predictor: options.predictor,
+    pyramid: options.pyramid,
+    tile: options.tile,
+    tileWidth: options.tileWidth,
+    tileHeight: options.tileHeight,
+    xres: options.xres,
+    yres: options.yres,
+    bitdepth: options.bitdepth,
+    miniswhite: options.miniswhite,
+    resolutionUnit: options.resolutionUnit
+  };
+};
+var toSharpHeifOptions = (options) => {
+  return {
+    force: options.force,
+    quality: options.quality,
+    compression: options.compression,
+    lossless: options.lossless,
+    effort: options.effort,
+    chromaSubsampling: options.chromaSubsampling,
+    bitdepth: options.bitdepth
+  };
+};
+async function format(input, options) {
+  const sharpInstance = await toSharpInstance(input);
+  const resizeOptions = toSharpResizeOptions(options);
+  const resizedInstance = sharpInstance.resize(resizeOptions);
+  if (isFormatJpgOptions(options)) return Outcome.makeSuccess(await resizedInstance.jpeg(toSharpJpegOptions(options)).toBuffer());
+  if (isFormatPngOptions(options)) return Outcome.makeSuccess(await resizedInstance.png(toSharpPngOptions(options)).toBuffer());
+  if (isFormatWebpOptions(options)) return Outcome.makeSuccess(await resizedInstance.webp(toSharpWebpOptions(options)).toBuffer());
+  if (isFormatAvifOptions(options)) return Outcome.makeSuccess(await resizedInstance.avif(toSharpAvifOptions(options)).toBuffer());
+  if (isFormatTiffOptions(options)) return Outcome.makeSuccess(await resizedInstance.tiff(toSharpTiffOptions(options)).toBuffer());
+  if (isFormatHeifOptions(options)) return Outcome.makeSuccess(await resizedInstance.heif(toSharpHeifOptions(options)).toBuffer());
+  return Outcome.makeSuccess(await resizedInstance.toBuffer());
+}
+var toWidth = async (input, width) => (await toSharpInstance(input)).resize({ width }).toBuffer();
+var toHeight = async (input, height) => (await toSharpInstance(input)).resize({ height }).toBuffer();
+var toJpg = async (input, quality) => (await toSharpInstance(input)).jpeg({ quality: clamp(quality ?? 100, 1, 100) }).toBuffer();
+var toPng = async (input, quality, compressionLevel) => (await toSharpInstance(input)).png({ quality: clamp(quality ?? 100, 1, 100), compressionLevel }).toBuffer();
+var toWebp = async (input, quality) => (await toSharpInstance(input)).webp({ quality: clamp(quality ?? 100, 1, 100) }).toBuffer();
+var toAvif = async (input, quality) => (await toSharpInstance(input)).avif({ quality: clamp(quality ?? 100, 1, 100) }).toBuffer();
+var toTiff = async (input, quality, compression) => (await toSharpInstance(input)).tiff({ quality: clamp(quality ?? 100, 1, 100), compression }).toBuffer();
+var toHeif = async (input, quality) => (await toSharpInstance(input)).heif({ quality: clamp(quality ?? 100, 1, 100) }).toBuffer();
+
+export {
+  isFormatCommonOptions,
+  isFormatJpgOptions,
+  isFormatPngOptions,
+  isFormatWebpOptions,
+  isFormatAvifOptions,
+  isFormatTiffOptions,
+  isFormatHeifOptions,
+  isFormatOptions,
+  toSharpResizeOptions,
+  toSharpJpegOptions,
+  toSharpPngOptions,
+  toSharpWebpOptions,
+  toSharpAvifOptions,
+  toSharpTiffOptions,
+  toSharpHeifOptions,
+  format,
+  toWidth,
+  toHeight,
+  toJpg,
+  toPng,
+  toWebp,
+  toAvif,
+  toTiff,
+  toHeif,
+  format_exports
+};

package/chunks/chunk-JHUOMGOX.js

@@ -0,0 +1,81 @@
+import {
+  zod_default
+} from "./chunk-DZ2T5DTY.js";
+import {
+  isDuckTypedSharpInstance
+} from "./chunk-BKIF2ELV.js";
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+
+// src/node/images/transform/operations/overlay/index.ts
+function isOverlayOperationParams(obj) {
+  const schema = zod_default.object({
+    input: zod_default.custom(isDuckTypedSharpInstance),
+    top: zod_default.number().optional(),
+    left: zod_default.number().optional(),
+    tile: zod_default.boolean().optional(),
+    premultiplied: zod_default.boolean().optional(),
+    density: zod_default.number().optional(),
+    animated: zod_default.boolean().optional(),
+    autoOrient: zod_default.boolean().optional(),
+    ignoreIcc: zod_default.boolean().optional(),
+    pages: zod_default.number().optional(),
+    page: zod_default.number().optional(),
+    blend: zod_default.enum([
+      "clear",
+      "source",
+      "over",
+      "in",
+      "out",
+      "atop",
+      "dest",
+      "dest-over",
+      "dest-in",
+      "dest-out",
+      "dest-atop",
+      "xor",
+      "add",
+      "saturate",
+      "multiply",
+      "screen",
+      "overlay",
+      "darken",
+      "lighten",
+      "color-dodge",
+      "colour-dodge",
+      "color-burn",
+      "colour-burn",
+      "hard-light",
+      "soft-light",
+      "difference",
+      "exclusion"
+    ]).optional(),
+    gravity: zod_default.enum([
+      "north",
+      "northeast",
+      "southeast",
+      "south",
+      "southwest",
+      "west",
+      "northwest",
+      "east",
+      "center",
+      "centre"
+    ]).optional()
+  });
+  const result = schema.safeParse(obj);
+  if (!result.success) return Outcome.makeFailure(result.error.message);
+  return Outcome.makeSuccess(result.data);
+}
+async function overlay(sharpInstance, params) {
+  return sharpInstance.composite([{
+    ...params,
+    input: await params.input.toBuffer()
+  }]);
+}
+
+export {
+  isOverlayOperationParams,
+  overlay
+};

package/chunks/{chunk-EDJ3TVNV.js → chunk-KDOMQ4LM.js}

@@ -1,12 +1,15 @@
-import {
-  isSharpColor
-} from "./chunk-MFYNJMVM.js";
 import {
   zod_default
 } from "./chunk-DZ2T5DTY.js";
+import {
+  toSharpColor
+} from "./chunk-BKIF2ELV.js";
 import {
   Outcome
 } from "./chunk-JMU5PDBD.js";
+import {
+  isColor
+} from "./chunk-UG5EMKGN.js";
 
 // src/node/images/transform/operations/resize/index.ts
 function isResizeOperationParams(obj) {
@@ -24,13 +27,16 @@ function isResizeOperationParams(obj) {
       zod_default.number(),
       zod_default.string()
     ]).optional(),
-    background: zod_default.custom((val) => isSharpColor(val)).optional(),
+    background: zod_default.custom(isColor).optional(),
     kernel: zod_default.enum([
       "nearest",
       "cubic",
+      "linear",
       "mitchell",
       "lanczos2",
-      "lanczos3"
+      "lanczos3",
+      "mks2013",
+      "mks2021"
     ]).optional(),
     withoutEnlargement: zod_default.boolean().optional(),
     withoutReduction: zod_default.boolean().optional(),
@@ -41,7 +47,10 @@ function isResizeOperationParams(obj) {
   return Outcome.makeSuccess(result.data);
 }
 async function resize(sharpInstance, params) {
-  return sharpInstance.resize(params);
+  return sharpInstance.resize({
+    ...params,
+    background: params.background !== void 0 ? toSharpColor(params.background) : void 0
+  });
 }
 
 export {

package/chunks/chunk-MN4FVOU2.js

@@ -0,0 +1,28 @@
+import {
+  luminance
+} from "./chunk-VA67YLZL.js";
+import {
+  toRgb
+} from "./chunk-YZVZKBVJ.js";
+
+// src/agnostic/colors/contrast/index.ts
+function contrastWcag(c1, c2) {
+  const L1 = luminance(c1, "rgb");
+  const L2 = luminance(c2, "rgb");
+  const lighter = Math.max(L1, L2);
+  const darker = Math.min(L1, L2);
+  const numerator = lighter + 0.05;
+  const denominator = darker + 0.05;
+  const ratio = numerator / denominator;
+  return ratio;
+}
+function contrast(c1, c2, method = "wcag") {
+  switch (method) {
+    case "wcag":
+      return contrastWcag(toRgb(c1), toRgb(c2));
+  }
+}
+
+export {
+  contrast
+};

package/chunks/{chunk-2M33FCDG.js → chunk-O7VFJHQX.js}

@@ -1,24 +1,30 @@
-import {
-  isSharpColor
-} from "./chunk-MFYNJMVM.js";
 import {
   zod_default
 } from "./chunk-DZ2T5DTY.js";
+import {
+  toSharpColor
+} from "./chunk-BKIF2ELV.js";
 import {
   Outcome
 } from "./chunk-JMU5PDBD.js";
+import {
+  isColor
+} from "./chunk-UG5EMKGN.js";
 
 // src/node/images/transform/operations/flatten/index.ts
 function isFlattenOperationParams(obj) {
   const schema = zod_default.object({
-    background: zod_default.custom((val) => isSharpColor(val)).optional()
+    background: zod_default.custom(isColor).optional()
   });
   const result = schema.safeParse(obj);
   if (!result.success) return Outcome.makeFailure(result.error.message);
   return Outcome.makeSuccess(result.data);
 }
 async function flatten(sharpInstance, params) {
-  return sharpInstance.flatten(params);
+  const inputBg = params.background;
+  const rgbBackground = inputBg !== void 0 ? toSharpColor(inputBg) : void 0;
+  const background = rgbBackground !== void 0 ? rgbBackground : void 0;
+  return sharpInstance.flatten({ background });
 }
 
 export {

package/chunks/{chunk-2UAVBQI5.js → chunk-OD2XVVE2.js}

@@ -1,9 +1,9 @@
-import {
-  directory_exports
-} from "./chunk-4OK2UH4M.js";
 import {
   file_exports
-} from "./chunk-LAVXHKKR.js";
+} from "./chunk-73FF7HWQ.js";
+import {
+  directory_exports
+} from "./chunk-ZBAKY6DB.js";
 import {
   __export
 } from "./chunk-WSFCRVEQ.js";

package/chunks/{chunk-CHUOCTRP.js → chunk-P2H6PV4O.js}

@@ -1,9 +1,9 @@
 import {
   Crossenv
-} from "./chunk-UFKH5WD2.js";
+} from "./chunk-FR5H2OCV.js";
 import {
   Errors
-} from "./chunk-WH6BPDAC.js";
+} from "./chunk-2KT7AKRW.js";
 
 // src/shared/errors/index.ts
 var register = Errors.Register.from({

package/chunks/chunk-P4YT4RBG.js

@@ -0,0 +1,51 @@
+import {
+  toLab
+} from "./chunk-YZVZKBVJ.js";
+
+// src/agnostic/colors/distance/index.ts
+function distanceCiede2000(c1, c2) {
+  const deg2rad = (deg) => Math.PI / 180 * deg;
+  const rad2deg = (rad) => 180 / Math.PI * rad;
+  const C1 = Math.sqrt(c1.a * c1.a + c1.b * c1.b);
+  const C2 = Math.sqrt(c2.a * c2.a + c2.b * c2.b);
+  const meanC = (C1 + C2) / 2;
+  const meanC7 = Math.pow(meanC, 7);
+  const G = 0.5 * (1 - Math.sqrt(meanC7 / (meanC7 + Math.pow(25, 7))));
+  const a1p = (1 + G) * c1.a;
+  const a2p = (1 + G) * c2.a;
+  const C1p = Math.sqrt(a1p * a1p + c1.b * c1.b);
+  const C2p = Math.sqrt(a2p * a2p + c2.b * c2.b);
+  const h1p = Math.atan2(c1.b, a1p);
+  const h2p = Math.atan2(c2.b, a2p);
+  const dLp = c2.l - c1.l;
+  const dCp = C2p - C1p;
+  let dhp = h2p - h1p;
+  if (dhp > Math.PI) dhp -= 2 * Math.PI;
+  if (dhp < -Math.PI) dhp += 2 * Math.PI;
+  const dHp = 2 * Math.sqrt(C1p * C2p) * Math.sin(dhp / 2);
+  const meanLp = (c1.l + c2.l) / 2;
+  let meanHp = (h1p + h2p) / 2;
+  if (Math.abs(h1p - h2p) > Math.PI) {
+    meanHp += Math.PI;
+  }
+  const T = 1 - 0.17 * Math.cos(meanHp - deg2rad(30)) + 0.24 * Math.cos(2 * meanHp) + 0.32 * Math.cos(3 * meanHp + deg2rad(6)) - 0.2 * Math.cos(4 * meanHp - deg2rad(63));
+  const SL = 1 + 0.015 * (meanLp - 50) * (meanLp - 50) / Math.sqrt(20 + (meanLp - 50) * (meanLp - 50));
+  const SC = 1 + 0.045 * meanC;
+  const SH = 1 + 0.015 * meanC * T;
+  const deltaTheta = deg2rad(60) * Math.exp(-((rad2deg(meanHp) - 275) / 25) * ((rad2deg(meanHp) - 275) / 25));
+  const RC = Math.sqrt(Math.pow(meanC, 7) / (Math.pow(meanC, 7) + Math.pow(25, 7)));
+  const RT = -2 * RC * Math.sin(deltaTheta);
+  return Math.sqrt(
+    dLp / SL * (dLp / SL) + dCp / SC * (dCp / SC) + dHp / SH * (dHp / SH) + RT * (dCp / SC) * (dHp / SH)
+  );
+}
+function distance(c1, c2, method = "ciede2000") {
+  switch (method) {
+    case "ciede2000":
+      return distanceCiede2000(toLab(c1), toLab(c2));
+  }
+}
+
+export {
+  distance
+};

package/chunks/{chunk-CYUEPBUN.js → chunk-PX4DPCZM.js}

@@ -1,9 +1,9 @@
 import {
   Random
-} from "./chunk-OVG5RGI3.js";
+} from "./chunk-S32K7POB.js";
 import {
   register
-} from "./chunk-CHUOCTRP.js";
+} from "./chunk-P2H6PV4O.js";
 
 // src/agnostic/css/styles-set/index.tsx
 import { Component } from "react";

package/chunks/{chunk-YIZODJC7.js → chunk-QRS3G3YD.js}

@@ -1,12 +1,12 @@
+import {
+  directory_exports
+} from "./chunk-X5F6XGEP.js";
 import {
   file_exports
-} from "./chunk-IWDIKDYR.js";
+} from "./chunk-E33DCHHS.js";
 import {
   bucket_exports
-} from "./chunk-UXEKCYL7.js";
-import {
-  directory_exports
-} from "./chunk-AIC5YAJU.js";
+} from "./chunk-UEAMPAHK.js";
 import {
   __export
 } from "./chunk-WSFCRVEQ.js";

package/chunks/{chunk-FQ4UTWMP.js → chunk-QTA7ZEVX.js}

@@ -15,7 +15,9 @@ function isSaturateOperationParams(obj) {
   return Outcome.makeSuccess(result.data);
 }
 async function saturate(sharpInstance, params) {
-  return sharpInstance.modulate({ saturation: params.saturation });
+  return sharpInstance.modulate({
+    saturation: params.saturation
+  });
 }
 
 export {

package/chunks/chunk-QW34TQCS.js

@@ -0,0 +1,48 @@
+import {
+  addChannel
+} from "./chunk-ZJ63OCMA.js";
+import {
+  viaLab,
+  viaLch
+} from "./chunk-YZVZKBVJ.js";
+import {
+  absoluteModulo
+} from "./chunk-DNIOWD7K.js";
+
+// src/agnostic/colors/rotate/index.ts
+function rotateHsl(color, degrees) {
+  return addChannel(color, "hue", degrees);
+}
+function rotateLab(color, degrees) {
+  return viaLab(color, (lab) => {
+    const hue = Math.atan2(lab.b, lab.a) * (180 / Math.PI);
+    const chroma = Math.sqrt(lab.a ** 2 + lab.b ** 2);
+    const newHue = absoluteModulo(hue + degrees, 360);
+    const rad = newHue * (Math.PI / 180);
+    return {
+      ...lab,
+      a: chroma * Math.cos(rad),
+      b: chroma * Math.sin(rad)
+    };
+  });
+}
+function rotateLch(color, degrees) {
+  return viaLch(color, (lch) => ({
+    ...lch,
+    h: absoluteModulo(lch.h + degrees, 360)
+  }));
+}
+function rotate(color, degrees, method = "hsl") {
+  switch (method) {
+    case "hsl":
+      return rotateHsl(color, degrees);
+    case "lab":
+      return rotateLab(color, degrees);
+    case "lch":
+      return rotateLch(color, degrees);
+  }
+}
+
+export {
+  rotate
+};