@fecp/designer 5.6.5 → 5.6.8

package/lib/node_modules/khroma/dist/channels/index.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const index = require("../utils/index.js");
+const type = require("./type.js");
+const constants = require("../constants.js");
+class Channels {
+  /* CONSTRUCTOR */
+  constructor(data, color) {
+    this.color = color;
+    this.changed = false;
+    this.data = data;
+    this.type = new type.default();
+  }
+  /* API */
+  set(data, color) {
+    this.color = color;
+    this.changed = false;
+    this.data = data;
+    this.type.type = constants.TYPE.ALL;
+    return this;
+  }
+  /* HELPERS */
+  _ensureHSL() {
+    const data = this.data;
+    const { h, s, l } = data;
+    if (h === void 0)
+      data.h = index.default.channel.rgb2hsl(data, "h");
+    if (s === void 0)
+      data.s = index.default.channel.rgb2hsl(data, "s");
+    if (l === void 0)
+      data.l = index.default.channel.rgb2hsl(data, "l");
+  }
+  _ensureRGB() {
+    const data = this.data;
+    const { r, g, b } = data;
+    if (r === void 0)
+      data.r = index.default.channel.hsl2rgb(data, "r");
+    if (g === void 0)
+      data.g = index.default.channel.hsl2rgb(data, "g");
+    if (b === void 0)
+      data.b = index.default.channel.hsl2rgb(data, "b");
+  }
+  /* GETTERS */
+  get r() {
+    const data = this.data;
+    const r = data.r;
+    if (!this.type.is(constants.TYPE.HSL) && r !== void 0)
+      return r;
+    this._ensureHSL();
+    return index.default.channel.hsl2rgb(data, "r");
+  }
+  get g() {
+    const data = this.data;
+    const g = data.g;
+    if (!this.type.is(constants.TYPE.HSL) && g !== void 0)
+      return g;
+    this._ensureHSL();
+    return index.default.channel.hsl2rgb(data, "g");
+  }
+  get b() {
+    const data = this.data;
+    const b = data.b;
+    if (!this.type.is(constants.TYPE.HSL) && b !== void 0)
+      return b;
+    this._ensureHSL();
+    return index.default.channel.hsl2rgb(data, "b");
+  }
+  get h() {
+    const data = this.data;
+    const h = data.h;
+    if (!this.type.is(constants.TYPE.RGB) && h !== void 0)
+      return h;
+    this._ensureRGB();
+    return index.default.channel.rgb2hsl(data, "h");
+  }
+  get s() {
+    const data = this.data;
+    const s = data.s;
+    if (!this.type.is(constants.TYPE.RGB) && s !== void 0)
+      return s;
+    this._ensureRGB();
+    return index.default.channel.rgb2hsl(data, "s");
+  }
+  get l() {
+    const data = this.data;
+    const l = data.l;
+    if (!this.type.is(constants.TYPE.RGB) && l !== void 0)
+      return l;
+    this._ensureRGB();
+    return index.default.channel.rgb2hsl(data, "l");
+  }
+  get a() {
+    return this.data.a;
+  }
+  /* SETTERS */
+  set r(r) {
+    this.type.set(constants.TYPE.RGB);
+    this.changed = true;
+    this.data.r = r;
+  }
+  set g(g) {
+    this.type.set(constants.TYPE.RGB);
+    this.changed = true;
+    this.data.g = g;
+  }
+  set b(b) {
+    this.type.set(constants.TYPE.RGB);
+    this.changed = true;
+    this.data.b = b;
+  }
+  set h(h) {
+    this.type.set(constants.TYPE.HSL);
+    this.changed = true;
+    this.data.h = h;
+  }
+  set s(s) {
+    this.type.set(constants.TYPE.HSL);
+    this.changed = true;
+    this.data.s = s;
+  }
+  set l(l) {
+    this.type.set(constants.TYPE.HSL);
+    this.changed = true;
+    this.data.l = l;
+  }
+  set a(a) {
+    this.changed = true;
+    this.data.a = a;
+  }
+}
+exports.default = Channels;

package/lib/node_modules/khroma/dist/channels/reusable.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const index = require("./index.js");
+const channels = new index.default({ r: 0, g: 0, b: 0, a: 0 }, "transparent");
+exports.default = channels;

