Gutenberg / 22.9.0

Gutenberg v22.9.0

gutenberg / build / scripts / theme / index.js

index.js in Gutenberg 22.9.0, at build/scripts/theme/index.js

4,262 lines 128.1 KB

Raw Download Zip

1	var wp;
2	(wp \|\|= {}).theme = (() => {
3	var __create = Object.create;
4	var __defProp = Object.defineProperty;
5	var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
6	var __getOwnPropNames = Object.getOwnPropertyNames;
7	var __getProtoOf = Object.getPrototypeOf;
8	var __hasOwnProp = Object.prototype.hasOwnProperty;
9	var __commonJS = (cb, mod) => function __require() {
10	return mod \|\| (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
11	};
12	var __export = (target, all) => {
13	for (var name in all)
14	__defProp(target, name, { get: all[name], enumerable: true });
15	};
16	var __copyProps = (to2, from, except, desc) => {
17	if (from && typeof from === "object" \|\| typeof from === "function") {
18	for (let key of __getOwnPropNames(from))
19	if (!__hasOwnProp.call(to2, key) && key !== except)
20	__defProp(to2, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) \|\| desc.enumerable });
21	}
22	return to2;
23	};
24	var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
25	// If the importer is in node compatibility mode or this is not an ESM
26	// file that has been converted to a CommonJS file using a Babel-
27	// compatible transform (i.e. "__esModule" has not been set), then set
28	// "default" to the CommonJS "module.exports" for node compatibility.
29	isNodeMode \|\| !mod \|\| !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
30	mod
31	));
32	var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
33
34	// package-external:@wordpress/private-apis
35	var require_private_apis = __commonJS({
36	"package-external:@wordpress/private-apis"(exports, module) {
37	module.exports = window.wp.privateApis;
38	}
39	});
40
41	// package-external:@wordpress/element
42	var require_element = __commonJS({
43	"package-external:@wordpress/element"(exports, module) {
44	module.exports = window.wp.element;
45	}
46	});
47
48	// vendor-external:react/jsx-runtime
49	var require_jsx_runtime = __commonJS({
50	"vendor-external:react/jsx-runtime"(exports, module) {
51	module.exports = window.ReactJSXRuntime;
52	}
53	});
54
55	// packages/theme/build-module/index.mjs
56	var index_exports = {};
57	__export(index_exports, {
58	privateApis: () => privateApis
59	});
60
61	// packages/theme/build-module/lock-unlock.mjs
62	var import_private_apis = __toESM(require_private_apis(), 1);
63	var { lock, unlock } = (0, import_private_apis.__dangerousOptInToUnstableAPIsOnlyForCoreModules)(
64	"I acknowledge private features are not for use in themes or plugins and doing so will break in the next version of WordPress.",
65	"@wordpress/theme"
66	);
67
68	// packages/theme/build-module/theme-provider.mjs
69	var import_element3 = __toESM(require_element(), 1);
70
71	// packages/theme/build-module/context.mjs
72	var import_element = __toESM(require_element(), 1);
73	var ThemeContext = (0, import_element.createContext)({
74	resolvedSettings: {
75	color: {},
76	cursor: void 0
77	}
78	});
79
80	// packages/theme/node_modules/colorjs.io/src/multiply-matrices.js
81	function dot3(a, b2) {
82	return a[0] * b2[0] + a[1] * b2[1] + a[2] * b2[2];
83	}
84	function multiply_v3_m3x3(input, matrix, out = [0, 0, 0]) {
85	const x = dot3(input, matrix[0]);
86	const y = dot3(input, matrix[1]);
87	const z = dot3(input, matrix[2]);
88	out[0] = x;
89	out[1] = y;
90	out[2] = z;
91	return out;
92	}
93
94	// packages/theme/node_modules/colorjs.io/src/util.js
95	function isString(str) {
96	return type(str) === "string";
97	}
98	function type(o) {
99	let str = Object.prototype.toString.call(o);
100	return (str.match(/^\[object\s+(.*?)\]$/)[1] \|\| "").toLowerCase();
101	}
102	function serializeNumber(n2, { precision = 16, unit }) {
103	if (isNone(n2)) {
104	return "none";
105	}
106	n2 = +toPrecision(n2, precision);
107	return n2 + (unit ?? "");
108	}
109	function isNone(n2) {
110	return n2 === null;
111	}
112	function toPrecision(n2, precision) {
113	if (n2 === 0) {
114	return 0;
115	}
116	let integer = ~~n2;
117	let digits = 0;
118	if (integer && precision) {
119	digits = ~~Math.log10(Math.abs(integer)) + 1;
120	}
121	const multiplier = 10 ** (precision - digits);
122	return Math.floor(n2 * multiplier + 0.5) / multiplier;
123	}
124	function interpolate(start, end, p2) {
125	if (isNaN(start)) {
126	return end;
127	}
128	if (isNaN(end)) {
129	return start;
130	}
131	return start + (end - start) * p2;
132	}
133	function interpolateInv(start, end, value) {
134	return (value - start) / (end - start);
135	}
136	function mapRange(from, to2, value) {
137	if (!from \|\| !to2 \|\| from === to2 \|\| from[0] === to2[0] && from[1] === to2[1] \|\| isNaN(value) \|\| value === null) {
138	return value;
139	}
140	return interpolate(to2[0], to2[1], interpolateInv(from[0], from[1], value));
141	}
142	function clamp(min, val, max) {
143	return Math.max(Math.min(max, val), min);
144	}
145	function copySign(to2, from) {
146	return Math.sign(to2) === Math.sign(from) ? to2 : -to2;
147	}
148	function spow(base, exp) {
149	return copySign(Math.abs(base) ** exp, base);
150	}
151	function zdiv(n2, d2) {
152	return d2 === 0 ? 0 : n2 / d2;
153	}
154	function bisectLeft(arr, value, lo = 0, hi = arr.length) {
155	while (lo < hi) {
156	const mid = lo + hi >> 1;
157	if (arr[mid] < value) {
158	lo = mid + 1;
159	} else {
160	hi = mid;
161	}
162	}
163	return lo;
164	}
165	function isInstance(arg, constructor) {
166	if (arg instanceof constructor) {
167	return true;
168	}
169	const targetName = constructor.name;
170	while (arg) {
171	const proto = Object.getPrototypeOf(arg);
172	const constructorName = proto?.constructor?.name;
173	if (constructorName === targetName) {
174	return true;
175	}
176	if (!constructorName \|\| constructorName === "Object") {
177	return false;
178	}
179	arg = proto;
180	}
181	return false;
182	}
183
184	// packages/theme/node_modules/colorjs.io/src/Type.js
185	var Type = class {
186	// Class properties - declared here so that type inference works
187	type;
188	coordMeta;
189	coordRange;
190	/** @type {[number, number]} */
191	range;
192	/**
193	* @param {any} type
194	* @param {import("./types.js").CoordMeta} coordMeta
195	*/
196	constructor(type2, coordMeta) {
197	if (typeof type2 === "object") {
198	this.coordMeta = type2;
199	}
200	if (coordMeta) {
201	this.coordMeta = coordMeta;
202	this.coordRange = coordMeta.range ?? coordMeta.refRange;
203	}
204	if (typeof type2 === "string") {
205	let params = type2.trim().match(/^(?<type><[a-z]+>)(\[(?<min>-?[.\d]+),\s*(?<max>-?[.\d]+)\])?$/);
206	if (!params) {
207	throw new TypeError(`Cannot parse ${type2} as a type definition.`);
208	}
209	this.type = params.groups.type;
210	let { min, max } = params.groups;
211	if (min \|\| max) {
212	this.range = [+min, +max];
213	}
214	}
215	}
216	/** @returns {[number, number]} */
217	get computedRange() {
218	if (this.range) {
219	return this.range;
220	}
221	if (this.type === "<percentage>") {
222	return this.percentageRange();
223	} else if (this.type === "<angle>") {
224	return [0, 360];
225	}
226	return null;
227	}
228	get unit() {
229	if (this.type === "<percentage>") {
230	return "%";
231	} else if (this.type === "<angle>") {
232	return "deg";
233	}
234	return "";
235	}
236	/**
237	* Map a number to the internal representation
238	* @param {number} number
239	*/
240	resolve(number) {
241	if (this.type === "<angle>") {
242	return number;
243	}
244	let fromRange = this.computedRange;
245	let toRange = this.coordRange;
246	if (this.type === "<percentage>") {
247	toRange ??= this.percentageRange();
248	}
249	return mapRange(fromRange, toRange, number);
250	}
251	/**
252	* Serialize a number from the internal representation to a string
253	* @param {number} number
254	* @param {number} [precision]
255	*/
256	serialize(number, precision) {
257	let toRange = this.type === "<percentage>" ? this.percentageRange(100) : this.computedRange;
258	let unit = this.unit;
259	number = mapRange(this.coordRange, toRange, number);
260	return serializeNumber(number, { unit, precision });
261	}
262	toString() {
263	let ret = this.type;
264	if (this.range) {
265	let [min = "", max = ""] = this.range;
266	ret += `[${min},${max}]`;
267	}
268	return ret;
269	}
270	/**
271	* Returns a percentage range for values of this type
272	* @param {number} scale
273	* @returns {[number, number]}
274	*/
275	percentageRange(scale = 1) {
276	let range;
277	if (this.coordMeta && this.coordMeta.range \|\| this.coordRange && this.coordRange[0] >= 0) {
278	range = [0, 1];
279	} else {
280	range = [-1, 1];
281	}
282	return [range[0] * scale, range[1] * scale];
283	}
284	static get(type2, coordMeta) {
285	if (isInstance(type2, this)) {
286	return type2;
287	}
288	return new this(type2, coordMeta);
289	}
290	};
291
292	// packages/theme/node_modules/colorjs.io/src/Format.js
293	var instance = /* @__PURE__ */ Symbol("instance");
294	var Format = class _Format {
295	// Class properties - declared here so that type inference works
296	type;
297	name;
298	spaceCoords;
299	/** @type {Type[][]} */
300	coords;
301	/** @type {string \| undefined} */
302	id;
303	/** @type {boolean \| undefined} */
304	alpha;
305	/**
306	* @param {FormatInterface} format
307	* @param {ColorSpace} space
308	*/
309	constructor(format, space = format.space) {
310	format[instance] = this;
311	this.type = "function";
312	this.name = "color";
313	Object.assign(this, format);
314	this.space = space;
315	if (this.type === "custom") {
316	return;
317	}
318	this.spaceCoords = Object.values(space.coords);
319	if (!this.coords) {
320	this.coords = this.spaceCoords.map((coordMeta) => {
321	let ret = ["<number>", "<percentage>"];
322	if (coordMeta.type === "angle") {
323	ret.push("<angle>");
324	}
325	return ret;
326	});
327	}
328	this.coords = this.coords.map(
329	/** @param {string \| string[] \| Type[]} types */
330	(types, i) => {
331	let coordMeta = this.spaceCoords[i];
332	if (typeof types === "string") {
333	types = types.trim().split(/\s\\|\s/);
334	}
335	return types.map((type2) => Type.get(type2, coordMeta));
336	}
337	);
338	}
339	/**
340	* @param {Coords} coords
341	* @param {number} precision
342	* @param {Type[]} types
343	*/
344	serializeCoords(coords, precision, types) {
345	types = coords.map((_, i) => Type.get(types?.[i] ?? this.coords[i][0], this.spaceCoords[i]));
346	return coords.map((c, i) => types[i].serialize(c, precision));
347	}
348	/**
349	* Validates the coordinates of a color against a format's coord grammar and
350	* maps the coordinates to the range or refRange of the coordinates.
351	* @param {Coords} coords
352	* @param {[string, string, string]} types
353	*/
354	coerceCoords(coords, types) {
355	return Object.entries(this.space.coords).map(([id, coordMeta], i) => {
356	let arg = coords[i];
357	if (isNone(arg) \|\| isNaN(arg)) {
358	return arg;
359	}
360	let providedType = types[i];
361	let type2 = this.coords[i].find((c) => c.type == providedType);
362	if (!type2) {
363	let coordName = coordMeta.name \|\| id;
364	throw new TypeError(
365	`${providedType ?? /** @type {any} */
366	arg?.raw ?? arg} not allowed for ${coordName} in ${this.name}()`
367	);
368	}
369	arg = type2.resolve(arg);
370	if (type2.range) {
371	types[i] = type2.toString();
372	}
373	return arg;
374	});
375	}
376	/**
377	* @returns {boolean \| Required<FormatInterface>["serialize"]}
378	*/
379	canSerialize() {
380	return this.type === "function" \|\| /** @type {any} */
381	this.serialize;
382	}
383	/**
384	* @param {string} str
385	* @returns {(import("./types.js").ColorConstructor) \| undefined \| null}
386	*/
387	parse(str) {
388	return null;
389	}
390	/**
391	* @param {Format \| FormatInterface} format
392	* @param {RemoveFirstElement<ConstructorParameters<typeof Format>>} args
393	* @returns {Format}
394	*/
395	static get(format, ...args) {
396	if (!format \|\| isInstance(format, this)) {
397	return (
398	/** @type {Format} */
399	format
400	);
401	}
402	if (format[instance]) {
403	return format[instance];
404	}
405	return new _Format(format, ...args);
406	}
407	};
408
409	// packages/theme/node_modules/colorjs.io/src/hooks.js
410	var Hooks = class {
411	add(name, callback, first) {
412	if (typeof arguments[0] != "string") {
413	for (var name in arguments[0]) {
414	this.add(name, arguments[0][name], arguments[1]);
415	}
416	return;
417	}
418	(Array.isArray(name) ? name : [name]).forEach(function(name2) {
419	this[name2] = this[name2] \|\| [];
420	if (callback) {
421	this[name2][first ? "unshift" : "push"](callback);
422	}
423	}, this);
424	}
425	run(name, env) {
426	this[name] = this[name] \|\| [];
427	this[name].forEach(function(callback) {
428	callback.call(env && env.context ? env.context : env, env);
429	});
430	}
431	};
432	var hooks = new Hooks();
433	var hooks_default = hooks;
434
435	// packages/theme/node_modules/colorjs.io/src/adapt.js
436	var WHITES = {
437	// for compatibility, the four-digit chromaticity-derived ones everyone else uses
438	D50: [0.3457 / 0.3585, 1, (1 - 0.3457 - 0.3585) / 0.3585],
439	D65: [0.3127 / 0.329, 1, (1 - 0.3127 - 0.329) / 0.329]
440	};
441	function getWhite(name) {
442	if (Array.isArray(name)) {
443	return name;
444	}
445	return WHITES[name];
446	}
447	function adapt(W1, W2, XYZ, options = {}) {
448	W1 = getWhite(W1);
449	W2 = getWhite(W2);
450	if (!W1 \|\| !W2) {
451	throw new TypeError(
452	`Missing white point to convert ${!W1 ? "from" : ""}${!W1 && !W2 ? "/" : ""}${!W2 ? "to" : ""}`
453	);
454	}
455	if (W1 === W2) {
456	return XYZ;
457	}
458	let env = { W1, W2, XYZ, options };
459	hooks_default.run("chromatic-adaptation-start", env);
460	if (!env.M) {
461	if (env.W1 === WHITES.D65 && env.W2 === WHITES.D50) {
462	env.M = [
463	[1.0479297925449969, 0.022946870601609652, -0.05019226628920524],
464	[0.02962780877005599, 0.9904344267538799, -0.017073799063418826],
465	[-0.009243040646204504, 0.015055191490298152, 0.7518742814281371]
466	];
467	} else if (env.W1 === WHITES.D50 && env.W2 === WHITES.D65) {
468	env.M = [
469	[0.955473421488075, -0.02309845494876471, 0.06325924320057072],
470	[-0.0283697093338637, 1.0099953980813041, 0.021041441191917323],
471	[0.012314014864481998, -0.020507649298898964, 1.330365926242124]
472	];
473	}
474	}
475	hooks_default.run("chromatic-adaptation-end", env);
476	if (env.M) {
477	return multiply_v3_m3x3(env.XYZ, env.M);
478	} else {
479	throw new TypeError("Only Bradford CAT with white points D50 and D65 supported for now.");
480	}
481	}
482
483	// packages/theme/node_modules/colorjs.io/src/defaults.js
484	var defaults_default = {
485	gamut_mapping: "css",
486	precision: 5,
487	deltaE: "76",
488	// Default deltaE method
489	verbose: globalThis?.process?.env?.NODE_ENV?.toLowerCase() !== "test",
490	warn: function warn(msg) {
491	if (this.verbose) {
492	globalThis?.console?.warn?.(msg);
493	}
494	}
495	};
496
497	// packages/theme/node_modules/colorjs.io/src/parse.js
498	function parse(str, options) {
499	let env = {
500	str: String(str)?.trim(),
501	options
502	};
503	hooks_default.run("parse-start", env);
504	if (env.color) {
505	return env.color;
506	}
507	env.parsed = parseFunction(env.str);
508	let ret;
509	let meta = env.options ? env.options.parseMeta ?? env.options.meta : null;
510	if (env.parsed) {
511	let name = env.parsed.name;
512	let format;
513	let space;
514	let coords = env.parsed.args;
515	let types = coords.map((c, i) => env.parsed.argMeta[i]?.type);
516	if (name === "color") {
517	let id = coords.shift();
518	types.shift();
519	let alternateId = id.startsWith("--") ? id.substring(2) : `--${id}`;
520	let ids = [id, alternateId];
521	format = ColorSpace.findFormat({ name, id: ids, type: "function" });
522	if (!format) {
523	let didYouMean;
524	let registryId = id in ColorSpace.registry ? id : alternateId;
525	if (registryId in ColorSpace.registry) {
526	let cssId = ColorSpace.registry[registryId].formats?.color?.id;
527	if (cssId) {
528	let altColor = str.replace("color(" + id, "color(" + cssId);
529	didYouMean = `Did you mean ${altColor}?`;
530	}
531	}
532	throw new TypeError(
533	`Cannot parse ${env.str}. ` + (didYouMean ?? "Missing a plugin?")
534	);
535	}
536	space = format.space;
537	if (format.id.startsWith("--") && !id.startsWith("--")) {
538	defaults_default.warn(
539	`${space.name} is a non-standard space and not currently supported in the CSS spec. Use prefixed color(${format.id}) instead of color(${id}).`
540	);
541	}
542	if (id.startsWith("--") && !format.id.startsWith("--")) {
543	defaults_default.warn(
544	`${space.name} is a standard space and supported in the CSS spec. Use color(${format.id}) instead of prefixed color(${id}).`
545	);
546	}
547	} else {
548	format = ColorSpace.findFormat({ name, type: "function" });
549	space = format.space;
550	}
551	if (meta) {
552	Object.assign(meta, {
553	format,
554	formatId: format.name,
555	types,
556	commas: env.parsed.commas
557	});
558	}
559	let alpha = 1;
560	if (env.parsed.lastAlpha) {
561	alpha = env.parsed.args.pop();
562	if (meta) {
563	meta.alphaType = types.pop();
564	}
565	}
566	let coordCount = format.coords.length;
567	if (coords.length !== coordCount) {
568	throw new TypeError(
569	`Expected ${coordCount} coordinates for ${space.id} in ${env.str}), got ${coords.length}`
570	);
571	}
572	coords = format.coerceCoords(coords, types);
573	ret = { spaceId: space.id, coords, alpha };
574	} else {
575	spaceloop: for (let space of ColorSpace.all) {
576	for (let formatId in space.formats) {
577	let format = space.formats[formatId];
578	if (format.type !== "custom") {
579	continue;
580	}
581	if (format.test && !format.test(env.str)) {
582	continue;
583	}
584	let formatObject = space.getFormat(format);
585	let color = formatObject.parse(env.str);
586	if (color) {
587	if (meta) {
588	Object.assign(meta, { format: formatObject, formatId });
589	}
590	ret = color;
591	break spaceloop;
592	}
593	}
594	}
595	}
596	if (!ret) {
597	throw new TypeError(`Could not parse ${str} as a color. Missing a plugin?`);
598	}
599	ret.alpha = isNone(ret.alpha) ? ret.alpha : ret.alpha === void 0 ? 1 : clamp(0, ret.alpha, 1);
600	return ret;
601	}
602	var units = {
603	"%": 0.01,
604	deg: 1,
605	grad: 0.9,
606	rad: 180 / Math.PI,
607	turn: 360
608	};
609	var regex = {
610	// Need to list calc(NaN) explicitly as otherwise its ending paren would terminate the function call
611	function: /^([a-z]+)\(((?:calc\(NaN\)\|.)+?)\)$/i,
612	number: /^([-+]?(?:[0-9]*\.)?[0-9]+(e[-+]?[0-9]+)?)$/i,
613	unitValue: RegExp(`(${Object.keys(units).join("\|")})$`),
614	// NOTE The -+ are not just for prefix, but also for idents, and e+N notation!
615	singleArgument: /\/?\s*(none\|NaN\|calc\(NaN\)\|[-+\w.]+(?:%\|deg\|g?rad\|turn)?)/g
616	};
617	function parseArgument(rawArg) {
618	let meta = {};
619	let unit = rawArg.match(regex.unitValue)?.[0];
620	let value = meta.raw = rawArg;
621	if (unit) {
622	meta.type = unit === "%" ? "<percentage>" : "<angle>";
623	meta.unit = unit;
624	meta.unitless = Number(value.slice(0, -unit.length));
625	value = meta.unitless * units[unit];
626	} else if (regex.number.test(value)) {
627	value = Number(value);
628	meta.type = "<number>";
629	} else if (value === "none") {
630	value = null;
631	} else if (value === "NaN" \|\| value === "calc(NaN)") {
632	value = NaN;
633	meta.type = "<number>";
634	} else {
635	meta.type = "<ident>";
636	}
637	return { value: (
638	/** @type {number} */
639	value
640	), meta: (
641	/** @type {ArgumentMeta} */
642	meta
643	) };
644	}
645	function parseFunction(str) {
646	if (!str) {
647	return;
648	}
649	str = str.trim();
650	let parts = str.match(regex.function);
651	if (parts) {
652	let args = [];
653	let argMeta = [];
654	let lastAlpha = false;
655	let name = parts[1].toLowerCase();
656	let separators = parts[2].replace(regex.singleArgument, ($0, rawArg) => {
657	let { value, meta } = parseArgument(rawArg);
658	if (
659	// If there's a slash here, it's modern syntax
660	$0.startsWith("/") \|\| // If there's still elements to process after there's already 3 in `args` (and the we're not dealing with "color()"), it's likely to be a legacy color like "hsl(0, 0%, 0%, 0.5)"
661	name !== "color" && args.length === 3
662	) {
663	lastAlpha = true;
664	}
665	args.push(value);
666	argMeta.push(meta);
667	return "";
668	});
669	return {
670	name,
671	args,
672	argMeta,
673	lastAlpha,
674	commas: separators.includes(","),
675	rawName: parts[1],
676	rawArgs: parts[2]
677	};
678	}
679	}
680
681	// packages/theme/node_modules/colorjs.io/src/getColor.js
682	function getColor(color, options) {
683	if (Array.isArray(color)) {
684	return color.map((c) => getColor(c, options));
685	}
686	if (!color) {
687	throw new TypeError("Empty color reference");
688	}
689	if (isString(color)) {
690	color = parse(color, options);
691	}
692	let space = color.space \|\| color.spaceId;
693	if (typeof space === "string") {
694	color.space = ColorSpace.get(space);
695	}
696	if (color.alpha === void 0) {
697	color.alpha = 1;
698	}
699	return color;
700	}
701
702	// packages/theme/node_modules/colorjs.io/src/ColorSpace.js
703	var \u03B5 = 75e-6;
704	var ColorSpace = class _ColorSpace {
705	constructor(options) {
706	this.id = options.id;
707	this.name = options.name;
708	this.base = options.base ? _ColorSpace.get(options.base) : null;
709	this.aliases = options.aliases;
710	if (this.base) {
711	this.fromBase = options.fromBase;
712	this.toBase = options.toBase;
713	}
714	let coords = options.coords ?? this.base.coords;
715	for (let name in coords) {
716	if (!("name" in coords[name])) {
717	coords[name].name = name;
718	}
719	}
720	this.coords = coords;
721	let white4 = options.white ?? this.base.white ?? "D65";
722	this.white = getWhite(white4);
723	this.formats = options.formats ?? {};
724	for (let name in this.formats) {
725	let format = this.formats[name];
726	format.type \|\|= "function";
727	format.name \|\|= name;
728	}
729	if (!this.formats.color?.id) {
730	this.formats.color = {
731	...this.formats.color ?? {},
732	id: options.cssId \|\| this.id
733	};
734	}
735	if (options.gamutSpace) {
736	this.gamutSpace = options.gamutSpace === "self" ? this : _ColorSpace.get(options.gamutSpace);
737	} else {
738	if (this.isPolar) {
739	this.gamutSpace = this.base;
740	} else {
741	this.gamutSpace = this;
742	}
743	}
744	if (this.gamutSpace.isUnbounded) {
745	this.inGamut = (coords2, options2) => {
746	return true;
747	};
748	}
749	this.referred = options.referred;
750	Object.defineProperty(this, "path", {
751	value: getPath(this).reverse(),
752	writable: false,
753	enumerable: true,
754	configurable: true
755	});
756	hooks_default.run("colorspace-init-end", this);
757	}
758	inGamut(coords, { epsilon = \u03B5 } = {}) {
759	if (!this.equals(this.gamutSpace)) {
760	coords = this.to(this.gamutSpace, coords);
761	return this.gamutSpace.inGamut(coords, { epsilon });
762	}
763	let coordMeta = Object.values(this.coords);
764	return coords.every((c, i) => {
765	let meta = coordMeta[i];
766	if (meta.type !== "angle" && meta.range) {
767	if (isNone(c)) {
768	return true;
769	}
770	let [min, max] = meta.range;
771	return (min === void 0 \|\| c >= min - epsilon) && (max === void 0 \|\| c <= max + epsilon);
772	}
773	return true;
774	});
775	}
776	get isUnbounded() {
777	return Object.values(this.coords).every((coord) => !("range" in coord));
778	}
779	get cssId() {
780	return this.formats?.color?.id \|\| this.id;
781	}
782	get isPolar() {
783	for (let id in this.coords) {
784	if (this.coords[id].type === "angle") {
785	return true;
786	}
787	}
788	return false;
789	}
790	/**
791	* Lookup a format in this color space
792	* @param {string \| object \| Format} format - Format id if string. If object, it's converted to a `Format` object and returned.
793	* @returns {Format}
794	*/
795	getFormat(format) {
796	if (!format) {
797	return null;
798	}
799	if (format === "default") {
800	format = Object.values(this.formats)[0];
801	} else if (typeof format === "string") {
802	format = this.formats[format];
803	}
804	let ret = Format.get(format, this);
805	if (ret !== format && format.name in this.formats) {
806	this.formats[format.name] = ret;
807	}
808	return ret;
809	}
810	/**
811	* Check if this color space is the same as another color space reference.
812	* Allows proxying color space objects and comparing color spaces with ids.
813	* @param {string \| ColorSpace} space ColorSpace object or id to compare to
814	* @returns {boolean}
815	*/
816	equals(space) {
817	if (!space) {
818	return false;
819	}
820	return this === space \|\| this.id === space \|\| this.id === space.id;
821	}
822	to(space, coords) {
823	if (arguments.length === 1) {
824	const color = getColor(space);
825	[space, coords] = [color.space, color.coords];
826	}
827	space = _ColorSpace.get(space);
828	if (this.equals(space)) {
829	return coords;
830	}
831	coords = coords.map((c) => isNone(c) ? 0 : c);
832	let myPath = this.path;
833	let otherPath = space.path;
834	let connectionSpace, connectionSpaceIndex;
835	for (let i = 0; i < myPath.length; i++) {
836	if (myPath[i].equals(otherPath[i])) {
837	connectionSpace = myPath[i];
838	connectionSpaceIndex = i;
839	} else {
840	break;
841	}
842	}
843	if (!connectionSpace) {
844	throw new Error(
845	`Cannot convert between color spaces ${this} and ${space}: no connection space was found`
846	);
847	}
848	for (let i = myPath.length - 1; i > connectionSpaceIndex; i--) {
849	coords = myPath[i].toBase(coords);
850	}
851	for (let i = connectionSpaceIndex + 1; i < otherPath.length; i++) {
852	coords = otherPath[i].fromBase(coords);
853	}
854	return coords;
855	}
856	from(space, coords) {
857	if (arguments.length === 1) {
858	const color = getColor(space);
859	[space, coords] = [color.space, color.coords];
860	}
861	space = _ColorSpace.get(space);
862	return space.to(this, coords);
863	}
864	toString() {
865	return `${this.name} (${this.id})`;
866	}
867	getMinCoords() {
868	let ret = [];
869	for (let id in this.coords) {
870	let meta = this.coords[id];
871	let range = meta.range \|\| meta.refRange;
872	ret.push(range?.min ?? 0);
873	}
874	return ret;
875	}
876	static registry = {};
877	// Returns array of unique color spaces
878	static get all() {
879	return [...new Set(Object.values(_ColorSpace.registry))];
880	}
881	static register(id, space) {
882	if (arguments.length === 1) {
883	space = arguments[0];
884	id = space.id;
885	}
886	space = this.get(space);
887	if (this.registry[id] && this.registry[id] !== space) {
888	throw new Error(`Duplicate color space registration: '${id}'`);
889	}
890	this.registry[id] = space;
891	if (arguments.length === 1 && space.aliases) {
892	for (let alias of space.aliases) {
893	this.register(alias, space);
894	}
895	}
896	return space;
897	}
898	/**
899	* Lookup ColorSpace object by name
900	* @param {ColorSpace \| string} name
901	*/
902	static get(space, ...alternatives) {
903	if (!space \|\| isInstance(space, this)) {
904	return space;
905	}
906	let argType = type(space);
907	if (argType === "string") {
908	let ret = _ColorSpace.registry[space.toLowerCase()];
909	if (!ret) {
910	throw new TypeError(`No color space found with id = "${space}"`);
911	}
912	return ret;
913	}
914	if (alternatives.length) {
915	return _ColorSpace.get(...alternatives);
916	}
917	throw new TypeError(`${space} is not a valid color space`);
918	}
919	/**
920	* Look up all color spaces for a format that matches certain criteria
921	* @param {object \| string} filters
922	* @param {Array<ColorSpace>} [spaces=ColorSpace.all]
923	* @returns {Format \| null}
924	*/
925	static findFormat(filters, spaces = _ColorSpace.all) {
926	if (!filters) {
927	return null;
928	}
929	if (typeof filters === "string") {
930	filters = { name: filters };
931	}
932	for (let space of spaces) {
933	for (let [name, format] of Object.entries(space.formats)) {
934	format.name ??= name;
935	format.type ??= "function";
936	let matches = (!filters.name \|\| format.name === filters.name) && (!filters.type \|\| format.type === filters.type);
937	if (filters.id) {
938	let ids = format.ids \|\| [format.id];
939	let filterIds = Array.isArray(filters.id) ? filters.id : [filters.id];
940	matches &&= filterIds.some((id) => ids.includes(id));
941	}
942	if (matches) {
943	let ret = Format.get(format, space);
944	if (ret !== format) {
945	space.formats[format.name] = ret;
946	}
947	return ret;
948	}
949	}
950	}
951	return null;
952	}
953	/**
954	* Get metadata about a coordinate of a color space
955	*
956	* @static
957	* @param {Array \| string} ref
958	* @param {ColorSpace \| string} [workingSpace]
959	* @return {Object}
960	*/
961	static resolveCoord(ref, workingSpace) {
962	let coordType = type(ref);
963	let space, coord;
964	if (coordType === "string") {
965	if (ref.includes(".")) {
966	[space, coord] = ref.split(".");
967	} else {
968	[space, coord] = [, ref];
969	}
970	} else if (Array.isArray(ref)) {
971	[space, coord] = ref;
972	} else {
973	space = ref.space;
974	coord = ref.coordId;
975	}
976	space = _ColorSpace.get(space);
977	if (!space) {
978	space = workingSpace;
979	}
980	if (!space) {
981	throw new TypeError(
982	`Cannot resolve coordinate reference ${ref}: No color space specified and relative references are not allowed here`
983	);
984	}
985	coordType = type(coord);
986	if (coordType === "number" \|\| coordType === "string" && coord >= 0) {
987	let meta = Object.entries(space.coords)[coord];
988	if (meta) {
989	return { space, id: meta[0], index: coord, ...meta[1] };
990	}
991	}
992	space = _ColorSpace.get(space);
993	let normalizedCoord = coord.toLowerCase();
994	let i = 0;
995	for (let id in space.coords) {
996	let meta = space.coords[id];
997	if (id.toLowerCase() === normalizedCoord \|\| meta.name?.toLowerCase() === normalizedCoord) {
998	return { space, id, index: i, ...meta };
999	}
1000	i++;
1001	}
1002	throw new TypeError(
1003	`No "${coord}" coordinate found in ${space.name}. Its coordinates are: ${Object.keys(space.coords).join(", ")}`
1004	);
1005	}
1006	static DEFAULT_FORMAT = {
1007	type: "functions",
1008	name: "color"
1009	};
1010	};
1011	function getPath(space) {
1012	let ret = [space];
1013	for (let s = space; s = s.base; ) {
1014	ret.push(s);
1015	}
1016	return ret;
1017	}
1018
1019	// packages/theme/node_modules/colorjs.io/src/spaces/xyz-d65.js
1020	var xyz_d65_default = new ColorSpace({
1021	id: "xyz-d65",
1022	name: "XYZ D65",
1023	coords: {
1024	x: {
1025	refRange: [0, 1],
1026	name: "X"
1027	},
1028	y: {
1029	refRange: [0, 1],
1030	name: "Y"
1031	},
1032	z: {
1033	refRange: [0, 1],
1034	name: "Z"
1035	}
1036	},
1037	white: "D65",
1038	formats: {
1039	color: {
1040	ids: ["xyz-d65", "xyz"]
1041	}
1042	},
1043	aliases: ["xyz"]
1044	});
1045
1046	// packages/theme/node_modules/colorjs.io/src/RGBColorSpace.js
1047	var RGBColorSpace = class extends ColorSpace {
1048	/**
1049	* Creates a new RGB ColorSpace.
1050	* If coords are not specified, they will use the default RGB coords.
1051	* Instead of `fromBase()` and `toBase()` functions,
1052	* you can specify to/from XYZ matrices and have `toBase()` and `fromBase()` automatically generated.
1053	* @param {RGBOptions} options
1054	*/
1055	constructor(options) {
1056	if (!options.coords) {
1057	options.coords = {
1058	r: {
1059	range: [0, 1],
1060	name: "Red"
1061	},
1062	g: {
1063	range: [0, 1],
1064	name: "Green"
1065	},
1066	b: {
1067	range: [0, 1],
1068	name: "Blue"
1069	}
1070	};
1071	}
1072	if (!options.base) {
1073	options.base = xyz_d65_default;
1074	}
1075	if (options.toXYZ_M && options.fromXYZ_M) {
1076	options.toBase ??= (rgb) => {
1077	let xyz = multiply_v3_m3x3(rgb, options.toXYZ_M);
1078	if (this.white !== this.base.white) {
1079	xyz = adapt(this.white, this.base.white, xyz);
1080	}
1081	return xyz;
1082	};
1083	options.fromBase ??= (xyz) => {
1084	xyz = adapt(this.base.white, this.white, xyz);
1085	return multiply_v3_m3x3(xyz, options.fromXYZ_M);
1086	};
1087	}
1088	options.referred ??= "display";
1089	super(options);
1090	}
1091	};
1092
1093	// packages/theme/node_modules/colorjs.io/src/getAll.js
1094	function getAll(color, options) {
1095	color = getColor(color);
1096	let space = ColorSpace.get(options, options?.space);
1097	let precision = options?.precision;
1098	let coords;
1099	if (!space \|\| color.space.equals(space)) {
1100	coords = color.coords.slice();
1101	} else {
1102	coords = space.from(color);
1103	}
1104	return precision === void 0 ? coords : coords.map((coord) => toPrecision(coord, precision));
1105	}
1106
1107	// packages/theme/node_modules/colorjs.io/src/get.js
1108	function get(color, prop) {
1109	color = getColor(color);
1110	if (prop === "alpha") {
1111	return color.alpha ?? 1;
1112	}
1113	let { space, index } = ColorSpace.resolveCoord(prop, color.space);
1114	let coords = getAll(color, space);
1115	return coords[index];
1116	}
1117
1118	// packages/theme/node_modules/colorjs.io/src/setAll.js
1119	function setAll(color, space, coords, alpha) {
1120	color = getColor(color);
1121	if (Array.isArray(space)) {
1122	[space, coords, alpha] = [color.space, space, coords];
1123	}
1124	space = ColorSpace.get(space);
1125	color.coords = space === color.space ? coords.slice() : space.to(color.space, coords);
1126	if (alpha !== void 0) {
1127	color.alpha = alpha;
1128	}
1129	return color;
1130	}
1131	setAll.returns = "color";
1132
1133	// packages/theme/node_modules/colorjs.io/src/set.js
1134	function set(color, prop, value) {
1135	color = getColor(color);
1136	if (arguments.length === 2 && type(arguments[1]) === "object") {
1137	let object = arguments[1];
1138	for (let p2 in object) {
1139	set(color, p2, object[p2]);
1140	}
1141	} else {
1142	if (typeof value === "function") {
1143	value = value(get(color, prop));
1144	}
1145	if (prop === "alpha") {
1146	color.alpha = value;
1147	} else {
1148	let { space, index } = ColorSpace.resolveCoord(prop, color.space);
1149	let coords = getAll(color, space);
1150	coords[index] = value;
1151	setAll(color, space, coords);
1152	}
1153	}
1154	return color;
1155	}
1156	set.returns = "color";
1157
1158	// packages/theme/node_modules/colorjs.io/src/spaces/xyz-d50.js
1159	var xyz_d50_default = new ColorSpace({
1160	id: "xyz-d50",
1161	name: "XYZ D50",
1162	white: "D50",
1163	base: xyz_d65_default,
1164	fromBase: (coords) => adapt(xyz_d65_default.white, "D50", coords),
1165	toBase: (coords) => adapt("D50", xyz_d65_default.white, coords)
1166	});
1167
1168	// packages/theme/node_modules/colorjs.io/src/spaces/lab.js
1169	var \u03B52 = 216 / 24389;
1170	var \u03B53 = 24 / 116;
1171	var \u03BA = 24389 / 27;
1172	var white = WHITES.D50;
1173	var lab_default = new ColorSpace({
1174	id: "lab",
1175	name: "Lab",
1176	coords: {
1177	l: {
1178	refRange: [0, 100],
1179	name: "Lightness"
1180	},
1181	a: {
1182	refRange: [-125, 125]
1183	},
1184	b: {
1185	refRange: [-125, 125]
1186	}
1187	},
1188	// Assuming XYZ is relative to D50, convert to CIE Lab
1189	// from CIE standard, which now defines these as a rational fraction
1190	white,
1191	base: xyz_d50_default,
1192	// Convert D50-adapted XYX to Lab
1193	// CIE 15.3:2004 section 8.2.1.1
1194	fromBase(XYZ) {
1195	let xyz = XYZ.map((value, i) => value / white[i]);
1196	let f = xyz.map((value) => value > \u03B52 ? Math.cbrt(value) : (\u03BA * value + 16) / 116);
1197	let L = 116 * f[1] - 16;
1198	let a = 500 * (f[0] - f[1]);
1199	let b2 = 200 * (f[1] - f[2]);
1200	return [L, a, b2];
1201	},
1202	// Convert Lab to D50-adapted XYZ
1203	// Same result as CIE 15.3:2004 Appendix D although the derivation is different
1204	// http://www.brucelindbloom.com/index.html?Eqn_RGB_XYZ_Matrix.html
1205	toBase(Lab) {
1206	let [L, a, b2] = Lab;
1207	let f = [];
1208	f[1] = (L + 16) / 116;
1209	f[0] = a / 500 + f[1];
1210	f[2] = f[1] - b2 / 200;
1211	let xyz = [
1212	f[0] > \u03B53 ? Math.pow(f[0], 3) : (116 * f[0] - 16) / \u03BA,
1213	Lab[0] > 8 ? Math.pow((Lab[0] + 16) / 116, 3) : Lab[0] / \u03BA,
1214	f[2] > \u03B53 ? Math.pow(f[2], 3) : (116 * f[2] - 16) / \u03BA
1215	];
1216	return xyz.map((value, i) => value * white[i]);
1217	},
1218	formats: {
1219	lab: {
1220	coords: [
1221	"<percentage> \| <number>",
1222	"<number> \| <percentage>",
1223	"<number> \| <percentage>"
1224	]
1225	}
1226	}
1227	});
1228
1229	// packages/theme/node_modules/colorjs.io/src/angles.js
1230	function constrain(angle) {
1231	if (typeof angle !== "number") {
1232	return angle;
1233	}
1234	return (angle % 360 + 360) % 360;
1235	}
1236
1237	// packages/theme/node_modules/colorjs.io/src/spaces/lch.js
1238	var lch_default = new ColorSpace({
1239	id: "lch",
1240	name: "LCH",
1241	coords: {
1242	l: {
1243	refRange: [0, 100],
1244	name: "Lightness"
1245	},
1246	c: {
1247	refRange: [0, 150],
1248	name: "Chroma"
1249	},
1250	h: {
1251	refRange: [0, 360],
1252	type: "angle",
1253	name: "Hue"
1254	}
1255	},
1256	base: lab_default,
1257	fromBase(Lab) {
1258	if (this.\u03B5 === void 0) {
1259	let range = Object.values(this.base.coords)[1].refRange;
1260	let extent = range[1] - range[0];
1261	this.\u03B5 = extent / 1e5;
1262	}
1263	let [L, a, b2] = Lab;
1264	let isAchromatic = Math.abs(a) < this.\u03B5 && Math.abs(b2) < this.\u03B5;
1265	let h = isAchromatic ? null : constrain(Math.atan2(b2, a) * 180 / Math.PI);
1266	let C = isAchromatic ? 0 : Math.sqrt(a 2 + b2 2);
1267	return [L, C, h];
1268	},
1269	toBase(lch) {
1270	let [L, C, h] = lch;
1271	let a = null, b2 = null;
1272	if (!isNone(h)) {
1273	C = C < 0 ? 0 : C;
1274	a = C * Math.cos(h * Math.PI / 180);
1275	b2 = C * Math.sin(h * Math.PI / 180);
1276	}
1277	return [L, a, b2];
1278	},
1279	formats: {
1280	lch: {
1281	coords: ["<percentage> \| <number>", "<number> \| <percentage>", "<number> \| <angle>"]
1282	}
1283	}
1284	});
1285
1286	// packages/theme/node_modules/colorjs.io/src/deltaE/deltaE2000.js
1287	var Gfactor = 25 ** 7;
1288	var \u03C0 = Math.PI;
1289	var r2d = 180 / \u03C0;
1290	var d2r = \u03C0 / 180;
1291	function pow7(x) {
1292	const x2 = x * x;
1293	const x7 = x2 * x2 * x2 * x;
1294	return x7;
1295	}
1296	function deltaE2000_default(color, sample, { kL = 1, kC = 1, kH = 1 } = {}) {
1297	[color, sample] = getColor([color, sample]);
1298	let [L1, a1, b1] = lab_default.from(color);
1299	let C1 = lch_default.from(lab_default, [L1, a1, b1])[1];
1300	let [L2, a2, b2] = lab_default.from(sample);
1301	let C2 = lch_default.from(lab_default, [L2, a2, b2])[1];
1302	if (C1 < 0) {
1303	C1 = 0;
1304	}
1305	if (C2 < 0) {
1306	C2 = 0;
1307	}
1308	let Cbar = (C1 + C2) / 2;
1309	let C7 = pow7(Cbar);
1310	let G = 0.5 * (1 - Math.sqrt(C7 / (C7 + Gfactor)));
1311	let adash1 = (1 + G) * a1;
1312	let adash2 = (1 + G) * a2;
1313	let Cdash1 = Math.sqrt(adash1 2 + b1 2);
1314	let Cdash2 = Math.sqrt(adash2 2 + b2 2);
1315	let h1 = adash1 === 0 && b1 === 0 ? 0 : Math.atan2(b1, adash1);
1316	let h2 = adash2 === 0 && b2 === 0 ? 0 : Math.atan2(b2, adash2);
1317	if (h1 < 0) {
1318	h1 += 2 * \u03C0;
1319	}
1320	if (h2 < 0) {
1321	h2 += 2 * \u03C0;
1322	}
1323	h1 *= r2d;
1324	h2 *= r2d;
1325	let \u0394L = L2 - L1;
1326	let \u0394C = Cdash2 - Cdash1;
1327	let hdiff = h2 - h1;
1328	let hsum = h1 + h2;
1329	let habs = Math.abs(hdiff);
1330	let \u0394h;
1331	if (Cdash1 * Cdash2 === 0) {
1332	\u0394h = 0;
1333	} else if (habs <= 180) {
1334	\u0394h = hdiff;
1335	} else if (hdiff > 180) {
1336	\u0394h = hdiff - 360;
1337	} else if (hdiff < -180) {
1338	\u0394h = hdiff + 360;
1339	} else {
1340	defaults_default.warn("the unthinkable has happened");
1341	}
1342	let \u0394H = 2 * Math.sqrt(Cdash2 * Cdash1) * Math.sin(\u0394h * d2r / 2);
1343	let Ldash = (L1 + L2) / 2;
1344	let Cdash = (Cdash1 + Cdash2) / 2;
1345	let Cdash7 = pow7(Cdash);
1346	let hdash;
1347	if (Cdash1 * Cdash2 === 0) {
1348	hdash = hsum;
1349	} else if (habs <= 180) {
1350	hdash = hsum / 2;
1351	} else if (hsum < 360) {
1352	hdash = (hsum + 360) / 2;
1353	} else {
1354	hdash = (hsum - 360) / 2;
1355	}
1356	let lsq = (Ldash - 50) ** 2;
1357	let SL = 1 + 0.015 * lsq / Math.sqrt(20 + lsq);
1358	let SC = 1 + 0.045 * Cdash;
1359	let T = 1;
1360	T -= 0.17 * Math.cos((hdash - 30) * d2r);
1361	T += 0.24 * Math.cos(2 * hdash * d2r);
1362	T += 0.32 * Math.cos((3 * hdash + 6) * d2r);
1363	T -= 0.2 * Math.cos((4 * hdash - 63) * d2r);
1364	let SH = 1 + 0.015 * Cdash * T;
1365	let \u0394\u03B8 = 30 * Math.exp(-1 * ((hdash - 275) / 25) ** 2);
1366	let RC = 2 * Math.sqrt(Cdash7 / (Cdash7 + Gfactor));
1367	let RT = -1 * Math.sin(2 * \u0394\u03B8 * d2r) * RC;
1368	let dE = (\u0394L / (kL * SL)) ** 2;
1369	dE += (\u0394C / (kC * SC)) ** 2;
1370	dE += (\u0394H / (kH * SH)) ** 2;
1371	dE += RT * (\u0394C / (kC * SC)) * (\u0394H / (kH * SH));
1372	return Math.sqrt(dE);
1373	}
1374
1375	// packages/theme/node_modules/colorjs.io/src/spaces/oklab.js
1376	var XYZtoLMS_M = [
1377	[0.819022437996703, 0.3619062600528904, -0.1288737815209879],
1378	[0.0329836539323885, 0.9292868615863434, 0.0361446663506424],
1379	[0.0481771893596242, 0.2642395317527308, 0.6335478284694309]
1380	];
1381	var LMStoXYZ_M = [
1382	[1.2268798758459243, -0.5578149944602171, 0.2813910456659647],
1383	[-0.0405757452148008, 1.112286803280317, -0.0717110580655164],
1384	[-0.0763729366746601, -0.4214933324022432, 1.5869240198367816]
1385	];
1386	var LMStoLab_M = [
1387	[0.210454268309314, 0.7936177747023054, -0.0040720430116193],
1388	[1.9779985324311684, -2.42859224204858, 0.450593709617411],
1389	[0.0259040424655478, 0.7827717124575296, -0.8086757549230774]
1390	];
1391	var LabtoLMS_M = [
1392	[1, 0.3963377773761749, 0.2158037573099136],
1393	[1, -0.1055613458156586, -0.0638541728258133],
1394	[1, -0.0894841775298119, -1.2914855480194092]
1395	];
1396	var oklab_default = new ColorSpace({
1397	id: "oklab",
1398	name: "Oklab",
1399	coords: {
1400	l: {
1401	refRange: [0, 1],
1402	name: "Lightness"
1403	},
1404	a: {
1405	refRange: [-0.4, 0.4]
1406	},
1407	b: {
1408	refRange: [-0.4, 0.4]
1409	}
1410	},
1411	// Note that XYZ is relative to D65
1412	white: "D65",
1413	base: xyz_d65_default,
1414	fromBase(XYZ) {
1415	let LMS = multiply_v3_m3x3(XYZ, XYZtoLMS_M);
1416	LMS[0] = Math.cbrt(LMS[0]);
1417	LMS[1] = Math.cbrt(LMS[1]);
1418	LMS[2] = Math.cbrt(LMS[2]);
1419	return multiply_v3_m3x3(LMS, LMStoLab_M, LMS);
1420	},
1421	toBase(OKLab) {
1422	let LMSg = multiply_v3_m3x3(OKLab, LabtoLMS_M);
1423	LMSg[0] = LMSg[0] ** 3;
1424	LMSg[1] = LMSg[1] ** 3;
1425	LMSg[2] = LMSg[2] ** 3;
1426	return multiply_v3_m3x3(LMSg, LMStoXYZ_M, LMSg);
1427	},
1428	formats: {
1429	oklab: {
1430	coords: [
1431	"<percentage> \| <number>",
1432	"<number> \| <percentage>",
1433	"<number> \| <percentage>"
1434	]
1435	}
1436	}
1437	});
1438
1439	// packages/theme/node_modules/colorjs.io/src/deltaE/deltaEOK.js
1440	function deltaEOK_default(color, sample) {
1441	[color, sample] = getColor([color, sample]);
1442	let [L1, a1, b1] = oklab_default.from(color);
1443	let [L2, a2, b2] = oklab_default.from(sample);
1444	let \u0394L = L1 - L2;
1445	let \u0394a = a1 - a2;
1446	let \u0394b = b1 - b2;
1447	return Math.sqrt(\u0394L 2 + \u0394a 2 + \u0394b ** 2);
1448	}
1449
1450	// packages/theme/node_modules/colorjs.io/src/inGamut.js
1451	var \u03B54 = 75e-6;
1452	function inGamut(color, space, { epsilon = \u03B54 } = {}) {
1453	color = getColor(color);
1454	if (!space) {
1455	space = color.space;
1456	}
1457	space = ColorSpace.get(space);
1458	let coords = color.coords;
1459	if (space !== color.space) {
1460	coords = space.from(color);
1461	}
1462	return space.inGamut(coords, { epsilon });
1463	}
1464
1465	// packages/theme/node_modules/colorjs.io/src/clone.js
1466	function clone(color) {
1467	return {
1468	space: color.space,
1469	coords: (
1470	/** @type {Coords} */
1471	color.coords.slice()
1472	),
1473	alpha: color.alpha
1474	};
1475	}
1476
1477	// packages/theme/node_modules/colorjs.io/src/distance.js
1478	function distance(color1, color2, space = "lab") {
1479	space = ColorSpace.get(space);
1480	let coords1 = space.from(color1);
1481	let coords2 = space.from(color2);
1482	return Math.sqrt(
1483	coords1.reduce((acc, c13, i) => {
1484	let c23 = coords2[i];
1485	if (isNone(c13) \|\| isNone(c23)) {
1486	return acc;
1487	}
1488	return acc + (c23 - c13) ** 2;
1489	}, 0)
1490	);
1491	}
1492
1493	// packages/theme/node_modules/colorjs.io/src/deltaE/deltaE76.js
1494	function deltaE76(color, sample) {
1495	return distance(color, sample, "lab");
1496	}
1497
1498	// packages/theme/node_modules/colorjs.io/src/deltaE/deltaECMC.js
1499	var \u03C02 = Math.PI;
1500	var d2r2 = \u03C02 / 180;
1501	function deltaECMC_default(color, sample, { l = 2, c = 1 } = {}) {
1502	[color, sample] = getColor([color, sample]);
1503	let [L1, a1, b1] = lab_default.from(color);
1504	let [, C1, H1] = lch_default.from(lab_default, [L1, a1, b1]);
1505	let [L2, a2, b2] = lab_default.from(sample);
1506	let C2 = lch_default.from(lab_default, [L2, a2, b2])[1];
1507	if (C1 < 0) {
1508	C1 = 0;
1509	}
1510	if (C2 < 0) {
1511	C2 = 0;
1512	}
1513	let \u0394L = L1 - L2;
1514	let \u0394C = C1 - C2;
1515	let \u0394a = a1 - a2;
1516	let \u0394b = b1 - b2;
1517	let H2 = \u0394a 2 + \u0394b 2 - \u0394C ** 2;
1518	let SL = 0.511;
1519	if (L1 >= 16) {
1520	SL = 0.040975 * L1 / (1 + 0.01765 * L1);
1521	}
1522	let SC = 0.0638 * C1 / (1 + 0.0131 * C1) + 0.638;
1523	let T;
1524	if (isNone(H1)) {
1525	H1 = 0;
1526	}
1527	if (H1 >= 164 && H1 <= 345) {
1528	T = 0.56 + Math.abs(0.2 * Math.cos((H1 + 168) * d2r2));
1529	} else {
1530	T = 0.36 + Math.abs(0.4 * Math.cos((H1 + 35) * d2r2));
1531	}
1532	let C4 = Math.pow(C1, 4);
1533	let F = Math.sqrt(C4 / (C4 + 1900));
1534	let SH = SC * (F * T + 1 - F);
1535	let dE = (\u0394L / (l * SL)) ** 2;
1536	dE += (\u0394C / (c * SC)) ** 2;
1537	dE += H2 / SH ** 2;
1538	return Math.sqrt(dE);
1539	}
1540
1541	// packages/theme/node_modules/colorjs.io/src/spaces/xyz-abs-d65.js
1542	var Yw = 203;
1543	var xyz_abs_d65_default = new ColorSpace({
1544	// Absolute CIE XYZ, with a D65 whitepoint,
1545	// as used in most HDR colorspaces as a starting point.
1546	// SDR spaces are converted per BT.2048
1547	// so that diffuse, media white is 203 cd/m²
1548	id: "xyz-abs-d65",
1549	cssId: "--xyz-abs-d65",
1550	name: "Absolute XYZ D65",
1551	coords: {
1552	x: {
1553	refRange: [0, 9504.7],
1554	name: "Xa"
1555	},
1556	y: {
1557	refRange: [0, 1e4],
1558	name: "Ya"
1559	},
1560	z: {
1561	refRange: [0, 10888.3],
1562	name: "Za"
1563	}
1564	},
1565	base: xyz_d65_default,
1566	fromBase(XYZ) {
1567	return XYZ.map((v) => v * Yw);
1568	},
1569	toBase(AbsXYZ) {
1570	return AbsXYZ.map((v) => v / Yw);
1571	}
1572	});
1573
1574	// packages/theme/node_modules/colorjs.io/src/spaces/jzazbz.js
1575	var b = 1.15;
1576	var g = 0.66;
1577	var n = 2610 / 2 ** 14;
1578	var ninv = 2 ** 14 / 2610;
1579	var c1 = 3424 / 2 ** 12;
1580	var c2 = 2413 / 2 ** 7;
1581	var c3 = 2392 / 2 ** 7;
1582	var p = 1.7 * 2523 / 2 ** 5;
1583	var pinv = 2 ** 5 / (1.7 * 2523);
1584	var d = -0.56;
1585	var d0 = 16295499532821565e-27;
1586	var XYZtoCone_M = [
1587	[0.41478972, 0.579999, 0.014648],
1588	[-0.20151, 1.120649, 0.0531008],
1589	[-0.0166008, 0.2648, 0.6684799]
1590	];
1591	var ConetoXYZ_M = [
1592	[1.9242264357876067, -1.0047923125953657, 0.037651404030618],
1593	[0.35031676209499907, 0.7264811939316552, -0.06538442294808501],
1594	[-0.09098281098284752, -0.3127282905230739, 1.5227665613052603]
1595	];
1596	var ConetoIab_M = [
1597	[0.5, 0.5, 0],
1598	[3.524, -4.066708, 0.542708],
1599	[0.199076, 1.096799, -1.295875]
1600	];
1601	var IabtoCone_M = [
1602	[1, 0.13860504327153927, 0.05804731615611883],
1603	[1, -0.1386050432715393, -0.058047316156118904],
1604	[1, -0.09601924202631895, -0.811891896056039]
1605	];
1606	var jzazbz_default = new ColorSpace({
1607	id: "jzazbz",
1608	name: "Jzazbz",
1609	coords: {
1610	jz: {
1611	refRange: [0, 1],
1612	name: "Jz"
1613	},
1614	az: {
1615	refRange: [-0.21, 0.21]
1616	},
1617	bz: {
1618	refRange: [-0.21, 0.21]
1619	}
1620	},
1621	base: xyz_abs_d65_default,
1622	fromBase(XYZ) {
1623	let [Xa, Ya, Za] = XYZ;
1624	let Xm = b * Xa - (b - 1) * Za;
1625	let Ym = g * Ya - (g - 1) * Xa;
1626	let LMS = multiply_v3_m3x3([Xm, Ym, Za], XYZtoCone_M);
1627	let PQLMS = (
1628	/** @type {Vector3} } */
1629	LMS.map(function(val) {
1630	let num = c1 + c2 * spow(val / 1e4, n);
1631	let denom = 1 + c3 * spow(val / 1e4, n);
1632	return spow(num / denom, p);
1633	})
1634	);
1635	let [Iz, az, bz] = multiply_v3_m3x3(PQLMS, ConetoIab_M);
1636	let Jz = (1 + d) * Iz / (1 + d * Iz) - d0;
1637	return [Jz, az, bz];
1638	},
1639	toBase(Jzazbz) {
1640	let [Jz, az, bz] = Jzazbz;
1641	let Iz = (Jz + d0) / (1 + d - d * (Jz + d0));
1642	let PQLMS = multiply_v3_m3x3([Iz, az, bz], IabtoCone_M);
1643	let LMS = (
1644	/** @type {Vector3} } */
1645	PQLMS.map(function(val) {
1646	let num = c1 - spow(val, pinv);
1647	let denom = c3 * spow(val, pinv) - c2;
1648	let x = 1e4 * spow(num / denom, ninv);
1649	return x;
1650	})
1651	);
1652	let [Xm, Ym, Za] = multiply_v3_m3x3(LMS, ConetoXYZ_M);
1653	let Xa = (Xm + (b - 1) * Za) / b;
1654	let Ya = (Ym + (g - 1) * Xa) / g;
1655	return [Xa, Ya, Za];
1656	},
1657	formats: {
1658	// https://drafts.csswg.org/css-color-hdr/#Jzazbz
1659	jzazbz: {
1660	coords: [
1661	"<percentage> \| <number>",
1662	"<number> \| <percentage>",
1663	"<number> \| <percentage>"
1664	]
1665	}
1666	}
1667	});
1668
1669	// packages/theme/node_modules/colorjs.io/src/spaces/jzczhz.js
1670	var jzczhz_default = new ColorSpace({
1671	id: "jzczhz",
1672	name: "JzCzHz",
1673	coords: {
1674	jz: {
1675	refRange: [0, 1],
1676	name: "Jz"
1677	},
1678	cz: {
1679	refRange: [0, 0.26],
1680	name: "Chroma"
1681	},
1682	hz: {
1683	refRange: [0, 360],
1684	type: "angle",
1685	name: "Hue"
1686	}
1687	},
1688	base: jzazbz_default,
1689	fromBase: lch_default.fromBase,
1690	toBase: lch_default.toBase,
1691	formats: {
1692	// https://drafts.csswg.org/css-color-hdr/#JzCzhz
1693	jzczhz: {
1694	coords: ["<percentage> \| <number>", "<number> \| <percentage>", "<number> \| <angle>"]
1695	}
1696	}
1697	});
1698
1699	// packages/theme/node_modules/colorjs.io/src/deltaE/deltaEJz.js
1700	function deltaEJz_default(color, sample) {
1701	[color, sample] = getColor([color, sample]);
1702	let [Jz1, Cz1, Hz1] = jzczhz_default.from(color);
1703	let [Jz2, Cz2, Hz2] = jzczhz_default.from(sample);
1704	let \u0394J = Jz1 - Jz2;
1705	let \u0394C = Cz1 - Cz2;
1706	if (isNone(Hz1) && isNone(Hz2)) {
1707	Hz1 = 0;
1708	Hz2 = 0;
1709	} else if (isNone(Hz1)) {
1710	Hz1 = Hz2;
1711	} else if (isNone(Hz2)) {
1712	Hz2 = Hz1;
1713	}
1714	let \u0394h = Hz1 - Hz2;
1715	let \u0394H = 2 * Math.sqrt(Cz1 * Cz2) * Math.sin(\u0394h / 2 * (Math.PI / 180));
1716	return Math.sqrt(\u0394J 2 + \u0394C 2 + \u0394H ** 2);
1717	}
1718
1719	// packages/theme/node_modules/colorjs.io/src/spaces/ictcp.js
1720	var c12 = 3424 / 4096;
1721	var c22 = 2413 / 128;
1722	var c32 = 2392 / 128;
1723	var m1 = 2610 / 16384;
1724	var m2 = 2523 / 32;
1725	var im1 = 16384 / 2610;
1726	var im2 = 32 / 2523;
1727	var XYZtoLMS_M2 = [
1728	[0.3592832590121217, 0.6976051147779502, -0.035891593232029],
1729	[-0.1920808463704993, 1.100476797037432, 0.0753748658519118],
1730	[0.0070797844607479, 0.0748396662186362, 0.8433265453898765]
1731	];
1732	var LMStoIPT_M = [
1733	[2048 / 4096, 2048 / 4096, 0],
1734	[6610 / 4096, -13613 / 4096, 7003 / 4096],
1735	[17933 / 4096, -17390 / 4096, -543 / 4096]
1736	];
1737	var IPTtoLMS_M = [
1738	[0.9999999999999998, 0.0086090370379328, 0.111029625003026],
1739	[0.9999999999999998, -0.0086090370379328, -0.1110296250030259],
1740	[0.9999999999999998, 0.5600313357106791, -0.3206271749873188]
1741	];
1742	var LMStoXYZ_M2 = [
1743	[2.0701522183894223, -1.3263473389671563, 0.2066510476294053],
1744	[0.3647385209748072, 0.6805660249472273, -0.0453045459220347],
1745	[-0.0497472075358123, -0.0492609666966131, 1.1880659249923042]
1746	];
1747	var ictcp_default = new ColorSpace({
1748	id: "ictcp",
1749	name: "ICTCP",
1750	// From BT.2100-2 page 7:
1751	// During production, signal values are expected to exceed the
1752	// range E′ = [0.0 : 1.0]. This provides processing headroom and avoids
1753	// signal degradation during cascaded processing. Such values of E′,
1754	// below 0.0 or exceeding 1.0, should not be clipped during production
1755	// and exchange.
1756	// Values below 0.0 should not be clipped in reference displays (even
1757	// though they represent “negative” light) to allow the black level of
1758	// the signal (LB) to be properly set using test signals known as “PLUGE”
1759	coords: {
1760	i: {
1761	refRange: [0, 1],
1762	// Constant luminance,
1763	name: "I"
1764	},
1765	ct: {
1766	refRange: [-0.5, 0.5],
1767	// Full BT.2020 gamut in range [-0.5, 0.5]
1768	name: "CT"
1769	},
1770	cp: {
1771	refRange: [-0.5, 0.5],
1772	name: "CP"
1773	}
1774	},
1775	base: xyz_abs_d65_default,
1776	fromBase(XYZ) {
1777	let LMS = multiply_v3_m3x3(XYZ, XYZtoLMS_M2);
1778	return LMStoICtCp(LMS);
1779	},
1780	toBase(ICtCp) {
1781	let LMS = ICtCptoLMS(ICtCp);
1782	return multiply_v3_m3x3(LMS, LMStoXYZ_M2);
1783	},
1784	formats: {
1785	ictcp: {
1786	coords: [
1787	"<percentage> \| <number>",
1788	"<number> \| <percentage>",
1789	"<number> \| <percentage>"
1790	]
1791	}
1792	}
1793	});
1794	function LMStoICtCp(LMS) {
1795	let PQLMS = (
1796	/** @type {Vector3} */
1797	LMS.map(function(val) {
1798	let num = c12 + c22 * (val / 1e4) ** m1;
1799	let denom = 1 + c32 * (val / 1e4) ** m1;
1800	return (num / denom) ** m2;
1801	})
1802	);
1803	return multiply_v3_m3x3(PQLMS, LMStoIPT_M);
1804	}
1805	function ICtCptoLMS(ICtCp) {
1806	let PQLMS = multiply_v3_m3x3(ICtCp, IPTtoLMS_M);
1807	let LMS = (
1808	/** @type {Vector3} */
1809	PQLMS.map(function(val) {
1810	let num = Math.max(val ** im2 - c12, 0);
1811	let denom = c22 - c32 * val ** im2;
1812	return 1e4 * (num / denom) ** im1;
1813	})
1814	);
1815	return LMS;
1816	}
1817
1818	// packages/theme/node_modules/colorjs.io/src/deltaE/deltaEITP.js
1819	function deltaEITP_default(color, sample) {
1820	[color, sample] = getColor([color, sample]);
1821	let [I1, T1, P1] = ictcp_default.from(color);
1822	let [I2, T2, P2] = ictcp_default.from(sample);
1823	return 720 * Math.sqrt((I1 - I2) ** 2 + 0.25 * (T1 - T2) 2 + (P1 - P2) 2);
1824	}
1825
1826	// packages/theme/node_modules/colorjs.io/src/deltaE/deltaEOK2.js
1827	function deltaEOK2_default(color, sample) {
1828	[color, sample] = getColor([color, sample]);
1829	let abscale = 2;
1830	let [L1, a1, b1] = oklab_default.from(color);
1831	let [L2, a2, b2] = oklab_default.from(sample);
1832	let \u0394L = L1 - L2;
1833	let \u0394a = abscale * (a1 - a2);
1834	let \u0394b = abscale * (b1 - b2);
1835	return Math.sqrt(\u0394L 2 + \u0394a 2 + \u0394b ** 2);
1836	}
1837
1838	// packages/theme/node_modules/colorjs.io/src/spaces/cam16.js
1839	var white2 = WHITES.D65;
1840	var adaptedCoef = 0.42;
1841	var adaptedCoefInv = 1 / adaptedCoef;
1842	var tau = 2 * Math.PI;
1843	var cat16 = [
1844	[0.401288, 0.650173, -0.051461],
1845	[-0.250268, 1.204414, 0.045854],
1846	[-2079e-6, 0.048952, 0.953127]
1847	];
1848	var cat16Inv = [
1849	[1.8620678550872327, -1.0112546305316843, 0.14918677544445175],
1850	[0.38752654323613717, 0.6214474419314753, -0.008973985167612518],
1851	[-0.015841498849333856, -0.03412293802851557, 1.0499644368778496]
1852	];
1853	var m12 = [
1854	[460, 451, 288],
1855	[460, -891, -261],
1856	[460, -220, -6300]
1857	];
1858	var surroundMap = {
1859	dark: [0.8, 0.525, 0.8],
1860	dim: [0.9, 0.59, 0.9],
1861	average: [1, 0.69, 1]
1862	};
1863	var hueQuadMap = {
1864	// Red, Yellow, Green, Blue, Red
1865	h: [20.14, 90, 164.25, 237.53, 380.14],
1866	e: [0.8, 0.7, 1, 1.2, 0.8],
1867	H: [0, 100, 200, 300, 400]
1868	};
1869	var rad2deg = 180 / Math.PI;
1870	var deg2rad = Math.PI / 180;
1871	function adapt2(coords, fl) {
1872	const temp = (
1873	/** @type {[number, number, number]} */
1874	coords.map((c) => {
1875	const x = spow(fl * Math.abs(c) * 0.01, adaptedCoef);
1876	return 400 * copySign(x, c) / (x + 27.13);
1877	})
1878	);
1879	return temp;
1880	}
1881	function unadapt(adapted, fl) {
1882	const constant = 100 / fl * 27.13 ** adaptedCoefInv;
1883	return (
1884	/** @type {[number, number, number]} */
1885	adapted.map((c) => {
1886	const cabs = Math.abs(c);
1887	return copySign(constant * spow(cabs / (400 - cabs), adaptedCoefInv), c);
1888	})
1889	);
1890	}
1891	function hueQuadrature(h) {
1892	let hp = constrain(h);
1893	if (hp <= hueQuadMap.h[0]) {
1894	hp += 360;
1895	}
1896	const i = bisectLeft(hueQuadMap.h, hp) - 1;
1897	const [hi, hii] = hueQuadMap.h.slice(i, i + 2);
1898	const [ei, eii] = hueQuadMap.e.slice(i, i + 2);
1899	const Hi = hueQuadMap.H[i];
1900	const t = (hp - hi) / ei;
1901	return Hi + 100 * t / (t + (hii - hp) / eii);
1902	}
1903	function invHueQuadrature(H) {
1904	let Hp = (H % 400 + 400) % 400;
1905	const i = Math.floor(0.01 * Hp);
1906	Hp = Hp % 100;
1907	const [hi, hii] = hueQuadMap.h.slice(i, i + 2);
1908	const [ei, eii] = hueQuadMap.e.slice(i, i + 2);
1909	return constrain((Hp * (eii * hi - ei * hii) - 100 * hi * eii) / (Hp * (eii - ei) - 100 * eii));
1910	}
1911	function environment(refWhite, adaptingLuminance, backgroundLuminance, surround, discounting) {
1912	const env = {};
1913	env.discounting = discounting;
1914	env.refWhite = refWhite;
1915	env.surround = surround;
1916	const xyzW = (
1917	/** @type {Vector3} */
1918	refWhite.map((c) => {
1919	return c * 100;
1920	})
1921	);
1922	env.la = adaptingLuminance;
1923	env.yb = backgroundLuminance;
1924	const yw = xyzW[1];
1925	const rgbW = multiply_v3_m3x3(xyzW, cat16);
1926	let values = surroundMap[env.surround];
1927	const f = values[0];
1928	env.c = values[1];
1929	env.nc = values[2];
1930	const k = 1 / (5 * env.la + 1);
1931	const k4 = k ** 4;
1932	env.fl = k4 * env.la + 0.1 * (1 - k4) * (1 - k4) * Math.cbrt(5 * env.la);
1933	env.flRoot = env.fl ** 0.25;
1934	env.n = env.yb / yw;
1935	env.z = 1.48 + Math.sqrt(env.n);
1936	env.nbb = 0.725 * env.n ** -0.2;
1937	env.ncb = env.nbb;
1938	const d2 = discounting ? 1 : Math.max(Math.min(f * (1 - 1 / 3.6 * Math.exp((-env.la - 42) / 92)), 1), 0);
1939	env.dRgb = /** @type {[number, number, number]} */
1940	rgbW.map((c) => {
1941	return interpolate(1, yw / c, d2);
1942	});
1943	env.dRgbInv = /** @type {[number, number, number]} */
1944	env.dRgb.map((c) => {
1945	return 1 / c;
1946	});
1947	const rgbCW = (
1948	/** @type {[number, number, number]} */
1949	rgbW.map((c, i) => {
1950	return c * env.dRgb[i];
1951	})
1952	);
1953	const rgbAW = adapt2(rgbCW, env.fl);
1954	env.aW = env.nbb * (2 * rgbAW[0] + rgbAW[1] + 0.05 * rgbAW[2]);
1955	return env;
1956	}
1957	var viewingConditions = environment(white2, 64 / Math.PI * 0.2, 20, "average", false);
1958	function fromCam16(cam16, env) {
1959	if (!(cam16.J !== void 0 ^ cam16.Q !== void 0)) {
1960	throw new Error("Conversion requires one and only one: 'J' or 'Q'");
1961	}
1962	if (!(cam16.C !== void 0 ^ cam16.M !== void 0 ^ cam16.s !== void 0)) {
1963	throw new Error("Conversion requires one and only one: 'C', 'M' or 's'");
1964	}
1965	if (!(cam16.h !== void 0 ^ cam16.H !== void 0)) {
1966	throw new Error("Conversion requires one and only one: 'h' or 'H'");
1967	}
1968	if (cam16.J === 0 \|\| cam16.Q === 0) {
1969	return [0, 0, 0];
1970	}
1971	let hRad = 0;
1972	if (cam16.h !== void 0) {
1973	hRad = constrain(cam16.h) * deg2rad;
1974	} else {
1975	hRad = invHueQuadrature(cam16.H) * deg2rad;
1976	}
1977	const cosh = Math.cos(hRad);
1978	const sinh = Math.sin(hRad);
1979	let Jroot = 0;
1980	if (cam16.J !== void 0) {
1981	Jroot = spow(cam16.J, 1 / 2) * 0.1;
1982	} else if (cam16.Q !== void 0) {
1983	Jroot = 0.25 * env.c * cam16.Q / ((env.aW + 4) * env.flRoot);
1984	}
1985	let alpha = 0;
1986	if (cam16.C !== void 0) {
1987	alpha = cam16.C / Jroot;
1988	} else if (cam16.M !== void 0) {
1989	alpha = cam16.M / env.flRoot / Jroot;
1990	} else if (cam16.s !== void 0) {
1991	alpha = 4e-4 * cam16.s ** 2 * (env.aW + 4) / env.c;
1992	}
1993	const t = spow(alpha * Math.pow(1.64 - Math.pow(0.29, env.n), -0.73), 10 / 9);
1994	const et = 0.25 * (Math.cos(hRad + 2) + 3.8);
1995	const A = env.aW * spow(Jroot, 2 / env.c / env.z);
1996	const p1 = 5e4 / 13 * env.nc * env.ncb * et;
1997	const p2 = A / env.nbb;
1998	const r = 23 * (p2 + 0.305) * zdiv(t, 23 * p1 + t * (11 * cosh + 108 * sinh));
1999	const a = r * cosh;
2000	const b2 = r * sinh;
2001	const rgb_c = unadapt(
2002	/** @type {Vector3} */
2003	multiply_v3_m3x3([p2, a, b2], m12).map((c) => {
2004	return c * 1 / 1403;
2005	}),
2006	env.fl
2007	);
2008	return (
2009	/** @type {Vector3} */
2010	multiply_v3_m3x3(
2011	/** @type {Vector3} */
2012	rgb_c.map((c, i) => {
2013	return c * env.dRgbInv[i];
2014	}),
2015	cat16Inv
2016	).map((c) => {
2017	return c / 100;
2018	})
2019	);
2020	}
2021	function toCam16(xyzd65, env) {
2022	const xyz100 = (
2023	/** @type {Vector3} */
2024	xyzd65.map((c) => {
2025	return c * 100;
2026	})
2027	);
2028	const rgbA = adapt2(
2029	/** @type {[number, number, number]} */
2030	multiply_v3_m3x3(xyz100, cat16).map((c, i) => {
2031	return c * env.dRgb[i];
2032	}),
2033	env.fl
2034	);
2035	const a = rgbA[0] + (-12 * rgbA[1] + rgbA[2]) / 11;
2036	const b2 = (rgbA[0] + rgbA[1] - 2 * rgbA[2]) / 9;
2037	const hRad = (Math.atan2(b2, a) % tau + tau) % tau;
2038	const et = 0.25 * (Math.cos(hRad + 2) + 3.8);
2039	const t = 5e4 / 13 * env.nc * env.ncb * zdiv(et * Math.sqrt(a 2 + b2 2), rgbA[0] + rgbA[1] + 1.05 * rgbA[2] + 0.305);
2040	const alpha = spow(t, 0.9) * Math.pow(1.64 - Math.pow(0.29, env.n), 0.73);
2041	const A = env.nbb * (2 * rgbA[0] + rgbA[1] + 0.05 * rgbA[2]);
2042	const Jroot = spow(A / env.aW, 0.5 * env.c * env.z);
2043	const J = 100 * spow(Jroot, 2);
2044	const Q = 4 / env.c * Jroot * (env.aW + 4) * env.flRoot;
2045	const C = alpha * Jroot;
2046	const M = C * env.flRoot;
2047	const h = constrain(hRad * rad2deg);
2048	const H = hueQuadrature(h);
2049	const s = 50 * spow(env.c * alpha / (env.aW + 4), 1 / 2);
2050	return { J, C, h, s, Q, M, H };
2051	}
2052	var cam16_default = new ColorSpace({
2053	id: "cam16-jmh",
2054	cssId: "--cam16-jmh",
2055	name: "CAM16-JMh",
2056	coords: {
2057	j: {
2058	refRange: [0, 100],
2059	name: "J"
2060	},
2061	m: {
2062	refRange: [0, 105],
2063	name: "Colorfulness"
2064	},
2065	h: {
2066	refRange: [0, 360],
2067	type: "angle",
2068	name: "Hue"
2069	}
2070	},
2071	base: xyz_d65_default,
2072	fromBase(xyz) {
2073	if (this.\u03B5 === void 0) {
2074	this.\u03B5 = Object.values(this.coords)[1].refRange[1] / 1e5;
2075	}
2076	const cam16 = toCam16(xyz, viewingConditions);
2077	const isAchromatic = Math.abs(cam16.M) < this.\u03B5;
2078	return [cam16.J, isAchromatic ? 0 : cam16.M, isAchromatic ? null : cam16.h];
2079	},
2080	toBase(cam16) {
2081	return fromCam16({ J: cam16[0], M: cam16[1], h: cam16[2] }, viewingConditions);
2082	}
2083	});
2084
2085	// packages/theme/node_modules/colorjs.io/src/spaces/hct.js
2086	var white3 = WHITES.D65;
2087	var \u03B55 = 216 / 24389;
2088	var \u03BA2 = 24389 / 27;
2089	function toLstar(y) {
2090	const fy = y > \u03B55 ? Math.cbrt(y) : (\u03BA2 * y + 16) / 116;
2091	return 116 * fy - 16;
2092	}
2093	function fromLstar(lstar) {
2094	return lstar > 8 ? Math.pow((lstar + 16) / 116, 3) : lstar / \u03BA2;
2095	}
2096	function fromHct(coords, env) {
2097	let [h, c, t] = coords;
2098	let xyz = [];
2099	let j = 0;
2100	if (t === 0) {
2101	return [0, 0, 0];
2102	}
2103	let y = fromLstar(t);
2104	if (t > 0) {
2105	j = 0.00379058511492914 * t ** 2 + 0.608983189401032 * t + 0.9155088574762233;
2106	} else {
2107	j = 9514440756550361e-21 * t ** 2 + 0.08693057439788597 * t - 21.928975842194614;
2108	}
2109	const threshold = 2e-12;
2110	const max_attempts = 15;
2111	let attempt = 0;
2112	let last = Infinity;
2113	let best = j;
2114	while (attempt <= max_attempts) {
2115	xyz = fromCam16({ J: j, C: c, h }, env);
2116	const delta = Math.abs(xyz[1] - y);
2117	if (delta < last) {
2118	if (delta <= threshold) {
2119	return xyz;
2120	}
2121	best = j;
2122	last = delta;
2123	}
2124	j = j - (xyz[1] - y) * j / (2 * xyz[1]);
2125	attempt += 1;
2126	}
2127	return fromCam16({ J: j, C: c, h }, env);
2128	}
2129	function toHct(xyz, env) {
2130	const t = toLstar(xyz[1]);
2131	if (t === 0) {
2132	return [0, 0, 0];
2133	}
2134	const cam16 = toCam16(xyz, viewingConditions2);
2135	return [constrain(cam16.h), cam16.C, t];
2136	}
2137	var viewingConditions2 = environment(
2138	white3,
2139	200 / Math.PI * fromLstar(50),
2140	fromLstar(50) * 100,
2141	"average",
2142	false
2143	);
2144	var hct_default = new ColorSpace({
2145	id: "hct",
2146	name: "HCT",
2147	coords: {
2148	h: {
2149	refRange: [0, 360],
2150	type: "angle",
2151	name: "Hue"
2152	},
2153	c: {
2154	refRange: [0, 145],
2155	name: "Colorfulness"
2156	},
2157	t: {
2158	refRange: [0, 100],
2159	name: "Tone"
2160	}
2161	},
2162	base: xyz_d65_default,
2163	fromBase(xyz) {
2164	if (this.\u03B5 === void 0) {
2165	this.\u03B5 = Object.values(this.coords)[1].refRange[1] / 1e5;
2166	}
2167	let hct = toHct(xyz, viewingConditions2);
2168	if (hct[1] < this.\u03B5) {
2169	hct[1] = 0;
2170	hct[0] = null;
2171	}
2172	return hct;
2173	},
2174	toBase(hct) {
2175	return fromHct(hct, viewingConditions2);
2176	},
2177	formats: {
2178	color: {
2179	id: "--hct",
2180	coords: ["<number> \| <angle>", "<percentage> \| <number>", "<percentage> \| <number>"]
2181	}
2182	}
2183	});
2184
2185	// packages/theme/node_modules/colorjs.io/src/deltaE/deltaEHCT.js
2186	var rad2deg2 = 180 / Math.PI;
2187	var deg2rad2 = Math.PI / 180;
2188	var ucsCoeff = [1, 7e-3, 0.0228];
2189	function convertUcsAb(coords) {
2190	if (coords[1] < 0) {
2191	coords = hct_default.fromBase(hct_default.toBase(coords));
2192	}
2193	const M = Math.log(Math.max(1 + ucsCoeff[2] * coords[1] * viewingConditions2.flRoot, 1)) / ucsCoeff[2];
2194	const hrad = coords[0] * deg2rad2;
2195	const a = M * Math.cos(hrad);
2196	const b2 = M * Math.sin(hrad);
2197	return [coords[2], a, b2];
2198	}
2199	function deltaEHCT_default(color, sample) {
2200	[color, sample] = getColor([color, sample]);
2201	let [t1, a1, b1] = convertUcsAb(hct_default.from(color));
2202	let [t2, a2, b2] = convertUcsAb(hct_default.from(sample));
2203	return Math.sqrt((t1 - t2) 2 + (a1 - a2) 2 + (b1 - b2) ** 2);
2204	}
2205
2206	// packages/theme/node_modules/colorjs.io/src/deltaE/index.js
2207	var deltaE_default = {
2208	deltaE76,
2209	deltaECMC: deltaECMC_default,
2210	deltaE2000: deltaE2000_default,
2211	deltaEJz: deltaEJz_default,
2212	deltaEITP: deltaEITP_default,
2213	deltaEOK: deltaEOK_default,
2214	deltaEOK2: deltaEOK2_default,
2215	deltaEHCT: deltaEHCT_default
2216	};
2217
2218	// packages/theme/node_modules/colorjs.io/src/toGamut.js
2219	function calcEpsilon(jnd) {
2220	const order = !jnd ? 0 : Math.floor(Math.log10(Math.abs(jnd)));
2221	return Math.max(parseFloat(`1e${order - 2}`), 1e-6);
2222	}
2223	var GMAPPRESET = {
2224	hct: {
2225	method: "hct.c",
2226	jnd: 2,
2227	deltaEMethod: "hct",
2228	blackWhiteClamp: {}
2229	},
2230	"hct-tonal": {
2231	method: "hct.c",
2232	jnd: 0,
2233	deltaEMethod: "hct",
2234	blackWhiteClamp: { channel: "hct.t", min: 0, max: 100 }
2235	}
2236	};
2237	function toGamut(color, {
2238	method = defaults_default.gamut_mapping,
2239	space = void 0,
2240	deltaEMethod = "",
2241	jnd = 2,
2242	blackWhiteClamp = void 0
2243	} = {}) {
2244	color = getColor(color);
2245	if (isString(arguments[1])) {
2246	space = arguments[1];
2247	} else if (!space) {
2248	space = color.space;
2249	}
2250	space = ColorSpace.get(space);
2251	if (inGamut(color, space, { epsilon: 0 })) {
2252	return (
2253	/** @type {PlainColorObject} */
2254	color
2255	);
2256	}
2257	let spaceColor;
2258	if (method === "css") {
2259	spaceColor = toGamutCSS(color, { space });
2260	} else {
2261	if (method !== "clip" && !inGamut(color, space)) {
2262	if (Object.prototype.hasOwnProperty.call(GMAPPRESET, method)) {
2263	({ method, jnd, deltaEMethod, blackWhiteClamp } = GMAPPRESET[method]);
2264	}
2265	let de = deltaE2000_default;
2266	if (deltaEMethod !== "") {
2267	for (let m in deltaE_default) {
2268	if ("deltae" + deltaEMethod.toLowerCase() === m.toLowerCase()) {
2269	de = deltaE_default[m];
2270	break;
2271	}
2272	}
2273	}
2274	if (jnd === 0) {
2275	jnd = 1e-16;
2276	}
2277	let clipped = toGamut(to(color, space), { method: "clip", space });
2278	if (de(color, clipped) > jnd) {
2279	if (blackWhiteClamp && Object.keys(blackWhiteClamp).length === 3) {
2280	let channelMeta = ColorSpace.resolveCoord(blackWhiteClamp.channel);
2281	let channel = get(to(color, channelMeta.space), channelMeta.id);
2282	if (isNone(channel)) {
2283	channel = 0;
2284	}
2285	if (channel >= blackWhiteClamp.max) {
2286	return to({ space: "xyz-d65", coords: WHITES["D65"] }, color.space);
2287	} else if (channel <= blackWhiteClamp.min) {
2288	return to({ space: "xyz-d65", coords: [0, 0, 0] }, color.space);
2289	}
2290	}
2291	let coordMeta = ColorSpace.resolveCoord(method);
2292	let mapSpace = coordMeta.space;
2293	let coordId = coordMeta.id;
2294	let mappedColor = to(color, mapSpace);
2295	mappedColor.coords.forEach((c, i) => {
2296	if (isNone(c)) {
2297	mappedColor.coords[i] = 0;
2298	}
2299	});
2300	let bounds = coordMeta.range \|\| coordMeta.refRange;
2301	let min = bounds[0];
2302	let \u03B56 = calcEpsilon(jnd);
2303	let low = min;
2304	let high = get(mappedColor, coordId);
2305	while (high - low > \u03B56) {
2306	let clipped2 = clone(mappedColor);
2307	clipped2 = toGamut(clipped2, { space, method: "clip" });
2308	let deltaE = de(mappedColor, clipped2);
2309	if (deltaE - jnd < \u03B56) {
2310	low = get(mappedColor, coordId);
2311	} else {
2312	high = get(mappedColor, coordId);
2313	}
2314	set(mappedColor, coordId, (low + high) / 2);
2315	}
2316	spaceColor = to(mappedColor, space);
2317	} else {
2318	spaceColor = clipped;
2319	}
2320	} else {
2321	spaceColor = to(color, space);
2322	}
2323	if (method === "clip" \|\| // Dumb coord clipping
2324	// finish off smarter gamut mapping with clip to get rid of ε, see #17
2325	!inGamut(spaceColor, space, { epsilon: 0 })) {
2326	let bounds = Object.values(space.coords).map((c) => c.range \|\| []);
2327	spaceColor.coords = /** @type {[number, number, number]} */
2328	spaceColor.coords.map((c, i) => {
2329	let [min, max] = bounds[i];
2330	if (min !== void 0) {
2331	c = Math.max(min, c);
2332	}
2333	if (max !== void 0) {
2334	c = Math.min(c, max);
2335	}
2336	return c;
2337	});
2338	}
2339	}
2340	if (space !== color.space) {
2341	spaceColor = to(spaceColor, color.space);
2342	}
2343	color.coords = spaceColor.coords;
2344	return (
2345	/** @type {PlainColorObject} */
2346	color
2347	);
2348	}
2349	toGamut.returns = "color";
2350	var COLORS = {
2351	WHITE: { space: oklab_default, coords: [1, 0, 0], alpha: 1 },
2352	BLACK: { space: oklab_default, coords: [0, 0, 0], alpha: 1 }
2353	};
2354	function toGamutCSS(origin, { space } = {}) {
2355	const JND = 0.02;
2356	const \u03B56 = 1e-4;
2357	origin = getColor(origin);
2358	if (!space) {
2359	space = origin.space;
2360	}
2361	space = ColorSpace.get(space);
2362	const oklchSpace = ColorSpace.get("oklch");
2363	if (space.isUnbounded) {
2364	return to(origin, space);
2365	}
2366	const origin_OKLCH = to(origin, oklchSpace);
2367	let L = origin_OKLCH.coords[0];
2368	if (L >= 1) {
2369	const white4 = to(COLORS.WHITE, space);
2370	white4.alpha = origin.alpha;
2371	return to(white4, space);
2372	}
2373	if (L <= 0) {
2374	const black = to(COLORS.BLACK, space);
2375	black.alpha = origin.alpha;
2376	return to(black, space);
2377	}
2378	if (inGamut(origin_OKLCH, space, { epsilon: 0 })) {
2379	return to(origin_OKLCH, space);
2380	}
2381	function clip(_color) {
2382	const destColor = to(_color, space);
2383	const spaceCoords = Object.values(
2384	/** @type {ColorSpace} */
2385	space.coords
2386	);
2387	destColor.coords = /** @type {[number, number, number]} */
2388	destColor.coords.map((coord, index) => {
2389	if ("range" in spaceCoords[index]) {
2390	const [min2, max2] = spaceCoords[index].range;
2391	return clamp(min2, coord, max2);
2392	}
2393	return coord;
2394	});
2395	return destColor;
2396	}
2397	let min = 0;
2398	let max = origin_OKLCH.coords[1];
2399	let min_inGamut = true;
2400	let current = clone(origin_OKLCH);
2401	let clipped = clip(current);
2402	let E = deltaEOK_default(clipped, current);
2403	if (E < JND) {
2404	return clipped;
2405	}
2406	while (max - min > \u03B56) {
2407	const chroma = (min + max) / 2;
2408	current.coords[1] = chroma;
2409	if (min_inGamut && inGamut(current, space, { epsilon: 0 })) {
2410	min = chroma;
2411	} else {
2412	clipped = clip(current);
2413	E = deltaEOK_default(clipped, current);
2414	if (E < JND) {
2415	if (JND - E < \u03B56) {
2416	break;
2417	} else {
2418	min_inGamut = false;
2419	min = chroma;
2420	}
2421	} else {
2422	max = chroma;
2423	}
2424	}
2425	}
2426	return clipped;
2427	}
2428
2429	// packages/theme/node_modules/colorjs.io/src/to.js
2430	function to(color, space, { inGamut: inGamut2 } = {}) {
2431	color = getColor(color);
2432	space = ColorSpace.get(space);
2433	let coords = space.from(color);
2434	let ret = { space, coords, alpha: color.alpha };
2435	if (inGamut2) {
2436	ret = toGamut(ret, inGamut2 === true ? void 0 : inGamut2);
2437	}
2438	return ret;
2439	}
2440	to.returns = "color";
2441
2442	// packages/theme/node_modules/colorjs.io/src/serialize.js
2443	function serialize(color, options = {}) {
2444	let {
2445	precision = defaults_default.precision,
2446	format,
2447	inGamut: inGamut2 = true,
2448	coords: coordFormat,
2449	alpha: alphaFormat,
2450	commas
2451	} = options;
2452	let ret;
2453	let colorWithMeta = (
2454	/** @type {PlainColorObject & ParseOptions} */
2455	getColor(color)
2456	);
2457	let formatId = format;
2458	let parseMeta = colorWithMeta.parseMeta;
2459	if (parseMeta && !format) {
2460	if (parseMeta.format.canSerialize()) {
2461	format = parseMeta.format;
2462	formatId = parseMeta.formatId;
2463	}
2464	coordFormat ??= parseMeta.types;
2465	alphaFormat ??= parseMeta.alphaType;
2466	commas ??= parseMeta.commas;
2467	}
2468	if (formatId) {
2469	format = colorWithMeta.space.getFormat(format) ?? ColorSpace.findFormat(formatId);
2470	}
2471	if (!format) {
2472	format = colorWithMeta.space.getFormat("default") ?? ColorSpace.DEFAULT_FORMAT;
2473	formatId = format.name;
2474	}
2475	if (format && format.space && format.space !== colorWithMeta.space) {
2476	colorWithMeta = to(colorWithMeta, format.space);
2477	}
2478	let coords = colorWithMeta.coords.slice();
2479	inGamut2 \|\|= format.toGamut;
2480	if (inGamut2 && !inGamut(colorWithMeta)) {
2481	coords = toGamut(clone(colorWithMeta), inGamut2 === true ? void 0 : inGamut2).coords;
2482	}
2483	if (format.type === "custom") {
2484	if (format.serialize) {
2485	ret = format.serialize(coords, colorWithMeta.alpha, options);
2486	} else {
2487	throw new TypeError(
2488	`format ${formatId} can only be used to parse colors, not for serialization`
2489	);
2490	}
2491	} else {
2492	let name = format.name \|\| "color";
2493	let args = format.serializeCoords(coords, precision, coordFormat);
2494	if (name === "color") {
2495	let cssId = format.id \|\| format.ids?.[0] \|\| colorWithMeta.space.cssId \|\| colorWithMeta.space.id;
2496	args.unshift(cssId);
2497	}
2498	let alpha = colorWithMeta.alpha;
2499	if (alphaFormat !== void 0 && !(typeof alphaFormat === "object")) {
2500	alphaFormat = typeof alphaFormat === "string" ? { type: alphaFormat } : { include: alphaFormat };
2501	}
2502	let alphaType = alphaFormat?.type ?? "<number>";
2503	let serializeAlpha = alphaFormat?.include === true \|\| format.alpha === true \|\| alphaFormat?.include !== false && format.alpha !== false && alpha < 1;
2504	let strAlpha = "";
2505	commas ??= format.commas;
2506	if (serializeAlpha) {
2507	if (precision !== null) {
2508	let unit;
2509	if (alphaType === "<percentage>") {
2510	unit = "%";
2511	alpha *= 100;
2512	}
2513	alpha = serializeNumber(alpha, { precision, unit });
2514	}
2515	strAlpha = `${commas ? "," : " /"} ${alpha}`;
2516	}
2517	ret = `${name}(${args.join(commas ? ", " : " ")}${strAlpha})`;
2518	}
2519	return ret;
2520	}
2521
2522	// packages/theme/node_modules/colorjs.io/src/spaces/p3-linear.js
2523	var toXYZ_M = [
2524	[0.4865709486482162, 0.26566769316909306, 0.1982172852343625],
2525	[0.2289745640697488, 0.6917385218365064, 0.079286914093745],
2526	[0, 0.04511338185890264, 1.043944368900976]
2527	];
2528	var fromXYZ_M = [
2529	[2.493496911941425, -0.9313836179191239, -0.40271078445071684],
2530	[-0.8294889695615747, 1.7626640603183463, 0.023624685841943577],
2531	[0.03584583024378447, -0.07617238926804182, 0.9568845240076872]
2532	];
2533	var p3_linear_default = new RGBColorSpace({
2534	id: "p3-linear",
2535	cssId: "display-p3-linear",
2536	name: "Linear P3",
2537	white: "D65",
2538	toXYZ_M,
2539	fromXYZ_M
2540	});
2541
2542	// packages/theme/node_modules/colorjs.io/src/spaces/srgb-linear.js
2543	var toXYZ_M2 = [
2544	[0.41239079926595934, 0.357584339383878, 0.1804807884018343],
2545	[0.21263900587151027, 0.715168678767756, 0.07219231536073371],
2546	[0.01933081871559182, 0.11919477979462598, 0.9505321522496607]
2547	];
2548	var fromXYZ_M2 = [
2549	[3.2409699419045226, -1.537383177570094, -0.4986107602930034],
2550	[-0.9692436362808796, 1.8759675015077202, 0.04155505740717559],
2551	[0.05563007969699366, -0.20397695888897652, 1.0569715142428786]
2552	];
2553	var srgb_linear_default = new RGBColorSpace({
2554	id: "srgb-linear",
2555	name: "Linear sRGB",
2556	white: "D65",
2557	toXYZ_M: toXYZ_M2,
2558	fromXYZ_M: fromXYZ_M2
2559	});
2560
2561	// packages/theme/node_modules/colorjs.io/src/keywords.js
2562	var keywords_default = {
2563	aliceblue: [240 / 255, 248 / 255, 1],
2564	antiquewhite: [250 / 255, 235 / 255, 215 / 255],
2565	aqua: [0, 1, 1],
2566	aquamarine: [127 / 255, 1, 212 / 255],
2567	azure: [240 / 255, 1, 1],
2568	beige: [245 / 255, 245 / 255, 220 / 255],
2569	bisque: [1, 228 / 255, 196 / 255],
2570	black: [0, 0, 0],
2571	blanchedalmond: [1, 235 / 255, 205 / 255],
2572	blue: [0, 0, 1],
2573	blueviolet: [138 / 255, 43 / 255, 226 / 255],
2574	brown: [165 / 255, 42 / 255, 42 / 255],
2575	burlywood: [222 / 255, 184 / 255, 135 / 255],
2576	cadetblue: [95 / 255, 158 / 255, 160 / 255],
2577	chartreuse: [127 / 255, 1, 0],
2578	chocolate: [210 / 255, 105 / 255, 30 / 255],
2579	coral: [1, 127 / 255, 80 / 255],
2580	cornflowerblue: [100 / 255, 149 / 255, 237 / 255],
2581	cornsilk: [1, 248 / 255, 220 / 255],
2582	crimson: [220 / 255, 20 / 255, 60 / 255],
2583	cyan: [0, 1, 1],
2584	darkblue: [0, 0, 139 / 255],
2585	darkcyan: [0, 139 / 255, 139 / 255],
2586	darkgoldenrod: [184 / 255, 134 / 255, 11 / 255],
2587	darkgray: [169 / 255, 169 / 255, 169 / 255],
2588	darkgreen: [0, 100 / 255, 0],
2589	darkgrey: [169 / 255, 169 / 255, 169 / 255],
2590	darkkhaki: [189 / 255, 183 / 255, 107 / 255],
2591	darkmagenta: [139 / 255, 0, 139 / 255],
2592	darkolivegreen: [85 / 255, 107 / 255, 47 / 255],
2593	darkorange: [1, 140 / 255, 0],
2594	darkorchid: [153 / 255, 50 / 255, 204 / 255],
2595	darkred: [139 / 255, 0, 0],
2596	darksalmon: [233 / 255, 150 / 255, 122 / 255],
2597	darkseagreen: [143 / 255, 188 / 255, 143 / 255],
2598	darkslateblue: [72 / 255, 61 / 255, 139 / 255],
2599	darkslategray: [47 / 255, 79 / 255, 79 / 255],
2600	darkslategrey: [47 / 255, 79 / 255, 79 / 255],
2601	darkturquoise: [0, 206 / 255, 209 / 255],
2602	darkviolet: [148 / 255, 0, 211 / 255],
2603	deeppink: [1, 20 / 255, 147 / 255],
2604	deepskyblue: [0, 191 / 255, 1],
2605	dimgray: [105 / 255, 105 / 255, 105 / 255],
2606	dimgrey: [105 / 255, 105 / 255, 105 / 255],
2607	dodgerblue: [30 / 255, 144 / 255, 1],
2608	firebrick: [178 / 255, 34 / 255, 34 / 255],
2609	floralwhite: [1, 250 / 255, 240 / 255],
2610	forestgreen: [34 / 255, 139 / 255, 34 / 255],
2611	fuchsia: [1, 0, 1],
2612	gainsboro: [220 / 255, 220 / 255, 220 / 255],
2613	ghostwhite: [248 / 255, 248 / 255, 1],
2614	gold: [1, 215 / 255, 0],
2615	goldenrod: [218 / 255, 165 / 255, 32 / 255],
2616	gray: [128 / 255, 128 / 255, 128 / 255],
2617	green: [0, 128 / 255, 0],
2618	greenyellow: [173 / 255, 1, 47 / 255],
2619	grey: [128 / 255, 128 / 255, 128 / 255],
2620	honeydew: [240 / 255, 1, 240 / 255],
2621	hotpink: [1, 105 / 255, 180 / 255],
2622	indianred: [205 / 255, 92 / 255, 92 / 255],
2623	indigo: [75 / 255, 0, 130 / 255],
2624	ivory: [1, 1, 240 / 255],
2625	khaki: [240 / 255, 230 / 255, 140 / 255],
2626	lavender: [230 / 255, 230 / 255, 250 / 255],
2627	lavenderblush: [1, 240 / 255, 245 / 255],
2628	lawngreen: [124 / 255, 252 / 255, 0],
2629	lemonchiffon: [1, 250 / 255, 205 / 255],
2630	lightblue: [173 / 255, 216 / 255, 230 / 255],
2631	lightcoral: [240 / 255, 128 / 255, 128 / 255],
2632	lightcyan: [224 / 255, 1, 1],
2633	lightgoldenrodyellow: [250 / 255, 250 / 255, 210 / 255],
2634	lightgray: [211 / 255, 211 / 255, 211 / 255],
2635	lightgreen: [144 / 255, 238 / 255, 144 / 255],
2636	lightgrey: [211 / 255, 211 / 255, 211 / 255],
2637	lightpink: [1, 182 / 255, 193 / 255],
2638	lightsalmon: [1, 160 / 255, 122 / 255],
2639	lightseagreen: [32 / 255, 178 / 255, 170 / 255],
2640	lightskyblue: [135 / 255, 206 / 255, 250 / 255],
2641	lightslategray: [119 / 255, 136 / 255, 153 / 255],
2642	lightslategrey: [119 / 255, 136 / 255, 153 / 255],
2643	lightsteelblue: [176 / 255, 196 / 255, 222 / 255],
2644	lightyellow: [1, 1, 224 / 255],
2645	lime: [0, 1, 0],
2646	limegreen: [50 / 255, 205 / 255, 50 / 255],
2647	linen: [250 / 255, 240 / 255, 230 / 255],
2648	magenta: [1, 0, 1],
2649	maroon: [128 / 255, 0, 0],
2650	mediumaquamarine: [102 / 255, 205 / 255, 170 / 255],
2651	mediumblue: [0, 0, 205 / 255],
2652	mediumorchid: [186 / 255, 85 / 255, 211 / 255],
2653	mediumpurple: [147 / 255, 112 / 255, 219 / 255],
2654	mediumseagreen: [60 / 255, 179 / 255, 113 / 255],
2655	mediumslateblue: [123 / 255, 104 / 255, 238 / 255],
2656	mediumspringgreen: [0, 250 / 255, 154 / 255],
2657	mediumturquoise: [72 / 255, 209 / 255, 204 / 255],
2658	mediumvioletred: [199 / 255, 21 / 255, 133 / 255],
2659	midnightblue: [25 / 255, 25 / 255, 112 / 255],
2660	mintcream: [245 / 255, 1, 250 / 255],
2661	mistyrose: [1, 228 / 255, 225 / 255],
2662	moccasin: [1, 228 / 255, 181 / 255],
2663	navajowhite: [1, 222 / 255, 173 / 255],
2664	navy: [0, 0, 128 / 255],
2665	oldlace: [253 / 255, 245 / 255, 230 / 255],
2666	olive: [128 / 255, 128 / 255, 0],
2667	olivedrab: [107 / 255, 142 / 255, 35 / 255],
2668	orange: [1, 165 / 255, 0],
2669	orangered: [1, 69 / 255, 0],
2670	orchid: [218 / 255, 112 / 255, 214 / 255],
2671	palegoldenrod: [238 / 255, 232 / 255, 170 / 255],
2672	palegreen: [152 / 255, 251 / 255, 152 / 255],
2673	paleturquoise: [175 / 255, 238 / 255, 238 / 255],
2674	palevioletred: [219 / 255, 112 / 255, 147 / 255],
2675	papayawhip: [1, 239 / 255, 213 / 255],
2676	peachpuff: [1, 218 / 255, 185 / 255],
2677	peru: [205 / 255, 133 / 255, 63 / 255],
2678	pink: [1, 192 / 255, 203 / 255],
2679	plum: [221 / 255, 160 / 255, 221 / 255],
2680	powderblue: [176 / 255, 224 / 255, 230 / 255],
2681	purple: [128 / 255, 0, 128 / 255],
2682	rebeccapurple: [102 / 255, 51 / 255, 153 / 255],
2683	red: [1, 0, 0],
2684	rosybrown: [188 / 255, 143 / 255, 143 / 255],
2685	royalblue: [65 / 255, 105 / 255, 225 / 255],
2686	saddlebrown: [139 / 255, 69 / 255, 19 / 255],
2687	salmon: [250 / 255, 128 / 255, 114 / 255],
2688	sandybrown: [244 / 255, 164 / 255, 96 / 255],
2689	seagreen: [46 / 255, 139 / 255, 87 / 255],
2690	seashell: [1, 245 / 255, 238 / 255],
2691	sienna: [160 / 255, 82 / 255, 45 / 255],
2692	silver: [192 / 255, 192 / 255, 192 / 255],
2693	skyblue: [135 / 255, 206 / 255, 235 / 255],
2694	slateblue: [106 / 255, 90 / 255, 205 / 255],
2695	slategray: [112 / 255, 128 / 255, 144 / 255],
2696	slategrey: [112 / 255, 128 / 255, 144 / 255],
2697	snow: [1, 250 / 255, 250 / 255],
2698	springgreen: [0, 1, 127 / 255],
2699	steelblue: [70 / 255, 130 / 255, 180 / 255],
2700	tan: [210 / 255, 180 / 255, 140 / 255],
2701	teal: [0, 128 / 255, 128 / 255],
2702	thistle: [216 / 255, 191 / 255, 216 / 255],
2703	tomato: [1, 99 / 255, 71 / 255],
2704	turquoise: [64 / 255, 224 / 255, 208 / 255],
2705	violet: [238 / 255, 130 / 255, 238 / 255],
2706	wheat: [245 / 255, 222 / 255, 179 / 255],
2707	white: [1, 1, 1],
2708	whitesmoke: [245 / 255, 245 / 255, 245 / 255],
2709	yellow: [1, 1, 0],
2710	yellowgreen: [154 / 255, 205 / 255, 50 / 255]
2711	};
2712
2713	// packages/theme/node_modules/colorjs.io/src/spaces/srgb.js
2714	var coordGrammar = Array(3).fill("<percentage> \| <number>[0, 255]");
2715	var coordGrammarNumber = Array(3).fill("<number>[0, 255]");
2716	var srgb_default = new RGBColorSpace({
2717	id: "srgb",
2718	name: "sRGB",
2719	base: srgb_linear_default,
2720	fromBase: (rgb) => {
2721	return rgb.map((val) => {
2722	let sign = val < 0 ? -1 : 1;
2723	let abs = val * sign;
2724	if (abs > 31308e-7) {
2725	return sign * (1.055 * abs ** (1 / 2.4) - 0.055);
2726	}
2727	return 12.92 * val;
2728	});
2729	},
2730	toBase: (rgb) => {
2731	return rgb.map((val) => {
2732	let sign = val < 0 ? -1 : 1;
2733	let abs = val * sign;
2734	if (abs <= 0.04045) {
2735	return val / 12.92;
2736	}
2737	return sign * ((abs + 0.055) / 1.055) ** 2.4;
2738	});
2739	},
2740	formats: {
2741	rgb: {
2742	coords: coordGrammar
2743	},
2744	rgb_number: {
2745	name: "rgb",
2746	commas: true,
2747	coords: coordGrammarNumber,
2748	alpha: false
2749	},
2750	color: {
2751	/* use defaults */
2752	},
2753	rgba: {
2754	coords: coordGrammar,
2755	commas: true,
2756	alpha: true
2757	},
2758	rgba_number: {
2759	name: "rgba",
2760	commas: true,
2761	coords: coordGrammarNumber
2762	},
2763	hex: {
2764	type: "custom",
2765	toGamut: true,
2766	test: (str) => /^#(([a-f0-9]{2}){3,4}\|[a-f0-9]{3,4})$/i.test(str),
2767	parse(str) {
2768	if (str.length <= 5) {
2769	str = str.replace(/[a-f0-9]/gi, "$&$&");
2770	}
2771	let rgba = [];
2772	str.replace(/[a-f0-9]{2}/gi, (component) => {
2773	rgba.push(parseInt(component, 16) / 255);
2774	});
2775	return {
2776	spaceId: "srgb",
2777	coords: (
2778	/** @type {Coords} */
2779	rgba.slice(0, 3)
2780	),
2781	alpha: (
2782	/** @type {number} */
2783	rgba.slice(3)[0]
2784	)
2785	};
2786	},
2787	serialize: (coords, alpha, {
2788	collapse = true,
2789	// collapse to 3-4 digit hex when possible?
2790	alpha: alphaFormat
2791	} = {}) => {
2792	if (alphaFormat !== false && alpha < 1 \|\| alphaFormat === true) {
2793	coords.push(alpha);
2794	}
2795	coords = /** @type {[number, number, number]} */
2796	coords.map((c) => Math.round(c * 255));
2797	let collapsible = collapse && coords.every((c) => c % 17 === 0);
2798	let hex = coords.map((c) => {
2799	if (collapsible) {
2800	return (c / 17).toString(16);
2801	}
2802	return c.toString(16).padStart(2, "0");
2803	}).join("");
2804	return "#" + hex;
2805	}
2806	},
2807	keyword: {
2808	type: "custom",
2809	test: (str) => /^[a-z]+$/i.test(str),
2810	parse(str) {
2811	str = str.toLowerCase();
2812	let ret = { spaceId: "srgb", coords: null, alpha: 1 };
2813	if (str === "transparent") {
2814	ret.coords = keywords_default.black;
2815	ret.alpha = 0;
2816	} else {
2817	ret.coords = keywords_default[str];
2818	}
2819	if (ret.coords) {
2820	return ret;
2821	}
2822	}
2823	}
2824	}
2825	});
2826
2827	// packages/theme/node_modules/colorjs.io/src/spaces/p3.js
2828	var p3_default = new RGBColorSpace({
2829	id: "p3",
2830	cssId: "display-p3",
2831	name: "P3",
2832	base: p3_linear_default,
2833	// Gamma encoding/decoding is the same as sRGB
2834	fromBase: srgb_default.fromBase,
2835	toBase: srgb_default.toBase
2836	});
2837
2838	// packages/theme/node_modules/colorjs.io/src/luminance.js
2839	function getLuminance(color) {
2840	return get(color, [xyz_d65_default, "y"]);
2841	}
2842
2843	// packages/theme/node_modules/colorjs.io/src/contrast/WCAG21.js
2844	function contrastWCAG21(color1, color2) {
2845	color1 = getColor(color1);
2846	color2 = getColor(color2);
2847	let Y1 = Math.max(getLuminance(color1), 0);
2848	let Y2 = Math.max(getLuminance(color2), 0);
2849	if (Y2 > Y1) {
2850	[Y1, Y2] = [Y2, Y1];
2851	}
2852	return (Y1 + 0.05) / (Y2 + 0.05);
2853	}
2854
2855	// packages/theme/node_modules/colorjs.io/src/spaces/hsl.js
2856	var hsl_default = new ColorSpace({
2857	id: "hsl",
2858	name: "HSL",
2859	coords: {
2860	h: {
2861	refRange: [0, 360],
2862	type: "angle",
2863	name: "Hue"
2864	},
2865	s: {
2866	range: [0, 100],
2867	name: "Saturation"
2868	},
2869	l: {
2870	range: [0, 100],
2871	name: "Lightness"
2872	}
2873	},
2874	base: srgb_default,
2875	// Adapted from https://drafts.csswg.org/css-color-4/better-rgbToHsl.js
2876	fromBase: (rgb) => {
2877	let max = Math.max(...rgb);
2878	let min = Math.min(...rgb);
2879	let [r, g2, b2] = rgb;
2880	let [h, s, l] = [null, 0, (min + max) / 2];
2881	let d2 = max - min;
2882	if (d2 !== 0) {
2883	s = l === 0 \|\| l === 1 ? 0 : (max - l) / Math.min(l, 1 - l);
2884	switch (max) {
2885	case r:
2886	h = (g2 - b2) / d2 + (g2 < b2 ? 6 : 0);
2887	break;
2888	case g2:
2889	h = (b2 - r) / d2 + 2;
2890	break;
2891	case b2:
2892	h = (r - g2) / d2 + 4;
2893	}
2894	h = h * 60;
2895	}
2896	if (s < 0) {
2897	h += 180;
2898	s = Math.abs(s);
2899	}
2900	if (h >= 360) {
2901	h -= 360;
2902	}
2903	return [h, s * 100, l * 100];
2904	},
2905	// Adapted from https://en.wikipedia.org/wiki/HSL_and_HSV#HSL_to_RGB_alternative
2906	toBase: (hsl) => {
2907	let [h, s, l] = hsl;
2908	h = h % 360;
2909	if (h < 0) {
2910	h += 360;
2911	}
2912	s /= 100;
2913	l /= 100;
2914	function f(n2) {
2915	let k = (n2 + h / 30) % 12;
2916	let a = s * Math.min(l, 1 - l);
2917	return l - a * Math.max(-1, Math.min(k - 3, 9 - k, 1));
2918	}
2919	return [f(0), f(8), f(4)];
2920	},
2921	formats: {
2922	hsl: {
2923	coords: ["<number> \| <angle>", "<percentage> \| <number>", "<percentage> \| <number>"]
2924	},
2925	hsla: {
2926	coords: ["<number> \| <angle>", "<percentage> \| <number>", "<percentage> \| <number>"],
2927	commas: true,
2928	alpha: true
2929	}
2930	}
2931	});
2932
2933	// packages/theme/node_modules/colorjs.io/src/spaces/oklch.js
2934	var oklch_default = new ColorSpace({
2935	id: "oklch",
2936	name: "OkLCh",
2937	coords: {
2938	l: {
2939	refRange: [0, 1],
2940	name: "Lightness"
2941	},
2942	c: {
2943	refRange: [0, 0.4],
2944	name: "Chroma"
2945	},
2946	h: {
2947	refRange: [0, 360],
2948	type: "angle",
2949	name: "Hue"
2950	}
2951	},
2952	white: "D65",
2953	base: oklab_default,
2954	fromBase: lch_default.fromBase,
2955	toBase: lch_default.toBase,
2956	formats: {
2957	oklch: {
2958	coords: ["<percentage> \| <number>", "<number> \| <percentage>", "<number> \| <angle>"]
2959	}
2960	}
2961	});
2962
2963	// node_modules/memize/dist/index.js
2964	function memize(fn, options) {
2965	var size = 0;
2966	var head;
2967	var tail;
2968	options = options \|\| {};
2969	function memoized() {
2970	var node = head, len = arguments.length, args, i;
2971	searchCache: while (node) {
2972	if (node.args.length !== arguments.length) {
2973	node = node.next;
2974	continue;
2975	}
2976	for (i = 0; i < len; i++) {
2977	if (node.args[i] !== arguments[i]) {
2978	node = node.next;
2979	continue searchCache;
2980	}
2981	}
2982	if (node !== head) {
2983	if (node === tail) {
2984	tail = node.prev;
2985	}
2986	node.prev.next = node.next;
2987	if (node.next) {
2988	node.next.prev = node.prev;
2989	}
2990	node.next = head;
2991	node.prev = null;
2992	head.prev = node;
2993	head = node;
2994	}
2995	return node.val;
2996	}
2997	args = new Array(len);
2998	for (i = 0; i < len; i++) {
2999	args[i] = arguments[i];
3000	}
3001	node = {
3002	args,
3003	// Generate the result from original function
3004	val: fn.apply(null, args)
3005	};
3006	if (head) {
3007	head.prev = node;
3008	node.next = head;
3009	} else {
3010	tail = node;
3011	}
3012	if (size === /** @type {MemizeOptions} */
3013	options.maxSize) {
3014	tail = /** @type {MemizeCacheNode} */
3015	tail.prev;
3016	tail.next = null;
3017	} else {
3018	size++;
3019	}
3020	head = node;
3021	return node.val;
3022	}
3023	memoized.clear = function() {
3024	head = null;
3025	tail = null;
3026	size = 0;
3027	};
3028	return memoized;
3029	}
3030
3031	// packages/theme/build-module/use-theme-provider-styles.mjs
3032	var import_element2 = __toESM(require_element(), 1);
3033
3034	// packages/theme/build-module/color-ramps/lib/register-color-spaces.mjs
3035	ColorSpace.register(srgb_default);
3036	ColorSpace.register(oklch_default);
3037	ColorSpace.register(p3_default);
3038	ColorSpace.register(hsl_default);
3039
3040	// packages/theme/build-module/prebuilt/ts/color-tokens.mjs
3041	var color_tokens_default = {
3042	"primary-bgFill1": ["bg-interactive-brand-strong"],
3043	"primary-fgFill": [
3044	"fg-interactive-brand-strong",
3045	"fg-interactive-brand-strong-active"
3046	],
3047	"primary-bgFill2": ["bg-interactive-brand-strong-active"],
3048	"primary-surface4": ["bg-interactive-brand-weak-active"],
3049	"primary-fgSurface3": [
3050	"fg-interactive-brand",
3051	"fg-interactive-brand-active"
3052	],
3053	"primary-stroke3": [
3054	"bg-thumb-brand",
3055	"bg-thumb-brand-active",
3056	"stroke-focus-brand",
3057	"stroke-interactive-brand",
3058	"stroke-surface-brand-strong"
3059	],
3060	"primary-stroke4": ["stroke-interactive-brand-active"],
3061	"primary-stroke1": ["stroke-surface-brand"],
3062	"primary-surface1": ["bg-surface-brand"],
3063	"info-surface2": ["bg-surface-info-weak"],
3064	"info-surface4": ["bg-surface-info"],
3065	"info-fgSurface4": ["fg-content-info"],
3066	"info-fgSurface3": ["fg-content-info-weak"],
3067	"info-stroke3": ["stroke-surface-info-strong"],
3068	"info-stroke1": ["stroke-surface-info"],
3069	"success-surface2": ["bg-surface-success-weak"],
3070	"success-surface4": ["bg-surface-success"],
3071	"success-fgSurface4": ["fg-content-success"],
3072	"success-fgSurface3": ["fg-content-success-weak"],
3073	"success-stroke3": ["stroke-surface-success-strong"],
3074	"success-stroke1": ["stroke-surface-success"],
3075	"warning-surface2": ["bg-surface-warning-weak"],
3076	"warning-surface4": ["bg-surface-warning"],
3077	"warning-fgSurface4": ["fg-content-warning"],
3078	"warning-fgSurface3": ["fg-content-warning-weak"],
3079	"warning-stroke3": ["stroke-surface-warning-strong"],
3080	"warning-stroke1": ["stroke-surface-warning"],
3081	"error-bgFill1": ["bg-interactive-error-strong"],
3082	"error-fgFill": [
3083	"fg-interactive-error-strong",
3084	"fg-interactive-error-strong-active"
3085	],
3086	"error-bgFill2": ["bg-interactive-error-strong-active"],
3087	"error-surface2": [
3088	"bg-interactive-error-active",
3089	"bg-surface-error-weak"
3090	],
3091	"error-surface4": [
3092	"bg-interactive-error-weak-active",
3093	"bg-surface-error"
3094	],
3095	"error-fgSurface4": ["fg-content-error"],
3096	"error-fgSurface3": [
3097	"fg-content-error-weak",
3098	"fg-interactive-error",
3099	"fg-interactive-error-active"
3100	],
3101	"error-stroke3": [
3102	"stroke-interactive-error",
3103	"stroke-interactive-error-strong",
3104	"stroke-surface-error-strong"
3105	],
3106	"error-stroke4": ["stroke-interactive-error-active"],
3107	"error-stroke1": ["stroke-surface-error"],
3108	"bg-surface2": ["bg-surface-neutral"],
3109	"bg-surface5": ["bg-interactive-neutral-strong-disabled"],
3110	"bg-surface4": ["bg-interactive-neutral-weak-active"],
3111	"bg-surface3": ["bg-surface-neutral-strong"],
3112	"bg-fgSurface4": [
3113	"fg-content-neutral",
3114	"fg-interactive-neutral",
3115	"fg-interactive-neutral-active"
3116	],
3117	"bg-fgSurface3": [
3118	"fg-content-neutral-weak",
3119	"fg-interactive-neutral-weak"
3120	],
3121	"bg-fgSurface2": [
3122	"fg-interactive-neutral-disabled",
3123	"fg-interactive-neutral-strong-disabled",
3124	"fg-interactive-neutral-weak-disabled"
3125	],
3126	"bg-stroke3": [
3127	"bg-thumb-neutral-weak",
3128	"stroke-interactive-neutral",
3129	"stroke-surface-neutral-strong"
3130	],
3131	"bg-stroke4": [
3132	"bg-thumb-neutral-weak-active",
3133	"stroke-interactive-neutral-active",
3134	"stroke-interactive-neutral-strong"
3135	],
3136	"bg-stroke2": [
3137	"bg-thumb-neutral-disabled",
3138	"bg-track-neutral",
3139	"stroke-interactive-neutral-disabled",
3140	"stroke-surface-neutral"
3141	],
3142	"bg-stroke1": ["bg-track-neutral-weak", "stroke-surface-neutral-weak"],
3143	"bg-bgFillInverted2": ["bg-interactive-neutral-strong-active"],
3144	"bg-bgFillInverted1": ["bg-interactive-neutral-strong"],
3145	"bg-fgFillInverted": [
3146	"fg-interactive-neutral-strong",
3147	"fg-interactive-neutral-strong-active"
3148	],
3149	"bg-surface1": ["bg-surface-neutral-weak"],
3150	"caution-surface2": ["bg-surface-caution-weak"],
3151	"caution-surface4": ["bg-surface-caution"],
3152	"caution-fgSurface4": ["fg-content-caution"],
3153	"caution-fgSurface3": ["fg-content-caution-weak"]
3154	};
3155
3156	// packages/theme/build-module/color-ramps/lib/color-utils.mjs
3157	function getColorString(color) {
3158	const rgbRounded = serialize(to(color, srgb_default));
3159	return serialize(rgbRounded, { format: "hex" });
3160	}
3161	function getContrast(colorA, colorB) {
3162	return contrastWCAG21(colorA, colorB);
3163	}
3164	function clampToGamut(c) {
3165	return to(toGamut(c, { space: srgb_default, method: "css" }), oklch_default);
3166	}
3167
3168	// packages/theme/build-module/color-ramps/lib/constants.mjs
3169	var WHITE = to("white", oklch_default);
3170	var BLACK = to("black", oklch_default);
3171	var UNIVERSAL_CONTRAST_TOPUP = 0.02;
3172	var WHITE_TEXT_CONTRAST_MARGIN = 3.1;
3173	var ACCENT_SCALE_BASE_LIGHTNESS_THRESHOLDS = {
3174	lighter: { min: 0.2, max: 0.4 },
3175	darker: { min: 0.75, max: 0.98 }
3176	};
3177	var CONTRAST_EPSILON = 4e-3;
3178	var MAX_BISECTION_ITERATIONS = 10;
3179	var DEFAULT_SEED_COLORS = {
3180	bg: "#f8f8f8",
3181	primary: "#3858e9",
3182	info: "#0090ff",
3183	success: "#4ab866",
3184	caution: "#f0d149",
3185	warning: "#f0b849",
3186	error: "#cc1818"
3187	};
3188
3189	// packages/theme/build-module/color-ramps/lib/utils.mjs
3190	function buildDependencyGraph(config) {
3191	const dependencies = /* @__PURE__ */ new Map();
3192	const dependents = /* @__PURE__ */ new Map();
3193	Object.keys(config).forEach((step) => {
3194	dependencies.set(step, []);
3195	});
3196	dependents.set("seed", []);
3197	Object.keys(config).forEach((step) => {
3198	dependents.set(step, []);
3199	});
3200	Object.entries(config).forEach(([stepName, stepConfig]) => {
3201	const step = stepName;
3202	const reference = stepConfig.contrast.reference;
3203	dependencies.get(step).push(reference);
3204	dependents.get(reference).push(step);
3205	if (stepConfig.sameAsIfPossible) {
3206	dependencies.get(step).push(stepConfig.sameAsIfPossible);
3207	dependents.get(stepConfig.sameAsIfPossible).push(step);
3208	}
3209	});
3210	return { dependencies, dependents };
3211	}
3212	function sortByDependency(config) {
3213	const { dependents } = buildDependencyGraph(config);
3214	const result = [];
3215	const visited = /* @__PURE__ */ new Set();
3216	const visiting = /* @__PURE__ */ new Set();
3217	function visit(node) {
3218	if (visiting.has(node)) {
3219	throw new Error(
3220	`Circular dependency detected involving step: ${String(
3221	node
3222	)}`
3223	);
3224	}
3225	if (visited.has(node)) {
3226	return;
3227	}
3228	visiting.add(node);
3229	const nodeDependents = dependents.get(node) \|\| [];
3230	nodeDependents.forEach((dependent) => {
3231	visit(dependent);
3232	});
3233	visiting.delete(node);
3234	visited.add(node);
3235	if (node !== "seed") {
3236	result.unshift(node);
3237	}
3238	}
3239	visit("seed");
3240	return result;
3241	}
3242	function stepsForStep(stepName, config) {
3243	const result = /* @__PURE__ */ new Set();
3244	function visit(step) {
3245	if (step === "seed" \|\| result.has(step)) {
3246	return;
3247	}
3248	const stepConfig = config[step];
3249	if (!stepConfig) {
3250	return;
3251	}
3252	visit(stepConfig.contrast.reference);
3253	if (stepConfig.sameAsIfPossible) {
3254	visit(stepConfig.sameAsIfPossible);
3255	}
3256	result.add(step);
3257	}
3258	visit(stepName);
3259	return Array.from(result);
3260	}
3261	function computeBetterFgColorDirection(seed, preferLighter) {
3262	const contrastAgainstBlack = getContrast(seed, BLACK);
3263	const contrastAgainstWhite = getContrast(seed, WHITE);
3264	return contrastAgainstBlack > contrastAgainstWhite + (preferLighter ? WHITE_TEXT_CONTRAST_MARGIN : 0) ? { better: "darker", worse: "lighter" } : { better: "lighter", worse: "darker" };
3265	}
3266	function adjustContrastTarget(target) {
3267	if (target === 1) {
3268	return 1;
3269	}
3270	return target + UNIVERSAL_CONTRAST_TOPUP;
3271	}
3272	function clampAccentScaleReferenceLightness(rawLightness, direction) {
3273	const thresholds = ACCENT_SCALE_BASE_LIGHTNESS_THRESHOLDS[direction];
3274	return Math.max(thresholds.min, Math.min(thresholds.max, rawLightness));
3275	}
3276	function solveWithBisect(calculateC, calculateValue, initLowerL, initLowerValue, initUpperL, initUpperValue) {
3277	let lowerL = initLowerL;
3278	let lowerValue = initLowerValue;
3279	let lowerReplaced = false;
3280	let upperL = initUpperL;
3281	let upperValue = initUpperValue;
3282	let upperReplaced = false;
3283	let bestC;
3284	let bestValue;
3285	let iterations = 0;
3286	while (true) {
3287	iterations++;
3288	const newL = (lowerL * upperValue - upperL * lowerValue) / (upperValue - lowerValue);
3289	bestC = calculateC(newL);
3290	bestValue = calculateValue(bestC);
3291	if (Math.abs(bestValue) <= CONTRAST_EPSILON \|\| iterations >= MAX_BISECTION_ITERATIONS) {
3292	break;
3293	}
3294	if (bestValue <= 0) {
3295	lowerL = newL;
3296	lowerValue = bestValue;
3297	if (lowerReplaced) {
3298	upperValue /= 2;
3299	}
3300	lowerReplaced = true;
3301	upperReplaced = false;
3302	} else {
3303	upperL = newL;
3304	upperValue = bestValue;
3305	if (upperReplaced) {
3306	lowerValue /= 2;
3307	}
3308	upperReplaced = true;
3309	lowerReplaced = false;
3310	}
3311	}
3312	return bestC;
3313	}
3314
3315	// packages/theme/build-module/color-ramps/lib/taper-chroma.mjs
3316	function taperChroma(seed, lTarget, options = {}) {
3317	const gamut = options.gamut ?? srgb_default;
3318	const alpha = options.alpha ?? 0.65;
3319	const carry = options.carry ?? 0.5;
3320	const cUpperBound = options.cUpperBound ?? 0.45;
3321	const radiusLight = options.radiusLight ?? 0.2;
3322	const radiusDark = options.radiusDark ?? 0.2;
3323	const kLight = options.kLight ?? 0.85;
3324	const kDark = options.kDark ?? 0.85;
3325	const achromaEpsilon = options.achromaEpsilon ?? 5e-3;
3326	const cSeed = Math.max(0, get(seed, [oklch_default, "c"]));
3327	let hSeed = get(seed, [oklch_default, "h"]);
3328	const chromaIsTiny = cSeed < achromaEpsilon;
3329	const hueIsInvalid = hSeed === null \|\| !Number.isFinite(hSeed);
3330	if (chromaIsTiny \|\| hueIsInvalid) {
3331	if (typeof options.hueFallback === "number") {
3332	hSeed = normalizeHue(options.hueFallback);
3333	} else {
3334	return {
3335	space: oklch_default,
3336	coords: [clamp01(lTarget), 0, 0],
3337	alpha: 1
3338	};
3339	}
3340	}
3341	const lSeed = clamp01(get(seed, [oklch_default, "l"]));
3342	const cmaxSeed = getCachedMaxChromaAtLH(lSeed, hSeed, gamut, cUpperBound);
3343	const cmaxTarget = getCachedMaxChromaAtLH(
3344	clamp01(lTarget),
3345	hSeed,
3346	gamut,
3347	cUpperBound
3348	);
3349	let seedRelative = 0;
3350	const denom = cmaxSeed > 0 ? cmaxSeed : 1e-6;
3351	seedRelative = clamp01(cSeed / denom);
3352	const cIntendedBase = alpha * cmaxTarget;
3353	const cWithCarry = cIntendedBase * Math.pow(seedRelative, clamp01(carry));
3354	const t = continuousTaper(lSeed, lTarget, {
3355	radiusLight,
3356	radiusDark,
3357	kLight,
3358	kDark
3359	});
3360	const cPlanned = cWithCarry * t;
3361	const lOut = clamp01(lTarget);
3362	return { l: lOut, c: cPlanned };
3363	}
3364	function clamp01(x) {
3365	if (x < 0) {
3366	return 0;
3367	}
3368	if (x > 1) {
3369	return 1;
3370	}
3371	return x;
3372	}
3373	function normalizeHue(h) {
3374	let hue = h % 360;
3375	if (hue < 0) {
3376	hue += 360;
3377	}
3378	return hue;
3379	}
3380	function raisedCosine(u) {
3381	const x = clamp01(u);
3382	return 0.5 - 0.5 * Math.cos(Math.PI * x);
3383	}
3384	function continuousTaper(seedL, targetL, opts) {
3385	const d2 = targetL - seedL;
3386	if (d2 >= 0) {
3387	const u2 = opts.radiusLight > 0 ? Math.abs(d2) / opts.radiusLight : 1;
3388	const w2 = raisedCosine(u2 > 1 ? 1 : u2);
3389	return 1 - (1 - opts.kLight) * w2;
3390	}
3391	const u = opts.radiusDark > 0 ? Math.abs(d2) / opts.radiusDark : 1;
3392	const w = raisedCosine(u > 1 ? 1 : u);
3393	return 1 - (1 - opts.kDark) * w;
3394	}
3395	var maxChromaCache = /* @__PURE__ */ new Map();
3396	function keyMax(l, h, gamut, cap) {
3397	const lq = quantize(l, 0.05);
3398	const hq = quantize(normalizeHue(h), 10);
3399	const cq = quantize(cap, 0.05);
3400	return `${gamut}\|L:${lq}\|H:${hq}\|cap:${cq}`;
3401	}
3402	function quantize(x, step) {
3403	const k = Math.round(x / step);
3404	return k * step;
3405	}
3406	function getCachedMaxChromaAtLH(l, h, gamutSpace, cap) {
3407	const gamut = gamutSpace.id;
3408	const key = keyMax(l, h, gamut, cap);
3409	const hit = maxChromaCache.get(key);
3410	if (typeof hit === "number") {
3411	return hit;
3412	}
3413	const computed = maxInGamutChromaAtLH(l, h, gamutSpace, cap);
3414	maxChromaCache.set(key, computed);
3415	return computed;
3416	}
3417	function maxInGamutChromaAtLH(l, h, gamutSpace, cap) {
3418	const probe = {
3419	space: oklch_default,
3420	coords: [l, cap, h],
3421	alpha: 1
3422	};
3423	const clamped = toGamut(probe, { space: gamutSpace, method: "css" });
3424	return get(clamped, [oklch_default, "c"]);
3425	}
3426
3427	// packages/theme/build-module/color-ramps/lib/find-color-with-constraints.mjs
3428	function cdiff(c13, c23) {
3429	return Math.log(c13 / c23);
3430	}
3431	function findColorMeetingRequirements(reference, seed, target, direction, {
3432	lightnessConstraint,
3433	taperChromaOptions
3434	} = {}) {
3435	if (target <= 1) {
3436	return {
3437	color: reference,
3438	reached: true,
3439	achieved: 1
3440	};
3441	}
3442	function getColorForL(l) {
3443	let newL = l;
3444	let newC = get(seed, [oklch_default, "c"]);
3445	if (taperChromaOptions) {
3446	const tapered = taperChroma(seed, newL, taperChromaOptions);
3447	if ("l" in tapered && "c" in tapered) {
3448	newL = tapered.l;
3449	newC = tapered.c;
3450	} else {
3451	return tapered;
3452	}
3453	}
3454	return clampToGamut({
3455	spaceId: "oklch",
3456	coords: [newL, newC, get(seed, [oklch_default, "h"])]
3457	});
3458	}
3459	const mostContrastingL = direction === "lighter" ? 1 : 0;
3460	const mostContrastingColor = direction === "lighter" ? WHITE : BLACK;
3461	const highestContrast = getContrast(reference, mostContrastingColor);
3462	if (lightnessConstraint) {
3463	const colorWithExactL = getColorForL(lightnessConstraint.value);
3464	const exactLContrast = getContrast(reference, colorWithExactL);
3465	const exactLContrastMeetsTarget = cdiff(exactLContrast, target) >= -CONTRAST_EPSILON;
3466	if (exactLContrastMeetsTarget \|\| lightnessConstraint.type === "force") {
3467	return {
3468	color: colorWithExactL,
3469	reached: exactLContrastMeetsTarget,
3470	achieved: exactLContrast,
3471	deficit: exactLContrastMeetsTarget ? cdiff(exactLContrast, highestContrast) : cdiff(target, exactLContrast)
3472	};
3473	}
3474	}
3475	if (cdiff(highestContrast, target) <= CONTRAST_EPSILON) {
3476	return {
3477	color: mostContrastingColor,
3478	reached: cdiff(highestContrast, target) >= -CONTRAST_EPSILON,
3479	achieved: highestContrast,
3480	deficit: cdiff(target, highestContrast)
3481	};
3482	}
3483	const lowerL = get(reference, [oklch_default, "l"]);
3484	const lowerContrast = cdiff(1, target);
3485	const upperL = mostContrastingL;
3486	const upperContrast = cdiff(highestContrast, target);
3487	const bestColor = solveWithBisect(
3488	getColorForL,
3489	(c) => cdiff(getContrast(reference, c), target),
3490	lowerL,
3491	lowerContrast,
3492	upperL,
3493	upperContrast
3494	);
3495	return {
3496	color: bestColor,
3497	reached: true,
3498	achieved: target,
3499	// Negative number that specifies how much room we have.
3500	deficit: cdiff(target, highestContrast)
3501	};
3502	}
3503
3504	// packages/theme/build-module/color-ramps/lib/index.mjs
3505	function calculateRamp({
3506	seed,
3507	sortedSteps,
3508	config,
3509	mainDir,
3510	oppDir,
3511	pinLightness
3512	}) {
3513	const rampResults = {};
3514	let warnings;
3515	let maxDeficit = -Infinity;
3516	let maxDeficitDirection = "lighter";
3517	let maxDeficitStep;
3518	const calculatedColors = /* @__PURE__ */ new Map();
3519	calculatedColors.set("seed", seed);
3520	for (const stepName of sortedSteps) {
3521	let computeDirection = function(color, followDirection) {
3522	if (followDirection === "main") {
3523	return mainDir;
3524	}
3525	if (followDirection === "opposite") {
3526	return oppDir;
3527	}
3528	if (followDirection === "best") {
3529	return computeBetterFgColorDirection(
3530	color,
3531	contrast.preferLighter
3532	).better;
3533	}
3534	return followDirection;
3535	};
3536	const {
3537	contrast,
3538	lightness: stepLightnessConstraint,
3539	taperChromaOptions,
3540	sameAsIfPossible
3541	} = config[stepName];
3542	const referenceColor = calculatedColors.get(contrast.reference);
3543	if (!referenceColor) {
3544	throw new Error(
3545	`Reference color for step ${stepName} not found: ${contrast.reference}`
3546	);
3547	}
3548	if (sameAsIfPossible) {
3549	const candidateColor = calculatedColors.get(sameAsIfPossible);
3550	if (!candidateColor) {
3551	throw new Error(
3552	`Same-as color for step ${stepName} not found: ${sameAsIfPossible}`
3553	);
3554	}
3555	const candidateContrast = getContrast(
3556	referenceColor,
3557	candidateColor
3558	);
3559	const adjustedTarget2 = adjustContrastTarget(contrast.target);
3560	if (candidateContrast >= adjustedTarget2) {
3561	calculatedColors.set(stepName, candidateColor);
3562	rampResults[stepName] = getColorString(candidateColor);
3563	continue;
3564	}
3565	}
3566	const computedDir = computeDirection(
3567	referenceColor,
3568	contrast.followDirection
3569	);
3570	const adjustedTarget = adjustContrastTarget(contrast.target);
3571	let lightnessConstraint;
3572	if (pinLightness?.stepName === stepName) {
3573	lightnessConstraint = {
3574	value: pinLightness.value,
3575	type: "force"
3576	};
3577	} else if (stepLightnessConstraint) {
3578	lightnessConstraint = {
3579	value: stepLightnessConstraint(computedDir),
3580	type: "onlyIfSucceeds"
3581	};
3582	}
3583	const searchResults = findColorMeetingRequirements(
3584	referenceColor,
3585	seed,
3586	adjustedTarget,
3587	computedDir,
3588	{
3589	lightnessConstraint,
3590	taperChromaOptions
3591	}
3592	);
3593	if (!contrast.ignoreWhenAdjustingSeed && searchResults.deficit && searchResults.deficit > maxDeficit) {
3594	maxDeficit = searchResults.deficit;
3595	maxDeficitDirection = computedDir;
3596	maxDeficitStep = stepName;
3597	}
3598	calculatedColors.set(stepName, searchResults.color);
3599	rampResults[stepName] = getColorString(searchResults.color);
3600	if (!searchResults.reached && !contrast.ignoreWhenAdjustingSeed) {
3601	warnings ??= [];
3602	warnings.push(stepName);
3603	}
3604	}
3605	return {
3606	rampResults,
3607	warnings,
3608	maxDeficit,
3609	maxDeficitDirection,
3610	maxDeficitStep
3611	};
3612	}
3613	function buildRamp(seedArg, config, {
3614	mainDirection,
3615	pinLightness,
3616	rescaleToFitContrastTargets = true
3617	} = {}) {
3618	let seed;
3619	try {
3620	seed = clampToGamut(seedArg);
3621	} catch (error) {
3622	throw new Error(
3623	`Invalid seed color "${seedArg}": ${error instanceof Error ? error.message : "Unknown error"}`
3624	);
3625	}
3626	let mainDir = "lighter";
3627	let oppDir = "darker";
3628	if (mainDirection) {
3629	mainDir = mainDirection;
3630	oppDir = mainDirection === "darker" ? "lighter" : "darker";
3631	} else {
3632	const { better, worse } = computeBetterFgColorDirection(seed);
3633	mainDir = better;
3634	oppDir = worse;
3635	}
3636	const sortedSteps = sortByDependency(config);
3637	const {
3638	rampResults,
3639	warnings,
3640	maxDeficit,
3641	maxDeficitDirection,
3642	maxDeficitStep
3643	} = calculateRamp({
3644	seed,
3645	sortedSteps,
3646	config,
3647	mainDir,
3648	oppDir,
3649	pinLightness
3650	});
3651	let bestRamp = rampResults;
3652	if (maxDeficit > CONTRAST_EPSILON && rescaleToFitContrastTargets) {
3653	let getSeedForL = function(l) {
3654	return clampToGamut(set(clone(seed), [oklch_default, "l"], l));
3655	}, getDeficitForSeed = function(s) {
3656	const iterationResults = calculateRamp({
3657	seed: s,
3658	sortedSteps: iterSteps,
3659	config,
3660	mainDir,
3661	oppDir,
3662	pinLightness
3663	});
3664	return iterationResults.maxDeficitDirection === maxDeficitDirection ? iterationResults.maxDeficit : -maxDeficit;
3665	};
3666	const iterSteps = stepsForStep(maxDeficitStep, config);
3667	const lowerSeedL = maxDeficitDirection === "lighter" ? 0 : 1;
3668	const lowerDeficit = -maxDeficit;
3669	const upperSeedL = get(seed, [oklch_default, "l"]);
3670	const upperDeficit = maxDeficit;
3671	const bestSeed = solveWithBisect(
3672	getSeedForL,
3673	getDeficitForSeed,
3674	lowerSeedL,
3675	lowerDeficit,
3676	upperSeedL,
3677	upperDeficit
3678	);
3679	bestRamp = calculateRamp({
3680	seed: bestSeed,
3681	sortedSteps,
3682	config,
3683	mainDir,
3684	oppDir,
3685	pinLightness
3686	}).rampResults;
3687	}
3688	if (mainDir === "darker") {
3689	const tmpSurface1 = bestRamp.surface1;
3690	bestRamp.surface1 = bestRamp.surface3;
3691	bestRamp.surface3 = tmpSurface1;
3692	}
3693	return {
3694	ramp: bestRamp,
3695	warnings,
3696	direction: mainDir
3697	};
3698	}
3699
3700	// packages/theme/build-module/color-ramps/lib/ramp-configs.mjs
3701	var lightnessConstraintForegroundHighContrast = (direction) => direction === "lighter" ? 0.9551 : 0.235;
3702	var lightnessConstraintForegroundMediumContrast = (direction) => direction === "lighter" ? 0.77 : 0.56;
3703	var lightnessConstraintBgFill = (direction) => direction === "lighter" ? 0.67 : 0.45;
3704	var BG_SURFACE_TAPER_CHROMA = {
3705	alpha: 0.7
3706	};
3707	var FG_TAPER_CHROMA = {
3708	alpha: 0.6,
3709	kLight: 0.2,
3710	kDark: 0.2
3711	};
3712	var STROKE_TAPER_CHROMA = {
3713	alpha: 0.6,
3714	radiusDark: 0.01,
3715	radiusLight: 0.01,
3716	kLight: 0.8,
3717	kDark: 0.8
3718	};
3719	var ACCENT_SURFACE_TAPER_CHROMA = {
3720	alpha: 0.75,
3721	radiusDark: 0.01,
3722	radiusLight: 0.01
3723	};
3724	var fgSurface4Config = {
3725	contrast: {
3726	reference: "surface3",
3727	followDirection: "main",
3728	target: 7,
3729	preferLighter: true
3730	},
3731	lightness: lightnessConstraintForegroundHighContrast,
3732	taperChromaOptions: FG_TAPER_CHROMA
3733	};
3734	var BG_RAMP_CONFIG = {
3735	// Surface
3736	surface1: {
3737	contrast: {
3738	reference: "surface2",
3739	followDirection: "opposite",
3740	target: 1.06,
3741	ignoreWhenAdjustingSeed: true
3742	},
3743	taperChromaOptions: BG_SURFACE_TAPER_CHROMA
3744	},
3745	surface2: {
3746	contrast: {
3747	reference: "seed",
3748	followDirection: "main",
3749	target: 1
3750	}
3751	},
3752	surface3: {
3753	contrast: {
3754	reference: "surface2",
3755	followDirection: "main",
3756	target: 1.06
3757	},
3758	taperChromaOptions: BG_SURFACE_TAPER_CHROMA
3759	},
3760	surface4: {
3761	contrast: {
3762	reference: "surface2",
3763	followDirection: "main",
3764	target: 1.12
3765	},
3766	taperChromaOptions: BG_SURFACE_TAPER_CHROMA
3767	},
3768	surface5: {
3769	contrast: {
3770	reference: "surface2",
3771	followDirection: "main",
3772	target: 1.2
3773	},
3774	taperChromaOptions: BG_SURFACE_TAPER_CHROMA
3775	},
3776	surface6: {
3777	contrast: {
3778	reference: "surface2",
3779	followDirection: "main",
3780	target: 1.4
3781	},
3782	taperChromaOptions: BG_SURFACE_TAPER_CHROMA
3783	},
3784	// Bg fill
3785	bgFill1: {
3786	contrast: {
3787	reference: "surface2",
3788	followDirection: "main",
3789	target: 4
3790	},
3791	lightness: lightnessConstraintBgFill
3792	},
3793	bgFill2: {
3794	contrast: {
3795	reference: "bgFill1",
3796	followDirection: "main",
3797	target: 1.2
3798	}
3799	},
3800	bgFillInverted1: {
3801	contrast: {
3802	reference: "bgFillInverted2",
3803	followDirection: "opposite",
3804	target: 1.2
3805	}
3806	},
3807	bgFillInverted2: fgSurface4Config,
3808	bgFillDark: {
3809	contrast: {
3810	reference: "surface3",
3811	followDirection: "darker",
3812	// This is what causes the token to be always dark
3813	target: 7,
3814	ignoreWhenAdjustingSeed: true
3815	},
3816	lightness: lightnessConstraintForegroundHighContrast,
3817	taperChromaOptions: FG_TAPER_CHROMA
3818	},
3819	// Stroke
3820	stroke1: {
3821	contrast: {
3822	reference: "stroke3",
3823	followDirection: "opposite",
3824	target: 2.6
3825	},
3826	taperChromaOptions: STROKE_TAPER_CHROMA
3827	},
3828	stroke2: {
3829	contrast: {
3830	reference: "stroke3",
3831	followDirection: "opposite",
3832	target: 2.4
3833	},
3834	taperChromaOptions: STROKE_TAPER_CHROMA
3835	},
3836	stroke3: {
3837	contrast: {
3838	reference: "surface3",
3839	followDirection: "main",
3840	target: 3
3841	},
3842	taperChromaOptions: STROKE_TAPER_CHROMA
3843	},
3844	stroke4: {
3845	contrast: {
3846	reference: "stroke3",
3847	followDirection: "main",
3848	target: 1.5
3849	},
3850	taperChromaOptions: STROKE_TAPER_CHROMA
3851	},
3852	// fgSurface
3853	fgSurface1: {
3854	contrast: {
3855	reference: "surface3",
3856	followDirection: "main",
3857	target: 2,
3858	preferLighter: true
3859	},
3860	taperChromaOptions: FG_TAPER_CHROMA
3861	},
3862	fgSurface2: {
3863	contrast: {
3864	reference: "surface3",
3865	followDirection: "main",
3866	target: 3,
3867	preferLighter: true
3868	},
3869	taperChromaOptions: FG_TAPER_CHROMA
3870	},
3871	fgSurface3: {
3872	contrast: {
3873	reference: "surface3",
3874	followDirection: "main",
3875	target: 4.5,
3876	preferLighter: true
3877	},
3878	lightness: lightnessConstraintForegroundMediumContrast,
3879	taperChromaOptions: FG_TAPER_CHROMA
3880	},
3881	fgSurface4: fgSurface4Config,
3882	// fgFill
3883	fgFill: {
3884	contrast: {
3885	reference: "bgFill1",
3886	followDirection: "best",
3887	target: 4.5,
3888	preferLighter: true
3889	},
3890	lightness: lightnessConstraintForegroundHighContrast,
3891	taperChromaOptions: FG_TAPER_CHROMA
3892	},
3893	fgFillInverted: {
3894	contrast: {
3895	reference: "bgFillInverted1",
3896	followDirection: "best",
3897	target: 4.5,
3898	preferLighter: true
3899	},
3900	lightness: lightnessConstraintForegroundHighContrast,
3901	taperChromaOptions: FG_TAPER_CHROMA
3902	},
3903	fgFillDark: {
3904	contrast: {
3905	reference: "bgFillDark",
3906	followDirection: "best",
3907	target: 4.5,
3908	preferLighter: true
3909	},
3910	lightness: lightnessConstraintForegroundHighContrast,
3911	taperChromaOptions: FG_TAPER_CHROMA
3912	}
3913	};
3914	var ACCENT_RAMP_CONFIG = {
3915	...BG_RAMP_CONFIG,
3916	surface1: {
3917	...BG_RAMP_CONFIG.surface1,
3918	taperChromaOptions: ACCENT_SURFACE_TAPER_CHROMA
3919	},
3920	surface2: {
3921	contrast: {
3922	reference: "bgFill1",
3923	followDirection: "opposite",
3924	target: BG_RAMP_CONFIG.bgFill1.contrast.target,
3925	ignoreWhenAdjustingSeed: true
3926	},
3927	taperChromaOptions: ACCENT_SURFACE_TAPER_CHROMA
3928	},
3929	surface3: {
3930	...BG_RAMP_CONFIG.surface3,
3931	taperChromaOptions: ACCENT_SURFACE_TAPER_CHROMA
3932	},
3933	surface4: {
3934	...BG_RAMP_CONFIG.surface4,
3935	taperChromaOptions: ACCENT_SURFACE_TAPER_CHROMA
3936	},
3937	surface5: {
3938	...BG_RAMP_CONFIG.surface5,
3939	taperChromaOptions: ACCENT_SURFACE_TAPER_CHROMA
3940	},
3941	surface6: {
3942	...BG_RAMP_CONFIG.surface6,
3943	taperChromaOptions: ACCENT_SURFACE_TAPER_CHROMA
3944	},
3945	bgFill1: {
3946	contrast: {
3947	reference: "seed",
3948	followDirection: "main",
3949	target: 1
3950	}
3951	},
3952	stroke1: {
3953	...BG_RAMP_CONFIG.stroke1
3954	},
3955	stroke2: {
3956	...BG_RAMP_CONFIG.stroke2
3957	},
3958	stroke3: {
3959	...BG_RAMP_CONFIG.stroke3,
3960	sameAsIfPossible: "fgSurface3",
3961	taperChromaOptions: void 0
3962	},
3963	stroke4: {
3964	...BG_RAMP_CONFIG.stroke4,
3965	taperChromaOptions: void 0
3966	},
3967	// fgSurface: do not de-saturate
3968	fgSurface1: {
3969	...BG_RAMP_CONFIG.fgSurface1,
3970	taperChromaOptions: void 0
3971	},
3972	fgSurface2: {
3973	...BG_RAMP_CONFIG.fgSurface2,
3974	taperChromaOptions: void 0
3975	},
3976	fgSurface3: {
3977	...BG_RAMP_CONFIG.fgSurface3,
3978	taperChromaOptions: void 0,
3979	sameAsIfPossible: "bgFill1"
3980	},
3981	fgSurface4: {
3982	...BG_RAMP_CONFIG.fgSurface4,
3983	taperChromaOptions: void 0
3984	}
3985	};
3986
3987	// packages/theme/build-module/color-ramps/index.mjs
3988	function buildBgRamp(seed) {
3989	if (typeof seed !== "string" \|\| seed.trim() === "") {
3990	throw new Error("Seed color must be a non-empty string");
3991	}
3992	return buildRamp(seed, BG_RAMP_CONFIG);
3993	}
3994	var STEP_TO_PIN = "surface2";
3995	function getBgRampInfo(ramp) {
3996	return {
3997	mainDirection: ramp.direction,
3998	pinLightness: {
3999	stepName: STEP_TO_PIN,
4000	value: clampAccentScaleReferenceLightness(
4001	get(ramp.ramp[STEP_TO_PIN], [oklch_default, "l"]),
4002	ramp.direction
4003	)
4004	}
4005	};
4006	}
4007	function buildAccentRamp(seed, bgRamp) {
4008	if (typeof seed !== "string" \|\| seed.trim() === "") {
4009	throw new Error("Seed color must be a non-empty string");
4010	}
4011	const bgRampInfo = bgRamp ? getBgRampInfo(bgRamp) : void 0;
4012	return buildRamp(seed, ACCENT_RAMP_CONFIG, bgRampInfo);
4013	}
4014
4015	// packages/theme/build-module/use-theme-provider-styles.mjs
4016	var getCachedBgRamp = memize(buildBgRamp, { maxSize: 10 });
4017	var getCachedAccentRamp = memize(buildAccentRamp, { maxSize: 10 });
4018	var legacyWpComponentsOverridesCSS = [
4019	["--wp-components-color-accent", "var(--wp-admin-theme-color)"],
4020	[
4021	"--wp-components-color-accent-darker-10",
4022	"var(--wp-admin-theme-color-darker-10)"
4023	],
4024	[
4025	"--wp-components-color-accent-darker-20",
4026	"var(--wp-admin-theme-color-darker-20)"
4027	],
4028	[
4029	"--wp-components-color-accent-inverted",
4030	"var(--wpds-color-fg-interactive-brand-strong, #fff)"
4031	],
4032	[
4033	"--wp-components-color-background",
4034	"var(--wpds-color-bg-surface-neutral-strong, #ffffff)"
4035	],
4036	[
4037	"--wp-components-color-foreground",
4038	"var(--wpds-color-fg-content-neutral, #1e1e1e)"
4039	],
4040	[
4041	"--wp-components-color-foreground-inverted",
4042	"var(--wpds-color-bg-surface-neutral, #f8f8f8)"
4043	],
4044	[
4045	"--wp-components-color-gray-100",
4046	"var(--wpds-color-bg-surface-neutral, #f8f8f8)"
4047	],
4048	[
4049	"--wp-components-color-gray-200",
4050	"var(--wpds-color-stroke-surface-neutral, #d8d8d8)"
4051	],
4052	[
4053	"--wp-components-color-gray-300",
4054	"var(--wpds-color-stroke-surface-neutral, #d8d8d8)"
4055	],
4056	[
4057	"--wp-components-color-gray-400",
4058	"var(--wpds-color-stroke-interactive-neutral, #8a8a8a)"
4059	],
4060	[
4061	"--wp-components-color-gray-600",
4062	"var(--wpds-color-stroke-interactive-neutral, #8a8a8a)"
4063	],
4064	[
4065	"--wp-components-color-gray-700",
4066	"var(--wpds-color-fg-content-neutral-weak, #6d6d6d)"
4067	],
4068	[
4069	"--wp-components-color-gray-800",
4070	"var(--wpds-color-fg-content-neutral, #1e1e1e)"
4071	]
4072	];
4073	function customRgbFormat(color) {
4074	const rgb = to(color, srgb_default);
4075	return rgb.coords.map((n2) => Math.round((n2 ?? 0) * 255)).join(", ");
4076	}
4077	function legacyWpAdminThemeOverridesCSS(accent) {
4078	const parsedAccent = to(accent, hsl_default);
4079	const parsedL = parsedAccent.coords[2] ?? 0;
4080	const darker10 = set(
4081	clone(parsedAccent),
4082	[hsl_default, "l"],
4083	Math.max(0, parsedL - 5)
4084	// L reduced by 5%
4085	);
4086	const darker20 = set(
4087	clone(parsedAccent),
4088	[hsl_default, "l"],
4089	Math.max(0, parsedL - 10)
4090	// L reduced by 10%
4091	);
4092	return [
4093	["--wp-admin-theme-color", getColorString(parsedAccent)],
4094	["--wp-admin-theme-color--rgb", customRgbFormat(parsedAccent)],
4095	["--wp-admin-theme-color-darker-10", getColorString(darker10)],
4096	[
4097	"--wp-admin-theme-color-darker-10--rgb",
4098	customRgbFormat(darker10)
4099	],
4100	["--wp-admin-theme-color-darker-20", getColorString(darker20)],
4101	[
4102	"--wp-admin-theme-color-darker-20--rgb",
4103	customRgbFormat(darker20)
4104	]
4105	];
4106	}
4107	function colorTokensCSS(computedColorRamps) {
4108	const entries = [];
4109	for (const [rampName, { ramp }] of computedColorRamps) {
4110	for (const [tokenName, tokenValue] of Object.entries(ramp)) {
4111	const key = `${rampName}-${tokenName}`;
4112	const aliasedBy = color_tokens_default[key] ?? [];
4113	for (const aliasedId of aliasedBy) {
4114	entries.push([`--wpds-color-${aliasedId}`, tokenValue]);
4115	}
4116	}
4117	}
4118	return entries;
4119	}
4120	function generateStyles({
4121	primary,
4122	computedColorRamps
4123	}) {
4124	return Object.fromEntries(
4125	[
4126	// Semantic color tokens
4127	colorTokensCSS(computedColorRamps),
4128	// Legacy overrides
4129	legacyWpAdminThemeOverridesCSS(primary),
4130	legacyWpComponentsOverridesCSS
4131	].flat()
4132	);
4133	}
4134	function useThemeProviderStyles({
4135	color = {},
4136	cursor
4137	} = {}) {
4138	const { resolvedSettings: inheritedSettings } = (0, import_element2.useContext)(ThemeContext);
4139	const primary = color.primary ?? inheritedSettings.color?.primary ?? DEFAULT_SEED_COLORS.primary;
4140	const bg = color.bg ?? inheritedSettings.color?.bg ?? DEFAULT_SEED_COLORS.bg;
4141	const cursorControl = cursor?.control ?? inheritedSettings.cursor?.control;
4142	const resolvedSettings = (0, import_element2.useMemo)(
4143	() => ({
4144	color: {
4145	primary,
4146	bg
4147	},
4148	cursor: cursorControl ? { control: cursorControl } : void 0
4149	}),
4150	[primary, bg, cursorControl]
4151	);
4152	const colorStyles = (0, import_element2.useMemo)(() => {
4153	const seeds = {
4154	...DEFAULT_SEED_COLORS,
4155	bg,
4156	primary
4157	};
4158	const computedColorRamps = /* @__PURE__ */ new Map();
4159	const bgRamp = getCachedBgRamp(seeds.bg);
4160	Object.entries(seeds).forEach(([rampName, seed]) => {
4161	if (rampName === "bg") {
4162	computedColorRamps.set(rampName, bgRamp);
4163	} else {
4164	computedColorRamps.set(
4165	rampName,
4166	getCachedAccentRamp(seed, bgRamp)
4167	);
4168	}
4169	});
4170	return generateStyles({
4171	primary: seeds.primary,
4172	computedColorRamps
4173	});
4174	}, [primary, bg]);
4175	const themeProviderStyles = (0, import_element2.useMemo)(
4176	() => ({
4177	...colorStyles,
4178	...cursorControl && {
4179	"--wpds-cursor-control": cursorControl
4180	}
4181	}),
4182	[colorStyles, cursorControl]
4183	);
4184	return {
4185	resolvedSettings,
4186	themeProviderStyles
4187	};
4188	}
4189
4190	// packages/theme/build-module/theme-provider.mjs
4191	var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
4192	if (typeof document !== "undefined" && true && !document.head.querySelector("style[data-wp-hash='f4e6e06c6a']")) {
4193	const style = document.createElement("style");
4194	style.setAttribute("data-wp-hash", "f4e6e06c6a");
4195	style.appendChild(document.createTextNode(".dba930ea7a9438fd__root{display:contents}"));
4196	document.head.appendChild(style);
4197	}
4198	var style_default = { "root": "dba930ea7a9438fd__root" };
4199	function cssObjectToText(values) {
4200	return Object.entries(values).map(([key, value]) => `${key}: ${value};`).join("");
4201	}
4202	function generateCSSSelector({
4203	instanceId,
4204	isRoot
4205	}) {
4206	const rootSel = `[data-wpds-root-provider="true"]`;
4207	const instanceIdSel = `[data-wpds-theme-provider-id="${instanceId}"]`;
4208	const selectors = [];
4209	if (isRoot) {
4210	selectors.push(
4211	`:root:has(.${style_default.root}${rootSel}${instanceIdSel})`
4212	);
4213	}
4214	selectors.push(`.${style_default.root}.${style_default.root}${instanceIdSel}`);
4215	return selectors.join(",");
4216	}
4217	var ThemeProvider = ({
4218	children,
4219	color = {},
4220	cursor,
4221	isRoot = false,
4222	density
4223	}) => {
4224	const instanceId = (0, import_element3.useId)();
4225	const { themeProviderStyles, resolvedSettings } = useThemeProviderStyles({
4226	color,
4227	cursor
4228	});
4229	const contextValue = (0, import_element3.useMemo)(
4230	() => ({
4231	resolvedSettings
4232	}),
4233	[resolvedSettings]
4234	);
4235	return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
4236	themeProviderStyles ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("style", { children: `${generateCSSSelector({
4237	instanceId,
4238	isRoot
4239	})} {${cssObjectToText(themeProviderStyles)}}` }) : null,
4240	/* @__PURE__ */ (0, import_jsx_runtime.jsx)(
4241	"div",
4242	{
4243	"data-wpds-theme-provider-id": instanceId,
4244	"data-wpds-root-provider": isRoot,
4245	"data-wpds-density": density,
4246	className: style_default.root,
4247	children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(ThemeContext.Provider, { value: contextValue, children })
4248	}
4249	)
4250	] });
4251	};
4252
4253	// packages/theme/build-module/private-apis.mjs
4254	var privateApis = {};
4255	lock(privateApis, {
4256	ThemeProvider,
4257	useThemeProviderStyles
4258	});
4259	return __toCommonJS(index_exports);
4260	})();
4261	//# sourceMappingURL=index.js.map
4262