@elmethis/core 1.0.0-alpha.147 → 1.0.0-alpha.148

package/dist/node_modules/.pnpm/internmap@2.0.3/node_modules/internmap/src/index.mjs

@@ -0,0 +1,43 @@
+class InternMap extends Map {
+  constructor(entries, key = keyof) {
+    super();
+    Object.defineProperties(this, { _intern: { value: /* @__PURE__ */ new Map() }, _key: { value: key } });
+    if (entries != null) for (const [key2, value] of entries) this.set(key2, value);
+  }
+  get(key) {
+    return super.get(intern_get(this, key));
+  }
+  has(key) {
+    return super.has(intern_get(this, key));
+  }
+  set(key, value) {
+    return super.set(intern_set(this, key), value);
+  }
+  delete(key) {
+    return super.delete(intern_delete(this, key));
+  }
+}
+function intern_get({ _intern, _key }, value) {
+  const key = _key(value);
+  return _intern.has(key) ? _intern.get(key) : value;
+}
+function intern_set({ _intern, _key }, value) {
+  const key = _key(value);
+  if (_intern.has(key)) return _intern.get(key);
+  _intern.set(key, value);
+  return value;
+}
+function intern_delete({ _intern, _key }, value) {
+  const key = _key(value);
+  if (_intern.has(key)) {
+    value = _intern.get(key);
+    _intern.delete(key);
+  }
+  return value;
+}
+function keyof(value) {
+  return value !== null && typeof value === "object" ? value.valueOf() : value;
+}
+export {
+  InternMap
+};

package/dist/node_modules/.pnpm/khroma@2.1.0/node_modules/khroma/dist/channels/index.mjs

@@ -0,0 +1,131 @@
+import Utils from "../utils/index.mjs";
+import Type from "./type.mjs";
+import { TYPE } from "../constants.mjs";
+class Channels {
+  /* CONSTRUCTOR */
+  constructor(data, color) {
+    this.color = color;
+    this.changed = false;
+    this.data = data;
+    this.type = new Type();
+  }
+  /* API */
+  set(data, color) {
+    this.color = color;
+    this.changed = false;
+    this.data = data;
+    this.type.type = TYPE.ALL;
+    return this;
+  }
+  /* HELPERS */
+  _ensureHSL() {
+    const data = this.data;
+    const { h, s, l } = data;
+    if (h === void 0)
+      data.h = Utils.channel.rgb2hsl(data, "h");
+    if (s === void 0)
+      data.s = Utils.channel.rgb2hsl(data, "s");
+    if (l === void 0)
+      data.l = Utils.channel.rgb2hsl(data, "l");
+  }
+  _ensureRGB() {
+    const data = this.data;
+    const { r, g, b } = data;
+    if (r === void 0)
+      data.r = Utils.channel.hsl2rgb(data, "r");
+    if (g === void 0)
+      data.g = Utils.channel.hsl2rgb(data, "g");
+    if (b === void 0)
+      data.b = Utils.channel.hsl2rgb(data, "b");
+  }
+  /* GETTERS */
+  get r() {
+    const data = this.data;
+    const r = data.r;
+    if (!this.type.is(TYPE.HSL) && r !== void 0)
+      return r;
+    this._ensureHSL();
+    return Utils.channel.hsl2rgb(data, "r");
+  }
+  get g() {
+    const data = this.data;
+    const g = data.g;
+    if (!this.type.is(TYPE.HSL) && g !== void 0)
+      return g;
+    this._ensureHSL();
+    return Utils.channel.hsl2rgb(data, "g");
+  }
+  get b() {
+    const data = this.data;
+    const b = data.b;
+    if (!this.type.is(TYPE.HSL) && b !== void 0)
+      return b;
+    this._ensureHSL();
+    return Utils.channel.hsl2rgb(data, "b");
+  }
+  get h() {
+    const data = this.data;
+    const h = data.h;
+    if (!this.type.is(TYPE.RGB) && h !== void 0)
+      return h;
+    this._ensureRGB();
+    return Utils.channel.rgb2hsl(data, "h");
+  }
+  get s() {
+    const data = this.data;
+    const s = data.s;
+    if (!this.type.is(TYPE.RGB) && s !== void 0)
+      return s;
+    this._ensureRGB();
+    return Utils.channel.rgb2hsl(data, "s");
+  }
+  get l() {
+    const data = this.data;
+    const l = data.l;
+    if (!this.type.is(TYPE.RGB) && l !== void 0)
+      return l;
+    this._ensureRGB();
+    return Utils.channel.rgb2hsl(data, "l");
+  }
+  get a() {
+    return this.data.a;
+  }
+  /* SETTERS */
+  set r(r) {
+    this.type.set(TYPE.RGB);
+    this.changed = true;
+    this.data.r = r;
+  }
+  set g(g) {
+    this.type.set(TYPE.RGB);
+    this.changed = true;
+    this.data.g = g;
+  }
+  set b(b) {
+    this.type.set(TYPE.RGB);
+    this.changed = true;
+    this.data.b = b;
+  }
+  set h(h) {
+    this.type.set(TYPE.HSL);
+    this.changed = true;
+    this.data.h = h;
+  }
+  set s(s) {
+    this.type.set(TYPE.HSL);
+    this.changed = true;
+    this.data.s = s;
+  }
+  set l(l) {
+    this.type.set(TYPE.HSL);
+    this.changed = true;
+    this.data.l = l;
+  }
+  set a(a) {
+    this.changed = true;
+    this.data.a = a;
+  }
+}
+export {
+  Channels as default
+};