package/lib/node_modules/khroma/dist/channels/type.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const constants = require("../constants.js");
+class Type {
+  constructor() {
+    this.type = constants.TYPE.ALL;
+  }
+  /* API */
+  get() {
+    return this.type;
+  }
+  set(type) {
+    if (this.type && this.type !== type)
+      throw new Error("Cannot change both RGB and HSL channels at the same time");
+    this.type = type;
+  }
+  reset() {
+    this.type = constants.TYPE.ALL;
+  }
+  is(type) {
+    return this.type === type;
+  }
+}
+exports.default = Type;

package/lib/node_modules/khroma/dist/color/hex.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const reusable = require("../channels/reusable.js");
+const constants = require("../constants.js");
+const Hex = {
+  /* VARIABLES */
+  re: /^#((?:[a-f0-9]{2}){2,4}|[a-f0-9]{3})$/i,
+  /* API */
+  parse: (color) => {
+    if (color.charCodeAt(0) !== 35)
+      return;
+    const match = color.match(Hex.re);
+    if (!match)
+      return;
+    const hex = match[1];
+    const dec = parseInt(hex, 16);
+    const length = hex.length;
+    const hasAlpha = length % 4 === 0;
+    const isFullLength = length > 4;
+    const multiplier = isFullLength ? 1 : 17;
+    const bits = isFullLength ? 8 : 4;
+    const bitsOffset = hasAlpha ? 0 : -1;
+    const mask = isFullLength ? 255 : 15;
+    return reusable.default.set({
+      r: (dec >> bits * (bitsOffset + 3) & mask) * multiplier,
+      g: (dec >> bits * (bitsOffset + 2) & mask) * multiplier,
+      b: (dec >> bits * (bitsOffset + 1) & mask) * multiplier,
+      a: hasAlpha ? (dec & mask) * multiplier / 255 : 1
+    }, color);
+  },
+  stringify: (channels) => {
+    const { r, g, b, a } = channels;
+    if (a < 1) {
+      return `#${constants.DEC2HEX[Math.round(r)]}${constants.DEC2HEX[Math.round(g)]}${constants.DEC2HEX[Math.round(b)]}${constants.DEC2HEX[Math.round(a * 255)]}`;
+    } else {
+      return `#${constants.DEC2HEX[Math.round(r)]}${constants.DEC2HEX[Math.round(g)]}${constants.DEC2HEX[Math.round(b)]}`;
+    }
+  }
+};
+exports.default = Hex;

package/lib/node_modules/khroma/dist/color/hsl.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const index = require("../utils/index.js");
+const reusable = require("../channels/reusable.js");
+const HSL = {
+  /* VARIABLES */
+  re: /^hsla?\(\s*?(-?(?:\d+(?:\.\d+)?|(?:\.\d+))(?:e-?\d+)?(?:deg|grad|rad|turn)?)\s*?(?:,|\s)\s*?(-?(?:\d+(?:\.\d+)?|(?:\.\d+))(?:e-?\d+)?%)\s*?(?:,|\s)\s*?(-?(?:\d+(?:\.\d+)?|(?:\.\d+))(?:e-?\d+)?%)(?:\s*?(?:,|\/)\s*?\+?(-?(?:\d+(?:\.\d+)?|(?:\.\d+))(?:e-?\d+)?(%)?))?\s*?\)$/i,
+  hueRe: /^(.+?)(deg|grad|rad|turn)$/i,
+  /* HELPERS */
+  _hue2deg: (hue) => {
+    const match = hue.match(HSL.hueRe);
+    if (match) {
+      const [, number, unit] = match;
+      switch (unit) {
+        case "grad":
+          return index.default.channel.clamp.h(parseFloat(number) * 0.9);
+        case "rad":
+          return index.default.channel.clamp.h(parseFloat(number) * 180 / Math.PI);
+        case "turn":
+          return index.default.channel.clamp.h(parseFloat(number) * 360);
+      }
+    }
+    return index.default.channel.clamp.h(parseFloat(hue));
+  },
+  /* API */
+  parse: (color) => {
+    const charCode = color.charCodeAt(0);
+    if (charCode !== 104 && charCode !== 72)
+      return;
+    const match = color.match(HSL.re);
+    if (!match)
+      return;
+    const [, h, s, l, a, isAlphaPercentage] = match;
+    return reusable.default.set({
+      h: HSL._hue2deg(h),
+      s: index.default.channel.clamp.s(parseFloat(s)),
+      l: index.default.channel.clamp.l(parseFloat(l)),
+      a: a ? index.default.channel.clamp.a(isAlphaPercentage ? parseFloat(a) / 100 : parseFloat(a)) : 1
+    }, color);
+  },
+  stringify: (channels) => {
+    const { h, s, l, a } = channels;
+    if (a < 1) {
+      return `hsla(${index.default.lang.round(h)}, ${index.default.lang.round(s)}%, ${index.default.lang.round(l)}%, ${a})`;
+    } else {
+      return `hsl(${index.default.lang.round(h)}, ${index.default.lang.round(s)}%, ${index.default.lang.round(l)}%)`;
+    }
+  }
+};
+exports.default = HSL;

