@udixio/theme 1.3.1 → 2.1.0

package/dist/loader-CoayTlSl.js

@@ -0,0 +1,3906 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { asClass, createContainer, InjectionMode } from "awilix";
+import { argbFromLstar, sanitizeDegreesDouble, yFromLstar, argbFromLinrgb, Cam16, signum, matrixMultiply, ViewingConditions, lstarFromArgb, lstarFromY, lerp, clampDouble, Contrast, DynamicColor as DynamicColor$1, argbFromHex, hexFromArgb, TonalPalette } from "@material/material-color-utilities";
+class API {
+  constructor({
+    colorApi,
+    pluginApi,
+    context,
+    paletteApi
+  }) {
+    __publicField(this, "colors");
+    __publicField(this, "plugins");
+    __publicField(this, "context");
+    __publicField(this, "palettes");
+    colorApi.api = this;
+    this.context = context;
+    this.plugins = pluginApi;
+    this.colors = colorApi;
+    this.palettes = paletteApi;
+  }
+  async load() {
+    return this.plugins.loadPlugins();
+  }
+}
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const _HctSolver = class _HctSolver {
+  /**
+   * Finds an sRGB color with the given hue, chroma, and L*, if
+   * possible.
+   *
+   * @param hueDegrees The desired hue, in degrees.
+   * @param chroma The desired chroma.
+   * @param lstar The desired L*.
+   * @return A hexadecimal representing the sRGB color. The color
+   * has sufficiently close hue, chroma, and L* to the desired
+   * values, if possible; otherwise, the hue and L* will be
+   * sufficiently close, and chroma will be maximized.
+   */
+  static solveToInt(hueDegrees, chroma, lstar) {
+    if (chroma < 1e-4 || lstar < 1e-4 || lstar > 99.9999) {
+      return argbFromLstar(lstar);
+    }
+    hueDegrees = sanitizeDegreesDouble(hueDegrees);
+    const hueRadians = hueDegrees / 180 * Math.PI;
+    const y = yFromLstar(lstar);
+    const exactAnswer = _HctSolver.findResultByJ(hueRadians, chroma, y);
+    if (exactAnswer !== 0) {
+      return exactAnswer;
+    }
+    const linrgb = _HctSolver.bisectToLimit(y, hueRadians);
+    return argbFromLinrgb(linrgb);
+  }
+  /**
+   * Finds an sRGB color with the given hue, chroma, and L*, if
+   * possible.
+   *
+   * @param hueDegrees The desired hue, in degrees.
+   * @param chroma The desired chroma.
+   * @param lstar The desired L*.
+   * @return An CAM16 object representing the sRGB color. The color
+   * has sufficiently close hue, chroma, and L* to the desired
+   * values, if possible; otherwise, the hue and L* will be
+   * sufficiently close, and chroma will be maximized.
+   */
+  static solveToCam(hueDegrees, chroma, lstar) {
+    return Cam16.fromInt(_HctSolver.solveToInt(hueDegrees, chroma, lstar));
+  }
+  /**
+   * Sanitizes a small enough angle in radians.
+   *
+   * @param angle An angle in radians; must not deviate too much
+   * from 0.
+   * @return A coterminal angle between 0 and 2pi.
+   */
+  static sanitizeRadians(angle) {
+    return (angle + Math.PI * 8) % (Math.PI * 2);
+  }
+  /**
+   * Delinearizes an RGB component, returning a floating-point
+   * number.
+   *
+   * @param rgbComponent 0.0 <= rgb_component <= 100.0, represents
+   * linear R/G/B channel
+   * @return 0.0 <= output <= 255.0, color channel converted to
+   * regular RGB space
+   */
+  static trueDelinearized(rgbComponent) {
+    const normalized = rgbComponent / 100;
+    let delinearized = 0;
+    if (normalized <= 31308e-7) {
+      delinearized = normalized * 12.92;
+    } else {
+      delinearized = 1.055 * Math.pow(normalized, 1 / 2.4) - 0.055;
+    }
+    return delinearized * 255;
+  }
+  static chromaticAdaptation(component) {
+    const af = Math.pow(Math.abs(component), 0.42);
+    return signum(component) * 400 * af / (af + 27.13);
+  }
+  /**
+   * Returns the hue of a linear RGB color in CAM16.
+   *
+   * @param linrgb The linear RGB coordinates of a color.
+   * @return The hue of the color in CAM16, in radians.
+   */
+  static hueOf(linrgb) {
+    const scaledDiscount = matrixMultiply(
+      linrgb,
+      _HctSolver.SCALED_DISCOUNT_FROM_LINRGB
+    );
+    const rA = _HctSolver.chromaticAdaptation(scaledDiscount[0]);
+    const gA = _HctSolver.chromaticAdaptation(scaledDiscount[1]);
+    const bA = _HctSolver.chromaticAdaptation(scaledDiscount[2]);
+    const a = (11 * rA + -12 * gA + bA) / 11;
+    const b = (rA + gA - 2 * bA) / 9;
+    return Math.atan2(b, a);
+  }
+  static areInCyclicOrder(a, b, c) {
+    const deltaAB = _HctSolver.sanitizeRadians(b - a);
+    const deltaAC = _HctSolver.sanitizeRadians(c - a);
+    return deltaAB < deltaAC;
+  }
+  /**
+   * Solves the lerp equation.
+   *
+   * @param source The starting number.
+   * @param mid The number in the middle.
+   * @param target The ending number.
+   * @return A number t such that lerp(source, target, t) = mid.
+   */
+  static intercept(source, mid, target) {
+    return (mid - source) / (target - source);
+  }
+  static lerpPoint(source, t, target) {
+    return [
+      source[0] + (target[0] - source[0]) * t,
+      source[1] + (target[1] - source[1]) * t,
+      source[2] + (target[2] - source[2]) * t
+    ];
+  }
+  /**
+   * Intersects a segment with a plane.
+   *
+   * @param source The coordinates of point A.
+   * @param coordinate The R-, G-, or B-coordinate of the plane.
+   * @param target The coordinates of point B.
+   * @param axis The axis the plane is perpendicular with. (0: R, 1:
+   * G, 2: B)
+   * @return The intersection point of the segment AB with the plane
+   * R=coordinate, G=coordinate, or B=coordinate
+   */
+  static setCoordinate(source, coordinate, target, axis) {
+    const t = _HctSolver.intercept(source[axis], coordinate, target[axis]);
+    return _HctSolver.lerpPoint(source, t, target);
+  }
+  static isBounded(x) {
+    return 0 <= x && x <= 100;
+  }
+  /**
+   * Returns the nth possible vertex of the polygonal intersection.
+   *
+   * @param y The Y value of the plane.
+   * @param n The zero-based index of the point. 0 <= n <= 11.
+   * @return The nth possible vertex of the polygonal intersection
+   * of the y plane and the RGB cube, in linear RGB coordinates, if
+   * it exists. If this possible vertex lies outside of the cube,
+   * [-1.0, -1.0, -1.0] is returned.
+   */
+  static nthVertex(y, n) {
+    const kR = _HctSolver.Y_FROM_LINRGB[0];
+    const kG = _HctSolver.Y_FROM_LINRGB[1];
+    const kB = _HctSolver.Y_FROM_LINRGB[2];
+    const coordA = n % 4 <= 1 ? 0 : 100;
+    const coordB = n % 2 === 0 ? 0 : 100;
+    if (n < 4) {
+      const g = coordA;
+      const b = coordB;
+      const r = (y - g * kG - b * kB) / kR;
+      if (_HctSolver.isBounded(r)) {
+        return [r, g, b];
+      } else {
+        return [-1, -1, -1];
+      }
+    } else if (n < 8) {
+      const b = coordA;
+      const r = coordB;
+      const g = (y - r * kR - b * kB) / kG;
+      if (_HctSolver.isBounded(g)) {
+        return [r, g, b];
+      } else {
+        return [-1, -1, -1];
+      }
+    } else {
+      const r = coordA;
+      const g = coordB;
+      const b = (y - r * kR - g * kG) / kB;
+      if (_HctSolver.isBounded(b)) {
+        return [r, g, b];
+      } else {
+        return [-1, -1, -1];
+      }
+    }
+  }
+  /**
+   * Finds the segment containing the desired color.
+   *
+   * @param y The Y value of the color.
+   * @param targetHue The hue of the color.
+   * @return A list of two sets of linear RGB coordinates, each
+   * corresponding to an endpoint of the segment containing the
+   * desired color.
+   */
+  static bisectToSegment(y, targetHue) {
+    let left = [-1, -1, -1];
+    let right = left;
+    let leftHue = 0;
+    let rightHue = 0;
+    let initialized = false;
+    let uncut = true;
+    for (let n = 0; n < 12; n++) {
+      const mid = _HctSolver.nthVertex(y, n);
+      if (mid[0] < 0) {
+        continue;
+      }
+      const midHue = _HctSolver.hueOf(mid);
+      if (!initialized) {
+        left = mid;
+        right = mid;
+        leftHue = midHue;
+        rightHue = midHue;
+        initialized = true;
+        continue;
+      }
+      if (uncut || _HctSolver.areInCyclicOrder(leftHue, midHue, rightHue)) {
+        uncut = false;
+        if (_HctSolver.areInCyclicOrder(leftHue, targetHue, midHue)) {
+          right = mid;
+          rightHue = midHue;
+        } else {
+          left = mid;
+          leftHue = midHue;
+        }
+      }
+    }
+    return [left, right];
+  }
+  static midpoint(a, b) {
+    return [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2, (a[2] + b[2]) / 2];
+  }
+  static criticalPlaneBelow(x) {
+    return Math.floor(x - 0.5);
+  }
+  static criticalPlaneAbove(x) {
+    return Math.ceil(x - 0.5);
+  }
+  /**
+   * Finds a color with the given Y and hue on the boundary of the
+   * cube.
+   *
+   * @param y The Y value of the color.
+   * @param targetHue The hue of the color.
+   * @return The desired color, in linear RGB coordinates.
+   */
+  static bisectToLimit(y, targetHue) {
+    const segment = _HctSolver.bisectToSegment(y, targetHue);
+    let left = segment[0];
+    let leftHue = _HctSolver.hueOf(left);
+    let right = segment[1];
+    for (let axis = 0; axis < 3; axis++) {
+      if (left[axis] !== right[axis]) {
+        let lPlane = -1;
+        let rPlane = 255;
+        if (left[axis] < right[axis]) {
+          lPlane = _HctSolver.criticalPlaneBelow(
+            _HctSolver.trueDelinearized(left[axis])
+          );
+          rPlane = _HctSolver.criticalPlaneAbove(
+            _HctSolver.trueDelinearized(right[axis])
+          );
+        } else {
+          lPlane = _HctSolver.criticalPlaneAbove(
+            _HctSolver.trueDelinearized(left[axis])
+          );
+          rPlane = _HctSolver.criticalPlaneBelow(
+            _HctSolver.trueDelinearized(right[axis])
+          );
+        }
+        for (let i = 0; i < 8; i++) {
+          if (Math.abs(rPlane - lPlane) <= 1) {
+            break;
+          } else {
+            const mPlane = Math.floor((lPlane + rPlane) / 2);
+            const midPlaneCoordinate = _HctSolver.CRITICAL_PLANES[mPlane];
+            const mid = _HctSolver.setCoordinate(
+              left,
+              midPlaneCoordinate,
+              right,
+              axis
+            );
+            const midHue = _HctSolver.hueOf(mid);
+            if (_HctSolver.areInCyclicOrder(leftHue, targetHue, midHue)) {
+              right = mid;
+              rPlane = mPlane;
+            } else {
+              left = mid;
+              leftHue = midHue;
+              lPlane = mPlane;
+            }
+          }
+        }
+      }
+    }
+    return _HctSolver.midpoint(left, right);
+  }
+  static inverseChromaticAdaptation(adapted) {
+    const adaptedAbs = Math.abs(adapted);
+    const base = Math.max(0, 27.13 * adaptedAbs / (400 - adaptedAbs));
+    return signum(adapted) * Math.pow(base, 1 / 0.42);
+  }
+  /**
+   * Finds a color with the given hue, chroma, and Y.
+   *
+   * @param hueRadians The desired hue in radians.
+   * @param chroma The desired chroma.
+   * @param y The desired Y.
+   * @return The desired color as a hexadecimal integer, if found; 0
+   * otherwise.
+   */
+  static findResultByJ(hueRadians, chroma, y) {
+    let j = Math.sqrt(y) * 11;
+    const viewingConditions = ViewingConditions.DEFAULT;
+    const tInnerCoeff = 1 / Math.pow(1.64 - Math.pow(0.29, viewingConditions.n), 0.73);
+    const eHue = 0.25 * (Math.cos(hueRadians + 2) + 3.8);
+    const p1 = eHue * (5e4 / 13) * viewingConditions.nc * viewingConditions.ncb;
+    const hSin = Math.sin(hueRadians);
+    const hCos = Math.cos(hueRadians);
+    for (let iterationRound = 0; iterationRound < 5; iterationRound++) {
+      const jNormalized = j / 100;
+      const alpha = chroma === 0 || j === 0 ? 0 : chroma / Math.sqrt(jNormalized);
+      const t = Math.pow(alpha * tInnerCoeff, 1 / 0.9);
+      const ac = viewingConditions.aw * Math.pow(jNormalized, 1 / viewingConditions.c / viewingConditions.z);
+      const p2 = ac / viewingConditions.nbb;
+      const gamma = 23 * (p2 + 0.305) * t / (23 * p1 + 11 * t * hCos + 108 * t * hSin);
+      const a = gamma * hCos;
+      const b = gamma * hSin;
+      const rA = (460 * p2 + 451 * a + 288 * b) / 1403;
+      const gA = (460 * p2 - 891 * a - 261 * b) / 1403;
+      const bA = (460 * p2 - 220 * a - 6300 * b) / 1403;
+      const rCScaled = _HctSolver.inverseChromaticAdaptation(rA);
+      const gCScaled = _HctSolver.inverseChromaticAdaptation(gA);
+      const bCScaled = _HctSolver.inverseChromaticAdaptation(bA);
+      const linrgb = matrixMultiply(
+        [rCScaled, gCScaled, bCScaled],
+        _HctSolver.LINRGB_FROM_SCALED_DISCOUNT
+      );
+      if (linrgb[0] < 0 || linrgb[1] < 0 || linrgb[2] < 0) {
+        return 0;
+      }
+      const kR = _HctSolver.Y_FROM_LINRGB[0];
+      const kG = _HctSolver.Y_FROM_LINRGB[1];
+      const kB = _HctSolver.Y_FROM_LINRGB[2];
+      const fnj = kR * linrgb[0] + kG * linrgb[1] + kB * linrgb[2];
+      if (fnj <= 0) {
+        return 0;
+      }
+      if (iterationRound === 4 || Math.abs(fnj - y) < 2e-3) {
+        if (linrgb[0] > 100.01 || linrgb[1] > 100.01 || linrgb[2] > 100.01) {
+          return 0;
+        }
+        return argbFromLinrgb(linrgb);
+      }
+      j = j - (fnj - y) * j / (2 * fnj);
+    }
+    return 0;
+  }
+};
+__publicField(_HctSolver, "SCALED_DISCOUNT_FROM_LINRGB", [
+  [0.001200833568784504, 0.002389694492170889, 2795742885861124e-19],
+  [5891086651375999e-19, 0.0029785502573438758, 3270666104008398e-19],
+  [10146692491640572e-20, 5364214359186694e-19, 0.0032979401770712076]
+]);
+__publicField(_HctSolver, "LINRGB_FROM_SCALED_DISCOUNT", [
+  [1373.2198709594231, -1100.4251190754821, -7.278681089101213],
+  [-271.815969077903, 559.6580465940733, -32.46047482791194],
+  [1.9622899599665666, -57.173814538844006, 308.7233197812385]
+]);
+__publicField(_HctSolver, "Y_FROM_LINRGB", [0.2126, 0.7152, 0.0722]);
+__publicField(_HctSolver, "CRITICAL_PLANES", [
+  0.015176349177441876,
+  0.045529047532325624,
+  0.07588174588720938,
+  0.10623444424209313,
+  0.13658714259697685,
+  0.16693984095186062,
+  0.19729253930674434,
+  0.2276452376616281,
+  0.2579979360165119,
+  0.28835063437139563,
+  0.3188300904430532,
+  0.350925934958123,
+  0.3848314933096426,
+  0.42057480301049466,
+  0.458183274052838,
+  0.4976837250274023,
+  0.5391024159806381,
+  0.5824650784040898,
+  0.6277969426914107,
+  0.6751227633498623,
+  0.7244668422128921,
+  0.775853049866786,
+  0.829304845476233,
+  0.8848452951698498,
+  0.942497089126609,
+  1.0022825574869039,
+  1.0642236851973577,
+  1.1283421258858297,
+  1.1946592148522128,
+  1.2631959812511864,
+  1.3339731595349034,
+  1.407011200216447,
+  1.4823302800086415,
+  1.5599503113873272,
+  1.6398909516233677,
+  1.7221716113234105,
+  1.8068114625156377,
+  1.8938294463134073,
+  1.9832442801866852,
+  2.075074464868551,
+  2.1693382909216234,
+  2.2660538449872063,
+  2.36523901573795,
+  2.4669114995532007,
+  2.5710888059345764,
+  2.6777882626779785,
+  2.7870270208169257,
+  2.898822059350997,
+  3.0131901897720907,
+  3.1301480604002863,
+  3.2497121605402226,
+  3.3718988244681087,
+  3.4967242352587946,
+  3.624204428461639,
+  3.754355295633311,
+  3.887192587735158,
+  4.022731918402185,
+  4.160988767090289,
+  4.301978482107941,
+  4.445716283538092,
+  4.592217266055746,
+  4.741496401646282,
+  4.893568542229298,
+  5.048448422192488,
+  5.20615066083972,
+  5.3666897647573375,
+  5.5300801301023865,
+  5.696336044816294,
+  5.865471690767354,
+  6.037501145825082,
+  6.212438385869475,
+  6.390297286737924,
+  6.571091626112461,
+  6.7548350853498045,
+  6.941541251256611,
+  7.131223617812143,
+  7.323895587840543,
+  7.5195704746346665,
+  7.7182615035334345,
+  7.919981813454504,
+  8.124744458384042,
+  8.332562408825165,
+  8.543448553206703,
+  8.757415699253682,
+  8.974476575321063,
+  9.194643831691977,
+  9.417930041841839,
+  9.644347703669503,
+  9.873909240696694,
+  10.106627003236781,
+  10.342513269534024,
+  10.58158024687427,
+  10.8238400726681,
+  11.069304815507364,
+  11.317986476196008,
+  11.569896988756009,
+  11.825048221409341,
+  12.083451977536606,
+  12.345119996613247,
+  12.610063955123938,
+  12.878295467455942,
+  13.149826086772048,
+  13.42466730586372,
+  13.702830557985108,
+  13.984327217668513,
+  14.269168601521828,
+  14.55736596900856,
+  14.848930523210871,
+  15.143873411576273,
+  15.44220572664832,
+  15.743938506781891,
+  16.04908273684337,
+  16.35764934889634,
+  16.66964922287304,
+  16.985093187232053,
+  17.30399201960269,
+  17.62635644741625,
+  17.95219714852476,
+  18.281524751807332,
+  18.614349837764564,
+  18.95068293910138,
+  19.290534541298456,
+  19.633915083172692,
+  19.98083495742689,
+  20.331304511189067,
+  20.685334046541502,
+  21.042933821039977,
+  21.404114048223256,
+  21.76888489811322,
+  22.137256497705877,
+  22.50923893145328,
+  22.884842241736916,
+  23.264076429332462,
+  23.6469514538663,
+  24.033477234264016,
+  24.42366364919083,
+  24.817520537484558,
+  25.21505769858089,
+  25.61628489293138,
+  26.021211842414342,
+  26.429848230738664,
+  26.842203703840827,
+  27.258287870275353,
+  27.678110301598522,
+  28.10168053274597,
+  28.529008062403893,
+  28.96010235337422,
+  29.39497283293396,
+  29.83362889318845,
+  30.276079891419332,
+  30.722335150426627,
+  31.172403958865512,
+  31.62629557157785,
+  32.08401920991837,
+  32.54558406207592,
+  33.010999283389665,
+  33.4802739966603,
+  33.953417292456834,
+  34.430438229418264,
+  34.911345834551085,
+  35.39614910352207,
+  35.88485700094671,
+  36.37747846067349,
+  36.87402238606382,
+  37.37449765026789,
+  37.87891309649659,
+  38.38727753828926,
+  38.89959975977785,
+  39.41588851594697,
+  39.93615253289054,
+  40.460400508064545,
+  40.98864111053629,
+  41.520882981230194,
+  42.05713473317016,
+  42.597404951718396,
+  43.141702194811224,
+  43.6900349931913,
+  44.24241185063697,
+  44.798841244188324,
+  45.35933162437017,
+  45.92389141541209,
+  46.49252901546552,
+  47.065252796817916,
+  47.64207110610409,
+  48.22299226451468,
+  48.808024568002054,
+  49.3971762874833,
+  49.9904556690408,
+  50.587870934119984,
+  51.189430279724725,
+  51.79514187861014,
+  52.40501387947288,
+  53.0190544071392,
+  53.637271562750364,
+  54.259673423945976,
+  54.88626804504493,
+  55.517063457223934,
+  56.15206766869424,
+  56.79128866487574,
+  57.43473440856916,
+  58.08241284012621,
+  58.734331877617365,
+  59.39049941699807,
+  60.05092333227251,
+  60.715611475655585,
+  61.38457167773311,
+  62.057811747619894,
+  62.7353394731159,
+  63.417162620860914,
+  64.10328893648692,
+  64.79372614476921,
+  65.48848194977529,
+  66.18756403501224,
+  66.89098006357258,
+  67.59873767827808,
+  68.31084450182222,
+  69.02730813691093,
+  69.74813616640164,
+  70.47333615344107,
+  71.20291564160104,
+  71.93688215501312,
+  72.67524319850172,
+  73.41800625771542,
+  74.16517879925733,
+  74.9167682708136,
+  75.67278210128072,
+  76.43322770089146,
+  77.1981124613393,
+  77.96744375590167,
+  78.74122893956174,
+  79.51947534912904,
+  80.30219030335869,
+  81.08938110306934,
+  81.88105503125999,
+  82.67721935322541,
+  83.4778813166706,
+  84.28304815182372,
+  85.09272707154808,
+  85.90692527145302,
+  86.72564993000343,
+  87.54890820862819,
+  88.3767072518277,
+  89.2090541872801,
+  90.04595612594655,
+  90.88742016217518,
+  91.73345337380438,
+  92.58406282226491,
+  93.43925555268066,
+  94.29903859396902,
+  95.16341895893969,
+  96.03240364439274,
+  96.9059996312159,
+  97.78421388448044,
+  98.6670533535366,
+  99.55452497210776
+]);
+let HctSolver = _HctSolver;
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class Hct {
+  constructor(argb) {
+    /**
+     * @param hue 0 <= hue < 360; invalid values are corrected.
+     * @param chroma 0 <= chroma < ?; Informally, colorfulness. The color
+     *     returned may be lower than the requested chroma. Chroma has a different
+     *     maximum for any given hue and tone.
+     * @param tone 0 <= tone <= 100; invalid values are corrected.
+     * @return HCT representation of a color in default viewing conditions.
+     */
+    __publicField(this, "internalHue");
+    __publicField(this, "internalChroma");
+    __publicField(this, "internalTone");
+    this.argb = argb;
+    const cam = Cam16.fromInt(argb);
+    this.internalHue = cam.hue;
+    this.internalChroma = cam.chroma;
+    this.internalTone = lstarFromArgb(argb);
+    this.argb = argb;
+  }
+  /**
+   * A number, in degrees, representing ex. red, orange, yellow, etc.
+   * Ranges from 0 <= hue < 360.
+   */
+  get hue() {
+    return this.internalHue;
+  }
+  /**
+   * @param newHue 0 <= newHue < 360; invalid values are corrected.
+   * Chroma may decrease because chroma has a different maximum for any given
+   * hue and tone.
+   */
+  set hue(newHue) {
+    this.setInternalState(
+      HctSolver.solveToInt(newHue, this.internalChroma, this.internalTone)
+    );
+  }
+  get chroma() {
+    return this.internalChroma;
+  }
+  /**
+   * @param newChroma 0 <= newChroma < ?
+   * Chroma may decrease because chroma has a different maximum for any given
+   * hue and tone.
+   */
+  set chroma(newChroma) {
+    this.setInternalState(
+      HctSolver.solveToInt(this.internalHue, newChroma, this.internalTone)
+    );
+  }
+  /** Lightness. Ranges from 0 to 100. */
+  get tone() {
+    return this.internalTone;
+  }
+  /**
+   * @param newTone 0 <= newTone <= 100; invalid valids are corrected.
+   * Chroma may decrease because chroma has a different maximum for any given
+   * hue and tone.
+   */
+  set tone(newTone) {
+    this.setInternalState(
+      HctSolver.solveToInt(this.internalHue, this.internalChroma, newTone)
+    );
+  }
+  static from(hue, chroma, tone) {
+    return new Hct(HctSolver.solveToInt(hue, chroma, tone));
+  }
+  /**
+   * @param argb ARGB representation of a color.
+   * @return HCT representation of a color in default viewing conditions
+   */
+  static fromInt(argb) {
+    return new Hct(argb);
+  }
+  static isBlue(hue) {
+    return hue >= 250 && hue < 270;
+  }
+  static isYellow(hue) {
+    return hue >= 105 && hue < 125;
+  }
+  static isCyan(hue) {
+    return hue >= 170 && hue < 207;
+  }
+  toInt() {
+    return this.argb;
+  }
+  /** Sets a property of the Hct object. */
+  setValue(propertyName, value) {
+    this[propertyName] = value;
+  }
+  toString() {
+    return `HCT(${this.hue.toFixed(0)}, ${this.chroma.toFixed(0)}, ${this.tone.toFixed(
+      0
+    )})`;
+  }
+  /**
+   * Translates a color into different [ViewingConditions].
+   *
+   * Colors change appearance. They look different with lights on versus off,
+   * the same color, as in hex code, on white looks different when on black.
+   * This is called color relativity, most famously explicated by Josef Albers
+   * in Interaction of Color.
+   *
+   * In color science, color appearance models can account for this and
+   * calculate the appearance of a color in different settings. HCT is based on
+   * CAM16, a color appearance model, and uses it to make these calculations.
+   *
+   * See [ViewingConditions.make] for parameters affecting color appearance.
+   */
+  inViewingConditions(vc) {
+    const cam = Cam16.fromInt(this.toInt());
+    const viewedInVc = cam.xyzInViewingConditions(vc);
+    const recastInVc = Cam16.fromXyzInViewingConditions(
+      viewedInVc[0],
+      viewedInVc[1],
+      viewedInVc[2],
+      ViewingConditions.make()
+    );
+    const recastHct = Hct.from(
+      recastInVc.hue,
+      recastInVc.chroma,
+      lstarFromY(viewedInVc[1])
+    );
+    return recastHct;
+  }
+  setInternalState(argb) {
+    const cam = Cam16.fromInt(argb);
+    this.internalHue = cam.hue;
+    this.internalChroma = cam.chroma;
+    this.internalTone = lstarFromArgb(argb);
+    this.argb = argb;
+  }
+}
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class ContrastCurve {
+  /**
+   * Creates a `ContrastCurve` object.
+   *
+   * @param low Value for contrast level -1.0
+   * @param normal Value for contrast level 0.0
+   * @param medium Value for contrast level 0.5
+   * @param high Value for contrast level 1.0
+   */
+  constructor(low, normal, medium, high) {
+    this.low = low;
+    this.normal = normal;
+    this.medium = medium;
+    this.high = high;
+  }
+  /**
+   * Returns the value at a given contrast level.
+   *
+   * @param contrastLevel The contrast level. 0.0 is the default (normal); -1.0
+   *     is the lowest; 1.0 is the highest.
+   * @return The value. For contrast ratios, a number between 1.0 and 21.0.
+   */
+  get(contrastLevel) {
+    if (contrastLevel <= -1) {
+      return this.low;
+    } else if (contrastLevel < 0) {
+      return lerp(this.low, this.normal, (contrastLevel - -1) / 1);
+    } else if (contrastLevel < 0.5) {
+      return lerp(this.normal, this.medium, (contrastLevel - 0) / 0.5);
+    } else if (contrastLevel < 1) {
+      return lerp(this.medium, this.high, (contrastLevel - 0.5) / 0.5);
+    } else {
+      return this.high;
+    }
+  }
+}
+function getCurve(defaultContrast) {
+  if (defaultContrast === 1.5) {
+    return new ContrastCurve(1.5, 1.5, 3, 4.5);
+  } else if (defaultContrast === 3) {
+    return new ContrastCurve(3, 3, 4.5, 7);
+  } else if (defaultContrast === 4.5) {
+    return new ContrastCurve(4.5, 4.5, 7, 11);
+  } else if (defaultContrast === 6) {
+    return new ContrastCurve(6, 6, 7, 11);
+  } else if (defaultContrast === 7) {
+    return new ContrastCurve(7, 7, 11, 21);
+  } else if (defaultContrast === 9) {
+    return new ContrastCurve(9, 9, 11, 21);
+  } else if (defaultContrast === 11) {
+    return new ContrastCurve(11, 11, 21, 21);
+  } else if (defaultContrast === 21) {
+    return new ContrastCurve(21, 21, 21, 21);
+  } else {
+    return new ContrastCurve(defaultContrast, defaultContrast, 7, 21);
+  }
+}
+function tMaxC(palette, lowerBound = 0, upperBound = 100, chromaMultiplier = 1) {
+  const answer = findBestToneForChroma(
+    palette.hue,
+    palette.chroma * chromaMultiplier,
+    100,
+    true
+  );
+  return clampDouble(lowerBound, upperBound, answer);
+}
+function tMinC(palette, lowerBound = 0, upperBound = 100) {
+  const answer = findBestToneForChroma(palette.hue, palette.chroma, 0, false);
+  return clampDouble(lowerBound, upperBound, answer);
+}
+function findBestToneForChroma(hue, chroma, tone, byDecreasingTone) {
+  let answer = tone;
+  let bestCandidate = Hct.from(hue, chroma, answer);
+  while (bestCandidate.chroma < chroma) {
+    if (tone < 0 || tone > 100) {
+      break;
+    }
+    tone += byDecreasingTone ? -1 : 1;
+    const newCandidate = Hct.from(hue, chroma, tone);
+    if (bestCandidate.chroma < newCandidate.chroma) {
+      bestCandidate = newCandidate;
+      answer = tone;
+    }
+  }
+  return answer;
+}
+function calculateToneAdjustmentPercentage(toneA, toneB, desiredRatio) {
+  const currentRatio = Contrast.ratioOfTones(toneA, toneB);
+  if (currentRatio >= desiredRatio) {
+    return 0;
+  }
+  const lighterTone = Contrast.lighter(toneA, desiredRatio);
+  const darkerTone = Contrast.darker(toneA, desiredRatio);
+  if (lighterTone !== -1 && toneB < lighterTone) {
+    const percentageToAdjust = (toneB - lighterTone) / (toneA - lighterTone);
+    return clampDouble(0, 1, percentageToAdjust);
+  }
+  if (darkerTone !== -1 && toneB > darkerTone) {
+    const percentageToAdjust = (toneB - darkerTone) / (toneA - darkerTone);
+    return clampDouble(0, 1, percentageToAdjust);
+  }
+  return 0;
+}
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class DynamicColor {
+  /**
+   * The base constructor for DynamicColor.
+   *
+   * _Strongly_ prefer using one of the convenience constructors. This class is
+   * arguably too flexible to ensure it can support any scenario. Functional
+   * arguments allow  overriding without risks that come with subclasses.
+   *
+   * For example, the default behavior of adjust tone at max contrast
+   * to be at a 7.0 ratio with its background is principled and
+   * matches accessibility guidance. That does not mean it's the desired
+   * approach for _every_ design system, and every color pairing,
+   * always, in every case.
+   *
+   * @param name The name of the dynamic color. Defaults to empty.
+   * @param palette Function that provides a TonalPalette given DynamicScheme. A
+   *     TonalPalette is defined by a hue and chroma, so this replaces the need
+   *     to specify hue/chroma. By providing a tonal palette, when contrast
+   *     adjustments are made, intended chroma can be preserved.
+   * @param tone Function that provides a tone, given a DynamicScheme.
+   * @param isBackground Whether this dynamic color is a background, with some
+   *     other color as the foreground. Defaults to false.
+   * @param chromaMultiplier A factor that multiplies the chroma for this color.
+   * @param background The background of the dynamic color (as a function of a
+   *     `DynamicScheme`), if it exists.
+   * @param secondBackground A second background of the dynamic color (as a
+   *     function of a `DynamicScheme`), if it exists.
+   * @param contrastCurve A `ContrastCurve` object specifying how its contrast
+   *     against its background should behave in various contrast levels
+   *     options.
+   * @param adjustTone A `AdjustTone` object specifying a tone delta
+   *     constraint between two colors. One of them must be the color being
+   *     constructed.
+   */
+  constructor(name, palette, tone, isBackground, chromaMultiplier, background, secondBackground, contrastCurve, adjustTone) {
+    this.name = name;
+    this.palette = palette;
+    this.tone = tone;
+    this.isBackground = isBackground;
+    this.chromaMultiplier = chromaMultiplier;
+    this.background = background;
+    this.secondBackground = secondBackground;
+    this.contrastCurve = contrastCurve;
+    this.adjustTone = adjustTone;
+    if (!background && secondBackground) {
+      throw new Error(
+        `Color ${name} has secondBackgrounddefined, but background is not defined.`
+      );
+    }
+    if (!background && contrastCurve) {
+      throw new Error(
+        `Color ${name} has contrastCurvedefined, but background is not defined.`
+      );
+    }
+    if (background && !contrastCurve) {
+      throw new Error(
+        `Color ${name} has backgrounddefined, but contrastCurve is not defined.`
+      );
+    }
+  }
+  /**
+   * Create a DynamicColor defined by a TonalPalette and HCT tone.
+   *
+   * @param args Functions with DynamicScheme as input. Must provide a palette
+   *     and tone. May provide a background DynamicColor and ToneDeltaPair.
+   */
+  static fromPalette(args) {
+    return new DynamicColor(
+      args.name ?? "",
+      args.palette,
+      args.tone ?? (() => DynamicColor.getInitialToneFromBackground(args.background)),
+      args.isBackground ?? false,
+      args.chromaMultiplier,
+      args.background,
+      args.secondBackground,
+      args.contrastCurve,
+      args.adjustTone
+    );
+  }
+  // static getInitialToneFromBackground(
+  //   background?: () => Color | undefined,
+  // ): number {
+  //   if (background === undefined) {
+  //     return 50;
+  //   }
+  //   return (background() ? background()!.getTone() : 50);
+  // }
+  /**
+   * Given a background tone, finds a foreground tone, while ensuring they reach
+   * a contrast ratio that is as close to [ratio] as possible.
+   *
+   * @param bgTone Tone in HCT. Range is 0 to 100, undefined behavior when it
+   *     falls outside that range.
+   * @param ratio The contrast ratio desired between bgTone and the return
+   *     value.
+   */
+  static foregroundTone(bgTone, ratio) {
+    const lighterTone = Contrast.lighterUnsafe(bgTone, ratio);
+    const darkerTone = Contrast.darkerUnsafe(bgTone, ratio);
+    const lighterRatio = Contrast.ratioOfTones(lighterTone, bgTone);
+    const darkerRatio = Contrast.ratioOfTones(darkerTone, bgTone);
+    const preferLighter = DynamicColor.tonePrefersLightForeground(bgTone);
+    if (preferLighter) {
+      const negligibleDifference = Math.abs(lighterRatio - darkerRatio) < 0.1 && lighterRatio < ratio && darkerRatio < ratio;
+      return lighterRatio >= ratio || lighterRatio >= darkerRatio || negligibleDifference ? lighterTone : darkerTone;
+    } else {
+      return darkerRatio >= ratio || darkerRatio >= lighterRatio ? darkerTone : lighterTone;
+    }
+  }
+  /**
+   * Returns whether [tone] prefers a light foreground.
+   *
+   * People prefer white foregrounds on ~T60-70. Observed over time, and also
+   * by Andrew Somers during research for APCA.
+   *
+   * T60 used as to create the smallest discontinuity possible when skipping
+   * down to T49 in order to ensure light foregrounds.
+   * Since `tertiaryContainer` in dark monochrome scheme requires a tone of
+   * 60, it should not be adjusted. Therefore, 60 is excluded here.
+   */
+  static tonePrefersLightForeground(tone) {
+    return Math.round(tone) < 60;
+  }
+  /**
+   * Returns whether [tone] can reach a contrast ratio of 4.5 with a lighter
+   * color.
+   */
+  static toneAllowsLightForeground(tone) {
+    return Math.round(tone) <= 49;
+  }
+  /**
+   * Adjusts a tone such that white has 4.5 contrast, if the tone is
+   * reasonably close to supporting it.
+   */
+  static enableLightForeground(tone) {
+    if (DynamicColor.tonePrefersLightForeground(tone) && !DynamicColor.toneAllowsLightForeground(tone)) {
+      return 49;
+    }
+    return tone;
+  }
+  /**
+   * Returns a deep copy of this DynamicColor.
+   */
+  clone() {
+    return DynamicColor.fromPalette({
+      name: this.name,
+      palette: this.palette,
+      tone: this.tone,
+      isBackground: this.isBackground,
+      chromaMultiplier: this.chromaMultiplier,
+      background: this.background,
+      secondBackground: this.secondBackground,
+      contrastCurve: this.contrastCurve,
+      adjustTone: this.adjustTone
+    });
+  }
+  /**
+   * Returns a ARGB integer (i.e. a hex code).
+   *
+   * @param scheme Defines the conditions of the user interface, for example,
+   *     whether or not it is dark mode or light mode, and what the desired
+   *     contrast level is.
+   */
+  getArgb(scheme) {
+    return this.getHct(scheme).toInt();
+  }
+  /**
+   * Returns a color, expressed in the HCT color space, that this
+   * DynamicColor is under the conditions in scheme.
+   *
+   * @param scheme Defines the conditions of the user interface, for example,
+   *     whether or not it is dark mode or light mode, and what the desired
+   *     contrast level is.
+   */
+  getHct(scheme) {
+    const palette = this.palette(scheme);
+    const tone = this.getTone(scheme);
+    const hue = palette.hue;
+    const chroma = palette.chroma * (this.chromaMultiplier ? this.chromaMultiplier(scheme) : 1);
+    return Hct.from(hue, chroma, tone);
+  }
+  /**
+   * Returns a tone, T in the HCT color space, that this DynamicColor is under
+   * the conditions in scheme.
+   *
+   * @param scheme Defines the conditions of the user interface, for example,
+   *     whether or not it is dark mode or light mode, and what the desired
+   *     contrast level is.
+   */
+  getTone(scheme) {
+    const adjustTone = this.adjustTone ? this.adjustTone(scheme) : void 0;
+    if (adjustTone) {
+      return adjustTone({ scheme, dynamicColor: this });
+    } else {
+      let answer = this.tone(scheme);
+      if (this.background == void 0 || this.background(scheme) === void 0 || this.contrastCurve == void 0 || this.contrastCurve(scheme) === void 0) {
+        return answer;
+      }
+      const bgTone = this.background(scheme).getTone(scheme);
+      const desiredRatio = this.contrastCurve(scheme).get(
+        scheme.contrastLevel
+      );
+      answer = Contrast.ratioOfTones(bgTone, answer) >= desiredRatio && scheme.contrastLevel >= 0 ? answer : DynamicColor.foregroundTone(bgTone, desiredRatio);
+      if (this.isBackground && !this.name.endsWith("_fixed_dim")) {
+        if (answer >= 57) {
+          answer = clampDouble(65, 100, answer);
+        } else {
+          answer = clampDouble(0, 49, answer);
+        }
+      }
+      if (this.secondBackground == void 0 || this.secondBackground(scheme) === void 0) {
+        return answer;
+      }
+      const [bg1, bg2] = [this.background, this.secondBackground];
+      const [bgTone1, bgTone2] = [
+        bg1(scheme).getTone(scheme),
+        bg2(scheme).getTone(scheme)
+      ];
+      const [upper, lower] = [
+        Math.max(bgTone1, bgTone2),
+        Math.min(bgTone1, bgTone2)
+      ];
+      if (Contrast.ratioOfTones(upper, answer) >= desiredRatio && Contrast.ratioOfTones(lower, answer) >= desiredRatio) {
+        return answer;
+      }
+      const lightOption = Contrast.lighter(upper, desiredRatio);
+      const darkOption = Contrast.darker(lower, desiredRatio);
+      const availables = [];
+      if (lightOption !== -1) availables.push(lightOption);
+      if (darkOption !== -1) availables.push(darkOption);
+      const prefersLight = DynamicColor.tonePrefersLightForeground(bgTone1) || DynamicColor.tonePrefersLightForeground(bgTone2);
+      if (prefersLight) {
+        return lightOption < 0 ? 100 : lightOption;
+      }
+      if (availables.length === 1) {
+        return availables[0];
+      }
+      return darkOption < 0 ? 0 : darkOption;
+    }
+  }
+}
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class ToneDeltaPair {
+  /**
+   * Documents a constraint in tone distance between two DynamicColors.
+   *
+   * The polarity is an adjective that describes "A", compared to "B".
+   *
+   * For instance, ToneDeltaPair(A, B, 15, 'darker', 'exact') states that
+   * A's tone should be exactly 15 darker than B's.
+   *
+   * 'relative_darker' and 'relative_lighter' describes the tone adjustment
+   * relative to the surface color trend (white in light mode; black in dark
+   * mode). For instance, ToneDeltaPair(A, B, 10, 'relative_lighter',
+   * 'farther') states that A should be at least 10 lighter than B in light
+   * mode, and at least 10 darker than B in dark mode.
+   *
+   * @param roleA The first role in a pair.
+   * @param roleB The second role in a pair.
+   * @param delta Required difference between tones. Absolute value, negative
+   * values have undefined behavior.
+   * @param polarity The relative relation between tones of roleA and roleB,
+   * as described above.
+   * @param constraint How to fulfill the tone delta pair constraint.
+   * @param stayTogether Whether these two roles should stay on the same side
+   * of the "awkward zone" (T50-59). This is necessary for certain cases where
+   * one role has two backgrounds.
+   */
+  constructor(roleA, roleB, delta, polarity, stayTogether, constraint) {
+    this.roleA = roleA;
+    this.roleB = roleB;
+    this.delta = delta;
+    this.polarity = polarity;
+    this.stayTogether = stayTogether;
+    this.constraint = constraint;
+    this.constraint = constraint ?? "exact";
+  }
+  adjustedTone({ context: ctx, color }) {
+    const roleA = this.roleA;
+    const roleB = this.roleB;
+    const polarity = this.polarity;
+    const constraint = this.constraint;
+    const absoluteDelta = polarity === "darker" || polarity === "relative_lighter" && ctx.isDark || polarity === "relative_darker" && !ctx.isDark ? -this.delta : this.delta;
+    const amRoleA = color.name === roleA.name;
+    const selfRole = amRoleA ? roleA : roleB;
+    const refRole = amRoleA ? roleB : roleA;
+    if (!(selfRole instanceof ColorFromPalette)) {
+      throw new Error("selfRole is not a ColorFromPalette");
+    }
+    let selfTone = selfRole.options.tone;
+    const refTone = refRole.getTone();
+    const relativeDelta = absoluteDelta * (amRoleA ? 1 : -1);
+    if (constraint === "exact") {
+      selfTone = clampDouble(0, 100, refTone + relativeDelta);
+    } else if (constraint === "nearer") {
+      if (relativeDelta > 0) {
+        selfTone = clampDouble(
+          0,
+          100,
+          clampDouble(refTone, refTone + relativeDelta, selfTone)
+        );
+      } else {
+        selfTone = clampDouble(
+          0,
+          100,
+          clampDouble(refTone + relativeDelta, refTone, selfTone)
+        );
+      }
+    } else if (constraint === "farther") {
+      if (relativeDelta > 0) {
+        selfTone = clampDouble(refTone + relativeDelta, 100, selfTone);
+      } else {
+        selfTone = clampDouble(0, refTone + relativeDelta, selfTone);
+      }
+    }
+    if (color instanceof ColorFromPalette) {
+      if (color.options.background && color.options.contrastCurve) {
+        const background = color.options.background;
+        const contrastCurve = color.options.contrastCurve;
+        if (background && contrastCurve) {
+          const bgTone = background.getTone();
+          const selfContrast = contrastCurve.get(ctx.contrastLevel);
+          selfTone = Contrast.ratioOfTones(bgTone, selfTone) >= selfContrast && ctx.contrastLevel >= 0 ? selfTone : DynamicColor$1.foregroundTone(bgTone, selfContrast);
+        }
+      }
+      if (color.options.isBackground && !color.name.endsWith("_fixed_dim")) {
+        if (selfTone >= 57) {
+          selfTone = clampDouble(65, 100, selfTone);
+        } else {
+          selfTone = clampDouble(0, 49, selfTone);
+        }
+      }
+    }
+    return selfTone;
+  }
+}
+const toneDeltaPair = (...params) => {
+  return (args) => new ToneDeltaPair(...params).adjustedTone(args);
+};
+function argbToRgb(argb) {
+  return {
+    r: argb >> 16 & 255,
+    g: argb >> 8 & 255,
+    b: argb & 255
+  };
+}
+function getInitialToneFromBackground(background) {
+  if (background === void 0) {
+    return 50;
+  }
+  return background.getTone();
+}
+class Color {
+  constructor(name) {
+    this.name = name;
+  }
+  static maxChroma(hue, tone = 50) {
+    return Hct.from(hue, 200, tone).chroma;
+  }
+  getHex() {
+    return hexFromArgb(this.getArgb());
+  }
+  getArgb() {
+    return this.getHct().toInt();
+  }
+  getRgb() {
+    return argbToRgb(this.getArgb());
+  }
+  getTone() {
+    return this.getHct().tone;
+  }
+}
+class ColorAlias extends Color {
+  constructor(name, as, colorService) {
+    super(name);
+    this.as = as;
+    this.colorService = colorService;
+  }
+  getHct() {
+    return this.colorService.get(this.as).getHct();
+  }
+  color() {
+    return this.colorService.get(this.as);
+  }
+}
+class ColorFromHex extends Color {
+  constructor(name, _hex) {
+    super(name);
+    this._hex = _hex;
+    this._hex = _hex;
+  }
+  getHct() {
+    return Hct.fromInt(argbFromHex(this.getHex()));
+  }
+  getHex() {
+    return this._hex;
+  }
+  setHex(hex) {
+    this._hex = hex;
+  }
+}
+class ColorFromPalette extends Color {
+  constructor(name, _options, context) {
+    super(name);
+    this._options = _options;
+    this.context = context;
+    this.validateOption();
+  }
+  get options() {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+    const options = {
+      ...this._options,
+      palette: this._options.palette(),
+      tone: (_b = (_a = this._options).tone) == null ? void 0 : _b.call(_a),
+      chromaMultiplier: (_d = (_c = this._options).chromaMultiplier) == null ? void 0 : _d.call(_c),
+      background: (_f = (_e = this._options).background) == null ? void 0 : _f.call(_e),
+      secondBackground: (_h = (_g = this._options).secondBackground) == null ? void 0 : _h.call(_g),
+      contrastCurve: (_j = (_i = this._options).contrastCurve) == null ? void 0 : _j.call(_i),
+      adjustTone: (_l = (_k = this._options).adjustTone) == null ? void 0 : _l.call(_k)
+    };
+    return {
+      ...options,
+      chromaMultiplier: options.chromaMultiplier ?? 1,
+      tone: options.tone ?? getInitialToneFromBackground(options.background)
+    };
+  }
+  update(args) {
+    this._options = { ...this._options, ...args };
+    this.validateOption();
+  }
+  validateOption() {
+    const option = this._options;
+    if ("palette" in option) {
+      if (!option.background && option.secondBackground) {
+        throw new Error(
+          `Color ${this.name} has secondBackground defined, but background is not defined.`
+        );
+      }
+      if (!option.background && option.contrastCurve) {
+        throw new Error(
+          `Color ${this.name} has contrastCurve defined, but background is not defined.`
+        );
+      }
+      if (option.background && !option.contrastCurve) {
+        throw new Error(
+          `Color ${this.name} has background defined, but contrastCurve is not defined.`
+        );
+      }
+    }
+  }
+  getHct() {
+    const option = this.options;
+    const palette = option.palette;
+    const tone = this.getTone();
+    const hue = palette.hue;
+    const chroma = palette.chroma * option.chromaMultiplier;
+    return Hct.from(hue, chroma, tone);
+  }
+  getTone() {
+    const context = this.context;
+    const options = this.options;
+    const adjustTone = options.adjustTone;
+    if (adjustTone) {
+      return adjustTone({ context, color: this });
+    } else {
+      let answer = options.tone;
+      if (!options.background || !options.contrastCurve) {
+        return answer;
+      }
+      const bgTone = options.background.getTone();
+      const desiredRatio = options.contrastCurve.get(context.contrastLevel);
+      answer = Contrast.ratioOfTones(bgTone, answer) >= desiredRatio && context.contrastLevel >= 0 ? answer : DynamicColor.foregroundTone(bgTone, desiredRatio);
+      if (options.isBackground && !this.name.endsWith("_fixed_dim")) {
+        if (answer >= 57) {
+          answer = clampDouble(65, 100, answer);
+        } else {
+          answer = clampDouble(0, 49, answer);
+        }
+      }
+      if (!options.secondBackground) {
+        return answer;
+      }
+      const [bg1, bg2] = [options.background, options.secondBackground];
+      const [bgTone1, bgTone2] = [bg1.getTone(), bg2.getTone()];
+      const [upper, lower] = [
+        Math.max(bgTone1, bgTone2),
+        Math.min(bgTone1, bgTone2)
+      ];
+      if (Contrast.ratioOfTones(upper, answer) >= desiredRatio && Contrast.ratioOfTones(lower, answer) >= desiredRatio) {
+        return answer;
+      }
+      const lightOption = Contrast.lighter(upper, desiredRatio);
+      const darkOption = Contrast.darker(lower, desiredRatio);
+      const availables = [];
+      if (lightOption !== -1) availables.push(lightOption);
+      if (darkOption !== -1) availables.push(darkOption);
+      const prefersLight = DynamicColor.tonePrefersLightForeground(bgTone1) || DynamicColor.tonePrefersLightForeground(bgTone2);
+      if (prefersLight) {
+        return lightOption < 0 ? 100 : lightOption;
+      }
+      if (availables.length === 1) {
+        return availables[0];
+      }
+      return darkOption < 0 ? 0 : darkOption;
+    }
+  }
+}
+const highestSurface$1 = (context, colorService) => {
+  if (colorService instanceof ColorApi) {
+    return context.isDark ? colorService.get("surfaceBright") : colorService.get("surfaceDim");
+  } else {
+    return context.isDark ? colorService.get("surfaceBright") : colorService.get("surfaceDim");
+  }
+};
+const defaultColors = ({
+  colors,
+  context: c,
+  palettes
+}) => {
+  const getColor = (key) => {
+    return colors.get(key);
+  };
+  return {
+    ////////////////////////////////////////////////////////////////
+    // Surfaces [S]                                               //
+    ////////////////////////////////////////////////////////////////
+    surface: {
+      palette: () => palettes.get("neutral"),
+      tone: () => {
+        if (c.isDark) {
+          return 4;
+        } else {
+          if (Hct.isYellow(palettes.get("neutral").hue)) {
+            return 99;
+          } else if (c.variant.name === "vibrant") {
+            return 97;
+          } else {
+            return 98;
+          }
+        }
+      },
+      isBackground: true
+    },
+    surfaceDim: {
+      palette: () => palettes.get("neutral"),
+      tone: () => {
+        if (c.isDark) {
+          return 4;
+        } else {
+          if (Hct.isYellow(palettes.get("neutral").hue)) {
+            return 90;
+          } else if (c.variant.name === "vibrant") {
+            return 85;
+          } else {
+            return 87;
+          }
+        }
+      },
+      isBackground: true,
+      chromaMultiplier: () => {
+        if (!c.isDark) {
+          if (c.variant.name === "neutral") {
+            return 2.5;
+          } else if (c.variant.name === "tonalSpot") {
+            return 1.7;
+          } else if (c.variant.name === "expressive") {
+            return Hct.isYellow(palettes.get("neutral").hue) ? 2.7 : 1.75;
+          } else if (c.variant.name === "vibrant") {
+            return 1.36;
+          }
+        }
+        return 1;
+      }
+    },
+    surfaceBright: {
+      palette: () => palettes.get("neutral"),
+      tone: () => {
+        if (c.isDark) {
+          return 18;
+        } else {
+          if (Hct.isYellow(palettes.get("neutral").hue)) {
+            return 99;
+          } else if (c.variant.name === "vibrant") {
+            return 97;
+          } else {
+            return 98;
+          }
+        }
+      },
+      isBackground: true,
+      chromaMultiplier: () => {
+        if (c.isDark) {
+          if (c.variant.name === "neutral") {
+            return 2.5;
+          } else if (c.variant.name === "tonalSpot") {
+            return 1.7;
+          } else if (c.variant.name === "expressive") {
+            return Hct.isYellow(palettes.get("neutral").hue) ? 2.7 : 1.75;
+          } else if (c.variant.name === "vibrant") {
+            return 1.36;
+          }
+        }
+        return 1;
+      }
+    },
+    surfaceContainerLowest: {
+      palette: () => palettes.get("neutral"),
+      tone: () => c.isDark ? 0 : 100,
+      isBackground: true
+    },
+    surfaceContainerLow: {
+      palette: () => palettes.get("neutral"),
+      tone: () => {
+        if (c.isDark) {
+          return 6;
+        } else {
+          if (Hct.isYellow(palettes.get("neutral").hue)) {
+            return 98;
+          } else if (c.variant.name === "vibrant") {
+            return 95;
+          } else {
+            return 96;
+          }
+        }
+      },
+      isBackground: true,
+      chromaMultiplier: () => {
+        if (c.variant.name === "neutral") {
+          return 1.3;
+        } else if (c.variant.name === "tonalSpot") {
+          return 1.25;
+        } else if (c.variant.name === "expressive") {
+          return Hct.isYellow(palettes.get("neutral").hue) ? 1.3 : 1.15;
+        } else if (c.variant.name === "vibrant") {
+          return 1.08;
+        }
+        return 1;
+      }
+    },
+    surfaceContainer: {
+      palette: () => palettes.get("neutral"),
+      tone: () => {
+        if (c.isDark) {
+          return 9;
+        } else {
+          if (Hct.isYellow(palettes.get("neutral").hue)) {
+            return 96;
+          } else if (c.variant.name === "vibrant") {
+            return 92;
+          } else {
+            return 94;
+          }
+        }
+      },
+      isBackground: true,
+      chromaMultiplier: () => {
+        if (c.variant.name === "neutral") {
+          return 1.6;
+        } else if (c.variant.name === "tonalSpot") {
+          return 1.4;
+        } else if (c.variant.name === "expressive") {
+          return Hct.isYellow(palettes.get("neutral").hue) ? 1.6 : 1.3;
+        } else if (c.variant.name === "vibrant") {
+          return 1.15;
+        }
+        return 1;
+      }
+    },
+    surfaceContainerHigh: {
+      palette: () => palettes.get("neutral"),
+      tone: () => {
+        if (c.isDark) {
+          return 12;
+        } else {
+          if (Hct.isYellow(palettes.get("neutral").hue)) {
+            return 94;
+          } else if (c.variant.name === "vibrant") {
+            return 90;
+          } else {
+            return 92;
+          }
+        }
+      },
+      isBackground: true,
+      chromaMultiplier: () => {
+        if (c.variant.name === "neutral") {
+          return 1.9;
+        } else if (c.variant.name === "tonalSpot") {
+          return 1.5;
+        } else if (c.variant.name === "expressive") {
+          return Hct.isYellow(palettes.get("neutral").hue) ? 1.95 : 1.45;
+        } else if (c.variant.name === "vibrant") {
+          return 1.22;
+        }
+        return 1;
+      }
+    },
+    surfaceContainerHighest: {
+      palette: () => palettes.get("neutral"),
+      tone: () => {
+        if (c.isDark) {
+          return 15;
+        } else {
+          if (Hct.isYellow(palettes.get("neutral").hue)) {
+            return 92;
+          } else if (c.variant.name === "vibrant") {
+            return 88;
+          } else {
+            return 90;
+          }
+        }
+      },
+      isBackground: true,
+      chromaMultiplier: () => {
+        if (c.variant.name === "neutral") {
+          return 2.2;
+        } else if (c.variant.name === "tonalSpot") {
+          return 1.7;
+        } else if (c.variant.name === "expressive") {
+          return Hct.isYellow(palettes.get("neutral").hue) ? 2.3 : 1.6;
+        } else if (c.variant.name === "vibrant") {
+          return 1.29;
+        } else {
+          return 1;
+        }
+      }
+    },
+    onSurface: {
+      palette: () => palettes.get("neutral"),
+      tone: () => {
+        if (c.variant.name === "vibrant") {
+          return tMaxC(palettes.get("neutral"), 0, 100, 1.1);
+        } else {
+          return getInitialToneFromBackground(highestSurface$1(c, colors));
+        }
+      },
+      chromaMultiplier: () => {
+        if (c.variant.name === "neutral") {
+          return 2.2;
+        } else if (c.variant.name === "tonalSpot") {
+          return 1.7;
+        } else if (c.variant.name === "expressive") {
+          return Hct.isYellow(palettes.get("neutral").hue) ? c.isDark ? 3 : 2.3 : 1.6;
+        }
+        return 1;
+      },
+      background: () => highestSurface$1(c, colors),
+      contrastCurve: () => c.isDark ? getCurve(11) : getCurve(9)
+    },
+    onSurfaceVariant: {
+      palette: () => palettes.get("neutralVariant"),
+      chromaMultiplier: () => {
+        if (c.variant.name === "neutral") {
+          return 2.2;
+        } else if (c.variant.name === "tonalSpot") {
+          return 1.7;
+        } else if (c.variant.name === "expressive") {
+          return Hct.isYellow(palettes.get("neutral").hue) ? c.isDark ? 3 : 2.3 : 1.6;
+        }
+        return 1;
+      },
+      background: () => highestSurface$1(c, colors),
+      contrastCurve: () => c.isDark ? getCurve(6) : getCurve(4.5)
+    },
+    outline: {
+      palette: () => palettes.get("neutralVariant"),
+      chromaMultiplier: () => {
+        if (c.variant.name === "neutral") {
+          return 2.2;
+        } else if (c.variant.name === "tonalSpot") {
+          return 1.7;
+        } else if (c.variant.name === "expressive") {
+          return Hct.isYellow(palettes.get("neutral").hue) ? c.isDark ? 3 : 2.3 : 1.6;
+        }
+        return 1;
+      },
+      background: () => highestSurface$1(c, colors),
+      contrastCurve: () => getCurve(3)
+    },
+    outlineVariant: {
+      palette: () => palettes.get("neutralVariant"),
+      chromaMultiplier: () => {
+        if (c.variant.name === "neutral") {
+          return 2.2;
+        } else if (c.variant.name === "tonalSpot") {
+          return 1.7;
+        } else if (c.variant.name === "expressive") {
+          return Hct.isYellow(palettes.get("neutral").hue) ? c.isDark ? 3 : 2.3 : 1.6;
+        }
+        return 1;
+      },
+      background: () => highestSurface$1(c, colors),
+      contrastCurve: () => getCurve(1.5)
+    },
+    inverseSurface: {
+      palette: () => palettes.get("neutral"),
+      tone: () => c.isDark ? 98 : 4,
+      isBackground: true
+    },
+    inverseOnSurface: {
+      palette: () => palettes.get("neutral"),
+      tone: () => c.isDark ? 20 : 95,
+      background: () => colors.get("inverseSurface"),
+      contrastCurve: () => getCurve(7)
+    },
+    ////////////////////////////////////////////////////////////////
+    // Primaries [P]                                              //
+    ////////////////////////////////////////////////////////////////
+    primary: {
+      palette: () => palettes.get("primary"),
+      tone: () => {
+        if (c.variant.name === "neutral") {
+          return c.isDark ? 80 : 40;
+        } else if (c.variant.name === "tonalSpot") {
+          if (c.isDark) {
+            return 80;
+          } else {
+            return tMaxC(palettes.get("primary"));
+          }
+        } else if (c.variant.name === "expressive") {
+          return tMaxC(
+            palettes.get("primary"),
+            0,
+            Hct.isYellow(palettes.get("primary").hue) ? 25 : Hct.isCyan(palettes.get("primary").hue) ? 88 : 98
+          );
+        } else {
+          return tMaxC(
+            palettes.get("primary"),
+            0,
+            Hct.isCyan(palettes.get("primary").hue) ? 88 : 98
+          );
+        }
+      },
+      isBackground: true,
+      background: () => highestSurface$1(c, colors),
+      contrastCurve: () => getCurve(4.5),
+      adjustTone: () => toneDeltaPair(
+        colors.get("primaryContainer"),
+        colors.get("primary"),
+        5,
+        "relative_lighter",
+        true,
+        "farther"
+      )
+    },
+    primaryDim: {
+      palette: () => palettes.get("primary"),
+      tone: () => {
+        if (c.variant.name === "neutral") {
+          return 85;
+        } else if (c.variant.name === "tonalSpot") {
+          return tMaxC(palettes.get("primary"), 0, 90);
+        } else {
+          return tMaxC(palettes.get("primary"));
+        }
+      },
+      isBackground: true,
+      background: () => getColor("surfaceContainerHigh"),
+      contrastCurve: () => getCurve(4.5),
+      adjustTone: () => toneDeltaPair(
+        colors.get("primaryDim"),
+        colors.get("primary"),
+        5,
+        "darker",
+        true,
+        "farther"
+      )
+    },
+    onPrimary: {
+      palette: () => palettes.get("primary"),
+      background: () => colors.get("primary"),
+      contrastCurve: () => getCurve(6)
+    },
+    primaryContainer: {
+      palette: () => palettes.get("primary"),
+      tone: () => {
+        if (c.variant.name === "neutral") {
+          return c.isDark ? 30 : 90;
+        } else if (c.variant.name === "tonalSpot") {
+          return c.isDark ? tMinC(palettes.get("primary"), 35, 93) : tMaxC(palettes.get("primary"), 0, 90);
+        } else if (c.variant.name === "expressive") {
+          return c.isDark ? tMaxC(palettes.get("primary"), 30, 93) : tMaxC(
+            palettes.get("primary"),
+            78,
+            Hct.isCyan(palettes.get("primary").hue) ? 88 : 90
+          );
+        }
+        return c.isDark ? tMinC(palettes.get("primary"), 66, 93) : tMaxC(
+          palettes.get("primary"),
+          66,
+          Hct.isCyan(palettes.get("primary").hue) ? 88 : 93
+        );
+      },
+      isBackground: true,
+      background: () => highestSurface$1(c, colors),
+      contrastCurve: () => c.contrastLevel > 0 ? getCurve(1.5) : void 0
+    },
+    onPrimaryContainer: {
+      palette: () => palettes.get("primary"),
+      background: () => colors.get("primaryContainer"),
+      contrastCurve: () => getCurve(6)
+    },
+    primaryFixed: {
+      palette: () => palettes.get("primary"),
+      tone: () => {
+        return c.temp(
+          {
+            isDark: false,
+            contrastLevel: 0
+          },
+          () => {
+            const color = getColor("primaryContainer");
+            return color.getTone();
+          }
+        );
+      },
+      isBackground: true,
+      background: () => highestSurface$1(c, colors),
+      contrastCurve: () => c.contrastLevel > 0 ? getCurve(1.5) : void 0
+    },
+    primaryFixedDim: {
+      palette: () => palettes.get("primary"),
+      tone: () => colors.get("primaryFixed").getTone(),
+      isBackground: true,
+      adjustTone: () => toneDeltaPair(
+        getColor("primaryFixedDim"),
+        getColor("primaryFixed"),
+        5,
+        "darker",
+        true,
+        "exact"
+      )
+    },
+    onPrimaryFixed: {
+      palette: () => palettes.get("primary"),
+      background: () => colors.get("primaryFixedDim"),
+      contrastCurve: () => getCurve(7)
+    },
+    onPrimaryFixedVariant: {
+      palette: () => palettes.get("primary"),
+      background: () => colors.get("primaryFixedDim"),
+      contrastCurve: () => getCurve(4.5)
+    },
+    inversePrimary: {
+      palette: () => palettes.get("primary"),
+      tone: () => tMaxC(palettes.get("primary")),
+      background: () => colors.get("inverseSurface"),
+      contrastCurve: () => getCurve(6)
+    },
+    ////////////////////////////////////////////////////////////////
+    // Secondaries [Q]                                            //
+    ////////////////////////////////////////////////////////////////
+    secondary: {
+      palette: () => palettes.get("secondary"),
+      tone: () => {
+        if (c.variant.name === "neutral") {
+          return c.isDark ? tMinC(palettes.get("secondary"), 0, 98) : tMaxC(palettes.get("secondary"));
+        } else if (c.variant.name === "vibrant") {
+          return tMaxC(palettes.get("secondary"), 0, c.isDark ? 90 : 98);
+        } else {
+          return c.isDark ? 80 : tMaxC(palettes.get("secondary"));
+        }
+      },
+      isBackground: true,
+      background: () => highestSurface$1(c, colors),
+      contrastCurve: () => getCurve(4.5),
+      adjustTone: () => toneDeltaPair(
+        getColor("secondaryContainer"),
+        getColor("secondary"),
+        5,
+        "relative_lighter",
+        true,
+        "farther"
+      )
+    },
+    secondaryDim: {
+      palette: () => palettes.get("secondary"),
+      tone: () => {
+        if (c.variant.name === "neutral") {
+          return 85;
+        } else {
+          return tMaxC(palettes.get("secondary"), 0, 90);
+        }
+      },
+      isBackground: true,
+      background: () => getColor("surfaceContainerHigh"),
+      contrastCurve: () => getCurve(4.5),
+      adjustTone: () => toneDeltaPair(
+        getColor("secondaryDim"),
+        getColor("secondary"),
+        5,
+        "darker",
+        true,
+        "farther"
+      )
+    },
+    onSecondary: {
+      palette: () => palettes.get("secondary"),
+      background: () => getColor("secondary"),
+      contrastCurve: () => getCurve(6)
+    },
+    secondaryContainer: {
+      palette: () => palettes.get("secondary"),
+      tone: () => {
+        if (c.variant.name === "vibrant") {
+          return c.isDark ? tMinC(palettes.get("secondary"), 30, 40) : tMaxC(palettes.get("secondary"), 84, 90);
+        } else if (c.variant.name === "expressive") {
+          return c.isDark ? 15 : tMaxC(palettes.get("secondary"), 90, 95);
+        } else {
+          return c.isDark ? 25 : 90;
+        }
+      },
+      isBackground: true,
+      background: () => highestSurface$1(c, colors),
+      adjustTone: () => void 0,
+      contrastCurve: () => c.contrastLevel > 0 ? getCurve(1.5) : void 0
+    },
+    onSecondaryContainer: {
+      palette: () => palettes.get("secondary"),
+      background: () => getColor("secondaryContainer"),
+      contrastCurve: () => getCurve(6)
+    },
+    secondaryFixed: {
+      palette: () => palettes.get("secondary"),
+      tone: () => {
+        return c.temp(
+          {
+            isDark: false,
+            contrastLevel: 0
+          },
+          () => {
+            const color = getColor("secondaryContainer");
+            return color.getTone();
+          }
+        );
+      },
+      isBackground: true,
+      background: () => highestSurface$1(c, colors),
+      contrastCurve: () => c.contrastLevel > 0 ? getCurve(1.5) : void 0
+    },
+    secondaryFixedDim: {
+      palette: () => palettes.get("secondary"),
+      tone: () => getColor("secondaryFixed").getTone(),
+      isBackground: true,
+      adjustTone: () => toneDeltaPair(
+        getColor("secondaryFixedDim"),
+        getColor("secondaryFixed"),
+        5,
+        "darker",
+        true,
+        "exact"
+      )
+    },
+    onSecondaryFixed: {
+      palette: () => palettes.get("secondary"),
+      background: () => getColor("secondaryFixedDim"),
+      contrastCurve: () => getCurve(7)
+    },
+    onSecondaryFixedVariant: {
+      palette: () => palettes.get("secondary"),
+      background: () => getColor("secondaryFixedDim"),
+      contrastCurve: () => getCurve(4.5)
+    },
+    ////////////////////////////////////////////////////////////////
+    // Tertiaries [T]                                             //
+    ////////////////////////////////////////////////////////////////
+    tertiary: {
+      palette: () => palettes.get("tertiary"),
+      tone: () => {
+        if (c.variant.name === "expressive" || c.variant.name === "vibrant") {
+          return tMaxC(
+            palettes.get("tertiary"),
+            0,
+            Hct.isCyan(palettes.get("tertiary").hue) ? 88 : c.isDark ? 98 : 100
+          );
+        } else {
+          return c.isDark ? tMaxC(palettes.get("tertiary"), 0, 98) : tMaxC(palettes.get("tertiary"));
+        }
+      },
+      isBackground: true,
+      background: () => highestSurface$1(c, colors),
+      contrastCurve: () => getCurve(4.5),
+      adjustTone: () => toneDeltaPair(
+        getColor("tertiaryContainer"),
+        getColor("tertiary"),
+        5,
+        "relative_lighter",
+        true,
+        "farther"
+      )
+    },
+    tertiaryDim: {
+      palette: () => palettes.get("tertiary"),
+      tone: () => {
+        if (c.variant.name === "tonalSpot") {
+          return tMaxC(palettes.get("tertiary"), 0, 90);
+        } else {
+          return tMaxC(palettes.get("tertiary"));
+        }
+      },
+      isBackground: true,
+      background: () => getColor("surfaceContainerHigh"),
+      contrastCurve: () => getCurve(4.5),
+      adjustTone: () => toneDeltaPair(
+        getColor("tertiaryDim"),
+        getColor("tertiary"),
+        5,
+        "darker",
+        true,
+        "farther"
+      )
+    },
+    onTertiary: {
+      palette: () => palettes.get("tertiary"),
+      background: () => getColor("tertiary"),
+      contrastCurve: () => getCurve(6)
+    },
+    tertiaryContainer: {
+      palette: () => palettes.get("tertiary"),
+      tone: () => {
+        if (c.variant.name === "neutral") {
+          return c.isDark ? tMaxC(palettes.get("tertiary"), 0, 93) : tMaxC(palettes.get("tertiary"), 0, 96);
+        } else if (c.variant.name === "tonalSpot") {
+          return tMaxC(palettes.get("tertiary"), 0, c.isDark ? 93 : 100);
+        } else if (c.variant.name === "expressive") {
+          return tMaxC(
+            palettes.get("tertiary"),
+            75,
+            Hct.isCyan(palettes.get("tertiary").hue) ? 88 : c.isDark ? 93 : 100
+          );
+        } else {
+          return c.isDark ? tMaxC(palettes.get("tertiary"), 0, 93) : tMaxC(palettes.get("tertiary"), 72, 100);
+        }
+      },
+      isBackground: true,
+      background: () => highestSurface$1(c, colors),
+      adjustTone: () => void 0,
+      contrastCurve: () => c.contrastLevel > 0 ? getCurve(1.5) : void 0
+    },
+    onTertiaryContainer: {
+      palette: () => palettes.get("tertiary"),
+      background: () => getColor("tertiaryContainer"),
+      contrastCurve: () => getCurve(6)
+    },
+    tertiaryFixed: {
+      palette: () => palettes.get("tertiary"),
+      tone: () => {
+        return c.temp(
+          {
+            isDark: false,
+            contrastLevel: 0
+          },
+          () => {
+            const color = getColor("tertiaryContainer");
+            return color.getTone();
+          }
+        );
+      },
+      isBackground: true,
+      background: () => highestSurface$1(c, colors),
+      contrastCurve: () => c.contrastLevel > 0 ? getCurve(1.5) : void 0
+    },
+    tertiaryFixedDim: {
+      palette: () => palettes.get("tertiary"),
+      tone: () => getColor("tertiaryFixed").getTone(),
+      isBackground: true,
+      adjustTone: () => toneDeltaPair(
+        getColor("tertiaryFixedDim"),
+        getColor("tertiaryFixed"),
+        5,
+        "darker",
+        true,
+        "exact"
+      )
+    },
+    onTertiaryFixed: {
+      palette: () => palettes.get("tertiary"),
+      background: () => getColor("tertiaryFixedDim"),
+      contrastCurve: () => getCurve(7)
+    },
+    onTertiaryFixedVariant: {
+      palette: () => palettes.get("tertiary"),
+      background: () => getColor("tertiaryFixedDim"),
+      contrastCurve: () => getCurve(4.5)
+    },
+    ////////////////////////////////////////////////////////////////
+    // Errors [E]                                                 //
+    ////////////////////////////////////////////////////////////////
+    error: {
+      palette: () => palettes.get("error"),
+      tone: () => {
+        return c.isDark ? tMinC(palettes.get("error"), 0, 98) : tMaxC(palettes.get("error"));
+      },
+      isBackground: true,
+      background: () => highestSurface$1(c, colors),
+      contrastCurve: () => getCurve(4.5),
+      adjustTone: () => toneDeltaPair(
+        colors.get("errorContainer"),
+        colors.get("error"),
+        5,
+        "relative_lighter",
+        true,
+        "farther"
+      )
+    },
+    errorDim: {
+      palette: () => palettes.get("error"),
+      tone: () => tMinC(palettes.get("error")),
+      isBackground: true,
+      background: () => getColor("surfaceContainerHigh"),
+      contrastCurve: () => getCurve(4.5),
+      adjustTone: () => toneDeltaPair(
+        getColor("errorDim"),
+        getColor("error"),
+        5,
+        "darker",
+        true,
+        "farther"
+      )
+    },
+    onError: {
+      palette: () => palettes.get("error"),
+      background: () => colors.get("error"),
+      contrastCurve: () => getCurve(6)
+    },
+    errorContainer: {
+      palette: () => palettes.get("error"),
+      tone: () => {
+        return c.isDark ? tMinC(palettes.get("error"), 30, 93) : tMaxC(palettes.get("error"), 0, 90);
+      },
+      isBackground: true,
+      background: () => highestSurface$1(c, colors),
+      adjustTone: () => void 0,
+      contrastCurve: () => c.contrastLevel > 0 ? getCurve(1.5) : void 0
+    },
+    onErrorContainer: {
+      palette: () => palettes.get("error"),
+      background: () => colors.get("errorContainer"),
+      contrastCurve: () => getCurve(4.5)
+    },
+    /////////////////////////////////////////////////////////////////
+    // Remapped Colors                                             //
+    /////////////////////////////////////////////////////////////////
+    surfaceVariant: {
+      alias: "surfaceContainerHighest"
+    },
+    surfaceTint: {
+      alias: "primary"
+    },
+    background: {
+      alias: "surface"
+    },
+    onBackground: {
+      alias: "onSurface"
+    }
+  };
+};
+function capitalizeFirstLetter(string) {
+  return string.charAt(0).toUpperCase() + string.slice(1);
+}
+class ColorApi {
+  constructor({
+    colorManager,
+    context
+  }) {
+    __publicField(this, "colorManager");
+    __publicField(this, "context");
+    __publicField(this, "api");
+    this.context = context;
+    this.colorManager = colorManager;
+    this.context.onUpdate((changed) => {
+      if (changed.includes("variant")) {
+        this.colorManager.clear();
+        this.addColors(this.context.variant.colors);
+      }
+    });
+  }
+  getAll() {
+    return this.colorManager.getAll();
+  }
+  addColor(key, color) {
+    return this.colorManager.createOrUpdate(key, color);
+  }
+  addColors(args) {
+    if (!this.api)
+      throw new Error(
+        "The API is not initialized. Please call bootstrap() before calling addColors()."
+      );
+    if (typeof args === "function") {
+      args = args(this.api);
+    }
+    if (args) {
+      Object.entries(args).forEach(([name, colorOption]) => {
+        this.addColor(name, colorOption);
+      });
+    }
+  }
+  get(key) {
+    return this.colorManager.get(key);
+  }
+  remove(key) {
+    return this.colorManager.remove(key);
+  }
+  update(key, newColor) {
+    return this.colorManager.createOrUpdate(key, newColor);
+  }
+  addFromCustomPalette(key) {
+    if (this.context.variant.colorsFromCustomPalette) {
+      return this.addColors(this.context.variant.colorsFromCustomPalette(key));
+    }
+    const colorKey = key;
+    const colorDimKey = colorKey + "Dim";
+    const ColorKey = capitalizeFirstLetter(key);
+    const onColorKey = "on" + ColorKey;
+    const colorContainerKey = colorKey + "Container";
+    const onColorContainerKey = "on" + ColorKey + "Container";
+    const colorFixedKey = colorKey + "Fixed";
+    const colorFixedDimKey = colorKey + "FixedDim";
+    const onColorFixedKey = "on" + ColorKey + "Fixed";
+    const onColorFixedVariantKey = "on" + ColorKey + "FixedVariant";
+    const colors = ({ palettes, colors: colors2, context: ctx }) => ({
+      [colorKey]: {
+        palette: () => palettes.get(colorKey),
+        tone: () => {
+          if (ctx.variant.name === "neutral") {
+            return ctx.isDark ? tMinC(palettes.get(colorKey), 0, 98) : tMaxC(palettes.get(colorKey));
+          } else if (ctx.variant.name === "vibrant") {
+            return tMaxC(palettes.get(colorKey), 0, ctx.isDark ? 90 : 98);
+          } else {
+            return ctx.isDark ? 80 : tMaxC(palettes.get(colorKey));
+          }
+        },
+        isBackground: true,
+        background: () => highestSurface$1(ctx, this),
+        contrastCurve: () => getCurve(4.5),
+        adjustTone: () => toneDeltaPair(
+          colors2.get(colorContainerKey),
+          colors2.get(colorKey),
+          5,
+          "relative_lighter",
+          true,
+          "farther"
+        )
+      },
+      [colorDimKey]: {
+        palette: () => palettes.get(colorKey),
+        tone: () => {
+          if (ctx.variant.name === "neutral") {
+            return 85;
+          } else {
+            return tMaxC(palettes.get(colorKey), 0, 90);
+          }
+        },
+        isBackground: true,
+        background: () => this.get("surfaceContainerHigh"),
+        contrastCurve: () => getCurve(4.5),
+        adjustTone: () => toneDeltaPair(
+          this.get(colorDimKey),
+          this.get(colorKey),
+          5,
+          "darker",
+          true,
+          "farther"
+        )
+      },
+      [onColorKey]: {
+        palette: () => palettes.get(colorKey),
+        background: () => this.get(colorKey),
+        contrastCurve: () => getCurve(6)
+      },
+      [colorContainerKey]: {
+        palette: () => palettes.get(colorKey),
+        tone: () => {
+          if (ctx.variant.name === "vibrant") {
+            return ctx.isDark ? tMinC(palettes.get(colorKey), 30, 40) : tMaxC(palettes.get(colorKey), 84, 90);
+          } else if (ctx.variant.name === "expressive") {
+            return ctx.isDark ? 15 : tMaxC(palettes.get(colorKey), 90, 95);
+          } else {
+            return ctx.isDark ? 25 : 90;
+          }
+        },
+        isBackground: true,
+        background: () => highestSurface$1(ctx, this),
+        adjustTone: () => void 0,
+        contrastCurve: () => ctx.contrastLevel > 0 ? getCurve(1.5) : void 0
+      },
+      [onColorContainerKey]: {
+        palette: () => palettes.get(colorKey),
+        background: () => this.get(colorContainerKey),
+        contrastCurve: () => getCurve(6)
+      },
+      [colorFixedKey]: {
+        palette: () => palettes.get(colorKey),
+        tone: () => {
+          return ctx.temp({ isDark: false, contrastLevel: 0 }, () => {
+            const color = this.get(colorContainerKey);
+            return color.getTone();
+          });
+        },
+        isBackground: true,
+        background: () => highestSurface$1(ctx, this),
+        contrastCurve: () => ctx.contrastLevel > 0 ? getCurve(1.5) : void 0
+      },
+      [colorFixedDimKey]: {
+        palette: () => palettes.get(colorKey),
+        tone: () => this.get(colorFixedKey).getTone(),
+        isBackground: true,
+        adjustTone: () => toneDeltaPair(
+          this.get(colorFixedDimKey),
+          this.get(colorFixedKey),
+          5,
+          "darker",
+          true,
+          "exact"
+        )
+      },
+      [onColorFixedKey]: {
+        palette: () => palettes.get(colorKey),
+        background: () => this.get(colorFixedDimKey),
+        contrastCurve: () => getCurve(7)
+      },
+      [onColorFixedVariantKey]: {
+        palette: () => palettes.get(colorKey),
+        background: () => this.get(colorFixedDimKey),
+        contrastCurve: () => getCurve(4.5)
+      }
+    });
+    this.addColors(colors);
+  }
+}
+class ColorManager {
+  constructor(args) {
+    __publicField(this, "colorMap", /* @__PURE__ */ new Map());
+    __publicField(this, "context");
+    this.context = args.context;
+  }
+  createOrUpdate(key, args) {
+    let colorEntity = this.colorMap.get(key);
+    if ("alias" in args) {
+      colorEntity = new ColorAlias(key, args.alias, this);
+    } else if ("hex" in args) {
+      colorEntity = new ColorFromHex(key, args.hex);
+    } else {
+      try {
+        if (colorEntity instanceof ColorFromPalette) {
+          colorEntity.update(args);
+        } else {
+          colorEntity = new ColorFromPalette(key, args, this.context);
+        }
+      } catch (e) {
+        console.error(e);
+        throw new Error(`Invalid color options provided for ${key}`);
+      }
+    }
+    this.colorMap.set(key, colorEntity);
+    return colorEntity;
+  }
+  remove(key) {
+    return this.colorMap.delete(key);
+  }
+  clear() {
+    this.colorMap.clear();
+  }
+  get(key) {
+    const colorEntity = this.colorMap.get(key);
+    if (colorEntity) {
+      return colorEntity;
+    } else {
+      throw new Error(`Color ${key} does not exist`);
+    }
+  }
+  getAll() {
+    return this.colorMap;
+  }
+}
+const ColorModule = {
+  colorManager: asClass(ColorManager).singleton(),
+  colorApi: asClass(ColorApi).singleton()
+};
+const AppModule = {
+  api: asClass(API).singleton()
+};
+class PluginApi {
+  constructor() {
+    __publicField(this, "plugins", /* @__PURE__ */ new Map());
+  }
+  addPlugin(plugin) {
+    this.plugins.set(plugin.name, plugin);
+  }
+  initPlugins(api) {
+    const plugins = new Map(this.plugins);
+    let size = 0;
+    this.plugins = /* @__PURE__ */ new Map();
+    do {
+      size = plugins.size;
+      plugins.forEach((plugin, key) => {
+        const deps = plugin.dependencies.filter(
+          (dep) => !this.plugins.has(new dep().name)
+        );
+        if (deps.length === 0) {
+          this.plugins.set(plugin.name, plugin.init(api));
+          plugins.delete(key);
+        }
+      });
+    } while (plugins.size != 0 && plugins.size < size);
+    if (plugins.size > 0)
+      throw new Error(
+        "Some plugins couldn't be loaded due to missing dependencies: " + Array.from(plugins.keys())
+      );
+  }
+  async loadPlugins() {
+    var _a, _b;
+    for (const plugin of this.plugins.values()) {
+      await ((_b = (_a = plugin.getInstance()).onLoad) == null ? void 0 : _b.call(_a));
+    }
+  }
+  getPlugin(plugin) {
+    const pluginInstance = this.plugins.get(new plugin().name);
+    if (!pluginInstance) throw new Error(`Plugin ${plugin.name} not found`);
+    return pluginInstance;
+  }
+}
+const PluginModule = {
+  pluginApi: asClass(PluginApi).singleton()
+};
+class Context {
+  constructor() {
+    __publicField(this, "_options");
+    __publicField(this, "_temOptions", null);
+    __publicField(this, "updateCallbacks", []);
+    this.onUpdate((changed) => {
+      if (changed.includes("variant")) {
+        this.variant.init(this);
+      }
+    });
+  }
+  /**
+   * Runs the provided callback with a proxied Context and records which Context
+   * properties (getters) were accessed during its execution.
+   *
+   * This helps determine dependencies of the callback on the Context.
+   *
+   * Example usage:
+   * const { result, dependencies } = Context.trackDependencies(ctx, (c) => cb(c));
+   */
+  static trackDependencies(context, callback) {
+    const dependencies = /* @__PURE__ */ new Set();
+    const isGetterOnContext = (prop) => {
+      if (typeof prop !== "string") return false;
+      const desc = Object.getOwnPropertyDescriptor(Context.prototype, prop);
+      return !!desc && typeof desc.get === "function";
+    };
+    const proxy = new Proxy(context, {
+      get(target, prop, receiver) {
+        if (isGetterOnContext(prop)) {
+          dependencies.add(prop);
+        }
+        return Reflect.get(target, prop, receiver);
+      }
+    });
+    const result = callback(proxy);
+    return { result, dependencies: Array.from(dependencies) };
+  }
+  set(options) {
+    if (this._options) {
+      console.error(this._options);
+      throw new Error("Options already set");
+    }
+    if (typeof options.sourceColor === "string") {
+      options.sourceColor = Hct.fromInt(argbFromHex(options.sourceColor));
+    }
+    const changed = [];
+    for (const key of Object.keys(options)) {
+      changed.push(key);
+    }
+    this._options = options;
+    if (changed.length > 0) {
+      this.updateCallbacks.forEach((callback) => callback(changed));
+    }
+  }
+  update(args) {
+    const options = this._options;
+    if (!options) {
+      throw new Error("Options not found");
+    }
+    if (typeof args.sourceColor === "string") {
+      args.sourceColor = Hct.fromInt(argbFromHex(args.sourceColor));
+    }
+    const changed = [];
+    for (const key of Object.keys(args)) {
+      if (args[key] !== options[key]) {
+        changed.push(key);
+      }
+    }
+    this._options = {
+      ...options,
+      ...args
+    };
+    if (changed.length > 0) {
+      this.updateCallbacks.forEach((callback) => callback(changed));
+    }
+  }
+  getOptions() {
+    let options;
+    if (this._temOptions) {
+      options = this._temOptions;
+    } else {
+      options = this._options;
+    }
+    if (!options) {
+      throw new Error("Options not found");
+    }
+    return options;
+  }
+  set darkMode(isDark) {
+    this.update({ isDark });
+  }
+  get isDark() {
+    return this.getOptions().isDark;
+  }
+  set contrastLevel(contrastLevel) {
+    this.update({ contrastLevel });
+  }
+  get contrastLevel() {
+    return this.getOptions().contrastLevel;
+  }
+  set sourceColor(sourceColor) {
+    this.update({ sourceColor });
+  }
+  get sourceColor() {
+    let sourceColor = this.getOptions().sourceColor;
+    if (typeof sourceColor === "string") {
+      sourceColor = Hct.fromInt(argbFromHex(sourceColor));
+    }
+    return sourceColor;
+  }
+  set variant(variant2) {
+    this.update({ variant: variant2 });
+  }
+  get variant() {
+    return this.getOptions().variant;
+  }
+  temp(args, callback) {
+    const previousOptions = this.getOptions();
+    this._temOptions = {
+      ...previousOptions,
+      ...args
+    };
+    const result = callback();
+    this._temOptions = null;
+    return result;
+  }
+  onUpdate(callback) {
+    this.updateCallbacks.push(callback);
+  }
+}
+const ContextModule = {
+  context: asClass(Context).singleton()
+};
+class Palette {
+  constructor(name, callback, context) {
+    __publicField(this, "cache", /* @__PURE__ */ new Map());
+    __publicField(this, "hueCache", null);
+    __publicField(this, "chromaCache", null);
+    __publicField(this, "dependencies", null);
+    this.name = name;
+    this.callback = callback;
+    this.context = context;
+    this.update([]);
+  }
+  static fromVariant(name, color, ctx) {
+    const callback = (context) => {
+      return context.variant.customPalettes(context, color);
+    };
+    return new Palette(name, callback, ctx);
+  }
+  update(change) {
+    let result = null;
+    if (this.dependencies == null) {
+      const trackDependencies = Context.trackDependencies(
+        this.context,
+        (ctx) => this.callback(ctx)
+      );
+      this.dependencies = trackDependencies.dependencies;
+      result = trackDependencies.result;
+    } else if (change.length > 0 && change.some((c) => {
+      var _a;
+      return (_a = this.dependencies) == null ? void 0 : _a.includes(c);
+    })) {
+      result = this.callback(this.context);
+    }
+    if (result && (this.hueCache !== result.hue || this.chromaCache !== result.chroma)) {
+      this.clearCache();
+      this.hueCache = result.hue;
+      this.chromaCache = result.chroma;
+    }
+  }
+  clearCache() {
+    this.cache.clear();
+    this.hueCache = null;
+    this.chromaCache = null;
+  }
+  /**
+   * @param tone HCT tone, measured from 0 to 100.
+   * @return ARGB representation of a color with that tone.
+   */
+  tone(tone) {
+    const hue = this.hueCache;
+    const chroma = this.chromaCache;
+    if (hue == null || chroma == null)
+      throw new Error("Palette must be updated before using tone");
+    let argb = this.cache.get(tone);
+    if (argb === void 0) {
+      if (tone == 99 && Hct.isYellow(hue)) {
+        argb = this.averageArgb(this.tone(98), this.tone(100));
+      } else {
+        argb = Hct.from(hue, chroma, tone).toInt();
+      }
+      this.cache.set(tone, argb);
+    }
+    return argb;
+  }
+  /**
+   * @param tone HCT tone.
+   * @return HCT representation of a color with that tone.
+   */
+  getHct(tone) {
+    return Hct.fromInt(this.tone(tone));
+  }
+  get hue() {
+    const hue = this.hueCache;
+    if (hue == null) {
+      throw new Error(`Palette ${this.name} must be updated before using hue`);
+    }
+    return hue;
+  }
+  get chroma() {
+    const chroma = this.chromaCache;
+    if (chroma == null) {
+      throw new Error(`Palette ${this.name} must be updated before using hue`);
+    }
+    return chroma;
+  }
+  averageArgb(argb1, argb2) {
+    const red1 = argb1 >>> 16 & 255;
+    const green1 = argb1 >>> 8 & 255;
+    const blue1 = argb1 & 255;
+    const red2 = argb2 >>> 16 & 255;
+    const green2 = argb2 >>> 8 & 255;
+    const blue2 = argb2 & 255;
+    const red = Math.round((red1 + red2) / 2);
+    const green = Math.round((green1 + green2) / 2);
+    const blue = Math.round((blue1 + blue2) / 2);
+    return (255 << 24 | (red & 255) << 16 | (green & 255) << 8 | blue & 255) >>> 0;
+  }
+}
+class PaletteApi {
+  constructor({ paletteManager }) {
+    __publicField(this, "paletteManager");
+    this.paletteManager = paletteManager;
+  }
+  add(args) {
+    Object.entries(args).forEach(([key, callback]) => {
+      if (typeof callback === "string") {
+        this.paletteManager.addCustomPalette(
+          key,
+          Hct.fromInt(argbFromHex(callback))
+        );
+      } else {
+        this.paletteManager.add(key, callback);
+      }
+    });
+  }
+  get(key) {
+    return this.paletteManager.get(key);
+  }
+  getAll() {
+    return this.paletteManager.palettes;
+  }
+}
+class PaletteManager {
+  constructor(args) {
+    __publicField(this, "_palettes", {});
+    __publicField(this, "context");
+    __publicField(this, "colorApi");
+    this.colorApi = args.colorApi;
+    this.context = args.context;
+    this.context.onUpdate(
+      (changed) => Object.entries(this.palettes).forEach(([key, value]) => {
+        value.update(changed);
+      })
+    );
+  }
+  get palettes() {
+    return {
+      ...this.context.variant.palettes,
+      ...this._palettes
+    };
+  }
+  addCustomPalette(key, color) {
+    const palette = Palette.fromVariant(key, color, this.context);
+    this.add(key, palette);
+    this.colorApi.addFromCustomPalette(key);
+  }
+  add(key, palette) {
+    if (this._palettes["key"]) {
+      throw new Error(`Palette with key ${key} already exists`);
+    }
+    if (!(palette instanceof Palette))
+      palette = new Palette(key, palette, this.context);
+    this.set(key, palette);
+  }
+  get(key) {
+    const palette = this.palettes[key];
+    if (!palette) {
+      throw new Error(`Palette ${key} not found`);
+    }
+    return palette;
+  }
+  set(key, palette) {
+    this._palettes[key] = palette;
+  }
+  update(key, args) {
+    if (!this.palettes["key"]) {
+      throw new Error(`Palette with key ${key} not found`);
+    }
+    if (!(args instanceof Palette)) {
+      args = new Palette(key, args, this.context);
+    }
+    this.set(key, args);
+  }
+}
+const PaletteModule = {
+  paletteApi: asClass(PaletteApi).singleton(),
+  paletteManager: asClass(PaletteManager).singleton()
+};
+const AppContainer = () => {
+  function registerModule(...modules) {
+    modules.forEach((module) => {
+      Object.entries(module).forEach(([name, moduleClass]) => {
+        container.register(name, moduleClass);
+      });
+    });
+    return AppContainer;
+  }
+  const container = createContainer({
+    injectionMode: InjectionMode.PROXY
+  });
+  registerModule(
+    AppModule,
+    PluginModule,
+    ColorModule,
+    PaletteModule,
+    ContextModule
+  );
+  return container;
+};
+function bootstrap() {
+  return AppContainer().resolve("api");
+}
+const getPiecewiseHue = (sourceColor, hueBreakpoints, hues) => {
+  const size = Math.min(hueBreakpoints.length - 1, hues.length);
+  const sourceHue = sourceColor.hue;
+  for (let i = 0; i < size; i++) {
+    if (sourceHue >= hueBreakpoints[i] && sourceHue < hueBreakpoints[i + 1]) {
+      return sanitizeDegreesDouble(hues[i]);
+    }
+  }
+  return sourceHue;
+};
+const getRotatedHue = (sourceColor, hueBreakpoints, rotations) => {
+  let rotation = getPiecewiseHue(sourceColor, hueBreakpoints, rotations);
+  if (Math.min(hueBreakpoints.length - 1, rotations.length) <= 0) {
+    rotation = 0;
+  }
+  return sanitizeDegreesDouble(sourceColor.hue + rotation);
+};
+class Variant {
+  constructor(options) {
+    __publicField(this, "_palettes");
+    __publicField(this, "customPalettes");
+    __publicField(this, "colorsFromCustomPalette");
+    __publicField(this, "colors");
+    __publicField(this, "name");
+    __publicField(this, "context");
+    this.options = options;
+    this.customPalettes = options.customPalettes;
+    this.colors = options.colors || {};
+    this.name = options.name;
+    this.colorsFromCustomPalette = options.colorsFromCustomPalette;
+  }
+  get palettes() {
+    if (!this._palettes) {
+      throw new Error("Variant not initialized");
+    }
+    return this._palettes;
+  }
+  init(context) {
+    if (this.context) return;
+    this.context = context;
+    this._palettes = Object.entries(this.options.palettes).reduce(
+      (acc, [key, callback]) => ({
+        ...acc,
+        [key]: new Palette(key, callback, context)
+      }),
+      {}
+    );
+  }
+}
+const variant = (args) => new Variant(args);
+const getExpressiveNeutralHue = (sourceColor) => {
+  const hue = getRotatedHue(
+    sourceColor,
+    [0, 71, 124, 253, 278, 300, 360],
+    [10, 0, 10, 0, 10, 0]
+  );
+  return hue;
+};
+const getExpressiveNeutralChroma = (sourceColor, isDark) => {
+  const neutralHue = getExpressiveNeutralHue(sourceColor);
+  return isDark ? Hct.isYellow(neutralHue) ? 6 : 14 : 18;
+};
+const expressiveVariant = variant({
+  name: "expressive",
+  palettes: {
+    primary: ({ sourceColor, isDark }) => ({
+      hue: sourceColor.hue,
+      chroma: isDark ? 36 : 48
+    }),
+    secondary: ({ sourceColor, isDark }) => ({
+      hue: getRotatedHue(
+        sourceColor,
+        [0, 105, 140, 204, 253, 278, 300, 333, 360],
+        [-160, 155, -100, 96, -96, -156, -165, -160]
+      ),
+      chroma: isDark ? 16 : 24
+    }),
+    tertiary: ({ sourceColor }) => TonalPalette.fromHueAndChroma(
+      getRotatedHue(
+        sourceColor,
+        [0, 105, 140, 204, 253, 278, 300, 333, 360],
+        [-165, 160, -105, 101, -101, -160, -170, -165]
+      ),
+      48
+    ),
+    neutral: ({ sourceColor, isDark }) => TonalPalette.fromHueAndChroma(
+      getExpressiveNeutralHue(sourceColor),
+      getExpressiveNeutralChroma(sourceColor, isDark)
+    ),
+    neutralVariant: ({ sourceColor, isDark }) => {
+      const expressiveNeutralHue = getExpressiveNeutralHue(sourceColor);
+      const expressiveNeutralChroma = getExpressiveNeutralChroma(
+        sourceColor,
+        isDark
+      );
+      return TonalPalette.fromHueAndChroma(
+        expressiveNeutralHue,
+        expressiveNeutralChroma * (expressiveNeutralHue >= 105 && expressiveNeutralHue < 125 ? 1.6 : 2.3)
+      );
+    },
+    error: ({ sourceColor }) => {
+      const errorHue = getPiecewiseHue(
+        sourceColor,
+        [0, 3, 13, 23, 33, 43, 153, 273, 360],
+        [12, 22, 32, 12, 22, 32, 22, 12]
+      );
+      return TonalPalette.fromHueAndChroma(errorHue, 64);
+    }
+  },
+  customPalettes: ({ isDark }, color) => TonalPalette.fromHueAndChroma(
+    getRotatedHue(
+      color,
+      [0, 105, 140, 204, 253, 278, 300, 333, 360],
+      [-160, 155, -100, 96, -96, -156, -165, -160]
+    ),
+    isDark ? 16 : 24
+  ),
+  colors: defaultColors
+});
+const neutralVariant = variant({
+  name: "neutral",
+  palettes: {
+    primary: ({ sourceColor }) => TonalPalette.fromHueAndChroma(
+      sourceColor.hue,
+      Hct.isBlue(sourceColor.hue) ? 12 : 8
+    ),
+    secondary: ({ sourceColor }) => TonalPalette.fromHueAndChroma(
+      sourceColor.hue,
+      Hct.isBlue(sourceColor.hue) ? 6 : 4
+    ),
+    tertiary: ({ sourceColor }) => TonalPalette.fromHueAndChroma(
+      getRotatedHue(
+        sourceColor,
+        [0, 38, 105, 161, 204, 278, 333, 360],
+        [-32, 26, 10, -39, 24, -15, -32]
+      ),
+      20
+    ),
+    neutral: ({ sourceColor }) => TonalPalette.fromHueAndChroma(sourceColor.hue, 1.4),
+    neutralVariant: ({ sourceColor }) => TonalPalette.fromHueAndChroma(sourceColor.hue, 1.4 * 2.2),
+    error: ({ sourceColor }) => {
+      const errorHue = getPiecewiseHue(
+        sourceColor,
+        [0, 3, 13, 23, 33, 43, 153, 273, 360],
+        [12, 22, 32, 12, 22, 32, 22, 12]
+      );
+      return TonalPalette.fromHueAndChroma(errorHue, 50);
+    }
+  },
+  customPalettes: (_, colorHct) => TonalPalette.fromHueAndChroma(
+    colorHct.hue,
+    Hct.isBlue(colorHct.hue) ? 6 : 4
+  ),
+  colors: defaultColors
+});
+const tonalSpotVariant = variant({
+  name: "tonalSpot",
+  palettes: {
+    primary: ({ sourceColor, isDark }) => TonalPalette.fromHueAndChroma(sourceColor.hue, isDark ? 26 : 32),
+    secondary: ({ sourceColor }) => TonalPalette.fromHueAndChroma(sourceColor.hue, 16),
+    tertiary: ({ sourceColor }) => TonalPalette.fromHueAndChroma(
+      getRotatedHue(
+        sourceColor,
+        [0, 20, 71, 161, 333, 360],
+        [-40, 48, -32, 40, -32]
+      ),
+      28
+    ),
+    neutral: ({ sourceColor }) => TonalPalette.fromHueAndChroma(sourceColor.hue, 5),
+    neutralVariant: ({ sourceColor }) => TonalPalette.fromHueAndChroma(sourceColor.hue, 5 * 1.7),
+    error: ({ sourceColor }) => {
+      const errorHue = getPiecewiseHue(
+        sourceColor,
+        [0, 3, 13, 23, 33, 43, 153, 273, 360],
+        [12, 22, 32, 12, 22, 32, 22, 12]
+      );
+      return TonalPalette.fromHueAndChroma(errorHue, 60);
+    }
+  },
+  customPalettes: (_, colorHct) => TonalPalette.fromHueAndChroma(colorHct.hue, 16),
+  colors: defaultColors
+});
+const getVibrantNeutralHue = (sourceColor) => {
+  return getRotatedHue(
+    sourceColor,
+    [0, 38, 105, 140, 333, 360],
+    [-14, 10, -14, 10, -14]
+  );
+};
+const getVibrantNeutralChroma = (sourceColor) => {
+  return 28;
+};
+const vibrantVariant = variant({
+  name: "vibrant",
+  palettes: {
+    primary: ({ sourceColor }) => TonalPalette.fromHueAndChroma(sourceColor.hue, 74),
+    secondary: ({ sourceColor }) => TonalPalette.fromHueAndChroma(
+      getRotatedHue(
+        sourceColor,
+        [0, 38, 105, 140, 333, 360],
+        [-14, 10, -14, 10, -14]
+      ),
+      56
+    ),
+    tertiary: ({ sourceColor }) => TonalPalette.fromHueAndChroma(
+      getRotatedHue(
+        sourceColor,
+        [0, 38, 71, 105, 140, 161, 253, 333, 360],
+        [-72, 35, 24, -24, 62, 50, 62, -72]
+      ),
+      56
+    ),
+    neutral: ({ sourceColor }) => TonalPalette.fromHueAndChroma(
+      getVibrantNeutralHue(sourceColor),
+      getVibrantNeutralChroma()
+    ),
+    neutralVariant: ({ sourceColor }) => {
+      const vibrantNeutralHue = getVibrantNeutralHue(sourceColor);
+      const vibrantNeutralChroma = getVibrantNeutralChroma();
+      return TonalPalette.fromHueAndChroma(
+        vibrantNeutralHue,
+        vibrantNeutralChroma * 1.29
+      );
+    },
+    error: ({ sourceColor }) => {
+      const errorHue = getPiecewiseHue(
+        sourceColor,
+        [0, 3, 13, 23, 33, 43, 153, 273, 360],
+        [12, 22, 32, 12, 22, 32, 22, 12]
+      );
+      return TonalPalette.fromHueAndChroma(errorHue, 80);
+    }
+  },
+  customPalettes: (_, colorHct) => TonalPalette.fromHueAndChroma(
+    getRotatedHue(
+      colorHct,
+      [0, 38, 105, 140, 333, 360],
+      [-14, 10, -14, 10, -14]
+    ),
+    56
+  ),
+  colors: defaultColors
+});
+const surfaceContainerToneDelta = 2.5;
+const inverseTone = (tone) => {
+  return 100 - tone;
+};
+const surfaceContainerTone = (layer, api) => {
+  const t = surfaceContainerToneDelta * layer * (1 + api.context.contrastLevel);
+  if (api.context.isDark) {
+    return t * 1.5;
+  } else {
+    if (Hct.isYellow(api.palettes.get("neutral").hue)) {
+      return 100 - t - surfaceContainerToneDelta;
+    }
+    return 100 - t;
+  }
+};
+const highestSurface = (context, colorService) => {
+  if (colorService instanceof ColorApi) {
+    return colorService.get("surface");
+  } else {
+    return colorService.get("surface");
+  }
+};
+const udixioVariant = variant({
+  name: "udixio",
+  palettes: {
+    primary: ({ sourceColor }) => ({
+      hue: sourceColor.hue,
+      chroma: sourceColor.chroma
+    }),
+    secondary: ({ sourceColor }) => ({
+      hue: sourceColor.hue,
+      chroma: sourceColor.chroma / 1.4
+    }),
+    tertiary: ({ sourceColor }) => ({
+      hue: getRotatedHue(
+        sourceColor,
+        [0, 20, 71, 161, 333, 360],
+        [-40, 48, -32, 40, -32]
+      ),
+      chroma: sourceColor.chroma
+    }),
+    neutral: ({ sourceColor }) => {
+      return {
+        hue: sourceColor.hue,
+        chroma: 5
+      };
+    },
+    neutralVariant: ({ sourceColor }) => {
+      const neutral = 5;
+      return {
+        hue: sourceColor.hue,
+        chroma: neutral * 1.7
+      };
+    },
+    error: ({ sourceColor }) => {
+      const errorHue = getPiecewiseHue(
+        sourceColor,
+        [0, 3, 13, 23, 33, 43, 153, 273, 360],
+        [12, 22, 32, 12, 22, 32, 22, 12]
+      );
+      return {
+        hue: errorHue,
+        chroma: 60
+      };
+    }
+  },
+  customPalettes: ({ sourceColor }, colorHct) => ({
+    hue: colorHct.hue,
+    chroma: sourceColor.chroma
+  }),
+  colorsFromCustomPalette: (key) => {
+    const colorKey = key;
+    const ColorKey = capitalizeFirstLetter(key);
+    const onColorKey = "on" + ColorKey;
+    const colorContainerKey = colorKey + "Container";
+    const onColorContainerKey = "on" + ColorKey + "Container";
+    const colors = ({ palettes, colors: colors2, context: ctx }) => ({
+      [colorKey]: {
+        palette: () => palettes.get(colorKey),
+        tone: () => {
+          if (ctx.variant.name === "neutral") {
+            return ctx.isDark ? tMinC(palettes.get(colorKey), 0, 98) : tMaxC(palettes.get(colorKey));
+          } else if (ctx.variant.name === "vibrant") {
+            return tMaxC(palettes.get(colorKey), 0, ctx.isDark ? 90 : 98);
+          } else {
+            return ctx.isDark ? 80 : tMaxC(palettes.get(colorKey));
+          }
+        },
+        isBackground: true,
+        background: () => highestSurface(ctx, colors2),
+        contrastCurve: () => getCurve(4.5),
+        adjustTone: () => toneDeltaPair(
+          colors2.get(colorContainerKey),
+          colors2.get(colorKey),
+          5,
+          "relative_lighter",
+          true,
+          "farther"
+        )
+      },
+      // [colorDimKey]: {
+      //   palette: () => palettes.get(colorKey),
+      //   tone: () => {
+      //     if (ctx.variant.name === 'neutral') {
+      //       return 85;
+      //     } else {
+      //       return tMaxC(palettes.get(colorKey), 0, 90);
+      //     }
+      //   },
+      //   isBackground: true,
+      //   background: () => colors.get('surfaceContainerHigh'),
+      //   contrastCurve: () => getCurve(4.5),
+      //   adjustTone: () =>
+      //     toneDeltaPair(
+      //       colors.get(colorDimKey),
+      //       colors.get(colorKey),
+      //       5,
+      //       'darker',
+      //       true,
+      //       'farther',
+      //     ),
+      // },
+      [onColorKey]: {
+        palette: () => palettes.get(colorKey),
+        background: () => colors2.get(colorKey),
+        contrastCurve: () => getCurve(6)
+      },
+      [colorContainerKey]: {
+        palette: () => palettes.get(colorKey),
+        tone: () => {
+          if (ctx.variant.name === "vibrant") {
+            return ctx.isDark ? tMinC(palettes.get(colorKey), 30, 40) : tMaxC(palettes.get(colorKey), 84, 90);
+          } else if (ctx.variant.name === "expressive") {
+            return ctx.isDark ? 15 : tMaxC(palettes.get(colorKey), 90, 95);
+          } else {
+            return ctx.isDark ? 25 : 90;
+          }
+        },
+        isBackground: true,
+        background: () => highestSurface(ctx, colors2),
+        adjustTone: () => void 0,
+        contrastCurve: () => ctx.contrastLevel > 0 ? getCurve(1.5) : void 0
+      },
+      [onColorContainerKey]: {
+        palette: () => palettes.get(colorKey),
+        background: () => colors2.get(colorContainerKey),
+        contrastCurve: () => getCurve(6)
+      }
+      // [colorFixedKey]: {
+      //   palette: () => palettes.get(colorKey),
+      //   tone: () => {
+      //     return ctx.temp({ isDark: false, contrastLevel: 0 }, () => {
+      //       const color = colors.get(colorContainerKey);
+      //       return color.getTone();
+      //     });
+      //   },
+      //   isBackground: true,
+      //   background: () => highestSurface(ctx, colors),
+      //   contrastCurve: () =>
+      //     ctx.contrastLevel > 0 ? getCurve(1.5) : undefined,
+      // },
+      // [colorFixedDimKey]: {
+      //   palette: () => palettes.get(colorKey),
+      //   tone: () => colors.get(colorFixedKey).getTone(),
+      //   isBackground: true,
+      //   adjustTone: () =>
+      //     toneDeltaPair(
+      //       colors.get(colorFixedDimKey),
+      //       colors.get(colorFixedKey),
+      //       5,
+      //       'darker',
+      //       true,
+      //       'exact',
+      //     ),
+      // },
+      // [onColorFixedKey]: {
+      //   palette: () => palettes.get(colorKey),
+      //   background: () => this.get(colorFixedDimKey),
+      //   contrastCurve: () => getCurve(7),
+      // },
+      // [onColorFixedVariantKey]: {
+      //   palette: () => palettes.get(colorKey),
+      //   background: () => colors.get(colorFixedDimKey),
+      //   contrastCurve: () => getCurve(4.5),
+      // },
+    });
+    return colors;
+  },
+  colors: ({ colors, context: c, palettes }) => {
+    const getColor = (key) => {
+      return colors.get(key);
+    };
+    return {
+      ////////////////////////////////////////////////////////////////
+      // Surfaces [S]                                               //
+      ////////////////////////////////////////////////////////////////
+      surface: {
+        palette: () => palettes.get("neutral"),
+        tone: () => {
+          if (c.isDark) {
+            return 2;
+          } else {
+            return 99;
+          }
+        },
+        isBackground: true
+      },
+      // surfaceDim: {
+      //   palette: () => palettes.get('neutral'),
+      //   tone: () => {
+      //     if (c.isDark) {
+      //       return 4;
+      //     } else {
+      //       if (Hct.isYellow(palettes.get('neutral').hue)) {
+      //         return 90;
+      //       } else if (c.variant.name === 'vibrant') {
+      //         return 85;
+      //       } else {
+      //         return 87;
+      //       }
+      //     }
+      //   },
+      //   isBackground: true,
+      //   chromaMultiplier: () => {
+      //     if (!c.isDark) {
+      //       if (c.variant.name === 'neutral') {
+      //         return 2.5;
+      //       } else if (c.variant.name === 'tonalSpot') {
+      //         return 1.7;
+      //       } else if (c.variant.name === 'expressive') {
+      //         return Hct.isYellow(palettes.get('neutral').hue) ? 2.7 : 1.75;
+      //       } else if (c.variant.name === 'vibrant') {
+      //         return 1.36;
+      //       }
+      //     }
+      //     return 1;
+      //   },
+      // },
+      // surfaceBright: {
+      //   palette: () => palettes.get('neutral'),
+      //   tone: () => {
+      //     if (c.isDark) {
+      //       return 18;
+      //     } else {
+      //       if (Hct.isYellow(palettes.get('neutral').hue)) {
+      //         return 99;
+      //       } else if (c.variant.name === 'vibrant') {
+      //         return 97;
+      //       } else {
+      //         return 98;
+      //       }
+      //     }
+      //   },
+      //   isBackground: true,
+      //   chromaMultiplier: () => {
+      //     if (c.isDark) {
+      //       if (c.variant.name === 'neutral') {
+      //         return 2.5;
+      //       } else if (c.variant.name === 'tonalSpot') {
+      //         return 1.7;
+      //       } else if (c.variant.name === 'expressive') {
+      //         return Hct.isYellow(palettes.get('neutral').hue) ? 2.7 : 1.75;
+      //       } else if (c.variant.name === 'vibrant') {
+      //         return 1.36;
+      //       }
+      //     }
+      //     return 1;
+      //   },
+      // },
+      surfaceContainerLowest: {
+        palette: () => palettes.get("neutral"),
+        tone: () => surfaceContainerTone(0, { palettes, context: c }),
+        isBackground: true
+      },
+      surfaceContainerLow: {
+        palette: () => palettes.get("neutral"),
+        tone: () => surfaceContainerTone(1, { palettes, context: c }),
+        isBackground: true,
+        chromaMultiplier: () => {
+          return 1.25;
+        }
+      },
+      surfaceContainer: {
+        palette: () => palettes.get("neutral"),
+        tone: () => surfaceContainerTone(2, { palettes, context: c }),
+        isBackground: true,
+        chromaMultiplier: () => {
+          return 1.4;
+        }
+      },
+      surfaceContainerHigh: {
+        palette: () => palettes.get("neutral"),
+        tone: () => surfaceContainerTone(3, { palettes, context: c }),
+        isBackground: true,
+        chromaMultiplier: () => {
+          return 1.5;
+        }
+      },
+      surfaceContainerHighest: {
+        palette: () => palettes.get("neutral"),
+        tone: () => surfaceContainerTone(4, { palettes, context: c }),
+        isBackground: true,
+        chromaMultiplier: () => {
+          return 1.7;
+        }
+      },
+      onSurface: {
+        palette: () => palettes.get("neutral"),
+        tone: () => {
+          return getInitialToneFromBackground(highestSurface(c, colors));
+        },
+        chromaMultiplier: () => {
+          return 1.7;
+        },
+        background: () => highestSurface(c, colors),
+        contrastCurve: () => c.isDark ? getCurve(11) : getCurve(9)
+      },
+      onSurfaceVariant: {
+        palette: () => palettes.get("neutralVariant"),
+        chromaMultiplier: () => {
+          return 1.7;
+        },
+        background: () => highestSurface(c, colors),
+        contrastCurve: () => c.isDark ? getCurve(6) : getCurve(4.5)
+      },
+      outline: {
+        palette: () => palettes.get("neutralVariant"),
+        chromaMultiplier: () => {
+          return 1.7;
+        },
+        background: () => highestSurface(c, colors),
+        contrastCurve: () => getCurve(3)
+      },
+      outlineVariant: {
+        palette: () => palettes.get("neutralVariant"),
+        chromaMultiplier: () => {
+          return 1.7;
+        },
+        background: () => highestSurface(c, colors),
+        contrastCurve: () => getCurve(1.5)
+      },
+      inverseSurface: {
+        palette: () => palettes.get("neutral"),
+        tone: () => 100 - colors.get("surface").getTone(),
+        isBackground: true
+      },
+      inverseOnSurface: {
+        palette: () => palettes.get("neutral"),
+        tone: () => c.isDark ? 20 : 95,
+        background: () => colors.get("inverseSurface"),
+        contrastCurve: () => getCurve(7)
+      },
+      ////////////////////////////////////////////////////////////////
+      // Primaries [P]                                              //
+      ////////////////////////////////////////////////////////////////
+      primary: {
+        palette: () => palettes.get("primary"),
+        tone: () => {
+          return c.sourceColor.tone;
+        },
+        isBackground: true,
+        background: () => highestSurface(c, colors),
+        contrastCurve: () => getCurve(4.5),
+        adjustTone: () => () => {
+          const surfaceTone = colors.get("surface").getTone();
+          const primaryTone = colors.get("primary").options.tone;
+          let selfTone = primaryTone;
+          if (Contrast.ratioOfTones(surfaceTone, selfTone) < 3) {
+            const ratio = calculateToneAdjustmentPercentage(
+              surfaceTone,
+              selfTone,
+              3
+            );
+            const inverseT = inverseTone(primaryTone);
+            selfTone = selfTone + (inverseT - selfTone) * ratio;
+          }
+          return selfTone;
+        }
+      },
+      // primaryDim: {
+      //   palette: () => palettes.get('primary'),
+      //   tone: () => {
+      //     if (c.variant.name === 'neutral') {
+      //       return 85;
+      //     } else if (c.variant.name === 'tonalSpot') {
+      //       return tMaxC(palettes.get('primary'), 0, 90);
+      //     } else {
+      //       return tMaxC(palettes.get('primary'));
+      //     }
+      //   },
+      //   isBackground: true,
+      //   background: () => getColor('surfaceContainerHigh'),
+      //   contrastCurve: () => getCurve(4.5),
+      //   adjustTone: () =>
+      //     toneDeltaPair(
+      //       colors.get('primaryDim'),
+      //       colors.get('primary'),
+      //       5,
+      //       'darker',
+      //       true,
+      //       'farther',
+      //     ),
+      // },
+      onPrimary: {
+        palette: () => palettes.get("primary"),
+        background: () => colors.get("primary"),
+        contrastCurve: () => getCurve(6)
+      },
+      primaryContainer: {
+        palette: () => palettes.get("primary"),
+        tone: () => {
+          return c.isDark ? tMinC(palettes.get("primary"), 35, 93) : tMaxC(palettes.get("primary"), 0, 90);
+        },
+        isBackground: true,
+        background: () => highestSurface(c, colors),
+        adjustTone: () => c.variant.name == "fidelity" ? toneDeltaPair(
+          colors.get("primary"),
+          colors.get("primaryContainer"),
+          15,
+          "relative_darker",
+          true,
+          "farther"
+        ) : void 0,
+        contrastCurve: () => c.contrastLevel > 0 ? getCurve(1.5) : void 0
+      },
+      onPrimaryContainer: {
+        palette: () => palettes.get("primary"),
+        background: () => colors.get("primaryContainer"),
+        contrastCurve: () => getCurve(6)
+      },
+      // primaryFixed: {
+      //   palette: () => palettes.get('primary'),
+      //   tone: () => {
+      //     return c.temp(
+      //       {
+      //         isDark: false,
+      //         contrastLevel: 0,
+      //       },
+      //       () => {
+      //         const color = getColor('primaryContainer');
+      //         return color.getTone();
+      //       },
+      //     );
+      //   },
+      //   isBackground: true,
+      //   background: () => highestSurface(c, colors),
+      //   contrastCurve: () => (c.contrastLevel > 0 ? getCurve(1.5) : undefined),
+      // },
+      // primaryFixedDim: {
+      //   palette: () => palettes.get('primary'),
+      //   tone: () => colors.get('primaryFixed').getTone(),
+      //   isBackground: true,
+      //   adjustTone: () =>
+      //     toneDeltaPair(
+      //       getColor('primaryFixedDim'),
+      //       getColor('primaryFixed'),
+      //       5,
+      //       'darker',
+      //       true,
+      //       'exact',
+      //     ),
+      // },
+      // onPrimaryFixed: {
+      //   palette: () => palettes.get('primary'),
+      //   background: () => colors.get('primaryFixedDim'),
+      //   contrastCurve: () => getCurve(7),
+      // },
+      // onPrimaryFixedVariant: {
+      //   palette: () => palettes.get('primary'),
+      //   background: () => colors.get('primaryFixedDim'),
+      //   contrastCurve: () => getCurve(4.5),
+      // },
+      inversePrimary: {
+        palette: () => palettes.get("primary"),
+        tone: () => tMaxC(palettes.get("primary")),
+        background: () => colors.get("inverseSurface"),
+        contrastCurve: () => getCurve(6)
+      },
+      ////////////////////////////////////////////////////////////////
+      // Secondaries [Q]                                            //
+      ////////////////////////////////////////////////////////////////
+      secondary: {
+        palette: () => palettes.get("secondary"),
+        tone: () => {
+          return c.isDark ? 80 : tMaxC(palettes.get("secondary"));
+        },
+        isBackground: true,
+        background: () => highestSurface(c, colors),
+        contrastCurve: () => getCurve(4.5),
+        adjustTone: () => toneDeltaPair(
+          getColor("secondaryContainer"),
+          getColor("secondary"),
+          5,
+          "relative_lighter",
+          true,
+          "farther"
+        )
+      },
+      // secondaryDim: {
+      //   palette: () => palettes.get('secondary'),
+      //   tone: () => {
+      //     if (c.variant.name === 'neutral') {
+      //       return 85;
+      //     } else {
+      //       return tMaxC(palettes.get('secondary'), 0, 90);
+      //     }
+      //   },
+      //   isBackground: true,
+      //   background: () => getColor('surfaceContainerHigh'),
+      //   contrastCurve: () => getCurve(4.5),
+      //   adjustTone: () =>
+      //     toneDeltaPair(
+      //       getColor('secondaryDim'),
+      //       getColor('secondary'),
+      //       5,
+      //       'darker',
+      //       true,
+      //       'farther',
+      //     ),
+      // },
+      onSecondary: {
+        palette: () => palettes.get("secondary"),
+        background: () => getColor("secondary"),
+        contrastCurve: () => getCurve(6)
+      },
+      secondaryContainer: {
+        palette: () => palettes.get("secondary"),
+        tone: () => {
+          return c.isDark ? 25 : 90;
+        },
+        isBackground: true,
+        background: () => highestSurface(c, colors),
+        adjustTone: () => void 0,
+        contrastCurve: () => c.contrastLevel > 0 ? getCurve(1.5) : void 0
+      },
+      onSecondaryContainer: {
+        palette: () => palettes.get("secondary"),
+        background: () => getColor("secondaryContainer"),
+        contrastCurve: () => getCurve(6)
+      },
+      // secondaryFixed: {
+      //   palette: () => palettes.get('secondary'),
+      //   tone: () => {
+      //     return c.temp(
+      //       {
+      //         isDark: false,
+      //         contrastLevel: 0,
+      //       },
+      //       () => {
+      //         const color = getColor('secondaryContainer');
+      //         return color.getTone();
+      //       },
+      //     );
+      //   },
+      //   isBackground: true,
+      //   background: () => highestSurface(c, colors),
+      //   contrastCurve: () => (c.contrastLevel > 0 ? getCurve(1.5) : undefined),
+      // },
+      // secondaryFixedDim: {
+      //   palette: () => palettes.get('secondary'),
+      //   tone: () => getColor('secondaryFixed').getTone(),
+      //   isBackground: true,
+      //   adjustTone: () =>
+      //     toneDeltaPair(
+      //       getColor('secondaryFixedDim'),
+      //       getColor('secondaryFixed'),
+      //       5,
+      //       'darker',
+      //       true,
+      //       'exact',
+      //     ),
+      // },
+      // onSecondaryFixed: {
+      //   palette: () => palettes.get('secondary'),
+      //   background: () => getColor('secondaryFixedDim'),
+      //   contrastCurve: () => getCurve(7),
+      // },
+      // onSecondaryFixedVariant: {
+      //   palette: () => palettes.get('secondary'),
+      //   background: () => getColor('secondaryFixedDim'),
+      //   contrastCurve: () => getCurve(4.5),
+      // },
+      ////////////////////////////////////////////////////////////////
+      // Tertiaries [T]                                             //
+      ////////////////////////////////////////////////////////////////
+      tertiary: {
+        palette: () => palettes.get("tertiary"),
+        tone: () => {
+          return c.isDark ? tMaxC(palettes.get("tertiary"), 0, 98) : tMaxC(palettes.get("tertiary"));
+        },
+        isBackground: true,
+        background: () => highestSurface(c, colors),
+        contrastCurve: () => getCurve(4.5),
+        adjustTone: () => toneDeltaPair(
+          getColor("tertiaryContainer"),
+          getColor("tertiary"),
+          5,
+          "relative_lighter",
+          true,
+          "farther"
+        )
+      },
+      // tertiaryDim: {
+      //   palette: () => palettes.get('tertiary'),
+      //   tone: () => {
+      //     if (c.variant.name === 'tonalSpot') {
+      //       return tMaxC(palettes.get('tertiary'), 0, 90);
+      //     } else {
+      //       return tMaxC(palettes.get('tertiary'));
+      //     }
+      //   },
+      //   isBackground: true,
+      //   background: () => getColor('surfaceContainerHigh'),
+      //   contrastCurve: () => getCurve(4.5),
+      //   adjustTone: () =>
+      //     toneDeltaPair(
+      //       getColor('tertiaryDim'),
+      //       getColor('tertiary'),
+      //       5,
+      //       'darker',
+      //       true,
+      //       'farther',
+      //     ),
+      // },
+      onTertiary: {
+        palette: () => palettes.get("tertiary"),
+        background: () => getColor("tertiary"),
+        contrastCurve: () => getCurve(6)
+      },
+      tertiaryContainer: {
+        palette: () => palettes.get("tertiary"),
+        tone: () => {
+          return tMaxC(palettes.get("tertiary"), 0, c.isDark ? 93 : 100);
+        },
+        isBackground: true,
+        background: () => highestSurface(c, colors),
+        adjustTone: () => void 0,
+        contrastCurve: () => c.contrastLevel > 0 ? getCurve(1.5) : void 0
+      },
+      onTertiaryContainer: {
+        palette: () => palettes.get("tertiary"),
+        background: () => getColor("tertiaryContainer"),
+        contrastCurve: () => getCurve(6)
+      },
+      // tertiaryFixed: {
+      //   palette: () => palettes.get('tertiary'),
+      //   tone: () => {
+      //     return c.temp(
+      //       {
+      //         isDark: false,
+      //         contrastLevel: 0,
+      //       },
+      //       () => {
+      //         const color = getColor('tertiaryContainer');
+      //         return color.getTone();
+      //       },
+      //     );
+      //   },
+      //   isBackground: true,
+      //   background: () => highestSurface(c, colors),
+      //   contrastCurve: () => (c.contrastLevel > 0 ? getCurve(1.5) : undefined),
+      // },
+      // tertiaryFixedDim: {
+      //   palette: () => palettes.get('tertiary'),
+      //   tone: () => getColor('tertiaryFixed').getTone(),
+      //   isBackground: true,
+      //   adjustTone: () =>
+      //     toneDeltaPair(
+      //       getColor('tertiaryFixedDim'),
+      //       getColor('tertiaryFixed'),
+      //       5,
+      //       'darker',
+      //       true,
+      //       'exact',
+      //     ),
+      // },
+      // onTertiaryFixed: {
+      //   palette: () => palettes.get('tertiary'),
+      //   background: () => getColor('tertiaryFixedDim'),
+      //   contrastCurve: () => getCurve(7),
+      // },
+      // onTertiaryFixedVariant: {
+      //   palette: () => palettes.get('tertiary'),
+      //   background: () => getColor('tertiaryFixedDim'),
+      //   contrastCurve: () => getCurve(4.5),
+      // },
+      ////////////////////////////////////////////////////////////////
+      // Errors [E]                                                 //
+      ////////////////////////////////////////////////////////////////
+      error: {
+        palette: () => palettes.get("error"),
+        tone: () => {
+          return c.isDark ? tMinC(palettes.get("error"), 0, 98) : tMaxC(palettes.get("error"));
+        },
+        isBackground: true,
+        background: () => highestSurface(c, colors),
+        contrastCurve: () => getCurve(4.5),
+        adjustTone: () => toneDeltaPair(
+          colors.get("errorContainer"),
+          colors.get("error"),
+          5,
+          "relative_lighter",
+          true,
+          "farther"
+        )
+      },
+      // errorDim: {
+      //   palette: () => palettes.get('error'),
+      //   tone: () => tMinC(palettes.get('error')),
+      //   isBackground: true,
+      //   background: () => getColor('surfaceContainerHigh'),
+      //   contrastCurve: () => getCurve(4.5),
+      //   adjustTone: () =>
+      //     toneDeltaPair(
+      //       getColor('errorDim'),
+      //       getColor('error'),
+      //       5,
+      //       'darker',
+      //       true,
+      //       'farther',
+      //     ),
+      // },
+      onError: {
+        palette: () => palettes.get("error"),
+        background: () => colors.get("error"),
+        contrastCurve: () => getCurve(6)
+      },
+      errorContainer: {
+        palette: () => palettes.get("error"),
+        tone: () => {
+          return c.isDark ? tMinC(palettes.get("error"), 30, 93) : tMaxC(palettes.get("error"), 0, 90);
+        },
+        isBackground: true,
+        background: () => highestSurface(c, colors),
+        adjustTone: () => void 0,
+        contrastCurve: () => c.contrastLevel > 0 ? getCurve(1.5) : void 0
+      },
+      onErrorContainer: {
+        palette: () => palettes.get("error"),
+        background: () => colors.get("errorContainer"),
+        contrastCurve: () => getCurve(4.5)
+      },
+      /////////////////////////////////////////////////////////////////
+      // Remapped Colors                                             //
+      /////////////////////////////////////////////////////////////////
+      surfaceVariant: {
+        alias: "surfaceContainerHighest"
+      },
+      surfaceTint: {
+        alias: "primary"
+      },
+      background: {
+        alias: "surface"
+      },
+      onBackground: {
+        alias: "onSurface"
+      }
+    };
+  }
+});
+const Variants = {
+  Expressive: expressiveVariant,
+  Neutral: neutralVariant,
+  TonalSpot: tonalSpotVariant,
+  Vibrant: vibrantVariant,
+  Udixio: udixioVariant
+};
+const loader = async (config, load = true) => {
+  const api = bootstrap();
+  const init = () => {
+    const {
+      sourceColor,
+      contrastLevel = 0,
+      isDark = false,
+      variant: variant2 = Variants.TonalSpot,
+      palettes,
+      colors,
+      plugins
+    } = config;
+    api.context.set({
+      contrastLevel,
+      isDark,
+      sourceColor,
+      variant: variant2
+    });
+    if (palettes) {
+      api.palettes.add(palettes);
+    }
+    if (colors) {
+      api.colors.addColors(colors);
+    }
+    if (plugins) {
+      plugins.forEach((plugin) => {
+        api.plugins.addPlugin(plugin);
+      });
+      api.plugins.initPlugins(api);
+    }
+  };
+  init();
+  if (load) {
+    await api.load();
+  }
+  return api;
+};
+export {
+  API as A,
+  tonalSpotVariant as B,
+  ColorApi as C,
+  DynamicColor as D,
+  vibrantVariant as E,
+  expressiveVariant as F,
+  neutralVariant as G,
+  Palette as P,
+  Variant as V,
+  AppContainer as a,
+  AppModule as b,
+  bootstrap as c,
+  capitalizeFirstLetter as d,
+  ColorManager as e,
+  ColorModule as f,
+  getInitialToneFromBackground as g,
+  Color as h,
+  ColorAlias as i,
+  ColorFromHex as j,
+  ColorFromPalette as k,
+  highestSurface$1 as l,
+  defaultColors as m,
+  ContextModule as n,
+  Context as o,
+  loader as p,
+  ContrastCurve as q,
+  PaletteApi as r,
+  PaletteModule as s,
+  toneDeltaPair as t,
+  PluginModule as u,
+  PluginApi as v,
+  getPiecewiseHue as w,
+  getRotatedHue as x,
+  variant as y,
+  Variants as z
+};