@eggjs/mock 6.1.0-beta.3 → 6.1.0-beta.5

package/dist/node_modules/.pnpm/color-convert@2.0.1/node_modules/color-convert/conversions.js

@@ -0,0 +1,812 @@
+import { __commonJS } from "../../../../../_virtual/rolldown_runtime.js";
+import { require_color_name } from "../../../color-name@1.1.4/node_modules/color-name/index.js";
+
+//#region ../../node_modules/.pnpm/color-convert@2.0.1/node_modules/color-convert/conversions.js
+var require_conversions = /* @__PURE__ */ __commonJS({ "../../node_modules/.pnpm/color-convert@2.0.1/node_modules/color-convert/conversions.js": ((exports, module) => {
+	const cssKeywords = require_color_name();
+	const reverseKeywords = {};
+	for (const key of Object.keys(cssKeywords)) reverseKeywords[cssKeywords[key]] = key;
+	const convert = {
+		rgb: {
+			channels: 3,
+			labels: "rgb"
+		},
+		hsl: {
+			channels: 3,
+			labels: "hsl"
+		},
+		hsv: {
+			channels: 3,
+			labels: "hsv"
+		},
+		hwb: {
+			channels: 3,
+			labels: "hwb"
+		},
+		cmyk: {
+			channels: 4,
+			labels: "cmyk"
+		},
+		xyz: {
+			channels: 3,
+			labels: "xyz"
+		},
+		lab: {
+			channels: 3,
+			labels: "lab"
+		},
+		lch: {
+			channels: 3,
+			labels: "lch"
+		},
+		hex: {
+			channels: 1,
+			labels: ["hex"]
+		},
+		keyword: {
+			channels: 1,
+			labels: ["keyword"]
+		},
+		ansi16: {
+			channels: 1,
+			labels: ["ansi16"]
+		},
+		ansi256: {
+			channels: 1,
+			labels: ["ansi256"]
+		},
+		hcg: {
+			channels: 3,
+			labels: [
+				"h",
+				"c",
+				"g"
+			]
+		},
+		apple: {
+			channels: 3,
+			labels: [
+				"r16",
+				"g16",
+				"b16"
+			]
+		},
+		gray: {
+			channels: 1,
+			labels: ["gray"]
+		}
+	};
+	module.exports = convert;
+	for (const model of Object.keys(convert)) {
+		if (!("channels" in convert[model])) throw new Error("missing channels property: " + model);
+		if (!("labels" in convert[model])) throw new Error("missing channel labels property: " + model);
+		if (convert[model].labels.length !== convert[model].channels) throw new Error("channel and label counts mismatch: " + model);
+		const { channels, labels } = convert[model];
+		delete convert[model].channels;
+		delete convert[model].labels;
+		Object.defineProperty(convert[model], "channels", { value: channels });
+		Object.defineProperty(convert[model], "labels", { value: labels });
+	}
+	convert.rgb.hsl = function(rgb) {
+		const r = rgb[0] / 255;
+		const g = rgb[1] / 255;
+		const b = rgb[2] / 255;
+		const min = Math.min(r, g, b);
+		const max = Math.max(r, g, b);
+		const delta = max - min;
+		let h;
+		let s;
+		if (max === min) h = 0;
+		else if (r === max) h = (g - b) / delta;
+		else if (g === max) h = 2 + (b - r) / delta;
+		else if (b === max) h = 4 + (r - g) / delta;
+		h = Math.min(h * 60, 360);
+		if (h < 0) h += 360;
+		const l = (min + max) / 2;
+		if (max === min) s = 0;
+		else if (l <= .5) s = delta / (max + min);
+		else s = delta / (2 - max - min);
+		return [
+			h,
+			s * 100,
+			l * 100
+		];
+	};
+	convert.rgb.hsv = function(rgb) {
+		let rdif;
+		let gdif;
+		let bdif;
+		let h;
+		let s;
+		const r = rgb[0] / 255;
+		const g = rgb[1] / 255;
+		const b = rgb[2] / 255;
+		const v = Math.max(r, g, b);
+		const diff = v - Math.min(r, g, b);
+		const diffc = function(c) {
+			return (v - c) / 6 / diff + 1 / 2;
+		};
+		if (diff === 0) {
+			h = 0;
+			s = 0;
+		} else {
+			s = diff / v;
+			rdif = diffc(r);
+			gdif = diffc(g);
+			bdif = diffc(b);
+			if (r === v) h = bdif - gdif;
+			else if (g === v) h = 1 / 3 + rdif - bdif;
+			else if (b === v) h = 2 / 3 + gdif - rdif;
+			if (h < 0) h += 1;
+			else if (h > 1) h -= 1;
+		}
+		return [
+			h * 360,
+			s * 100,
+			v * 100
+		];
+	};
+	convert.rgb.hwb = function(rgb) {
+		const r = rgb[0];
+		const g = rgb[1];
+		let b = rgb[2];
+		const h = convert.rgb.hsl(rgb)[0];
+		const w = 1 / 255 * Math.min(r, Math.min(g, b));
+		b = 1 - 1 / 255 * Math.max(r, Math.max(g, b));
+		return [
+			h,
+			w * 100,
+			b * 100
+		];
+	};
+	convert.rgb.cmyk = function(rgb) {
+		const r = rgb[0] / 255;
+		const g = rgb[1] / 255;
+		const b = rgb[2] / 255;
+		const k = Math.min(1 - r, 1 - g, 1 - b);
+		const c = (1 - r - k) / (1 - k) || 0;
+		const m = (1 - g - k) / (1 - k) || 0;
+		const y = (1 - b - k) / (1 - k) || 0;
+		return [
+			c * 100,
+			m * 100,
+			y * 100,
+			k * 100
+		];
+	};
+	function comparativeDistance(x, y) {
+		return (x[0] - y[0]) ** 2 + (x[1] - y[1]) ** 2 + (x[2] - y[2]) ** 2;
+	}
+	convert.rgb.keyword = function(rgb) {
+		const reversed = reverseKeywords[rgb];
+		if (reversed) return reversed;
+		let currentClosestDistance = Infinity;
+		let currentClosestKeyword;
+		for (const keyword of Object.keys(cssKeywords)) {
+			const value = cssKeywords[keyword];
+			const distance = comparativeDistance(rgb, value);
+			if (distance < currentClosestDistance) {
+				currentClosestDistance = distance;
+				currentClosestKeyword = keyword;
+			}
+		}
+		return currentClosestKeyword;
+	};
+	convert.keyword.rgb = function(keyword) {
+		return cssKeywords[keyword];
+	};
+	convert.rgb.xyz = function(rgb) {
+		let r = rgb[0] / 255;
+		let g = rgb[1] / 255;
+		let b = rgb[2] / 255;
+		r = r > .04045 ? ((r + .055) / 1.055) ** 2.4 : r / 12.92;
+		g = g > .04045 ? ((g + .055) / 1.055) ** 2.4 : g / 12.92;
+		b = b > .04045 ? ((b + .055) / 1.055) ** 2.4 : b / 12.92;
+		const x = r * .4124 + g * .3576 + b * .1805;
+		const y = r * .2126 + g * .7152 + b * .0722;
+		const z = r * .0193 + g * .1192 + b * .9505;
+		return [
+			x * 100,
+			y * 100,
+			z * 100
+		];
+	};
+	convert.rgb.lab = function(rgb) {
+		const xyz = convert.rgb.xyz(rgb);
+		let x = xyz[0];
+		let y = xyz[1];
+		let z = xyz[2];
+		x /= 95.047;
+		y /= 100;
+		z /= 108.883;
+		x = x > .008856 ? x ** (1 / 3) : 7.787 * x + 16 / 116;
+		y = y > .008856 ? y ** (1 / 3) : 7.787 * y + 16 / 116;
+		z = z > .008856 ? z ** (1 / 3) : 7.787 * z + 16 / 116;
+		const l = 116 * y - 16;
+		const a = 500 * (x - y);
+		const b = 200 * (y - z);
+		return [
+			l,
+			a,
+			b
+		];
+	};
+	convert.hsl.rgb = function(hsl) {
+		const h = hsl[0] / 360;
+		const s = hsl[1] / 100;
+		const l = hsl[2] / 100;
+		let t2;
+		let t3;
+		let val;
+		if (s === 0) {
+			val = l * 255;
+			return [
+				val,
+				val,
+				val
+			];
+		}
+		if (l < .5) t2 = l * (1 + s);
+		else t2 = l + s - l * s;
+		const t1 = 2 * l - t2;
+		const rgb = [
+			0,
+			0,
+			0
+		];
+		for (let i = 0; i < 3; i++) {
+			t3 = h + 1 / 3 * -(i - 1);
+			if (t3 < 0) t3++;
+			if (t3 > 1) t3--;
+			if (6 * t3 < 1) val = t1 + (t2 - t1) * 6 * t3;
+			else if (2 * t3 < 1) val = t2;
+			else if (3 * t3 < 2) val = t1 + (t2 - t1) * (2 / 3 - t3) * 6;
+			else val = t1;
+			rgb[i] = val * 255;
+		}
+		return rgb;
+	};
+	convert.hsl.hsv = function(hsl) {
+		const h = hsl[0];
+		let s = hsl[1] / 100;
+		let l = hsl[2] / 100;
+		let smin = s;
+		const lmin = Math.max(l, .01);
+		l *= 2;
+		s *= l <= 1 ? l : 2 - l;
+		smin *= lmin <= 1 ? lmin : 2 - lmin;
+		const v = (l + s) / 2;
+		const sv = l === 0 ? 2 * smin / (lmin + smin) : 2 * s / (l + s);
+		return [
+			h,
+			sv * 100,
+			v * 100
+		];
+	};
+	convert.hsv.rgb = function(hsv) {
+		const h = hsv[0] / 60;
+		const s = hsv[1] / 100;
+		let v = hsv[2] / 100;
+		const hi = Math.floor(h) % 6;
+		const f = h - Math.floor(h);
+		const p = 255 * v * (1 - s);
+		const q = 255 * v * (1 - s * f);
+		const t = 255 * v * (1 - s * (1 - f));
+		v *= 255;
+		switch (hi) {
+			case 0: return [
+				v,
+				t,
+				p
+			];
+			case 1: return [
+				q,
+				v,
+				p
+			];
+			case 2: return [
+				p,
+				v,
+				t
+			];
+			case 3: return [
+				p,
+				q,
+				v
+			];
+			case 4: return [
+				t,
+				p,
+				v
+			];
+			case 5: return [
+				v,
+				p,
+				q
+			];
+		}
+	};
+	convert.hsv.hsl = function(hsv) {
+		const h = hsv[0];
+		const s = hsv[1] / 100;
+		const v = hsv[2] / 100;
+		const vmin = Math.max(v, .01);
+		let sl;
+		let l = (2 - s) * v;
+		const lmin = (2 - s) * vmin;
+		sl = s * vmin;
+		sl /= lmin <= 1 ? lmin : 2 - lmin;
+		sl = sl || 0;
+		l /= 2;
+		return [
+			h,
+			sl * 100,
+			l * 100
+		];
+	};
+	convert.hwb.rgb = function(hwb) {
+		const h = hwb[0] / 360;
+		let wh = hwb[1] / 100;
+		let bl = hwb[2] / 100;
+		const ratio = wh + bl;
+		let f;
+		if (ratio > 1) {
+			wh /= ratio;
+			bl /= ratio;
+		}
+		const i = Math.floor(6 * h);
+		const v = 1 - bl;
+		f = 6 * h - i;
+		if ((i & 1) !== 0) f = 1 - f;
+		const n = wh + f * (v - wh);
+		let r;
+		let g;
+		let b;
+		switch (i) {
+			default:
+			case 6:
+			case 0:
+				r = v;
+				g = n;
+				b = wh;
+				break;
+			case 1:
+				r = n;
+				g = v;
+				b = wh;
+				break;
+			case 2:
+				r = wh;
+				g = v;
+				b = n;
+				break;
+			case 3:
+				r = wh;
+				g = n;
+				b = v;
+				break;
+			case 4:
+				r = n;
+				g = wh;
+				b = v;
+				break;
+			case 5:
+				r = v;
+				g = wh;
+				b = n;
+				break;
+		}
+		return [
+			r * 255,
+			g * 255,
+			b * 255
+		];
+	};
+	convert.cmyk.rgb = function(cmyk) {
+		const c = cmyk[0] / 100;
+		const m = cmyk[1] / 100;
+		const y = cmyk[2] / 100;
+		const k = cmyk[3] / 100;
+		const r = 1 - Math.min(1, c * (1 - k) + k);
+		const g = 1 - Math.min(1, m * (1 - k) + k);
+		const b = 1 - Math.min(1, y * (1 - k) + k);
+		return [
+			r * 255,
+			g * 255,
+			b * 255
+		];
+	};
+	convert.xyz.rgb = function(xyz) {
+		const x = xyz[0] / 100;
+		const y = xyz[1] / 100;
+		const z = xyz[2] / 100;
+		let r;
+		let g;
+		let b;
+		r = x * 3.2406 + y * -1.5372 + z * -.4986;
+		g = x * -.9689 + y * 1.8758 + z * .0415;
+		b = x * .0557 + y * -.204 + z * 1.057;
+		r = r > .0031308 ? 1.055 * r ** (1 / 2.4) - .055 : r * 12.92;
+		g = g > .0031308 ? 1.055 * g ** (1 / 2.4) - .055 : g * 12.92;
+		b = b > .0031308 ? 1.055 * b ** (1 / 2.4) - .055 : b * 12.92;
+		r = Math.min(Math.max(0, r), 1);
+		g = Math.min(Math.max(0, g), 1);
+		b = Math.min(Math.max(0, b), 1);
+		return [
+			r * 255,
+			g * 255,
+			b * 255
+		];
+	};
+	convert.xyz.lab = function(xyz) {
+		let x = xyz[0];
+		let y = xyz[1];
+		let z = xyz[2];
+		x /= 95.047;
+		y /= 100;
+		z /= 108.883;
+		x = x > .008856 ? x ** (1 / 3) : 7.787 * x + 16 / 116;
+		y = y > .008856 ? y ** (1 / 3) : 7.787 * y + 16 / 116;
+		z = z > .008856 ? z ** (1 / 3) : 7.787 * z + 16 / 116;
+		const l = 116 * y - 16;
+		const a = 500 * (x - y);
+		const b = 200 * (y - z);
+		return [
+			l,
+			a,
+			b
+		];
+	};
+	convert.lab.xyz = function(lab) {
+		const l = lab[0];
+		const a = lab[1];
+		const b = lab[2];
+		let x;
+		let y;
+		let z;
+		y = (l + 16) / 116;
+		x = a / 500 + y;
+		z = y - b / 200;
+		const y2 = y ** 3;
+		const x2 = x ** 3;
+		const z2 = z ** 3;
+		y = y2 > .008856 ? y2 : (y - 16 / 116) / 7.787;
+		x = x2 > .008856 ? x2 : (x - 16 / 116) / 7.787;
+		z = z2 > .008856 ? z2 : (z - 16 / 116) / 7.787;
+		x *= 95.047;
+		y *= 100;
+		z *= 108.883;
+		return [
+			x,
+			y,
+			z
+		];
+	};
+	convert.lab.lch = function(lab) {
+		const l = lab[0];
+		const a = lab[1];
+		const b = lab[2];
+		let h = Math.atan2(b, a) * 360 / 2 / Math.PI;
+		if (h < 0) h += 360;
+		const c = Math.sqrt(a * a + b * b);
+		return [
+			l,
+			c,
+			h
+		];
+	};
+	convert.lch.lab = function(lch) {
+		const l = lch[0];
+		const c = lch[1];
+		const hr = lch[2] / 360 * 2 * Math.PI;
+		const a = c * Math.cos(hr);
+		const b = c * Math.sin(hr);
+		return [
+			l,
+			a,
+			b
+		];
+	};
+	convert.rgb.ansi16 = function(args, saturation = null) {
+		const [r, g, b] = args;
+		let value = saturation === null ? convert.rgb.hsv(args)[2] : saturation;
+		value = Math.round(value / 50);
+		if (value === 0) return 30;
+		let ansi = 30 + (Math.round(b / 255) << 2 | Math.round(g / 255) << 1 | Math.round(r / 255));
+		if (value === 2) ansi += 60;
+		return ansi;
+	};
+	convert.hsv.ansi16 = function(args) {
+		return convert.rgb.ansi16(convert.hsv.rgb(args), args[2]);
+	};
+	convert.rgb.ansi256 = function(args) {
+		const r = args[0];
+		const g = args[1];
+		const b = args[2];
+		if (r === g && g === b) {
+			if (r < 8) return 16;
+			if (r > 248) return 231;
+			return Math.round((r - 8) / 247 * 24) + 232;
+		}
+		return 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5);
+	};
+	convert.ansi16.rgb = function(args) {
+		let color = args % 10;
+		if (color === 0 || color === 7) {
+			if (args > 50) color += 3.5;
+			color = color / 10.5 * 255;
+			return [
+				color,
+				color,
+				color
+			];
+		}
+		const mult = (~~(args > 50) + 1) * .5;
+		const r = (color & 1) * mult * 255;
+		const g = (color >> 1 & 1) * mult * 255;
+		const b = (color >> 2 & 1) * mult * 255;
+		return [
+			r,
+			g,
+			b
+		];
+	};
+	convert.ansi256.rgb = function(args) {
+		if (args >= 232) {
+			const c = (args - 232) * 10 + 8;
+			return [
+				c,
+				c,
+				c
+			];
+		}
+		args -= 16;
+		let rem;
+		const r = Math.floor(args / 36) / 5 * 255;
+		const g = Math.floor((rem = args % 36) / 6) / 5 * 255;
+		const b = rem % 6 / 5 * 255;
+		return [
+			r,
+			g,
+			b
+		];
+	};
+	convert.rgb.hex = function(args) {
+		const string = (((Math.round(args[0]) & 255) << 16) + ((Math.round(args[1]) & 255) << 8) + (Math.round(args[2]) & 255)).toString(16).toUpperCase();
+		return "000000".substring(string.length) + string;
+	};
+	convert.hex.rgb = function(args) {
+		const match = args.toString(16).match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
+		if (!match) return [
+			0,
+			0,
+			0
+		];
+		let colorString = match[0];
+		if (match[0].length === 3) colorString = colorString.split("").map((char) => {
+			return char + char;
+		}).join("");
+		const integer = parseInt(colorString, 16);
+		const r = integer >> 16 & 255;
+		const g = integer >> 8 & 255;
+		const b = integer & 255;
+		return [
+			r,
+			g,
+			b
+		];
+	};
+	convert.rgb.hcg = function(rgb) {
+		const r = rgb[0] / 255;
+		const g = rgb[1] / 255;
+		const b = rgb[2] / 255;
+		const max = Math.max(Math.max(r, g), b);
+		const min = Math.min(Math.min(r, g), b);
+		const chroma = max - min;
+		let grayscale;
+		let hue;
+		if (chroma < 1) grayscale = min / (1 - chroma);
+		else grayscale = 0;
+		if (chroma <= 0) hue = 0;
+		else if (max === r) hue = (g - b) / chroma % 6;
+		else if (max === g) hue = 2 + (b - r) / chroma;
+		else hue = 4 + (r - g) / chroma;
+		hue /= 6;
+		hue %= 1;
+		return [
+			hue * 360,
+			chroma * 100,
+			grayscale * 100
+		];
+	};
+	convert.hsl.hcg = function(hsl) {
+		const s = hsl[1] / 100;
+		const l = hsl[2] / 100;
+		const c = l < .5 ? 2 * s * l : 2 * s * (1 - l);
+		let f = 0;
+		if (c < 1) f = (l - .5 * c) / (1 - c);
+		return [
+			hsl[0],
+			c * 100,
+			f * 100
+		];
+	};
+	convert.hsv.hcg = function(hsv) {
+		const s = hsv[1] / 100;
+		const v = hsv[2] / 100;
+		const c = s * v;
+		let f = 0;
+		if (c < 1) f = (v - c) / (1 - c);
+		return [
+			hsv[0],
+			c * 100,
+			f * 100
+		];
+	};
+	convert.hcg.rgb = function(hcg) {
+		const h = hcg[0] / 360;
+		const c = hcg[1] / 100;
+		const g = hcg[2] / 100;
+		if (c === 0) return [
+			g * 255,
+			g * 255,
+			g * 255
+		];
+		const pure = [
+			0,
+			0,
+			0
+		];
+		const hi = h % 1 * 6;
+		const v = hi % 1;
+		const w = 1 - v;
+		let mg = 0;
+		switch (Math.floor(hi)) {
+			case 0:
+				pure[0] = 1;
+				pure[1] = v;
+				pure[2] = 0;
+				break;
+			case 1:
+				pure[0] = w;
+				pure[1] = 1;
+				pure[2] = 0;
+				break;
+			case 2:
+				pure[0] = 0;
+				pure[1] = 1;
+				pure[2] = v;
+				break;
+			case 3:
+				pure[0] = 0;
+				pure[1] = w;
+				pure[2] = 1;
+				break;
+			case 4:
+				pure[0] = v;
+				pure[1] = 0;
+				pure[2] = 1;
+				break;
+			default:
+				pure[0] = 1;
+				pure[1] = 0;
+				pure[2] = w;
+		}
+		mg = (1 - c) * g;
+		return [
+			(c * pure[0] + mg) * 255,
+			(c * pure[1] + mg) * 255,
+			(c * pure[2] + mg) * 255
+		];
+	};
+	convert.hcg.hsv = function(hcg) {
+		const c = hcg[1] / 100;
+		const g = hcg[2] / 100;
+		const v = c + g * (1 - c);
+		let f = 0;
+		if (v > 0) f = c / v;
+		return [
+			hcg[0],
+			f * 100,
+			v * 100
+		];
+	};
+	convert.hcg.hsl = function(hcg) {
+		const c = hcg[1] / 100;
+		const l = hcg[2] / 100 * (1 - c) + .5 * c;
+		let s = 0;
+		if (l > 0 && l < .5) s = c / (2 * l);
+		else if (l >= .5 && l < 1) s = c / (2 * (1 - l));
+		return [
+			hcg[0],
+			s * 100,
+			l * 100
+		];
+	};
+	convert.hcg.hwb = function(hcg) {
+		const c = hcg[1] / 100;
+		const g = hcg[2] / 100;
+		const v = c + g * (1 - c);
+		return [
+			hcg[0],
+			(v - c) * 100,
+			(1 - v) * 100
+		];
+	};
+	convert.hwb.hcg = function(hwb) {
+		const w = hwb[1] / 100;
+		const v = 1 - hwb[2] / 100;
+		const c = v - w;
+		let g = 0;
+		if (c < 1) g = (v - c) / (1 - c);
+		return [
+			hwb[0],
+			c * 100,
+			g * 100
+		];
+	};
+	convert.apple.rgb = function(apple) {
+		return [
+			apple[0] / 65535 * 255,
+			apple[1] / 65535 * 255,
+			apple[2] / 65535 * 255
+		];
+	};
+	convert.rgb.apple = function(rgb) {
+		return [
+			rgb[0] / 255 * 65535,
+			rgb[1] / 255 * 65535,
+			rgb[2] / 255 * 65535
+		];
+	};
+	convert.gray.rgb = function(args) {
+		return [
+			args[0] / 100 * 255,
+			args[0] / 100 * 255,
+			args[0] / 100 * 255
+		];
+	};
+	convert.gray.hsl = function(args) {
+		return [
+			0,
+			0,
+			args[0]
+		];
+	};
+	convert.gray.hsv = convert.gray.hsl;
+	convert.gray.hwb = function(gray) {
+		return [
+			0,
+			100,
+			gray[0]
+		];
+	};
+	convert.gray.cmyk = function(gray) {
+		return [
+			0,
+			0,
+			0,
+			gray[0]
+		];
+	};
+	convert.gray.lab = function(gray) {
+		return [
+			gray[0],
+			0,
+			0
+		];
+	};
+	convert.gray.hex = function(gray) {
+		const val = Math.round(gray[0] / 100 * 255) & 255;
+		const string = ((val << 16) + (val << 8) + val).toString(16).toUpperCase();
+		return "000000".substring(string.length) + string;
+	};
+	convert.rgb.gray = function(rgb) {
+		return [(rgb[0] + rgb[1] + rgb[2]) / 3 / 255 * 100];
+	};
+}) });
+
+//#endregion
+export default require_conversions();
+
+export { require_conversions };