package/lib/node_modules/khroma/dist/color/index.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const hex = require("./hex.js");
+const hsl = require("./hsl.js");
+const keyword = require("./keyword.js");
+const rgb = require("./rgb.js");
+const constants = require("../constants.js");
+const Color = {
+  /* VARIABLES */
+  format: {
+    keyword: keyword.default,
+    hex: hex.default,
+    rgb: rgb.default,
+    rgba: rgb.default,
+    hsl: hsl.default,
+    hsla: hsl.default
+  },
+  /* API */
+  parse: (color) => {
+    if (typeof color !== "string")
+      return color;
+    const channels = hex.default.parse(color) || rgb.default.parse(color) || hsl.default.parse(color) || keyword.default.parse(color);
+    if (channels)
+      return channels;
+    throw new Error(`Unsupported color format: "${color}"`);
+  },
+  stringify: (channels) => {
+    if (!channels.changed && channels.color)
+      return channels.color;
+    if (channels.type.is(constants.TYPE.HSL) || channels.data.r === void 0) {
+      return hsl.default.stringify(channels);
+    } else if (channels.a < 1 || !Number.isInteger(channels.r) || !Number.isInteger(channels.g) || !Number.isInteger(channels.b)) {
+      return rgb.default.stringify(channels);
+    } else {
+      return hex.default.stringify(channels);
+    }
+  }
+};
+exports.default = Color;

