@design-edito/tools 0.2.37 → 0.2.40

package/chunks/chunk-DFDH7MGI.js

@@ -1,206 +0,0 @@
-import {
-  isLightenOperationParams,
-  lighten
-} from "./chunk-RHKFMXM3.js";
-import {
-  isResizeOperationParams,
-  resize
-} from "./chunk-STPN5KZL.js";
-import {
-  isNormalizeOperationParams,
-  normalize
-} from "./chunk-3G6FOHII.js";
-import {
-  isRotateOperationParams,
-  rotate
-} from "./chunk-QWNWZBIO.js";
-import {
-  hue,
-  isHueOperationParams
-} from "./chunk-QSU3CVGF.js";
-import {
-  isSaturateOperationParams,
-  saturate
-} from "./chunk-QTA7ZEVX.js";
-import {
-  isOverlayOperationParams,
-  overlay
-} from "./chunk-CLLJV343.js";
-import {
-  extend,
-  isExtendOperationParams
-} from "./chunk-YVKM7N55.js";
-import {
-  brighten,
-  isBrightenOperationParams
-} from "./chunk-SRXNICSE.js";
-import {
-  flatten,
-  isFlattenOperationParams
-} from "./chunk-P5JJOC5K.js";
-import {
-  extract,
-  isExtractOperationParams
-} from "./chunk-HFZGH6V2.js";
-import {
-  flip
-} from "./chunk-WNDMYNDU.js";
-import {
-  blur,
-  isBlurOperationParams
-} from "./chunk-P26Y7YUA.js";
-import {
-  isLevelOperationParams,
-  level
-} from "./chunk-2HJPX7E3.js";
-import {
-  flop
-} from "./chunk-YA2YCZUF.js";
-import {
-  toSharpInstance
-} from "./chunk-D5CCWCEI.js";
-import {
-  Outcome
-} from "./chunk-JMU5PDBD.js";
-import {
-  isNonNullObject
-} from "./chunk-HQLRJ7XW.js";
-import {
-  unknownToString
-} from "./chunk-FENXVJYO.js";
-import {
-  __export
-} from "./chunk-WSFCRVEQ.js";
-
-// src/node/images/transform/index.ts
-var transform_exports = {};
-__export(transform_exports, {
-  isOperationDescriptor: () => isOperationDescriptor,
-  transform: () => transform
-});
-var validators = {
-  ["blur" /* BLUR */]: isBlurOperationParams,
-  ["brighten" /* BRIGHTEN */]: isBrightenOperationParams,
-  ["extend" /* EXTEND */]: isExtendOperationParams,
-  ["extract" /* EXTRACT */]: isExtractOperationParams,
-  ["flatten" /* FLATTEN */]: isFlattenOperationParams,
-  ["hue" /* HUE */]: isHueOperationParams,
-  ["level" /* LEVEL */]: isLevelOperationParams,
-  ["lighten" /* LIGHTEN */]: isLightenOperationParams,
-  ["normalize" /* NORMALIZE */]: isNormalizeOperationParams,
-  ["overlay" /* OVERLAY */]: isOverlayOperationParams,
-  ["resize" /* RESIZE */]: isResizeOperationParams,
-  ["rotate" /* ROTATE */]: isRotateOperationParams,
-  ["saturate" /* SATURATE */]: isSaturateOperationParams
-};
-function isOperationDescriptor(obj) {
-  if (!isNonNullObject(obj)) return Outcome.makeFailure("Invalid operation descriptor");
-  if (!("name" in obj) || typeof obj.name !== "string") return Outcome.makeFailure("Field named 'name' in operation descriptor is required and must be a string");
-  const name = obj.name;
-  const validateOperation = (validatorFn) => {
-    const result = validatorFn(obj);
-    if (result.success) return Outcome.makeSuccess({ name: obj.name, ...result.payload });
-    return Outcome.makeFailure(result.error);
-  };
-  const simpleOperations = /* @__PURE__ */ new Set(["flip" /* FLIP */, "flop" /* FLOP */]);
-  if (simpleOperations.has(name)) return Outcome.makeSuccess({ name });
-  const validator = validators[name];
-  if (validator) return validateOperation(validator);
-  return Outcome.makeFailure("Invalid operation descriptor");
-}
-async function transform(input, operationsSequence, limits) {
-  let sharpInstance = await toSharpInstance(input);
-  const start = Date.now();
-  const deadline = limits?.timeoutMs !== void 0 ? start + limits.timeoutMs : void 0;
-  const runWithOpTimeout = async (op) => {
-    return limits?.opTimeoutMs === void 0 ? op() : Promise.race([op(), new Promise(
-      (resolve) => setTimeout(
-        () => resolve("op-timeout" /* OP_TIMEOUT */),
-        limits.opTimeoutMs
-      )
-    )]);
-  };
-  for (const operation of operationsSequence) {
-    if (deadline !== void 0 && Date.now() > deadline) return Outcome.makeFailure({
-      code: "process-timeout" /* PROCESS_TIMEOUT */,
-      details: "Process timed out"
-    });
-    let result;
-    try {
-      result = await runWithOpTimeout(async () => {
-        switch (operation.name) {
-          case "blur" /* BLUR */:
-            return blur(sharpInstance, operation);
-          case "brighten" /* BRIGHTEN */:
-            return brighten(sharpInstance, operation);
-          case "extend" /* EXTEND */:
-            return extend(sharpInstance, operation);
-          case "extract" /* EXTRACT */:
-            return extract(sharpInstance, operation);
-          case "flatten" /* FLATTEN */:
-            return flatten(sharpInstance, operation);
-          case "flip" /* FLIP */:
-            return flip(sharpInstance);
-          case "flop" /* FLOP */:
-            return flop(sharpInstance);
-          case "hue" /* HUE */:
-            return hue(sharpInstance, operation);
-          case "level" /* LEVEL */:
-            return level(sharpInstance, operation);
-          case "lighten" /* LIGHTEN */:
-            return lighten(sharpInstance, operation);
-          case "normalize" /* NORMALIZE */:
-            return normalize(sharpInstance, operation);
-          case "overlay" /* OVERLAY */:
-            return overlay(sharpInstance, operation);
-          case "resize" /* RESIZE */:
-            return resize(sharpInstance, operation);
-          case "rotate" /* ROTATE */:
-            return rotate(sharpInstance, operation);
-          case "saturate" /* SATURATE */:
-            return saturate(sharpInstance, operation);
-          default:
-            return sharpInstance;
-        }
-      });
-    } catch (err) {
-      return Outcome.makeFailure({
-        code: "unknown-error" /* UNKNOWN_ERROR */,
-        details: unknownToString(err)
-      });
-    }
-    if (result === "op-timeout" /* OP_TIMEOUT */) return Outcome.makeFailure({
-      code: "op-timeout" /* OP_TIMEOUT */,
-      details: "Operation timed out"
-    });
-    else {
-      sharpInstance = result;
-    }
-    if (limits === void 0) continue;
-    if (operation.name === "resize" /* RESIZE */ || operation.name === "extend" /* EXTEND */ || operation.name === "extract" /* EXTRACT */ || operation.name === "rotate" /* ROTATE */) {
-      try {
-        const meta = await sharpInstance.metadata();
-        if (limits.width !== void 0 && meta.width && meta.width > limits.width) return Outcome.makeFailure({
-          code: "width-limit-exceeded" /* WIDTH_LIMIT_EXCEEDED */,
-          details: `Image width exceeded the limit (${meta.width}px)`
-        });
-        if (limits.height !== void 0 && meta.height && meta.height > limits.height) return Outcome.makeFailure({
-          code: "height-limit-exceeded" /* HEIGHT_LIMIT_EXCEEDED */,
-          details: `Image height exceeded the limit (${meta.height}px)`
-        });
-      } catch (err) {
-        return Outcome.makeFailure({
-          code: "unknown-error" /* UNKNOWN_ERROR */,
-          details: `Failed to read metadata: ${unknownToString(err)}`
-        });
-      }
-    }
-  }
-  return Outcome.makeSuccess(sharpInstance);
-}
-
-export {
-  isOperationDescriptor,
-  transform,
-  transform_exports
-};

