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