package/lib/node_modules/khroma/dist/color/keyword.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const hex = require("./hex.js");
+const Keyword = {
+  /* VARIABLES */
+  colors: {
+    aliceblue: "#f0f8ff",
+    antiquewhite: "#faebd7",
+    aqua: "#00ffff",
+    aquamarine: "#7fffd4",
+    azure: "#f0ffff",
+    beige: "#f5f5dc",
+    bisque: "#ffe4c4",
+    black: "#000000",
+    blanchedalmond: "#ffebcd",
+    blue: "#0000ff",
+    blueviolet: "#8a2be2",
+    brown: "#a52a2a",
+    burlywood: "#deb887",
+    cadetblue: "#5f9ea0",
+    chartreuse: "#7fff00",
+    chocolate: "#d2691e",
+    coral: "#ff7f50",
+    cornflowerblue: "#6495ed",
+    cornsilk: "#fff8dc",
+    crimson: "#dc143c",
+    cyanaqua: "#00ffff",
+    darkblue: "#00008b",
+    darkcyan: "#008b8b",
+    darkgoldenrod: "#b8860b",
+    darkgray: "#a9a9a9",
+    darkgreen: "#006400",
+    darkgrey: "#a9a9a9",
+    darkkhaki: "#bdb76b",
+    darkmagenta: "#8b008b",
+    darkolivegreen: "#556b2f",
+    darkorange: "#ff8c00",
+    darkorchid: "#9932cc",
+    darkred: "#8b0000",
+    darksalmon: "#e9967a",
+    darkseagreen: "#8fbc8f",
+    darkslateblue: "#483d8b",
+    darkslategray: "#2f4f4f",
+    darkslategrey: "#2f4f4f",
+    darkturquoise: "#00ced1",
+    darkviolet: "#9400d3",
+    deeppink: "#ff1493",
+    deepskyblue: "#00bfff",
+    dimgray: "#696969",
+    dimgrey: "#696969",
+    dodgerblue: "#1e90ff",
+    firebrick: "#b22222",
+    floralwhite: "#fffaf0",
+    forestgreen: "#228b22",
+    fuchsia: "#ff00ff",
+    gainsboro: "#dcdcdc",
+    ghostwhite: "#f8f8ff",
+    gold: "#ffd700",
+    goldenrod: "#daa520",
+    gray: "#808080",
+    green: "#008000",
+    greenyellow: "#adff2f",
+    grey: "#808080",
+    honeydew: "#f0fff0",
+    hotpink: "#ff69b4",
+    indianred: "#cd5c5c",
+    indigo: "#4b0082",
+    ivory: "#fffff0",
+    khaki: "#f0e68c",
+    lavender: "#e6e6fa",
+    lavenderblush: "#fff0f5",
+    lawngreen: "#7cfc00",
+    lemonchiffon: "#fffacd",
+    lightblue: "#add8e6",
+    lightcoral: "#f08080",
+    lightcyan: "#e0ffff",
+    lightgoldenrodyellow: "#fafad2",
+    lightgray: "#d3d3d3",
+    lightgreen: "#90ee90",
+    lightgrey: "#d3d3d3",
+    lightpink: "#ffb6c1",
+    lightsalmon: "#ffa07a",
+    lightseagreen: "#20b2aa",
+    lightskyblue: "#87cefa",
+    lightslategray: "#778899",
+    lightslategrey: "#778899",
+    lightsteelblue: "#b0c4de",
+    lightyellow: "#ffffe0",
+    lime: "#00ff00",
+    limegreen: "#32cd32",
+    linen: "#faf0e6",
+    magenta: "#ff00ff",
+    maroon: "#800000",
+    mediumaquamarine: "#66cdaa",
+    mediumblue: "#0000cd",
+    mediumorchid: "#ba55d3",
+    mediumpurple: "#9370db",
+    mediumseagreen: "#3cb371",
+    mediumslateblue: "#7b68ee",
+    mediumspringgreen: "#00fa9a",
+    mediumturquoise: "#48d1cc",
+    mediumvioletred: "#c71585",
+    midnightblue: "#191970",
+    mintcream: "#f5fffa",
+    mistyrose: "#ffe4e1",
+    moccasin: "#ffe4b5",
+    navajowhite: "#ffdead",
+    navy: "#000080",
+    oldlace: "#fdf5e6",
+    olive: "#808000",
+    olivedrab: "#6b8e23",
+    orange: "#ffa500",
+    orangered: "#ff4500",
+    orchid: "#da70d6",
+    palegoldenrod: "#eee8aa",
+    palegreen: "#98fb98",
+    paleturquoise: "#afeeee",
+    palevioletred: "#db7093",
+    papayawhip: "#ffefd5",
+    peachpuff: "#ffdab9",
+    peru: "#cd853f",
+    pink: "#ffc0cb",
+    plum: "#dda0dd",
+    powderblue: "#b0e0e6",
+    purple: "#800080",
+    rebeccapurple: "#663399",
+    red: "#ff0000",
+    rosybrown: "#bc8f8f",
+    royalblue: "#4169e1",
+    saddlebrown: "#8b4513",
+    salmon: "#fa8072",
+    sandybrown: "#f4a460",
+    seagreen: "#2e8b57",
+    seashell: "#fff5ee",
+    sienna: "#a0522d",
+    silver: "#c0c0c0",
+    skyblue: "#87ceeb",
+    slateblue: "#6a5acd",
+    slategray: "#708090",
+    slategrey: "#708090",
+    snow: "#fffafa",
+    springgreen: "#00ff7f",
+    tan: "#d2b48c",
+    teal: "#008080",
+    thistle: "#d8bfd8",
+    transparent: "#00000000",
+    turquoise: "#40e0d0",
+    violet: "#ee82ee",
+    wheat: "#f5deb3",
+    white: "#ffffff",
+    whitesmoke: "#f5f5f5",
+    yellow: "#ffff00",
+    yellowgreen: "#9acd32"
+  },
+  /* API */
+  parse: (color) => {
+    color = color.toLowerCase();
+    const hex$1 = Keyword.colors[color];
+    if (!hex$1)
+      return;
+    return hex.default.parse(hex$1);
+  },
+  stringify: (channels) => {
+    const hex$1 = hex.default.stringify(channels);
+    for (const name in Keyword.colors) {
+      if (Keyword.colors[name] === hex$1)
+        return name;
+    }
+    return;
+  }
+};
+exports.default = Keyword;