package/dist/node_modules/.pnpm/khroma@2.1.0/node_modules/khroma/dist/channels/reusable.mjs

@@ -0,0 +1,5 @@
+import Channels from "./index.mjs";
+const channels = new Channels({ r: 0, g: 0, b: 0, a: 0 }, "transparent");
+export {
+  channels as default
+};

package/dist/node_modules/.pnpm/khroma@2.1.0/node_modules/khroma/dist/channels/type.mjs

@@ -0,0 +1,24 @@
+import { TYPE } from "../constants.mjs";
+class Type {
+  constructor() {
+    this.type = 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 = TYPE.ALL;
+  }
+  is(type) {
+    return this.type === type;
+  }
+}
+export {
+  Type as default
+};

package/dist/node_modules/.pnpm/khroma@2.1.0/node_modules/khroma/dist/color/hex.mjs

@@ -0,0 +1,40 @@
+import channels from "../channels/reusable.mjs";
+import { DEC2HEX } from "../constants.mjs";
+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 channels.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: (channels2) => {
+    const { r, g, b, a } = channels2;
+    if (a < 1) {
+      return `#${DEC2HEX[Math.round(r)]}${DEC2HEX[Math.round(g)]}${DEC2HEX[Math.round(b)]}${DEC2HEX[Math.round(a * 255)]}`;
+    } else {
+      return `#${DEC2HEX[Math.round(r)]}${DEC2HEX[Math.round(g)]}${DEC2HEX[Math.round(b)]}`;
+    }
+  }
+};
+export {
+  Hex as default
+};

package/dist/node_modules/.pnpm/khroma@2.1.0/node_modules/khroma/dist/color/hsl.mjs

@@ -0,0 +1,50 @@
+import Utils from "../utils/index.mjs";
+import channels from "../channels/reusable.mjs";
+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 Utils.channel.clamp.h(parseFloat(number) * 0.9);
+        case "rad":
+          return Utils.channel.clamp.h(parseFloat(number) * 180 / Math.PI);
+        case "turn":
+          return Utils.channel.clamp.h(parseFloat(number) * 360);
+      }
+    }
+    return Utils.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 channels.set({
+      h: HSL._hue2deg(h),
+      s: Utils.channel.clamp.s(parseFloat(s)),
+      l: Utils.channel.clamp.l(parseFloat(l)),
+      a: a ? Utils.channel.clamp.a(isAlphaPercentage ? parseFloat(a) / 100 : parseFloat(a)) : 1
+    }, color);
+  },
+  stringify: (channels2) => {
+    const { h, s, l, a } = channels2;
+    if (a < 1) {
+      return `hsla(${Utils.lang.round(h)}, ${Utils.lang.round(s)}%, ${Utils.lang.round(l)}%, ${a})`;
+    } else {
+      return `hsl(${Utils.lang.round(h)}, ${Utils.lang.round(s)}%, ${Utils.lang.round(l)}%)`;
+    }
+  }
+};
+export {
+  HSL as default
+};