package/chunks/chunk-DKITT7OT.js

@@ -1,296 +0,0 @@
-import {
-  zod_default
-} from "./chunk-DZ2T5DTY.js";
-import {
-  toSharpColor,
-  toSharpInstance
-} from "./chunk-D5CCWCEI.js";
-import {
-  Outcome
-} from "./chunk-JMU5PDBD.js";
-import {
-  clamp
-} from "./chunk-OSAXBA7G.js";
-import {
-  isColor
-} from "./chunk-67V4BGOB.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-EDVNAV3G.js

@@ -1,72 +0,0 @@
-// src/agnostic/css/generate-nice-color/index.ts
-var niceColors = [
-  "fuchsia",
-  "teal",
-  "aliceblue",
-  "bisque",
-  "blueviolet",
-  "burlywood",
-  "chocolate",
-  "coral",
-  "cornflowerblue",
-  "crimson",
-  "darkblue",
-  "darkgoldenrod",
-  "darkkhaki",
-  "darkmagenta",
-  "darkolivegreen",
-  "darkorange",
-  "darkorchid",
-  "darkred",
-  "darksalmon",
-  "darkslateblue",
-  "darkslategray",
-  "darkviolet",
-  "deeppink",
-  "deepskyblue",
-  "dodgerblue",
-  "firebrick",
-  "floralwhite",
-  "gainsboro",
-  "gold",
-  "hotpink",
-  "indianred",
-  "indigo",
-  "khaki",
-  "lavender",
-  "lightcoral",
-  "lightgreen",
-  "lightsalmon",
-  "lightsteelblue",
-  "limegreen",
-  "magenta",
-  "mediumseagreen",
-  "mediumspringgreen",
-  "mediumvioletred",
-  "moccasin",
-  "orangered",
-  "orchid",
-  "palegoldenrod",
-  "palevioletred",
-  "peachpuff",
-  "peru",
-  "plum",
-  "royalblue",
-  "sandybrown",
-  "springgreen",
-  "tan",
-  "thistle",
-  "tomato",
-  "violet",
-  "wheat",
-  "yellowgreen"
-];
-var generateNiceColor = () => {
-  const pos = Math.floor(Math.random() * niceColors.length);
-  return niceColors[pos];
-};
-
-export {
-  niceColors,
-  generateNiceColor
-};

package/chunks/chunk-EGBJXHCW.js

@@ -1,47 +0,0 @@
-import {
-  viaLab,
-  viaLch,
-  viaRgb
-} from "./chunk-FNQAF6CQ.js";
-import {
-  absoluteModulo
-} from "./chunk-DNIOWD7K.js";
-
-// src/agnostic/colors/invert/index.ts
-function invertRgb(color) {
-  return viaRgb(color, (rgb) => ({
-    ...rgb,
-    r: 255 - rgb.r,
-    g: 255 - rgb.g,
-    b: 255 - rgb.b
-  }));
-}
-function invertLab(color) {
-  return viaLab(color, (lab) => ({
-    ...lab,
-    l: 100 - lab.l,
-    a: -1 * lab.a,
-    b: -1 * lab.b
-  }));
-}
-function invertLch(color) {
-  return viaLch(color, (lch) => ({
-    ...lch,
-    l: 100 - lch.l,
-    h: absoluteModulo(lch.h + 180, 360)
-  }));
-}
-function invert(color, method = "lch") {
-  switch (method) {
-    case "rgb":
-      return invertRgb(color);
-    case "lab":
-      return invertLab(color);
-    case "lch":
-      return invertLch(color);
-  }
-}
-
-export {
-  invert
-};