package/lib/node_modules/khroma/dist/color/rgb.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const index = require("../utils/index.js");
+const reusable = require("../channels/reusable.js");
+const RGB = {
+  /* VARIABLES */
+  re: /^rgba?\(\s*?(-?(?:\d+(?:\.\d+)?|(?:\.\d+))(?:e\d+)?(%?))\s*?(?:,|\s)\s*?(-?(?:\d+(?:\.\d+)?|(?:\.\d+))(?:e\d+)?(%?))\s*?(?:,|\s)\s*?(-?(?:\d+(?:\.\d+)?|(?:\.\d+))(?:e\d+)?(%?))(?:\s*?(?:,|\/)\s*?\+?(-?(?:\d+(?:\.\d+)?|(?:\.\d+))(?:e\d+)?(%?)))?\s*?\)$/i,
+  /* API */
+  parse: (color) => {
+    const charCode = color.charCodeAt(0);
+    if (charCode !== 114 && charCode !== 82)
+      return;
+    const match = color.match(RGB.re);
+    if (!match)
+      return;
+    const [, r, isRedPercentage, g, isGreenPercentage, b, isBluePercentage, a, isAlphaPercentage] = match;
+    return reusable.default.set({
+      r: index.default.channel.clamp.r(isRedPercentage ? parseFloat(r) * 2.55 : parseFloat(r)),
+      g: index.default.channel.clamp.g(isGreenPercentage ? parseFloat(g) * 2.55 : parseFloat(g)),
+      b: index.default.channel.clamp.b(isBluePercentage ? parseFloat(b) * 2.55 : parseFloat(b)),
+      a: a ? index.default.channel.clamp.a(isAlphaPercentage ? parseFloat(a) / 100 : parseFloat(a)) : 1
+    }, color);
+  },
+  stringify: (channels) => {
+    const { r, g, b, a } = channels;
+    if (a < 1) {
+      return `rgba(${index.default.lang.round(r)}, ${index.default.lang.round(g)}, ${index.default.lang.round(b)}, ${index.default.lang.round(a)})`;
+    } else {
+      return `rgb(${index.default.lang.round(r)}, ${index.default.lang.round(g)}, ${index.default.lang.round(b)})`;
+    }
+  }
+};
+exports.default = RGB;

package/lib/node_modules/khroma/dist/constants.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const index = require("./utils/index.js");
+const DEC2HEX = {};
+for (let i = 0; i <= 255; i++)
+  DEC2HEX[i] = index.default.unit.dec2hex(i);
+const TYPE = {
+  ALL: 0,
+  RGB: 1,
+  HSL: 2
+};
+exports.DEC2HEX = DEC2HEX;
+exports.TYPE = TYPE;

package/lib/node_modules/khroma/dist/methods/adjust.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const index = require("../color/index.js");
+const change = require("./change.js");
+const adjust = (color, channels) => {
+  const ch = index.default.parse(color);
+  const changes = {};
+  for (const c in channels) {
+    if (!channels[c])
+      continue;
+    changes[c] = ch[c] + channels[c];
+  }
+  return change.default(color, changes);
+};
+exports.default = adjust;

package/lib/node_modules/khroma/dist/methods/adjust_channel.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const index$1 = require("../utils/index.js");
+const index = require("../color/index.js");
+const adjustChannel = (color, channel, amount) => {
+  const channels = index.default.parse(color);
+  const amountCurrent = channels[channel];
+  const amountNext = index$1.default.channel.clamp[channel](amountCurrent + amount);
+  if (amountCurrent !== amountNext)
+    channels[channel] = amountNext;
+  return index.default.stringify(channels);
+};
+exports.default = adjustChannel;