package/dist/node_modules/.pnpm/khroma@2.1.0/node_modules/khroma/dist/color/index.mjs

@@ -0,0 +1,39 @@
+import Hex from "./hex.mjs";
+import HSL from "./hsl.mjs";
+import Keyword from "./keyword.mjs";
+import RGB from "./rgb.mjs";
+import { TYPE } from "../constants.mjs";
+const Color = {
+  /* VARIABLES */
+  format: {
+    keyword: Keyword,
+    hex: Hex,
+    rgb: RGB,
+    rgba: RGB,
+    hsl: HSL,
+    hsla: HSL
+  },
+  /* API */
+  parse: (color) => {
+    if (typeof color !== "string")
+      return color;
+    const channels = Hex.parse(color) || RGB.parse(color) || HSL.parse(color) || Keyword.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(TYPE.HSL) || channels.data.r === void 0) {
+      return HSL.stringify(channels);
+    } else if (channels.a < 1 || !Number.isInteger(channels.r) || !Number.isInteger(channels.g) || !Number.isInteger(channels.b)) {
+      return RGB.stringify(channels);
+    } else {
+      return Hex.stringify(channels);
+    }
+  }
+};
+export {
+  Color as default
+};

package/dist/node_modules/.pnpm/khroma@2.1.0/node_modules/khroma/dist/color/keyword.mjs

@@ -0,0 +1,172 @@
+import Hex from "./hex.mjs";
+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 = Keyword.colors[color];
+    if (!hex)
+      return;
+    return Hex.parse(hex);
+  },
+  stringify: (channels) => {
+    const hex = Hex.stringify(channels);
+    for (const name in Keyword.colors) {
+      if (Keyword.colors[name] === hex)
+        return name;
+    }
+    return;
+  }
+};
+export {
+  Keyword as default
+};

package/dist/node_modules/.pnpm/khroma@2.1.0/node_modules/khroma/dist/color/rgb.mjs

@@ -0,0 +1,33 @@
+import Utils from "../utils/index.mjs";
+import channels from "../channels/reusable.mjs";
+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 channels.set({
+      r: Utils.channel.clamp.r(isRedPercentage ? parseFloat(r) * 2.55 : parseFloat(r)),
+      g: Utils.channel.clamp.g(isGreenPercentage ? parseFloat(g) * 2.55 : parseFloat(g)),
+      b: Utils.channel.clamp.b(isBluePercentage ? parseFloat(b) * 2.55 : parseFloat(b)),
+      a: a ? Utils.channel.clamp.a(isAlphaPercentage ? parseFloat(a) / 100 : parseFloat(a)) : 1
+    }, color);
+  },
+  stringify: (channels2) => {
+    const { r, g, b, a } = channels2;
+    if (a < 1) {
+      return `rgba(${Utils.lang.round(r)}, ${Utils.lang.round(g)}, ${Utils.lang.round(b)}, ${Utils.lang.round(a)})`;
+    } else {
+      return `rgb(${Utils.lang.round(r)}, ${Utils.lang.round(g)}, ${Utils.lang.round(b)})`;
+    }
+  }
+};
+export {
+  RGB as default
+};

package/dist/node_modules/.pnpm/khroma@2.1.0/node_modules/khroma/dist/constants.mjs

@@ -0,0 +1,13 @@
+import Utils from "./utils/index.mjs";
+const DEC2HEX = {};
+for (let i = 0; i <= 255; i++)
+  DEC2HEX[i] = Utils.unit.dec2hex(i);
+const TYPE = {
+  ALL: 0,
+  RGB: 1,
+  HSL: 2
+};
+export {
+  DEC2HEX,
+  TYPE
+};

package/dist/node_modules/.pnpm/khroma@2.1.0/node_modules/khroma/dist/methods/adjust.mjs

@@ -0,0 +1,15 @@
+import Color from "../color/index.mjs";
+import change from "./change.mjs";
+const adjust = (color, channels) => {
+  const ch = Color.parse(color);
+  const changes = {};
+  for (const c in channels) {
+    if (!channels[c])
+      continue;
+    changes[c] = ch[c] + channels[c];
+  }
+  return change(color, changes);
+};
+export {
+  adjust as default
+};