package/lib/node_modules/khroma/dist/methods/change.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const index$1 = require("../utils/index.js");
+const index = require("../color/index.js");
+const change = (color, channels) => {
+  const ch = index.default.parse(color);
+  for (const c in channels) {
+    ch[c] = index$1.default.channel.clamp[c](channels[c]);
+  }
+  return index.default.stringify(ch);
+};
+exports.default = change;

package/lib/node_modules/khroma/dist/methods/channel.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const index = require("../utils/index.js");
+const index$1 = require("../color/index.js");
+const channel = (color, channel2) => {
+  return index.default.lang.round(index$1.default.parse(color)[channel2]);
+};
+exports.default = channel;

package/lib/node_modules/khroma/dist/methods/darken.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const adjust_channel = require("./adjust_channel.js");
+const darken = (color, amount) => {
+  return adjust_channel.default(color, "l", -amount);
+};
+exports.default = darken;

package/lib/node_modules/khroma/dist/methods/invert.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const index = require("../color/index.js");
+const mix = require("./mix.js");
+const invert = (color, weight = 100) => {
+  const inverse = index.default.parse(color);
+  inverse.r = 255 - inverse.r;
+  inverse.g = 255 - inverse.g;
+  inverse.b = 255 - inverse.b;
+  return mix.default(inverse, color, weight);
+};
+exports.default = invert;

package/lib/node_modules/khroma/dist/methods/is_dark.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const is_light = require("./is_light.js");
+const isDark = (color) => {
+  return !is_light.default(color);
+};
+exports.default = isDark;

package/lib/node_modules/khroma/dist/methods/is_light.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const luminance = require("./luminance.js");
+const isLight = (color) => {
+  return luminance.default(color) >= 0.5;
+};
+exports.default = isLight;

package/lib/node_modules/khroma/dist/methods/lighten.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const adjust_channel = require("./adjust_channel.js");
+const lighten = (color, amount) => {
+  return adjust_channel.default(color, "l", amount);
+};
+exports.default = lighten;

package/lib/node_modules/khroma/dist/methods/luminance.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const index$1 = require("../utils/index.js");
+const index = require("../color/index.js");
+const luminance = (color) => {
+  const { r, g, b } = index.default.parse(color);
+  const luminance2 = 0.2126 * index$1.default.channel.toLinear(r) + 0.7152 * index$1.default.channel.toLinear(g) + 0.0722 * index$1.default.channel.toLinear(b);
+  return index$1.default.lang.round(luminance2);
+};
+exports.default = luminance;

package/lib/node_modules/khroma/dist/methods/mix.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const index = require("../color/index.js");
+const rgba = require("./rgba.js");
+const mix = (color1, color2, weight = 50) => {
+  const { r: r1, g: g1, b: b1, a: a1 } = index.default.parse(color1);
+  const { r: r2, g: g2, b: b2, a: a2 } = index.default.parse(color2);
+  const weightScale = weight / 100;
+  const weightNormalized = weightScale * 2 - 1;
+  const alphaDelta = a1 - a2;
+  const weight1combined = weightNormalized * alphaDelta === -1 ? weightNormalized : (weightNormalized + alphaDelta) / (1 + weightNormalized * alphaDelta);
+  const weight1 = (weight1combined + 1) / 2;
+  const weight2 = 1 - weight1;
+  const r = r1 * weight1 + r2 * weight2;
+  const g = g1 * weight1 + g2 * weight2;
+  const b = b1 * weight1 + b2 * weight2;
+  const a = a1 * weightScale + a2 * (1 - weightScale);
+  return rgba.default(r, g, b, a);
+};
+exports.default = mix;

package/lib/node_modules/khroma/dist/methods/rgba.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const index = require("../utils/index.js");
+const reusable = require("../channels/reusable.js");
+const index$1 = require("../color/index.js");
+const change = require("./change.js");
+const rgba = (r, g, b = 0, a = 1) => {
+  if (typeof r !== "number")
+    return change.default(r, { a: g });
+  const channels = reusable.default.set({
+    r: index.default.channel.clamp.r(r),
+    g: index.default.channel.clamp.g(g),
+    b: index.default.channel.clamp.b(b),
+    a: index.default.channel.clamp.a(a)
+  });
+  return index$1.default.stringify(channels);
+};
+exports.default = rgba;