package/dist/node_modules/.pnpm/khroma@2.1.0/node_modules/khroma/dist/methods/adjust_channel.mjs

@@ -0,0 +1,13 @@
+import Utils from "../utils/index.mjs";
+import Color from "../color/index.mjs";
+const adjustChannel = (color, channel, amount) => {
+  const channels = Color.parse(color);
+  const amountCurrent = channels[channel];
+  const amountNext = Utils.channel.clamp[channel](amountCurrent + amount);
+  if (amountCurrent !== amountNext)
+    channels[channel] = amountNext;
+  return Color.stringify(channels);
+};
+export {
+  adjustChannel as default
+};

package/dist/node_modules/.pnpm/khroma@2.1.0/node_modules/khroma/dist/methods/change.mjs

@@ -0,0 +1,12 @@
+import Utils from "../utils/index.mjs";
+import Color from "../color/index.mjs";
+const change = (color, channels) => {
+  const ch = Color.parse(color);
+  for (const c in channels) {
+    ch[c] = Utils.channel.clamp[c](channels[c]);
+  }
+  return Color.stringify(ch);
+};
+export {
+  change as default
+};

package/dist/node_modules/.pnpm/khroma@2.1.0/node_modules/khroma/dist/methods/channel.mjs

@@ -0,0 +1,8 @@
+import Utils from "../utils/index.mjs";
+import Color from "../color/index.mjs";
+const channel = (color, channel2) => {
+  return Utils.lang.round(Color.parse(color)[channel2]);
+};
+export {
+  channel as default
+};

package/dist/node_modules/.pnpm/khroma@2.1.0/node_modules/khroma/dist/methods/darken.mjs

@@ -0,0 +1,7 @@
+import adjustChannel from "./adjust_channel.mjs";
+const darken = (color, amount) => {
+  return adjustChannel(color, "l", -amount);
+};
+export {
+  darken as default
+};

package/dist/node_modules/.pnpm/khroma@2.1.0/node_modules/khroma/dist/methods/invert.mjs

@@ -0,0 +1,12 @@
+import Color from "../color/index.mjs";
+import mix from "./mix.mjs";
+const invert = (color, weight = 100) => {
+  const inverse = Color.parse(color);
+  inverse.r = 255 - inverse.r;
+  inverse.g = 255 - inverse.g;
+  inverse.b = 255 - inverse.b;
+  return mix(inverse, color, weight);
+};
+export {
+  invert as default
+};

package/dist/node_modules/.pnpm/khroma@2.1.0/node_modules/khroma/dist/methods/is_dark.mjs

@@ -0,0 +1,7 @@
+import isLight from "./is_light.mjs";
+const isDark = (color) => {
+  return !isLight(color);
+};
+export {
+  isDark as default
+};

package/dist/node_modules/.pnpm/khroma@2.1.0/node_modules/khroma/dist/methods/is_light.mjs

@@ -0,0 +1,7 @@
+import luminance from "./luminance.mjs";
+const isLight = (color) => {
+  return luminance(color) >= 0.5;
+};
+export {
+  isLight as default
+};

package/dist/node_modules/.pnpm/khroma@2.1.0/node_modules/khroma/dist/methods/lighten.mjs

@@ -0,0 +1,7 @@
+import adjustChannel from "./adjust_channel.mjs";
+const lighten = (color, amount) => {
+  return adjustChannel(color, "l", amount);
+};
+export {
+  lighten as default
+};

package/dist/node_modules/.pnpm/khroma@2.1.0/node_modules/khroma/dist/methods/luminance.mjs

@@ -0,0 +1,10 @@
+import Utils from "../utils/index.mjs";
+import Color from "../color/index.mjs";
+const luminance = (color) => {
+  const { r, g, b } = Color.parse(color);
+  const luminance2 = 0.2126 * Utils.channel.toLinear(r) + 0.7152 * Utils.channel.toLinear(g) + 0.0722 * Utils.channel.toLinear(b);
+  return Utils.lang.round(luminance2);
+};
+export {
+  luminance as default
+};