@m3e/web 2.5.7 → 2.5.9

package/dist/theme.js

@@ -4,9 +4,9 @@
  * See LICENSE file in the project root for full license text.
  */
 import { __decorate, __classPrivateFieldGet, __classPrivateFieldSet } from 'tslib';
-import { css, LitElement, html } from 'lit';
+import { unsafeCSS, css, LitElement, html } from 'lit';
 import { property } from 'lit/decorators.js';
-import { customElement, DesignToken } from '@m3e/web/core';
+import { DesignToken, registerStyleSheet, customElement } from '@m3e/web/core';
 
 /**
  * @license
@@ -104,6 +104,24 @@ function sanitizeDegreesDouble(degrees) {
   }
   return degrees;
 }
+/**
+ * Sign of direction change needed to travel from one angle to
+ * another.
+ *
+ * For angles that are 180 degrees apart from each other, both
+ * directions have the same travel distance, so either direction is
+ * shortest. The value 1.0 is returned in this case.
+ *
+ * @param from The angle travel starts from, in degrees.
+ * @param to The angle travel ends at, in degrees.
+ * @return -1 if decreasing from leads to the shortest travel
+ * distance, 1 if increasing from leads to the shortest travel
+ * distance.
+ */
+function rotationDirection(from, to) {
+  const increasingDifference = sanitizeDegreesDouble(to - from);
+  return increasingDifference <= 180.0 ? 1.0 : -1;
+}
 /**
  * Distance of two points on a circle, represented using degrees.
  */
@@ -582,7 +600,7 @@ class Cam16 {
     const p2 = (40.0 * rA + 20.0 * gA + bA) / 20.0;
     const atan2 = Math.atan2(b, a);
     const atanDegrees = atan2 * 180.0 / Math.PI;
-    const hue = atanDegrees < 0 ? atanDegrees + 360.0 : atanDegrees >= 360 ? atanDegrees - 360.0 : atanDegrees;
+    const hue = sanitizeDegreesDouble(atanDegrees);
     const hueRadians = hue * Math.PI / 180.0;
     const ac = p2 * viewingConditions.nbb;
     const j = 100.0 * Math.pow(ac / viewingConditions.aw, viewingConditions.c * viewingConditions.z);
@@ -1249,6 +1267,22 @@ class Hct {
   set tone(newTone) {
     this.setInternalState(HctSolver.solveToInt(this.internalHue, this.internalChroma, newTone));
   }
+  /** 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)})`;
+  }
+  static isBlue(hue) {
+    return hue >= 250 && hue < 270;
+  }
+  static isYellow(hue) {
+    return hue >= 105 && hue < 125;
+  }
+  static isCyan(hue) {
+    return hue >= 170 && hue < 207;
+  }
   constructor(argb) {
     this.argb = argb;
     const cam = Cam16.fromInt(argb);
@@ -1292,6 +1326,93 @@ class Hct {
   }
 }
 
+/**
+ * @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.
+ */
+// This file is automatically generated. Do not modify it.
+// material_color_utilities is designed to have a consistent API across
+// platforms and modular components that can be moved around easily. Using a
+// class as a namespace facilitates this.
+//
+// tslint:disable:class-as-namespace
+/**
+ * Functions for blending in HCT and CAM16.
+ */
+class Blend {
+  /**
+   * Blend the design color's HCT hue towards the key color's HCT
+   * hue, in a way that leaves the original color recognizable and
+   * recognizably shifted towards the key color.
+   *
+   * @param designColor ARGB representation of an arbitrary color.
+   * @param sourceColor ARGB representation of the main theme color.
+   * @return The design color with a hue shifted towards the
+   * system's color, a slightly warmer/cooler variant of the design
+   * color's hue.
+   */
+  static harmonize(designColor, sourceColor) {
+    const fromHct = Hct.fromInt(designColor);
+    const toHct = Hct.fromInt(sourceColor);
+    const differenceDegrees$1 = differenceDegrees(fromHct.hue, toHct.hue);
+    const rotationDegrees = Math.min(differenceDegrees$1 * 0.5, 15.0);
+    const outputHue = sanitizeDegreesDouble(fromHct.hue + rotationDegrees * rotationDirection(fromHct.hue, toHct.hue));
+    return Hct.from(outputHue, fromHct.chroma, fromHct.tone).toInt();
+  }
+  /**
+   * Blends hue from one color into another. The chroma and tone of
+   * the original color are maintained.
+   *
+   * @param from ARGB representation of color
+   * @param to ARGB representation of color
+   * @param amount how much blending to perform; 0.0 >= and <= 1.0
+   * @return from, with a hue blended towards to. Chroma and tone
+   * are constant.
+   */
+  static hctHue(from, to, amount) {
+    const ucs = Blend.cam16Ucs(from, to, amount);
+    const ucsCam = Cam16.fromInt(ucs);
+    const fromCam = Cam16.fromInt(from);
+    const blended = Hct.from(ucsCam.hue, fromCam.chroma, lstarFromArgb(from));
+    return blended.toInt();
+  }
+  /**
+   * Blend in CAM16-UCS space.
+   *
+   * @param from ARGB representation of color
+   * @param to ARGB representation of color
+   * @param amount how much blending to perform; 0.0 >= and <= 1.0
+   * @return from, blended towards to. Hue, chroma, and tone will
+   * change.
+   */
+  static cam16Ucs(from, to, amount) {
+    const fromCam = Cam16.fromInt(from);
+    const toCam = Cam16.fromInt(to);
+    const fromJ = fromCam.jstar;
+    const fromA = fromCam.astar;
+    const fromB = fromCam.bstar;
+    const toJ = toCam.jstar;
+    const toA = toCam.astar;
+    const toB = toCam.bstar;
+    const jstar = fromJ + (toJ - fromJ) * amount;
+    const astar = fromA + (toA - fromA) * amount;
+    const bstar = fromB + (toB - fromB) * amount;
+    return Cam16.fromUcs(jstar, astar, bstar).toInt();
+  }
+}
+
 /**
  * @license
  * Copyright 2022 Google LLC
@@ -1514,6 +1635,51 @@ class DislikeAnalyzer {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+function validateExtendedColor(originalColor, specVersion, extendedColor) {
+  if (originalColor.name !== extendedColor.name) {
+    throw new Error(`Attempting to extend color ${originalColor.name} with color ${extendedColor.name} of different name for spec version ${specVersion}.`);
+  }
+  if (originalColor.isBackground !== extendedColor.isBackground) {
+    throw new Error(`Attempting to extend color ${originalColor.name} as a ${originalColor.isBackground ? 'background' : 'foreground'} with color ${extendedColor.name} as a ${extendedColor.isBackground ? 'background' : 'foreground'} for spec version ${specVersion}.`);
+  }
+}
+/**
+ * Returns a new DynamicColor that is the same as the original color, but with
+ * the extended dynamic color's constraints for the given spec version.
+ *
+ * @param originlColor The original color.
+ * @param specVersion The spec version to extend.
+ * @param extendedColor The color with the values to extend.
+ */
+function extendSpecVersion(originlColor, specVersion, extendedColor) {
+  validateExtendedColor(originlColor, specVersion, extendedColor);
+  return DynamicColor.fromPalette({
+    name: originlColor.name,
+    palette: s => s.specVersion === specVersion ? extendedColor.palette(s) : originlColor.palette(s),
+    tone: s => s.specVersion === specVersion ? extendedColor.tone(s) : originlColor.tone(s),
+    isBackground: originlColor.isBackground,
+    chromaMultiplier: s => {
+      const chromaMultiplier = s.specVersion === specVersion ? extendedColor.chromaMultiplier : originlColor.chromaMultiplier;
+      return chromaMultiplier !== undefined ? chromaMultiplier(s) : 1;
+    },
+    background: s => {
+      const background = s.specVersion === specVersion ? extendedColor.background : originlColor.background;
+      return background !== undefined ? background(s) : undefined;
+    },
+    secondBackground: s => {
+      const secondBackground = s.specVersion === specVersion ? extendedColor.secondBackground : originlColor.secondBackground;
+      return secondBackground !== undefined ? secondBackground(s) : undefined;
+    },
+    contrastCurve: s => {
+      const contrastCurve = s.specVersion === specVersion ? extendedColor.contrastCurve : originlColor.contrastCurve;
+      return contrastCurve !== undefined ? contrastCurve(s) : undefined;
+    },
+    toneDeltaPair: s => {
+      const toneDeltaPair = s.specVersion === specVersion ? extendedColor.toneDeltaPair : originlColor.toneDeltaPair;
+      return toneDeltaPair !== undefined ? toneDeltaPair(s) : undefined;
+    }
+  });
+}
 /**
  * A color that adjusts itself based on UI state provided by DynamicScheme.
  *
@@ -1530,10 +1696,16 @@ class DynamicColor {
    * 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 ToneDeltaConstraint.
+   *     and tone. May provide a background DynamicColor and ToneDeltaPair.
    */
   static fromPalette(args) {
-    return new DynamicColor(args.name ?? '', args.palette, args.tone, args.isBackground ?? false, args.background, args.secondBackground, args.contrastCurve, args.toneDeltaPair);
+    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.toneDeltaPair);
+  }
+  static getInitialToneFromBackground(background) {
+    if (background === undefined) {
+      return s => 50;
+    }
+    return s => background(s) ? background(s).getTone(s) : 50;
   }
   /**
    * The base constructor for DynamicColor.
@@ -1549,29 +1721,31 @@ class DynamicColor {
    * 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 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 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.
+   *     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.
+   *     against its background should behave in various contrast levels
+   *     options.
    * @param toneDeltaPair A `ToneDeltaPair` object specifying a tone delta
-   * constraint between two colors. One of them must be the color being
-   * constructed.
+   *     constraint between two colors. One of them must be the color being
+   *     constructed.
    */
-  constructor(name, palette, tone, isBackground, background, secondBackground, contrastCurve, toneDeltaPair) {
+  constructor(name, palette, tone, isBackground, chromaMultiplier, background, secondBackground, contrastCurve, toneDeltaPair) {
     this.name = name;
     this.palette = palette;
     this.tone = tone;
     this.isBackground = isBackground;
+    this.chromaMultiplier = chromaMultiplier;
     this.background = background;
     this.secondBackground = secondBackground;
     this.contrastCurve = contrastCurve;
@@ -1588,30 +1762,52 @@ class DynamicColor {
     }
   }
   /**
-   * Return a ARGB integer (i.e. a hex code).
+   * 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,
+      toneDeltaPair: this.toneDeltaPair
+    });
+  }
+  /**
+   * Clears the cache of HCT values for this color. For testing or debugging
+   * purposes.
+   */
+  clearCache() {
+    this.hctCache.clear();
+  }
+  /**
+   * 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.
+   *     whether or not it is dark mode or light mode, and what the desired
+   *     contrast level is.
    */
   getArgb(scheme) {
     return this.getHct(scheme).toInt();
   }
   /**
-   * Return a color, expressed in the HCT color space, that this
+   * 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.
+   *     whether or not it is dark mode or light mode, and what the desired
+   *     contrast level is.
    */
   getHct(scheme) {
     const cachedAnswer = this.hctCache.get(scheme);
     if (cachedAnswer != null) {
       return cachedAnswer;
     }
-    const tone = this.getTone(scheme);
-    const answer = this.palette(scheme).getHct(tone);
+    const answer = getSpec$1(scheme.specVersion).getHct(scheme, this);
     if (this.hctCache.size > 4) {
       this.hctCache.clear();
     }
@@ -1619,48 +1815,135 @@ class DynamicColor {
     return answer;
   }
   /**
-   * Return a tone, T in the HCT color space, that this DynamicColor is under
+   * 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.
+   *     whether or not it is dark mode or light mode, and what the desired
+   *     contrast level is.
    */
   getTone(scheme) {
+    return getSpec$1(scheme.specVersion).getTone(scheme, this);
+  }
+  /**
+   * 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) {
+      // This handles an edge case where the initial contrast ratio is high
+      // (ex. 13.0), and the ratio passed to the function is that high
+      // ratio, and both the lighter and darker ratio fails to pass that
+      // ratio.
+      //
+      // This was observed with Tonal Spot's On Primary Container turning
+      // black momentarily between high and max contrast in light mode. PC's
+      // standard tone was T90, OPC's was T10, it was light mode, and the
+      // contrast value was 0.6568521221032331.
+      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.0;
+  }
+  /**
+   * Returns whether [tone] can reach a contrast ratio of 4.5 with a lighter
+   * color.
+   */
+  static toneAllowsLightForeground(tone) {
+    return Math.round(tone) <= 49.0;
+  }
+  /**
+   * 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.0;
+    }
+    return tone;
+  }
+}
+/**
+ * A delegate for the color calculation of a DynamicScheme in the 2021 spec.
+ */
+class ColorCalculationDelegateImpl2021 {
+  getHct(scheme, color) {
+    const tone = color.getTone(scheme);
+    const palette = color.palette(scheme);
+    return palette.getHct(tone);
+  }
+  getTone(scheme, color) {
     const decreasingContrast = scheme.contrastLevel < 0;
+    const toneDeltaPair = color.toneDeltaPair ? color.toneDeltaPair(scheme) : undefined;
     // Case 1: dual foreground, pair of colors with delta constraint.
-    if (this.toneDeltaPair) {
-      const toneDeltaPair = this.toneDeltaPair(scheme);
+    if (toneDeltaPair) {
       const roleA = toneDeltaPair.roleA;
       const roleB = toneDeltaPair.roleB;
       const delta = toneDeltaPair.delta;
       const polarity = toneDeltaPair.polarity;
       const stayTogether = toneDeltaPair.stayTogether;
-      const bg = this.background(scheme);
-      const bgTone = bg.getTone(scheme);
       const aIsNearer = polarity === 'nearer' || polarity === 'lighter' && !scheme.isDark || polarity === 'darker' && scheme.isDark;
       const nearer = aIsNearer ? roleA : roleB;
       const farther = aIsNearer ? roleB : roleA;
-      const amNearer = this.name === nearer.name;
+      const amNearer = color.name === nearer.name;
       const expansionDir = scheme.isDark ? 1 : -1;
-      // 1st round: solve to min, each
-      const nContrast = nearer.contrastCurve.get(scheme.contrastLevel);
-      const fContrast = farther.contrastCurve.get(scheme.contrastLevel);
-      // If a color is good enough, it is not adjusted.
-      // Initial and adjusted tones for `nearer`
-      const nInitialTone = nearer.tone(scheme);
-      let nTone = Contrast.ratioOfTones(bgTone, nInitialTone) >= nContrast ? nInitialTone : DynamicColor.foregroundTone(bgTone, nContrast);
-      // Initial and adjusted tones for `farther`
-      const fInitialTone = farther.tone(scheme);
-      let fTone = Contrast.ratioOfTones(bgTone, fInitialTone) >= fContrast ? fInitialTone : DynamicColor.foregroundTone(bgTone, fContrast);
-      if (decreasingContrast) {
-        // If decreasing contrast, adjust color to the "bare minimum"
-        // that satisfies contrast.
-        nTone = DynamicColor.foregroundTone(bgTone, nContrast);
-        fTone = DynamicColor.foregroundTone(bgTone, fContrast);
+      let nTone = nearer.tone(scheme);
+      let fTone = farther.tone(scheme);
+      // 1st round: solve to min for each, if background and contrast curve
+      // are defined.
+      if (color.background && nearer.contrastCurve && farther.contrastCurve) {
+        const bg = color.background(scheme);
+        const nContrastCurve = nearer.contrastCurve(scheme);
+        const fContrastCurve = farther.contrastCurve(scheme);
+        if (bg && nContrastCurve && fContrastCurve) {
+          const bgTone = bg.getTone(scheme);
+          const nContrast = nContrastCurve.get(scheme.contrastLevel);
+          const fContrast = fContrastCurve.get(scheme.contrastLevel);
+          // If a color is good enough, it is not adjusted.
+          // Initial and adjusted tones for `nearer`
+          if (Contrast.ratioOfTones(bgTone, nTone) < nContrast) {
+            nTone = DynamicColor.foregroundTone(bgTone, nContrast);
+          }
+          // Initial and adjusted tones for `farther`
+          if (Contrast.ratioOfTones(bgTone, fTone) < fContrast) {
+            fTone = DynamicColor.foregroundTone(bgTone, fContrast);
+          }
+          if (decreasingContrast) {
+            // If decreasing contrast, adjust color to the "bare minimum"
+            // that satisfies contrast.
+            nTone = DynamicColor.foregroundTone(bgTone, nContrast);
+            fTone = DynamicColor.foregroundTone(bgTone, fContrast);
+          }
+        }
       }
-      if ((fTone - nTone) * expansionDir >= delta) ; else {
-        // 2nd round: expand farther to match delta.
+      if ((fTone - nTone) * expansionDir < delta) {
+        // 2nd round: expand farther to match delta, if contrast is not
+        // satisfied.
         fTone = clampDouble(0, 100, nTone + delta * expansionDir);
         if ((fTone - nTone) * expansionDir >= delta) ; else {
           // 3rd round: contract nearer to match delta.
@@ -1702,12 +1985,12 @@ class DynamicColor {
       return amNearer ? nTone : fTone;
     } else {
       // Case 2: No contrast pair; just solve for itself.
-      let answer = this.tone(scheme);
-      if (this.background == null) {
+      let answer = color.tone(scheme);
+      if (color.background == undefined || color.background(scheme) === undefined || color.contrastCurve == undefined || color.contrastCurve(scheme) === undefined) {
         return answer; // No adjustment for colors with no background.
       }
-      const bgTone = this.background(scheme).getTone(scheme);
-      const desiredRatio = this.contrastCurve.get(scheme.contrastLevel);
+      const bgTone = color.background(scheme).getTone(scheme);
+      const desiredRatio = color.contrastCurve(scheme).get(scheme.contrastLevel);
       if (Contrast.ratioOfTones(bgTone, answer) >= desiredRatio) ; else {
         // Rough improvement.
         answer = DynamicColor.foregroundTone(bgTone, desiredRatio);
@@ -1715,7 +1998,7 @@ class DynamicColor {
       if (decreasingContrast) {
         answer = DynamicColor.foregroundTone(bgTone, desiredRatio);
       }
-      if (this.isBackground && 50 <= answer && answer < 60) {
+      if (color.isBackground && 50 <= answer && answer < 60) {
         // Must adjust
         if (Contrast.ratioOfTones(49, bgTone) >= desiredRatio) {
           answer = 49;
@@ -1723,99 +2006,159 @@ class DynamicColor {
           answer = 60;
         }
       }
-      if (this.secondBackground) {
-        // Case 3: Adjust for dual backgrounds.
-        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;
+      if (color.secondBackground == undefined || color.secondBackground(scheme) === undefined) {
+        return answer;
+      }
+      // Case 3: Adjust for dual backgrounds.
+      const [bg1, bg2] = [color.background, color.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;
+      }
+      // The darkest light tone that satisfies the desired ratio,
+      // or -1 if such ratio cannot be reached.
+      const lightOption = Contrast.lighter(upper, desiredRatio);
+      // The lightest dark tone that satisfies the desired ratio,
+      // or -1 if such ratio cannot be reached.
+      const darkOption = Contrast.darker(lower, desiredRatio);
+      // Tones suitable for the foreground.
+      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;
+    }
+  }
+}
+/**
+ * A delegate for the color calculation of a DynamicScheme in the 2025 spec.
+ */
+class ColorCalculationDelegateImpl2025 {
+  getHct(scheme, color) {
+    const palette = color.palette(scheme);
+    const tone = color.getTone(scheme);
+    const hue = palette.hue;
+    const chroma = palette.chroma * (color.chromaMultiplier ? color.chromaMultiplier(scheme) : 1);
+    return Hct.from(hue, chroma, tone);
+  }
+  getTone(scheme, color) {
+    const toneDeltaPair = color.toneDeltaPair ? color.toneDeltaPair(scheme) : undefined;
+    // Case 0: tone delta constraint.
+    if (toneDeltaPair) {
+      const roleA = toneDeltaPair.roleA;
+      const roleB = toneDeltaPair.roleB;
+      const polarity = toneDeltaPair.polarity;
+      const constraint = toneDeltaPair.constraint;
+      const absoluteDelta = polarity === 'darker' || polarity === 'relative_lighter' && scheme.isDark || polarity === 'relative_darker' && !scheme.isDark ? -toneDeltaPair.delta : toneDeltaPair.delta;
+      const amRoleA = color.name === roleA.name;
+      const selfRole = amRoleA ? roleA : roleB;
+      const refRole = amRoleA ? roleB : roleA;
+      let selfTone = selfRole.tone(scheme);
+      let refTone = refRole.getTone(scheme);
+      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));
         }
-        // The darkest light tone that satisfies the desired ratio,
-        // or -1 if such ratio cannot be reached.
-        const lightOption = Contrast.lighter(upper, desiredRatio);
-        // The lightest dark tone that satisfies the desired ratio,
-        // or -1 if such ratio cannot be reached.
-        const darkOption = Contrast.darker(lower, desiredRatio);
-        // Tones suitable for the foreground.
-        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;
+      } else if (constraint === 'farther') {
+        if (relativeDelta > 0) {
+          selfTone = clampDouble(refTone + relativeDelta, 100, selfTone);
+        } else {
+          selfTone = clampDouble(0, refTone + relativeDelta, selfTone);
         }
-        if (availables.length === 1) {
-          return availables[0];
+      }
+      if (color.background && color.contrastCurve) {
+        const background = color.background(scheme);
+        const contrastCurve = color.contrastCurve(scheme);
+        if (background && contrastCurve) {
+          // Adjust the tones for contrast, if background and contrast curve
+          // are defined.
+          const bgTone = background.getTone(scheme);
+          const selfContrast = contrastCurve.get(scheme.contrastLevel);
+          selfTone = Contrast.ratioOfTones(bgTone, selfTone) >= selfContrast && scheme.contrastLevel >= 0 ? selfTone : DynamicColor.foregroundTone(bgTone, selfContrast);
         }
-        return darkOption < 0 ? 0 : darkOption;
       }
-      return answer;
-    }
-  }
-  /**
-   * Given a background tone, find 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) {
-      // This handles an edge case where the initial contrast ratio is high
-      // (ex. 13.0), and the ratio passed to the function is that high
-      // ratio, and both the lighter and darker ratio fails to pass that
-      // ratio.
-      //
-      // This was observed with Tonal Spot's On Primary Container turning
-      // black momentarily between high and max contrast in light mode. PC's
-      // standard tone was T90, OPC's was T10, it was light mode, and the
-      // contrast value was 0.6568521221032331.
-      const negligibleDifference = Math.abs(lighterRatio - darkerRatio) < 0.1 && lighterRatio < ratio && darkerRatio < ratio;
-      return lighterRatio >= ratio || lighterRatio >= darkerRatio || negligibleDifference ? lighterTone : darkerTone;
+      // This can avoid the awkward tones for background colors including the
+      // access fixed colors. Accent fixed dim colors should not be adjusted.
+      if (color.isBackground && !color.name.endsWith('_fixed_dim')) {
+        if (selfTone >= 57) {
+          selfTone = clampDouble(65, 100, selfTone);
+        } else {
+          selfTone = clampDouble(0, 49, selfTone);
+        }
+      }
+      return selfTone;
     } 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.0;
-  }
-  /**
-   * Returns whether [tone] can reach a contrast ratio of 4.5 with a lighter
-   * color.
-   */
-  static toneAllowsLightForeground(tone) {
-    return Math.round(tone) <= 49.0;
-  }
-  /**
-   * Adjust 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.0;
+      // Case 1: No tone delta pair; just solve for itself.
+      let answer = color.tone(scheme);
+      if (color.background == undefined || color.background(scheme) === undefined || color.contrastCurve == undefined || color.contrastCurve(scheme) === undefined) {
+        return answer; // No adjustment for colors with no background.
+      }
+      const bgTone = color.background(scheme).getTone(scheme);
+      const desiredRatio = color.contrastCurve(scheme).get(scheme.contrastLevel);
+      // Recalculate the tone from desired contrast ratio if the current
+      // contrast ratio is not enough or desired contrast level is decreasing
+      // (<0).
+      answer = Contrast.ratioOfTones(bgTone, answer) >= desiredRatio && scheme.contrastLevel >= 0 ? answer : DynamicColor.foregroundTone(bgTone, desiredRatio);
+      // This can avoid the awkward tones for background colors including the
+      // access fixed colors. Accent fixed dim colors should not be adjusted.
+      if (color.isBackground && !color.name.endsWith('_fixed_dim')) {
+        if (answer >= 57) {
+          answer = clampDouble(65, 100, answer);
+        } else {
+          answer = clampDouble(0, 49, answer);
+        }
+      }
+      if (color.secondBackground == undefined || color.secondBackground(scheme) === undefined) {
+        return answer;
+      }
+      // Case 2: Adjust for dual backgrounds.
+      const [bg1, bg2] = [color.background, color.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;
+      }
+      // The darkest light tone that satisfies the desired ratio,
+      // or -1 if such ratio cannot be reached.
+      const lightOption = Contrast.lighter(upper, desiredRatio);
+      // The lightest dark tone that satisfies the desired ratio,
+      // or -1 if such ratio cannot be reached.
+      const darkOption = Contrast.darker(lower, desiredRatio);
+      // Tones suitable for the foreground.
+      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;
     }
-    return tone;
   }
 }
+const spec2021$1 = new ColorCalculationDelegateImpl2021();
+const spec2025$1 = new ColorCalculationDelegateImpl2025();
+/**
+ * Returns the ColorCalculationDelegate for the given spec version.
+ */
+function getSpec$1(specVersion) {
+  return specVersion === '2025' ? spec2025$1 : spec2021$1;
+}
 
 /**
  * @license
@@ -1875,7 +2218,11 @@ class TonalPalette {
   tone(tone) {
     let argb = this.cache.get(tone);
     if (argb === undefined) {
-      argb = Hct.from(this.hue, this.chroma, tone).toInt();
+      if (tone == 99 && Hct.isYellow(this.hue)) {
+        argb = this.averageArgb(this.tone(98), this.tone(100));
+      } else {
+        argb = Hct.from(this.hue, this.chroma, tone).toInt();
+      }
       this.cache.set(tone, argb);
     }
     return argb;
@@ -1887,6 +2234,18 @@ class TonalPalette {
   getHct(tone) {
     return Hct.fromInt(this.tone(tone));
   }
+  averageArgb(argb1, argb2) {
+    const red1 = argb1 >>> 16 & 0xff;
+    const green1 = argb1 >>> 8 & 0xff;
+    const blue1 = argb1 & 0xff;
+    const red2 = argb2 >>> 16 & 0xff;
+    const green2 = argb2 >>> 8 & 0xff;
+    const blue2 = argb2 & 0xff;
+    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;
+  }
 }
 /**
  * Key color is a color that represents the hue and chroma of a tonal palette
@@ -1972,34 +2331,299 @@ class KeyColor {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+// This file is automatically generated. Do not modify it.
 /**
- * A class containing a value that changes with the contrast level.
+ * Design utilities using color temperature theory.
  *
- * Usually represents the contrast requirements for a dynamic color on its
- * background. The four values correspond to values for contrast levels -1.0,
- * 0.0, 0.5, and 1.0, respectively.
+ * Analogous colors, complementary color, and cache to efficiently, lazily,
+ * generate data for calculations when needed.
  */
-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;
+class TemperatureCache {
+  constructor(input) {
+    this.input = input;
+    this.hctsByTempCache = [];
+    this.hctsByHueCache = [];
+    this.tempsByHctCache = new Map();
+    this.inputRelativeTemperatureCache = -1;
+    this.complementCache = null;
+  }
+  get hctsByTemp() {
+    if (this.hctsByTempCache.length > 0) {
+      return this.hctsByTempCache;
+    }
+    const hcts = this.hctsByHue.concat([this.input]);
+    const temperaturesByHct = this.tempsByHct;
+    hcts.sort((a, b) => temperaturesByHct.get(a) - temperaturesByHct.get(b));
+    this.hctsByTempCache = hcts;
+    return hcts;
+  }
+  get warmest() {
+    return this.hctsByTemp[this.hctsByTemp.length - 1];
+  }
+  get coldest() {
+    return this.hctsByTemp[0];
   }
   /**
-   * Returns the value at a given contrast level.
+   * A set of colors with differing hues, equidistant in temperature.
    *
-   * @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.
+   * In art, this is usually described as a set of 5 colors on a color wheel
+   * divided into 12 sections. This method allows provision of either of those
+   * values.
+   *
+   * Behavior is undefined when [count] or [divisions] is 0.
+   * When divisions < count, colors repeat.
+   *
+   * [count] The number of colors to return, includes the input color.
+   * [divisions] The number of divisions on the color wheel.
+   */
+  analogous(count = 5, divisions = 12) {
+    const startHue = Math.round(this.input.hue);
+    const startHct = this.hctsByHue[startHue];
+    let lastTemp = this.relativeTemperature(startHct);
+    const allColors = [startHct];
+    let absoluteTotalTempDelta = 0.0;
+    for (let i = 0; i < 360; i++) {
+      const hue = sanitizeDegreesInt(startHue + i);
+      const hct = this.hctsByHue[hue];
+      const temp = this.relativeTemperature(hct);
+      const tempDelta = Math.abs(temp - lastTemp);
+      lastTemp = temp;
+      absoluteTotalTempDelta += tempDelta;
+    }
+    let hueAddend = 1;
+    const tempStep = absoluteTotalTempDelta / divisions;
+    let totalTempDelta = 0.0;
+    lastTemp = this.relativeTemperature(startHct);
+    while (allColors.length < divisions) {
+      const hue = sanitizeDegreesInt(startHue + hueAddend);
+      const hct = this.hctsByHue[hue];
+      const temp = this.relativeTemperature(hct);
+      const tempDelta = Math.abs(temp - lastTemp);
+      totalTempDelta += tempDelta;
+      const desiredTotalTempDeltaForIndex = allColors.length * tempStep;
+      let indexSatisfied = totalTempDelta >= desiredTotalTempDeltaForIndex;
+      let indexAddend = 1;
+      // Keep adding this hue to the answers until its temperature is
+      // insufficient. This ensures consistent behavior when there aren't
+      // [divisions] discrete steps between 0 and 360 in hue with [tempStep]
+      // delta in temperature between them.
+      //
+      // For example, white and black have no analogues: there are no other
+      // colors at T100/T0. Therefore, they should just be added to the array
+      // as answers.
+      while (indexSatisfied && allColors.length < divisions) {
+        allColors.push(hct);
+        const desiredTotalTempDeltaForIndex = (allColors.length + indexAddend) * tempStep;
+        indexSatisfied = totalTempDelta >= desiredTotalTempDeltaForIndex;
+        indexAddend++;
+      }
+      lastTemp = temp;
+      hueAddend++;
+      if (hueAddend > 360) {
+        while (allColors.length < divisions) {
+          allColors.push(hct);
+        }
+        break;
+      }
+    }
+    const answers = [this.input];
+    // First, generate analogues from rotating counter-clockwise.
+    const increaseHueCount = Math.floor((count - 1) / 2.0);
+    for (let i = 1; i < increaseHueCount + 1; i++) {
+      let index = 0 - i;
+      while (index < 0) {
+        index = allColors.length + index;
+      }
+      if (index >= allColors.length) {
+        index = index % allColors.length;
+      }
+      answers.splice(0, 0, allColors[index]);
+    }
+    // Second, generate analogues from rotating clockwise.
+    const decreaseHueCount = count - increaseHueCount - 1;
+    for (let i = 1; i < decreaseHueCount + 1; i++) {
+      let index = i;
+      while (index < 0) {
+        index = allColors.length + index;
+      }
+      if (index >= allColors.length) {
+        index = index % allColors.length;
+      }
+      answers.push(allColors[index]);
+    }
+    return answers;
+  }
+  /**
+   * A color that complements the input color aesthetically.
+   *
+   * In art, this is usually described as being across the color wheel.
+   * History of this shows intent as a color that is just as cool-warm as the
+   * input color is warm-cool.
+   */
+  get complement() {
+    if (this.complementCache != null) {
+      return this.complementCache;
+    }
+    const coldestHue = this.coldest.hue;
+    const coldestTemp = this.tempsByHct.get(this.coldest);
+    const warmestHue = this.warmest.hue;
+    const warmestTemp = this.tempsByHct.get(this.warmest);
+    const range = warmestTemp - coldestTemp;
+    const startHueIsColdestToWarmest = TemperatureCache.isBetween(this.input.hue, coldestHue, warmestHue);
+    const startHue = startHueIsColdestToWarmest ? warmestHue : coldestHue;
+    const endHue = startHueIsColdestToWarmest ? coldestHue : warmestHue;
+    const directionOfRotation = 1.0;
+    let smallestError = 1000.0;
+    let answer = this.hctsByHue[Math.round(this.input.hue)];
+    const complementRelativeTemp = 1.0 - this.inputRelativeTemperature;
+    // Find the color in the other section, closest to the inverse percentile
+    // of the input color. This is the complement.
+    for (let hueAddend = 0.0; hueAddend <= 360.0; hueAddend += 1.0) {
+      const hue = sanitizeDegreesDouble(startHue + directionOfRotation * hueAddend);
+      if (!TemperatureCache.isBetween(hue, startHue, endHue)) {
+        continue;
+      }
+      const possibleAnswer = this.hctsByHue[Math.round(hue)];
+      const relativeTemp = (this.tempsByHct.get(possibleAnswer) - coldestTemp) / range;
+      const error = Math.abs(complementRelativeTemp - relativeTemp);
+      if (error < smallestError) {
+        smallestError = error;
+        answer = possibleAnswer;
+      }
+    }
+    this.complementCache = answer;
+    return this.complementCache;
+  }
+  /**
+   * Temperature relative to all colors with the same chroma and tone.
+   * Value on a scale from 0 to 1.
+   */
+  relativeTemperature(hct) {
+    const range = this.tempsByHct.get(this.warmest) - this.tempsByHct.get(this.coldest);
+    const differenceFromColdest = this.tempsByHct.get(hct) - this.tempsByHct.get(this.coldest);
+    // Handle when there's no difference in temperature between warmest and
+    // coldest: for example, at T100, only one color is available, white.
+    if (range === 0.0) {
+      return 0.5;
+    }
+    return differenceFromColdest / range;
+  }
+  /** Relative temperature of the input color. See [relativeTemperature]. */
+  get inputRelativeTemperature() {
+    if (this.inputRelativeTemperatureCache >= 0.0) {
+      return this.inputRelativeTemperatureCache;
+    }
+    this.inputRelativeTemperatureCache = this.relativeTemperature(this.input);
+    return this.inputRelativeTemperatureCache;
+  }
+  /** A Map with keys of HCTs in [hctsByTemp], values of raw temperature. */
+  get tempsByHct() {
+    if (this.tempsByHctCache.size > 0) {
+      return this.tempsByHctCache;
+    }
+    const allHcts = this.hctsByHue.concat([this.input]);
+    const temperaturesByHct = new Map();
+    for (const e of allHcts) {
+      temperaturesByHct.set(e, TemperatureCache.rawTemperature(e));
+    }
+    this.tempsByHctCache = temperaturesByHct;
+    return temperaturesByHct;
+  }
+  /**
+   * HCTs for all hues, with the same chroma/tone as the input.
+   * Sorted ascending, hue 0 to 360.
+   */
+  get hctsByHue() {
+    if (this.hctsByHueCache.length > 0) {
+      return this.hctsByHueCache;
+    }
+    const hcts = [];
+    for (let hue = 0.0; hue <= 360.0; hue += 1.0) {
+      const colorAtHue = Hct.from(hue, this.input.chroma, this.input.tone);
+      hcts.push(colorAtHue);
+    }
+    this.hctsByHueCache = hcts;
+    return this.hctsByHueCache;
+  }
+  /** Determines if an angle is between two other angles, rotating clockwise. */
+  static isBetween(angle, a, b) {
+    if (a < b) {
+      return a <= angle && angle <= b;
+    }
+    return a <= angle || angle <= b;
+  }
+  /**
+   * Value representing cool-warm factor of a color.
+   * Values below 0 are considered cool, above, warm.
+   *
+   * Color science has researched emotion and harmony, which art uses to select
+   * colors. Warm-cool is the foundation of analogous and complementary colors.
+   * See:
+   * - Li-Chen Ou's Chapter 19 in Handbook of Color Psychology (2015).
+   * - Josef Albers' Interaction of Color chapters 19 and 21.
+   *
+   * Implementation of Ou, Woodcock and Wright's algorithm, which uses
+   * L*a*b* / LCH color space.
+   * Return value has these properties:
+   * - Values below 0 are cool, above 0 are warm.
+   * - Lower bound: -0.52 - (chroma ^ 1.07 / 20). L*a*b* chroma is infinite.
+   *   Assuming max of 130 chroma, -9.66.
+   * - Upper bound: -0.52 + (chroma ^ 1.07 / 20). L*a*b* chroma is infinite.
+   *   Assuming max of 130 chroma, 8.61.
+   */
+  static rawTemperature(color) {
+    const lab = labFromArgb(color.toInt());
+    const hue = sanitizeDegreesDouble(Math.atan2(lab[2], lab[1]) * 180.0 / Math.PI);
+    const chroma = Math.sqrt(lab[1] * lab[1] + lab[2] * lab[2]);
+    const temperature = -0.5 + 0.02 * Math.pow(chroma, 1.07) * Math.cos(sanitizeDegreesDouble(hue - 50.0) * Math.PI / 180.0);
+    return temperature;
+  }
+}
+
+/**
+ * @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.
+ */
+/**
+ * A class containing a value that changes with the contrast level.
+ *
+ * Usually represents the contrast requirements for a dynamic color on its
+ * background. The four values correspond to values for contrast levels -1.0,
+ * 0.0, 0.5, and 1.0, respectively.
+ */
+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) {
@@ -2046,13 +2670,14 @@ class ToneDeltaPair {
    *
    * The polarity is an adjective that describes "A", compared to "B".
    *
-   * For instance, ToneDeltaPair(A, B, 15, 'darker', stayTogether) states that
-   * A's tone should be at least 15 darker than B's.
+   * For instance, ToneDeltaPair(A, B, 15, 'darker', 'exact') states that
+   * A's tone should be exactly 15 darker than B's.
    *
-   * 'nearer' and 'farther' describes closeness to the surface roles. For
-   * instance, ToneDeltaPair(A, B, 10, 'nearer', stayTogether) states that A
-   * should be 10 lighter than B in light mode, and 10 darker than B in dark
-   * mode.
+   * '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.
@@ -2060,16 +2685,19 @@ class ToneDeltaPair {
    * values have undefined behavior.
    * @param polarity The relative relation between tones of roleA and roleB,
    * as described above.
-   * @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
+   * @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) {
+  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';
   }
 }
 
@@ -2109,7 +2737,7 @@ var Variant;
 
 /**
  * @license
- * Copyright 2022 Google LLC
+ * Copyright 2025 Google LLC
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -2123,12 +2751,26 @@ var Variant;
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+/**
+ * Returns true if the scheme is Fidelity or Content.
+ */
 function isFidelity(scheme) {
   return scheme.variant === Variant.FIDELITY || scheme.variant === Variant.CONTENT;
 }
+/**
+ * Returns true if the scheme is Monochrome.
+ */
 function isMonochrome(scheme) {
   return scheme.variant === Variant.MONOCHROME;
 }
+/**
+ * Returns the desired chroma for a given tone at a specific hue.
+ *
+ * @param hue The given hue.
+ * @param chroma The target chroma.
+ * @param tone The tone to start with.
+ * @param byDecreasingTone Whether to search for lower tones.
+ */
 function findDesiredChromaByTone(hue, chroma, tone, byDecreasingTone) {
   let answer = tone;
   let closestToChroma = Hct.from(hue, chroma, tone);
@@ -2154,482 +2796,1979 @@ function findDesiredChromaByTone(hue, chroma, tone, byDecreasingTone) {
   return answer;
 }
 /**
- * DynamicColors for the colors in the Material Design system.
+ * A delegate for the dynamic color spec of a DynamicScheme in the 2021 spec.
  */
-// Material Color Utilities namespaces the various utilities it provides.
-// tslint:disable-next-line:class-as-namespace
-class MaterialDynamicColors {
-  static highestSurface(s) {
-    return s.isDark ? MaterialDynamicColors.surfaceBright : MaterialDynamicColors.surfaceDim;
+class ColorSpecDelegateImpl2021 {
+  ////////////////////////////////////////////////////////////////
+  // Main Palettes                                              //
+  ////////////////////////////////////////////////////////////////
+  primaryPaletteKeyColor() {
+    return DynamicColor.fromPalette({
+      name: 'primary_palette_key_color',
+      palette: s => s.primaryPalette,
+      tone: s => s.primaryPalette.keyColor.tone
+    });
+  }
+  secondaryPaletteKeyColor() {
+    return DynamicColor.fromPalette({
+      name: 'secondary_palette_key_color',
+      palette: s => s.secondaryPalette,
+      tone: s => s.secondaryPalette.keyColor.tone
+    });
+  }
+  tertiaryPaletteKeyColor() {
+    return DynamicColor.fromPalette({
+      name: 'tertiary_palette_key_color',
+      palette: s => s.tertiaryPalette,
+      tone: s => s.tertiaryPalette.keyColor.tone
+    });
+  }
+  neutralPaletteKeyColor() {
+    return DynamicColor.fromPalette({
+      name: 'neutral_palette_key_color',
+      palette: s => s.neutralPalette,
+      tone: s => s.neutralPalette.keyColor.tone
+    });
+  }
+  neutralVariantPaletteKeyColor() {
+    return DynamicColor.fromPalette({
+      name: 'neutral_variant_palette_key_color',
+      palette: s => s.neutralVariantPalette,
+      tone: s => s.neutralVariantPalette.keyColor.tone
+    });
+  }
+  errorPaletteKeyColor() {
+    return DynamicColor.fromPalette({
+      name: 'error_palette_key_color',
+      palette: s => s.errorPalette,
+      tone: s => s.errorPalette.keyColor.tone
+    });
+  }
+  ////////////////////////////////////////////////////////////////
+  // Surfaces [S]                                               //
+  ////////////////////////////////////////////////////////////////
+  background() {
+    return DynamicColor.fromPalette({
+      name: 'background',
+      palette: s => s.neutralPalette,
+      tone: s => s.isDark ? 6 : 98,
+      isBackground: true
+    });
+  }
+  onBackground() {
+    return DynamicColor.fromPalette({
+      name: 'on_background',
+      palette: s => s.neutralPalette,
+      tone: s => s.isDark ? 90 : 10,
+      background: s => this.background(),
+      contrastCurve: s => new ContrastCurve(3, 3, 4.5, 7)
+    });
+  }
+  surface() {
+    return DynamicColor.fromPalette({
+      name: 'surface',
+      palette: s => s.neutralPalette,
+      tone: s => s.isDark ? 6 : 98,
+      isBackground: true
+    });
+  }
+  surfaceDim() {
+    return DynamicColor.fromPalette({
+      name: 'surface_dim',
+      palette: s => s.neutralPalette,
+      tone: s => s.isDark ? 6 : new ContrastCurve(87, 87, 80, 75).get(s.contrastLevel),
+      isBackground: true
+    });
+  }
+  surfaceBright() {
+    return DynamicColor.fromPalette({
+      name: 'surface_bright',
+      palette: s => s.neutralPalette,
+      tone: s => s.isDark ? new ContrastCurve(24, 24, 29, 34).get(s.contrastLevel) : 98,
+      isBackground: true
+    });
+  }
+  surfaceContainerLowest() {
+    return DynamicColor.fromPalette({
+      name: 'surface_container_lowest',
+      palette: s => s.neutralPalette,
+      tone: s => s.isDark ? new ContrastCurve(4, 4, 2, 0).get(s.contrastLevel) : 100,
+      isBackground: true
+    });
+  }
+  surfaceContainerLow() {
+    return DynamicColor.fromPalette({
+      name: 'surface_container_low',
+      palette: s => s.neutralPalette,
+      tone: s => s.isDark ? new ContrastCurve(10, 10, 11, 12).get(s.contrastLevel) : new ContrastCurve(96, 96, 96, 95).get(s.contrastLevel),
+      isBackground: true
+    });
+  }
+  surfaceContainer() {
+    return DynamicColor.fromPalette({
+      name: 'surface_container',
+      palette: s => s.neutralPalette,
+      tone: s => s.isDark ? new ContrastCurve(12, 12, 16, 20).get(s.contrastLevel) : new ContrastCurve(94, 94, 92, 90).get(s.contrastLevel),
+      isBackground: true
+    });
+  }
+  surfaceContainerHigh() {
+    return DynamicColor.fromPalette({
+      name: 'surface_container_high',
+      palette: s => s.neutralPalette,
+      tone: s => s.isDark ? new ContrastCurve(17, 17, 21, 25).get(s.contrastLevel) : new ContrastCurve(92, 92, 88, 85).get(s.contrastLevel),
+      isBackground: true
+    });
+  }
+  surfaceContainerHighest() {
+    return DynamicColor.fromPalette({
+      name: 'surface_container_highest',
+      palette: s => s.neutralPalette,
+      tone: s => s.isDark ? new ContrastCurve(22, 22, 26, 30).get(s.contrastLevel) : new ContrastCurve(90, 90, 84, 80).get(s.contrastLevel),
+      isBackground: true
+    });
+  }
+  onSurface() {
+    return DynamicColor.fromPalette({
+      name: 'on_surface',
+      palette: s => s.neutralPalette,
+      tone: s => s.isDark ? 90 : 10,
+      background: s => this.highestSurface(s),
+      contrastCurve: s => new ContrastCurve(4.5, 7, 11, 21)
+    });
+  }
+  surfaceVariant() {
+    return DynamicColor.fromPalette({
+      name: 'surface_variant',
+      palette: s => s.neutralVariantPalette,
+      tone: s => s.isDark ? 30 : 90,
+      isBackground: true
+    });
+  }
+  onSurfaceVariant() {
+    return DynamicColor.fromPalette({
+      name: 'on_surface_variant',
+      palette: s => s.neutralVariantPalette,
+      tone: s => s.isDark ? 80 : 30,
+      background: s => this.highestSurface(s),
+      contrastCurve: s => new ContrastCurve(3, 4.5, 7, 11)
+    });
+  }
+  inverseSurface() {
+    return DynamicColor.fromPalette({
+      name: 'inverse_surface',
+      palette: s => s.neutralPalette,
+      tone: s => s.isDark ? 90 : 20,
+      isBackground: true
+    });
+  }
+  inverseOnSurface() {
+    return DynamicColor.fromPalette({
+      name: 'inverse_on_surface',
+      palette: s => s.neutralPalette,
+      tone: s => s.isDark ? 20 : 95,
+      background: s => this.inverseSurface(),
+      contrastCurve: s => new ContrastCurve(4.5, 7, 11, 21)
+    });
+  }
+  outline() {
+    return DynamicColor.fromPalette({
+      name: 'outline',
+      palette: s => s.neutralVariantPalette,
+      tone: s => s.isDark ? 60 : 50,
+      background: s => this.highestSurface(s),
+      contrastCurve: s => new ContrastCurve(1.5, 3, 4.5, 7)
+    });
+  }
+  outlineVariant() {
+    return DynamicColor.fromPalette({
+      name: 'outline_variant',
+      palette: s => s.neutralVariantPalette,
+      tone: s => s.isDark ? 30 : 80,
+      background: s => this.highestSurface(s),
+      contrastCurve: s => new ContrastCurve(1, 1, 3, 4.5)
+    });
+  }
+  shadow() {
+    return DynamicColor.fromPalette({
+      name: 'shadow',
+      palette: s => s.neutralPalette,
+      tone: s => 0
+    });
+  }
+  scrim() {
+    return DynamicColor.fromPalette({
+      name: 'scrim',
+      palette: s => s.neutralPalette,
+      tone: s => 0
+    });
+  }
+  surfaceTint() {
+    return DynamicColor.fromPalette({
+      name: 'surface_tint',
+      palette: s => s.primaryPalette,
+      tone: s => s.isDark ? 80 : 40,
+      isBackground: true
+    });
+  }
+  ////////////////////////////////////////////////////////////////
+  // Primary [P].                                               //
+  ////////////////////////////////////////////////////////////////
+  primary() {
+    return DynamicColor.fromPalette({
+      name: 'primary',
+      palette: s => s.primaryPalette,
+      tone: s => {
+        if (isMonochrome(s)) {
+          return s.isDark ? 100 : 0;
+        }
+        return s.isDark ? 80 : 40;
+      },
+      isBackground: true,
+      background: s => this.highestSurface(s),
+      contrastCurve: s => new ContrastCurve(3, 4.5, 7, 7),
+      toneDeltaPair: s => new ToneDeltaPair(this.primaryContainer(), this.primary(), 10, 'nearer', false)
+    });
+  }
+  primaryDim() {
+    return undefined;
+  }
+  onPrimary() {
+    return DynamicColor.fromPalette({
+      name: 'on_primary',
+      palette: s => s.primaryPalette,
+      tone: s => {
+        if (isMonochrome(s)) {
+          return s.isDark ? 10 : 90;
+        }
+        return s.isDark ? 20 : 100;
+      },
+      background: s => this.primary(),
+      contrastCurve: s => new ContrastCurve(4.5, 7, 11, 21)
+    });
+  }
+  primaryContainer() {
+    return DynamicColor.fromPalette({
+      name: 'primary_container',
+      palette: s => s.primaryPalette,
+      tone: s => {
+        if (isFidelity(s)) {
+          return s.sourceColorHct.tone;
+        }
+        if (isMonochrome(s)) {
+          return s.isDark ? 85 : 25;
+        }
+        return s.isDark ? 30 : 90;
+      },
+      isBackground: true,
+      background: s => this.highestSurface(s),
+      contrastCurve: s => new ContrastCurve(1, 1, 3, 4.5),
+      toneDeltaPair: s => new ToneDeltaPair(this.primaryContainer(), this.primary(), 10, 'nearer', false)
+    });
+  }
+  onPrimaryContainer() {
+    return DynamicColor.fromPalette({
+      name: 'on_primary_container',
+      palette: s => s.primaryPalette,
+      tone: s => {
+        if (isFidelity(s)) {
+          return DynamicColor.foregroundTone(this.primaryContainer().tone(s), 4.5);
+        }
+        if (isMonochrome(s)) {
+          return s.isDark ? 0 : 100;
+        }
+        return s.isDark ? 90 : 30;
+      },
+      background: s => this.primaryContainer(),
+      contrastCurve: s => new ContrastCurve(3, 4.5, 7, 11)
+    });
+  }
+  inversePrimary() {
+    return DynamicColor.fromPalette({
+      name: 'inverse_primary',
+      palette: s => s.primaryPalette,
+      tone: s => s.isDark ? 40 : 80,
+      background: s => this.inverseSurface(),
+      contrastCurve: s => new ContrastCurve(3, 4.5, 7, 7)
+    });
+  }
+  /////////////////////////////////////////////////////////////////
+  // Secondary [Q].                                              //
+  /////////////////////////////////////////////////////////////////
+  secondary() {
+    return DynamicColor.fromPalette({
+      name: 'secondary',
+      palette: s => s.secondaryPalette,
+      tone: s => s.isDark ? 80 : 40,
+      isBackground: true,
+      background: s => this.highestSurface(s),
+      contrastCurve: s => new ContrastCurve(3, 4.5, 7, 7),
+      toneDeltaPair: s => new ToneDeltaPair(this.secondaryContainer(), this.secondary(), 10, 'nearer', false)
+    });
+  }
+  secondaryDim() {
+    return undefined;
+  }
+  onSecondary() {
+    return DynamicColor.fromPalette({
+      name: 'on_secondary',
+      palette: s => s.secondaryPalette,
+      tone: s => {
+        if (isMonochrome(s)) {
+          return s.isDark ? 10 : 100;
+        } else {
+          return s.isDark ? 20 : 100;
+        }
+      },
+      background: s => this.secondary(),
+      contrastCurve: s => new ContrastCurve(4.5, 7, 11, 21)
+    });
+  }
+  secondaryContainer() {
+    return DynamicColor.fromPalette({
+      name: 'secondary_container',
+      palette: s => s.secondaryPalette,
+      tone: s => {
+        const initialTone = s.isDark ? 30 : 90;
+        if (isMonochrome(s)) {
+          return s.isDark ? 30 : 85;
+        }
+        if (!isFidelity(s)) {
+          return initialTone;
+        }
+        return findDesiredChromaByTone(s.secondaryPalette.hue, s.secondaryPalette.chroma, initialTone, s.isDark ? false : true);
+      },
+      isBackground: true,
+      background: s => this.highestSurface(s),
+      contrastCurve: s => new ContrastCurve(1, 1, 3, 4.5),
+      toneDeltaPair: s => new ToneDeltaPair(this.secondaryContainer(), this.secondary(), 10, 'nearer', false)
+    });
+  }
+  onSecondaryContainer() {
+    return DynamicColor.fromPalette({
+      name: 'on_secondary_container',
+      palette: s => s.secondaryPalette,
+      tone: s => {
+        if (isMonochrome(s)) {
+          return s.isDark ? 90 : 10;
+        }
+        if (!isFidelity(s)) {
+          return s.isDark ? 90 : 30;
+        }
+        return DynamicColor.foregroundTone(this.secondaryContainer().tone(s), 4.5);
+      },
+      background: s => this.secondaryContainer(),
+      contrastCurve: s => new ContrastCurve(3, 4.5, 7, 11)
+    });
+  }
+  /////////////////////////////////////////////////////////////////
+  // Tertiary [T].                                               //
+  /////////////////////////////////////////////////////////////////
+  tertiary() {
+    return DynamicColor.fromPalette({
+      name: 'tertiary',
+      palette: s => s.tertiaryPalette,
+      tone: s => {
+        if (isMonochrome(s)) {
+          return s.isDark ? 90 : 25;
+        }
+        return s.isDark ? 80 : 40;
+      },
+      isBackground: true,
+      background: s => this.highestSurface(s),
+      contrastCurve: s => new ContrastCurve(3, 4.5, 7, 7),
+      toneDeltaPair: s => new ToneDeltaPair(this.tertiaryContainer(), this.tertiary(), 10, 'nearer', false)
+    });
+  }
+  tertiaryDim() {
+    return undefined;
+  }
+  onTertiary() {
+    return DynamicColor.fromPalette({
+      name: 'on_tertiary',
+      palette: s => s.tertiaryPalette,
+      tone: s => {
+        if (isMonochrome(s)) {
+          return s.isDark ? 10 : 90;
+        }
+        return s.isDark ? 20 : 100;
+      },
+      background: s => this.tertiary(),
+      contrastCurve: s => new ContrastCurve(4.5, 7, 11, 21)
+    });
+  }
+  tertiaryContainer() {
+    return DynamicColor.fromPalette({
+      name: 'tertiary_container',
+      palette: s => s.tertiaryPalette,
+      tone: s => {
+        if (isMonochrome(s)) {
+          return s.isDark ? 60 : 49;
+        }
+        if (!isFidelity(s)) {
+          return s.isDark ? 30 : 90;
+        }
+        const proposedHct = s.tertiaryPalette.getHct(s.sourceColorHct.tone);
+        return DislikeAnalyzer.fixIfDisliked(proposedHct).tone;
+      },
+      isBackground: true,
+      background: s => this.highestSurface(s),
+      contrastCurve: s => new ContrastCurve(1, 1, 3, 4.5),
+      toneDeltaPair: s => new ToneDeltaPair(this.tertiaryContainer(), this.tertiary(), 10, 'nearer', false)
+    });
+  }
+  onTertiaryContainer() {
+    return DynamicColor.fromPalette({
+      name: 'on_tertiary_container',
+      palette: s => s.tertiaryPalette,
+      tone: s => {
+        if (isMonochrome(s)) {
+          return s.isDark ? 0 : 100;
+        }
+        if (!isFidelity(s)) {
+          return s.isDark ? 90 : 30;
+        }
+        return DynamicColor.foregroundTone(this.tertiaryContainer().tone(s), 4.5);
+      },
+      background: s => this.tertiaryContainer(),
+      contrastCurve: s => new ContrastCurve(3, 4.5, 7, 11)
+    });
+  }
+  //////////////////////////////////////////////////////////////////
+  // Error [E].                                                   //
+  //////////////////////////////////////////////////////////////////
+  error() {
+    return DynamicColor.fromPalette({
+      name: 'error',
+      palette: s => s.errorPalette,
+      tone: s => s.isDark ? 80 : 40,
+      isBackground: true,
+      background: s => this.highestSurface(s),
+      contrastCurve: s => new ContrastCurve(3, 4.5, 7, 7),
+      toneDeltaPair: s => new ToneDeltaPair(this.errorContainer(), this.error(), 10, 'nearer', false)
+    });
+  }
+  errorDim() {
+    return undefined;
+  }
+  onError() {
+    return DynamicColor.fromPalette({
+      name: 'on_error',
+      palette: s => s.errorPalette,
+      tone: s => s.isDark ? 20 : 100,
+      background: s => this.error(),
+      contrastCurve: s => new ContrastCurve(4.5, 7, 11, 21)
+    });
+  }
+  errorContainer() {
+    return DynamicColor.fromPalette({
+      name: 'error_container',
+      palette: s => s.errorPalette,
+      tone: s => s.isDark ? 30 : 90,
+      isBackground: true,
+      background: s => this.highestSurface(s),
+      contrastCurve: s => new ContrastCurve(1, 1, 3, 4.5),
+      toneDeltaPair: s => new ToneDeltaPair(this.errorContainer(), this.error(), 10, 'nearer', false)
+    });
+  }
+  onErrorContainer() {
+    return DynamicColor.fromPalette({
+      name: 'on_error_container',
+      palette: s => s.errorPalette,
+      tone: s => {
+        if (isMonochrome(s)) {
+          return s.isDark ? 90 : 10;
+        }
+        return s.isDark ? 90 : 30;
+      },
+      background: s => this.errorContainer(),
+      contrastCurve: s => new ContrastCurve(3, 4.5, 7, 11)
+    });
+  }
+  //////////////////////////////////////////////////////////////////
+  // Primary Fixed [PF]                                           //
+  //////////////////////////////////////////////////////////////////
+  primaryFixed() {
+    return DynamicColor.fromPalette({
+      name: 'primary_fixed',
+      palette: s => s.primaryPalette,
+      tone: s => isMonochrome(s) ? 40.0 : 90.0,
+      isBackground: true,
+      background: s => this.highestSurface(s),
+      contrastCurve: s => new ContrastCurve(1, 1, 3, 4.5),
+      toneDeltaPair: s => new ToneDeltaPair(this.primaryFixed(), this.primaryFixedDim(), 10, 'lighter', true)
+    });
+  }
+  primaryFixedDim() {
+    return DynamicColor.fromPalette({
+      name: 'primary_fixed_dim',
+      palette: s => s.primaryPalette,
+      tone: s => isMonochrome(s) ? 30.0 : 80.0,
+      isBackground: true,
+      background: s => this.highestSurface(s),
+      contrastCurve: s => new ContrastCurve(1, 1, 3, 4.5),
+      toneDeltaPair: s => new ToneDeltaPair(this.primaryFixed(), this.primaryFixedDim(), 10, 'lighter', true)
+    });
+  }
+  onPrimaryFixed() {
+    return DynamicColor.fromPalette({
+      name: 'on_primary_fixed',
+      palette: s => s.primaryPalette,
+      tone: s => isMonochrome(s) ? 100.0 : 10.0,
+      background: s => this.primaryFixedDim(),
+      secondBackground: s => this.primaryFixed(),
+      contrastCurve: s => new ContrastCurve(4.5, 7, 11, 21)
+    });
+  }
+  onPrimaryFixedVariant() {
+    return DynamicColor.fromPalette({
+      name: 'on_primary_fixed_variant',
+      palette: s => s.primaryPalette,
+      tone: s => isMonochrome(s) ? 90.0 : 30.0,
+      background: s => this.primaryFixedDim(),
+      secondBackground: s => this.primaryFixed(),
+      contrastCurve: s => new ContrastCurve(3, 4.5, 7, 11)
+    });
+  }
+  ///////////////////////////////////////////////////////////////////
+  // Secondary Fixed [QF]                                          //
+  ///////////////////////////////////////////////////////////////////
+  secondaryFixed() {
+    return DynamicColor.fromPalette({
+      name: 'secondary_fixed',
+      palette: s => s.secondaryPalette,
+      tone: s => isMonochrome(s) ? 80.0 : 90.0,
+      isBackground: true,
+      background: s => this.highestSurface(s),
+      contrastCurve: s => new ContrastCurve(1, 1, 3, 4.5),
+      toneDeltaPair: s => new ToneDeltaPair(this.secondaryFixed(), this.secondaryFixedDim(), 10, 'lighter', true)
+    });
+  }
+  secondaryFixedDim() {
+    return DynamicColor.fromPalette({
+      name: 'secondary_fixed_dim',
+      palette: s => s.secondaryPalette,
+      tone: s => isMonochrome(s) ? 70.0 : 80.0,
+      isBackground: true,
+      background: s => this.highestSurface(s),
+      contrastCurve: s => new ContrastCurve(1, 1, 3, 4.5),
+      toneDeltaPair: s => new ToneDeltaPair(this.secondaryFixed(), this.secondaryFixedDim(), 10, 'lighter', true)
+    });
+  }
+  onSecondaryFixed() {
+    return DynamicColor.fromPalette({
+      name: 'on_secondary_fixed',
+      palette: s => s.secondaryPalette,
+      tone: s => 10.0,
+      background: s => this.secondaryFixedDim(),
+      secondBackground: s => this.secondaryFixed(),
+      contrastCurve: s => new ContrastCurve(4.5, 7, 11, 21)
+    });
+  }
+  onSecondaryFixedVariant() {
+    return DynamicColor.fromPalette({
+      name: 'on_secondary_fixed_variant',
+      palette: s => s.secondaryPalette,
+      tone: s => isMonochrome(s) ? 25.0 : 30.0,
+      background: s => this.secondaryFixedDim(),
+      secondBackground: s => this.secondaryFixed(),
+      contrastCurve: s => new ContrastCurve(3, 4.5, 7, 11)
+    });
+  }
+  /////////////////////////////////////////////////////////////////
+  // Tertiary Fixed [TF]                                         //
+  /////////////////////////////////////////////////////////////////
+  tertiaryFixed() {
+    return DynamicColor.fromPalette({
+      name: 'tertiary_fixed',
+      palette: s => s.tertiaryPalette,
+      tone: s => isMonochrome(s) ? 40.0 : 90.0,
+      isBackground: true,
+      background: s => this.highestSurface(s),
+      contrastCurve: s => new ContrastCurve(1, 1, 3, 4.5),
+      toneDeltaPair: s => new ToneDeltaPair(this.tertiaryFixed(), this.tertiaryFixedDim(), 10, 'lighter', true)
+    });
+  }
+  tertiaryFixedDim() {
+    return DynamicColor.fromPalette({
+      name: 'tertiary_fixed_dim',
+      palette: s => s.tertiaryPalette,
+      tone: s => isMonochrome(s) ? 30.0 : 80.0,
+      isBackground: true,
+      background: s => this.highestSurface(s),
+      contrastCurve: s => new ContrastCurve(1, 1, 3, 4.5),
+      toneDeltaPair: s => new ToneDeltaPair(this.tertiaryFixed(), this.tertiaryFixedDim(), 10, 'lighter', true)
+    });
+  }
+  onTertiaryFixed() {
+    return DynamicColor.fromPalette({
+      name: 'on_tertiary_fixed',
+      palette: s => s.tertiaryPalette,
+      tone: s => isMonochrome(s) ? 100.0 : 10.0,
+      background: s => this.tertiaryFixedDim(),
+      secondBackground: s => this.tertiaryFixed(),
+      contrastCurve: s => new ContrastCurve(4.5, 7, 11, 21)
+    });
+  }
+  onTertiaryFixedVariant() {
+    return DynamicColor.fromPalette({
+      name: 'on_tertiary_fixed_variant',
+      palette: s => s.tertiaryPalette,
+      tone: s => isMonochrome(s) ? 90.0 : 30.0,
+      background: s => this.tertiaryFixedDim(),
+      secondBackground: s => this.tertiaryFixed(),
+      contrastCurve: s => new ContrastCurve(3, 4.5, 7, 11)
+    });
+  }
+  ////////////////////////////////////////////////////////////////
+  // Other                                                      //
+  ////////////////////////////////////////////////////////////////
+  highestSurface(s) {
+    return s.isDark ? this.surfaceBright() : this.surfaceDim();
   }
 }
-MaterialDynamicColors.contentAccentToneDelta = 15.0;
-MaterialDynamicColors.primaryPaletteKeyColor = DynamicColor.fromPalette({
-  name: 'primary_palette_key_color',
-  palette: s => s.primaryPalette,
-  tone: s => s.primaryPalette.keyColor.tone
-});
-MaterialDynamicColors.secondaryPaletteKeyColor = DynamicColor.fromPalette({
-  name: 'secondary_palette_key_color',
-  palette: s => s.secondaryPalette,
-  tone: s => s.secondaryPalette.keyColor.tone
-});
-MaterialDynamicColors.tertiaryPaletteKeyColor = DynamicColor.fromPalette({
-  name: 'tertiary_palette_key_color',
-  palette: s => s.tertiaryPalette,
-  tone: s => s.tertiaryPalette.keyColor.tone
-});
-MaterialDynamicColors.neutralPaletteKeyColor = DynamicColor.fromPalette({
-  name: 'neutral_palette_key_color',
-  palette: s => s.neutralPalette,
-  tone: s => s.neutralPalette.keyColor.tone
-});
-MaterialDynamicColors.neutralVariantPaletteKeyColor = DynamicColor.fromPalette({
-  name: 'neutral_variant_palette_key_color',
-  palette: s => s.neutralVariantPalette,
-  tone: s => s.neutralVariantPalette.keyColor.tone
-});
-MaterialDynamicColors.background = DynamicColor.fromPalette({
-  name: 'background',
-  palette: s => s.neutralPalette,
-  tone: s => s.isDark ? 6 : 98,
-  isBackground: true
-});
-MaterialDynamicColors.onBackground = DynamicColor.fromPalette({
-  name: 'on_background',
-  palette: s => s.neutralPalette,
-  tone: s => s.isDark ? 90 : 10,
-  background: s => MaterialDynamicColors.background,
-  contrastCurve: new ContrastCurve(3, 3, 4.5, 7)
-});
-MaterialDynamicColors.surface = DynamicColor.fromPalette({
-  name: 'surface',
-  palette: s => s.neutralPalette,
-  tone: s => s.isDark ? 6 : 98,
-  isBackground: true
-});
-MaterialDynamicColors.surfaceDim = DynamicColor.fromPalette({
-  name: 'surface_dim',
-  palette: s => s.neutralPalette,
-  tone: s => s.isDark ? 6 : new ContrastCurve(87, 87, 80, 75).get(s.contrastLevel),
-  isBackground: true
-});
-MaterialDynamicColors.surfaceBright = DynamicColor.fromPalette({
-  name: 'surface_bright',
-  palette: s => s.neutralPalette,
-  tone: s => s.isDark ? new ContrastCurve(24, 24, 29, 34).get(s.contrastLevel) : 98,
-  isBackground: true
-});
-MaterialDynamicColors.surfaceContainerLowest = DynamicColor.fromPalette({
-  name: 'surface_container_lowest',
-  palette: s => s.neutralPalette,
-  tone: s => s.isDark ? new ContrastCurve(4, 4, 2, 0).get(s.contrastLevel) : 100,
-  isBackground: true
-});
-MaterialDynamicColors.surfaceContainerLow = DynamicColor.fromPalette({
-  name: 'surface_container_low',
-  palette: s => s.neutralPalette,
-  tone: s => s.isDark ? new ContrastCurve(10, 10, 11, 12).get(s.contrastLevel) : new ContrastCurve(96, 96, 96, 95).get(s.contrastLevel),
-  isBackground: true
-});
-MaterialDynamicColors.surfaceContainer = DynamicColor.fromPalette({
-  name: 'surface_container',
-  palette: s => s.neutralPalette,
-  tone: s => s.isDark ? new ContrastCurve(12, 12, 16, 20).get(s.contrastLevel) : new ContrastCurve(94, 94, 92, 90).get(s.contrastLevel),
-  isBackground: true
-});
-MaterialDynamicColors.surfaceContainerHigh = DynamicColor.fromPalette({
-  name: 'surface_container_high',
-  palette: s => s.neutralPalette,
-  tone: s => s.isDark ? new ContrastCurve(17, 17, 21, 25).get(s.contrastLevel) : new ContrastCurve(92, 92, 88, 85).get(s.contrastLevel),
-  isBackground: true
-});
-MaterialDynamicColors.surfaceContainerHighest = DynamicColor.fromPalette({
-  name: 'surface_container_highest',
-  palette: s => s.neutralPalette,
-  tone: s => s.isDark ? new ContrastCurve(22, 22, 26, 30).get(s.contrastLevel) : new ContrastCurve(90, 90, 84, 80).get(s.contrastLevel),
-  isBackground: true
-});
-MaterialDynamicColors.onSurface = DynamicColor.fromPalette({
-  name: 'on_surface',
-  palette: s => s.neutralPalette,
-  tone: s => s.isDark ? 90 : 10,
-  background: s => MaterialDynamicColors.highestSurface(s),
-  contrastCurve: new ContrastCurve(4.5, 7, 11, 21)
-});
-MaterialDynamicColors.surfaceVariant = DynamicColor.fromPalette({
-  name: 'surface_variant',
-  palette: s => s.neutralVariantPalette,
-  tone: s => s.isDark ? 30 : 90,
-  isBackground: true
-});
-MaterialDynamicColors.onSurfaceVariant = DynamicColor.fromPalette({
-  name: 'on_surface_variant',
-  palette: s => s.neutralVariantPalette,
-  tone: s => s.isDark ? 80 : 30,
-  background: s => MaterialDynamicColors.highestSurface(s),
-  contrastCurve: new ContrastCurve(3, 4.5, 7, 11)
-});
-MaterialDynamicColors.inverseSurface = DynamicColor.fromPalette({
-  name: 'inverse_surface',
-  palette: s => s.neutralPalette,
-  tone: s => s.isDark ? 90 : 20
-});
-MaterialDynamicColors.inverseOnSurface = DynamicColor.fromPalette({
-  name: 'inverse_on_surface',
-  palette: s => s.neutralPalette,
-  tone: s => s.isDark ? 20 : 95,
-  background: s => MaterialDynamicColors.inverseSurface,
-  contrastCurve: new ContrastCurve(4.5, 7, 11, 21)
-});
-MaterialDynamicColors.outline = DynamicColor.fromPalette({
-  name: 'outline',
-  palette: s => s.neutralVariantPalette,
-  tone: s => s.isDark ? 60 : 50,
-  background: s => MaterialDynamicColors.highestSurface(s),
-  contrastCurve: new ContrastCurve(1.5, 3, 4.5, 7)
-});
-MaterialDynamicColors.outlineVariant = DynamicColor.fromPalette({
-  name: 'outline_variant',
-  palette: s => s.neutralVariantPalette,
-  tone: s => s.isDark ? 30 : 80,
-  background: s => MaterialDynamicColors.highestSurface(s),
-  contrastCurve: new ContrastCurve(1, 1, 3, 4.5)
-});
-MaterialDynamicColors.shadow = DynamicColor.fromPalette({
-  name: 'shadow',
-  palette: s => s.neutralPalette,
-  tone: s => 0
-});
-MaterialDynamicColors.scrim = DynamicColor.fromPalette({
-  name: 'scrim',
-  palette: s => s.neutralPalette,
-  tone: s => 0
-});
-MaterialDynamicColors.surfaceTint = DynamicColor.fromPalette({
-  name: 'surface_tint',
-  palette: s => s.primaryPalette,
-  tone: s => s.isDark ? 80 : 40,
-  isBackground: true
-});
-MaterialDynamicColors.primary = DynamicColor.fromPalette({
-  name: 'primary',
-  palette: s => s.primaryPalette,
-  tone: s => {
-    if (isMonochrome(s)) {
-      return s.isDark ? 100 : 0;
-    }
-    return s.isDark ? 80 : 40;
-  },
-  isBackground: true,
-  background: s => MaterialDynamicColors.highestSurface(s),
-  contrastCurve: new ContrastCurve(3, 4.5, 7, 7),
-  toneDeltaPair: s => new ToneDeltaPair(MaterialDynamicColors.primaryContainer, MaterialDynamicColors.primary, 10, 'nearer', false)
-});
-MaterialDynamicColors.onPrimary = DynamicColor.fromPalette({
-  name: 'on_primary',
-  palette: s => s.primaryPalette,
-  tone: s => {
-    if (isMonochrome(s)) {
-      return s.isDark ? 10 : 90;
-    }
-    return s.isDark ? 20 : 100;
-  },
-  background: s => MaterialDynamicColors.primary,
-  contrastCurve: new ContrastCurve(4.5, 7, 11, 21)
-});
-MaterialDynamicColors.primaryContainer = DynamicColor.fromPalette({
-  name: 'primary_container',
-  palette: s => s.primaryPalette,
-  tone: s => {
-    if (isFidelity(s)) {
-      return s.sourceColorHct.tone;
-    }
-    if (isMonochrome(s)) {
-      return s.isDark ? 85 : 25;
-    }
-    return s.isDark ? 30 : 90;
-  },
-  isBackground: true,
-  background: s => MaterialDynamicColors.highestSurface(s),
-  contrastCurve: new ContrastCurve(1, 1, 3, 4.5),
-  toneDeltaPair: s => new ToneDeltaPair(MaterialDynamicColors.primaryContainer, MaterialDynamicColors.primary, 10, 'nearer', false)
-});
-MaterialDynamicColors.onPrimaryContainer = DynamicColor.fromPalette({
-  name: 'on_primary_container',
-  palette: s => s.primaryPalette,
-  tone: s => {
-    if (isFidelity(s)) {
-      return DynamicColor.foregroundTone(MaterialDynamicColors.primaryContainer.tone(s), 4.5);
-    }
-    if (isMonochrome(s)) {
-      return s.isDark ? 0 : 100;
-    }
-    return s.isDark ? 90 : 30;
-  },
-  background: s => MaterialDynamicColors.primaryContainer,
-  contrastCurve: new ContrastCurve(3, 4.5, 7, 11)
-});
-MaterialDynamicColors.inversePrimary = DynamicColor.fromPalette({
-  name: 'inverse_primary',
-  palette: s => s.primaryPalette,
-  tone: s => s.isDark ? 40 : 80,
-  background: s => MaterialDynamicColors.inverseSurface,
-  contrastCurve: new ContrastCurve(3, 4.5, 7, 7)
-});
-MaterialDynamicColors.secondary = DynamicColor.fromPalette({
-  name: 'secondary',
-  palette: s => s.secondaryPalette,
-  tone: s => s.isDark ? 80 : 40,
-  isBackground: true,
-  background: s => MaterialDynamicColors.highestSurface(s),
-  contrastCurve: new ContrastCurve(3, 4.5, 7, 7),
-  toneDeltaPair: s => new ToneDeltaPair(MaterialDynamicColors.secondaryContainer, MaterialDynamicColors.secondary, 10, 'nearer', false)
-});
-MaterialDynamicColors.onSecondary = DynamicColor.fromPalette({
-  name: 'on_secondary',
-  palette: s => s.secondaryPalette,
-  tone: s => {
-    if (isMonochrome(s)) {
-      return s.isDark ? 10 : 100;
-    } else {
-      return s.isDark ? 20 : 100;
-    }
-  },
-  background: s => MaterialDynamicColors.secondary,
-  contrastCurve: new ContrastCurve(4.5, 7, 11, 21)
-});
-MaterialDynamicColors.secondaryContainer = DynamicColor.fromPalette({
-  name: 'secondary_container',
-  palette: s => s.secondaryPalette,
-  tone: s => {
-    const initialTone = s.isDark ? 30 : 90;
-    if (isMonochrome(s)) {
-      return s.isDark ? 30 : 85;
-    }
-    if (!isFidelity(s)) {
-      return initialTone;
-    }
-    return findDesiredChromaByTone(s.secondaryPalette.hue, s.secondaryPalette.chroma, initialTone, s.isDark ? false : true);
-  },
-  isBackground: true,
-  background: s => MaterialDynamicColors.highestSurface(s),
-  contrastCurve: new ContrastCurve(1, 1, 3, 4.5),
-  toneDeltaPair: s => new ToneDeltaPair(MaterialDynamicColors.secondaryContainer, MaterialDynamicColors.secondary, 10, 'nearer', false)
-});
-MaterialDynamicColors.onSecondaryContainer = DynamicColor.fromPalette({
-  name: 'on_secondary_container',
-  palette: s => s.secondaryPalette,
-  tone: s => {
-    if (isMonochrome(s)) {
-      return s.isDark ? 90 : 10;
-    }
-    if (!isFidelity(s)) {
-      return s.isDark ? 90 : 30;
-    }
-    return DynamicColor.foregroundTone(MaterialDynamicColors.secondaryContainer.tone(s), 4.5);
-  },
-  background: s => MaterialDynamicColors.secondaryContainer,
-  contrastCurve: new ContrastCurve(3, 4.5, 7, 11)
-});
-MaterialDynamicColors.tertiary = DynamicColor.fromPalette({
-  name: 'tertiary',
-  palette: s => s.tertiaryPalette,
-  tone: s => {
-    if (isMonochrome(s)) {
-      return s.isDark ? 90 : 25;
-    }
-    return s.isDark ? 80 : 40;
-  },
-  isBackground: true,
-  background: s => MaterialDynamicColors.highestSurface(s),
-  contrastCurve: new ContrastCurve(3, 4.5, 7, 7),
-  toneDeltaPair: s => new ToneDeltaPair(MaterialDynamicColors.tertiaryContainer, MaterialDynamicColors.tertiary, 10, 'nearer', false)
-});
-MaterialDynamicColors.onTertiary = DynamicColor.fromPalette({
-  name: 'on_tertiary',
-  palette: s => s.tertiaryPalette,
-  tone: s => {
-    if (isMonochrome(s)) {
-      return s.isDark ? 10 : 90;
-    }
-    return s.isDark ? 20 : 100;
-  },
-  background: s => MaterialDynamicColors.tertiary,
-  contrastCurve: new ContrastCurve(4.5, 7, 11, 21)
-});
-MaterialDynamicColors.tertiaryContainer = DynamicColor.fromPalette({
-  name: 'tertiary_container',
-  palette: s => s.tertiaryPalette,
-  tone: s => {
-    if (isMonochrome(s)) {
-      return s.isDark ? 60 : 49;
-    }
-    if (!isFidelity(s)) {
-      return s.isDark ? 30 : 90;
-    }
-    const proposedHct = s.tertiaryPalette.getHct(s.sourceColorHct.tone);
-    return DislikeAnalyzer.fixIfDisliked(proposedHct).tone;
-  },
-  isBackground: true,
-  background: s => MaterialDynamicColors.highestSurface(s),
-  contrastCurve: new ContrastCurve(1, 1, 3, 4.5),
-  toneDeltaPair: s => new ToneDeltaPair(MaterialDynamicColors.tertiaryContainer, MaterialDynamicColors.tertiary, 10, 'nearer', false)
-});
-MaterialDynamicColors.onTertiaryContainer = DynamicColor.fromPalette({
-  name: 'on_tertiary_container',
-  palette: s => s.tertiaryPalette,
-  tone: s => {
-    if (isMonochrome(s)) {
-      return s.isDark ? 0 : 100;
-    }
-    if (!isFidelity(s)) {
-      return s.isDark ? 90 : 30;
+
+/**
+ * @license
+ * Copyright 2025 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.
+ */
+/**
+ * Returns the maximum tone for a given chroma in the palette.
+ *
+ * @param palette The tonal palette to use.
+ * @param lowerBound The lower bound of the tone.
+ * @param upperBound The upper bound of the tone.
+ */
+function tMaxC(palette, lowerBound = 0, upperBound = 100, chromaMultiplier = 1) {
+  let answer = findBestToneForChroma(palette.hue, palette.chroma * chromaMultiplier, 100, true);
+  return clampDouble(lowerBound, upperBound, answer);
+}
+/**
+ * Returns the minimum tone for a given chroma in the palette.
+ *
+ * @param palette The tonal palette to use.
+ * @param lowerBound The lower bound of the tone.
+ * @param upperBound The upper bound of the tone.
+ */
+function tMinC(palette, lowerBound = 0, upperBound = 100) {
+  let answer = findBestToneForChroma(palette.hue, palette.chroma, 0, false);
+  return clampDouble(lowerBound, upperBound, answer);
+}
+/**
+ * Searches for the best tone with a given chroma from a given tone at a
+ * specific hue.
+ *
+ * @param hue The given hue.
+ * @param chroma The target chroma.
+ * @param tone The tone to start with.
+ * @param byDecreasingTone Whether to search for lower tones.
+ */
+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;
     }
-    return DynamicColor.foregroundTone(MaterialDynamicColors.tertiaryContainer.tone(s), 4.5);
-  },
-  background: s => MaterialDynamicColors.tertiaryContainer,
-  contrastCurve: new ContrastCurve(3, 4.5, 7, 11)
-});
-MaterialDynamicColors.error = DynamicColor.fromPalette({
-  name: 'error',
-  palette: s => s.errorPalette,
-  tone: s => s.isDark ? 80 : 40,
-  isBackground: true,
-  background: s => MaterialDynamicColors.highestSurface(s),
-  contrastCurve: new ContrastCurve(3, 4.5, 7, 7),
-  toneDeltaPair: s => new ToneDeltaPair(MaterialDynamicColors.errorContainer, MaterialDynamicColors.error, 10, 'nearer', false)
-});
-MaterialDynamicColors.onError = DynamicColor.fromPalette({
-  name: 'on_error',
-  palette: s => s.errorPalette,
-  tone: s => s.isDark ? 20 : 100,
-  background: s => MaterialDynamicColors.error,
-  contrastCurve: new ContrastCurve(4.5, 7, 11, 21)
-});
-MaterialDynamicColors.errorContainer = DynamicColor.fromPalette({
-  name: 'error_container',
-  palette: s => s.errorPalette,
-  tone: s => s.isDark ? 30 : 90,
-  isBackground: true,
-  background: s => MaterialDynamicColors.highestSurface(s),
-  contrastCurve: new ContrastCurve(1, 1, 3, 4.5),
-  toneDeltaPair: s => new ToneDeltaPair(MaterialDynamicColors.errorContainer, MaterialDynamicColors.error, 10, 'nearer', false)
-});
-MaterialDynamicColors.onErrorContainer = DynamicColor.fromPalette({
-  name: 'on_error_container',
-  palette: s => s.errorPalette,
-  tone: s => {
-    if (isMonochrome(s)) {
-      return s.isDark ? 90 : 10;
+    tone += byDecreasingTone ? -1 : 1.0;
+    const newCandidate = Hct.from(hue, chroma, tone);
+    if (bestCandidate.chroma < newCandidate.chroma) {
+      bestCandidate = newCandidate;
+      answer = tone;
     }
-    return s.isDark ? 90 : 30;
-  },
-  background: s => MaterialDynamicColors.errorContainer,
-  contrastCurve: new ContrastCurve(3, 4.5, 7, 11)
-});
-MaterialDynamicColors.primaryFixed = DynamicColor.fromPalette({
-  name: 'primary_fixed',
-  palette: s => s.primaryPalette,
-  tone: s => isMonochrome(s) ? 40.0 : 90.0,
-  isBackground: true,
-  background: s => MaterialDynamicColors.highestSurface(s),
-  contrastCurve: new ContrastCurve(1, 1, 3, 4.5),
-  toneDeltaPair: s => new ToneDeltaPair(MaterialDynamicColors.primaryFixed, MaterialDynamicColors.primaryFixedDim, 10, 'lighter', true)
-});
-MaterialDynamicColors.primaryFixedDim = DynamicColor.fromPalette({
-  name: 'primary_fixed_dim',
-  palette: s => s.primaryPalette,
-  tone: s => isMonochrome(s) ? 30.0 : 80.0,
-  isBackground: true,
-  background: s => MaterialDynamicColors.highestSurface(s),
-  contrastCurve: new ContrastCurve(1, 1, 3, 4.5),
-  toneDeltaPair: s => new ToneDeltaPair(MaterialDynamicColors.primaryFixed, MaterialDynamicColors.primaryFixedDim, 10, 'lighter', true)
-});
-MaterialDynamicColors.onPrimaryFixed = DynamicColor.fromPalette({
-  name: 'on_primary_fixed',
-  palette: s => s.primaryPalette,
-  tone: s => isMonochrome(s) ? 100.0 : 10.0,
-  background: s => MaterialDynamicColors.primaryFixedDim,
-  secondBackground: s => MaterialDynamicColors.primaryFixed,
-  contrastCurve: new ContrastCurve(4.5, 7, 11, 21)
-});
-MaterialDynamicColors.onPrimaryFixedVariant = DynamicColor.fromPalette({
-  name: 'on_primary_fixed_variant',
-  palette: s => s.primaryPalette,
-  tone: s => isMonochrome(s) ? 90.0 : 30.0,
-  background: s => MaterialDynamicColors.primaryFixedDim,
-  secondBackground: s => MaterialDynamicColors.primaryFixed,
-  contrastCurve: new ContrastCurve(3, 4.5, 7, 11)
-});
-MaterialDynamicColors.secondaryFixed = DynamicColor.fromPalette({
-  name: 'secondary_fixed',
-  palette: s => s.secondaryPalette,
-  tone: s => isMonochrome(s) ? 80.0 : 90.0,
-  isBackground: true,
-  background: s => MaterialDynamicColors.highestSurface(s),
-  contrastCurve: new ContrastCurve(1, 1, 3, 4.5),
-  toneDeltaPair: s => new ToneDeltaPair(MaterialDynamicColors.secondaryFixed, MaterialDynamicColors.secondaryFixedDim, 10, 'lighter', true)
-});
-MaterialDynamicColors.secondaryFixedDim = DynamicColor.fromPalette({
-  name: 'secondary_fixed_dim',
-  palette: s => s.secondaryPalette,
-  tone: s => isMonochrome(s) ? 70.0 : 80.0,
-  isBackground: true,
-  background: s => MaterialDynamicColors.highestSurface(s),
-  contrastCurve: new ContrastCurve(1, 1, 3, 4.5),
-  toneDeltaPair: s => new ToneDeltaPair(MaterialDynamicColors.secondaryFixed, MaterialDynamicColors.secondaryFixedDim, 10, 'lighter', true)
-});
-MaterialDynamicColors.onSecondaryFixed = DynamicColor.fromPalette({
-  name: 'on_secondary_fixed',
-  palette: s => s.secondaryPalette,
-  tone: s => 10.0,
-  background: s => MaterialDynamicColors.secondaryFixedDim,
-  secondBackground: s => MaterialDynamicColors.secondaryFixed,
-  contrastCurve: new ContrastCurve(4.5, 7, 11, 21)
-});
-MaterialDynamicColors.onSecondaryFixedVariant = DynamicColor.fromPalette({
-  name: 'on_secondary_fixed_variant',
-  palette: s => s.secondaryPalette,
-  tone: s => isMonochrome(s) ? 25.0 : 30.0,
-  background: s => MaterialDynamicColors.secondaryFixedDim,
-  secondBackground: s => MaterialDynamicColors.secondaryFixed,
-  contrastCurve: new ContrastCurve(3, 4.5, 7, 11)
-});
-MaterialDynamicColors.tertiaryFixed = DynamicColor.fromPalette({
-  name: 'tertiary_fixed',
-  palette: s => s.tertiaryPalette,
-  tone: s => isMonochrome(s) ? 40.0 : 90.0,
-  isBackground: true,
-  background: s => MaterialDynamicColors.highestSurface(s),
-  contrastCurve: new ContrastCurve(1, 1, 3, 4.5),
-  toneDeltaPair: s => new ToneDeltaPair(MaterialDynamicColors.tertiaryFixed, MaterialDynamicColors.tertiaryFixedDim, 10, 'lighter', true)
-});
-MaterialDynamicColors.tertiaryFixedDim = DynamicColor.fromPalette({
-  name: 'tertiary_fixed_dim',
-  palette: s => s.tertiaryPalette,
-  tone: s => isMonochrome(s) ? 30.0 : 80.0,
-  isBackground: true,
-  background: s => MaterialDynamicColors.highestSurface(s),
-  contrastCurve: new ContrastCurve(1, 1, 3, 4.5),
-  toneDeltaPair: s => new ToneDeltaPair(MaterialDynamicColors.tertiaryFixed, MaterialDynamicColors.tertiaryFixedDim, 10, 'lighter', true)
-});
-MaterialDynamicColors.onTertiaryFixed = DynamicColor.fromPalette({
-  name: 'on_tertiary_fixed',
-  palette: s => s.tertiaryPalette,
-  tone: s => isMonochrome(s) ? 100.0 : 10.0,
-  background: s => MaterialDynamicColors.tertiaryFixedDim,
-  secondBackground: s => MaterialDynamicColors.tertiaryFixed,
-  contrastCurve: new ContrastCurve(4.5, 7, 11, 21)
-});
-MaterialDynamicColors.onTertiaryFixedVariant = DynamicColor.fromPalette({
-  name: 'on_tertiary_fixed_variant',
-  palette: s => s.tertiaryPalette,
-  tone: s => isMonochrome(s) ? 90.0 : 30.0,
-  background: s => MaterialDynamicColors.tertiaryFixedDim,
-  secondBackground: s => MaterialDynamicColors.tertiaryFixed,
-  contrastCurve: new ContrastCurve(3, 4.5, 7, 11)
-});
+  }
+  return answer;
+}
+/**
+ * Returns the contrast curve for a given default contrast.
+ *
+ * @param defaultContrast The default contrast to use.
+ */
+function getCurve(defaultContrast) {
+  if (defaultContrast === 1.5) {
+    return new ContrastCurve(1.5, 1.5, 3, 5.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 {
+    // Shouldn't happen.
+    return new ContrastCurve(defaultContrast, defaultContrast, 7, 21);
+  }
+}
+/**
+ * A delegate for the dynamic color spec of a DynamicScheme in the 2025 spec.
+ */
+class ColorSpecDelegateImpl2025 extends ColorSpecDelegateImpl2021 {
+  ////////////////////////////////////////////////////////////////
+  // Surfaces [S]                                               //
+  ////////////////////////////////////////////////////////////////
+  surface() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'surface',
+      palette: s => s.neutralPalette,
+      tone: s => {
+        super.surface().tone(s);
+        if (s.platform === 'phone') {
+          if (s.isDark) {
+            return 4;
+          } else {
+            if (Hct.isYellow(s.neutralPalette.hue)) {
+              return 99;
+            } else if (s.variant === Variant.VIBRANT) {
+              return 97;
+            } else {
+              return 98;
+            }
+          }
+        } else {
+          return 0;
+        }
+      },
+      isBackground: true
+    });
+    return extendSpecVersion(super.surface(), '2025', color2025);
+  }
+  surfaceDim() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'surface_dim',
+      palette: s => s.neutralPalette,
+      tone: s => {
+        if (s.isDark) {
+          return 4;
+        } else {
+          if (Hct.isYellow(s.neutralPalette.hue)) {
+            return 90;
+          } else if (s.variant === Variant.VIBRANT) {
+            return 85;
+          } else {
+            return 87;
+          }
+        }
+      },
+      isBackground: true,
+      chromaMultiplier: s => {
+        if (!s.isDark) {
+          if (s.variant === Variant.NEUTRAL) {
+            return 2.5;
+          } else if (s.variant === Variant.TONAL_SPOT) {
+            return 1.7;
+          } else if (s.variant === Variant.EXPRESSIVE) {
+            return Hct.isYellow(s.neutralPalette.hue) ? 2.7 : 1.75;
+          } else if (s.variant === Variant.VIBRANT) {
+            return 1.36;
+          }
+        }
+        return 1;
+      }
+    });
+    return extendSpecVersion(super.surfaceDim(), '2025', color2025);
+  }
+  surfaceBright() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'surface_bright',
+      palette: s => s.neutralPalette,
+      tone: s => {
+        if (s.isDark) {
+          return 18;
+        } else {
+          if (Hct.isYellow(s.neutralPalette.hue)) {
+            return 99;
+          } else if (s.variant === Variant.VIBRANT) {
+            return 97;
+          } else {
+            return 98;
+          }
+        }
+      },
+      isBackground: true,
+      chromaMultiplier: s => {
+        if (s.isDark) {
+          if (s.variant === Variant.NEUTRAL) {
+            return 2.5;
+          } else if (s.variant === Variant.TONAL_SPOT) {
+            return 1.7;
+          } else if (s.variant === Variant.EXPRESSIVE) {
+            return Hct.isYellow(s.neutralPalette.hue) ? 2.7 : 1.75;
+          } else if (s.variant === Variant.VIBRANT) {
+            return 1.36;
+          }
+        }
+        return 1;
+      }
+    });
+    return extendSpecVersion(super.surfaceBright(), '2025', color2025);
+  }
+  surfaceContainerLowest() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'surface_container_lowest',
+      palette: s => s.neutralPalette,
+      tone: s => s.isDark ? 0 : 100,
+      isBackground: true
+    });
+    return extendSpecVersion(super.surfaceContainerLowest(), '2025', color2025);
+  }
+  surfaceContainerLow() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'surface_container_low',
+      palette: s => s.neutralPalette,
+      tone: s => {
+        if (s.platform === 'phone') {
+          if (s.isDark) {
+            return 6;
+          } else {
+            if (Hct.isYellow(s.neutralPalette.hue)) {
+              return 98;
+            } else if (s.variant === Variant.VIBRANT) {
+              return 95;
+            } else {
+              return 96;
+            }
+          }
+        } else {
+          return 15;
+        }
+      },
+      isBackground: true,
+      chromaMultiplier: s => {
+        if (s.platform === 'phone') {
+          if (s.variant === Variant.NEUTRAL) {
+            return 1.3;
+          } else if (s.variant === Variant.TONAL_SPOT) {
+            return 1.25;
+          } else if (s.variant === Variant.EXPRESSIVE) {
+            return Hct.isYellow(s.neutralPalette.hue) ? 1.3 : 1.15;
+          } else if (s.variant === Variant.VIBRANT) {
+            return 1.08;
+          }
+        }
+        return 1;
+      }
+    });
+    return extendSpecVersion(super.surfaceContainerLow(), '2025', color2025);
+  }
+  surfaceContainer() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'surface_container',
+      palette: s => s.neutralPalette,
+      tone: s => {
+        if (s.platform === 'phone') {
+          if (s.isDark) {
+            return 9;
+          } else {
+            if (Hct.isYellow(s.neutralPalette.hue)) {
+              return 96;
+            } else if (s.variant === Variant.VIBRANT) {
+              return 92;
+            } else {
+              return 94;
+            }
+          }
+        } else {
+          return 20;
+        }
+      },
+      isBackground: true,
+      chromaMultiplier: s => {
+        if (s.platform === 'phone') {
+          if (s.variant === Variant.NEUTRAL) {
+            return 1.6;
+          } else if (s.variant === Variant.TONAL_SPOT) {
+            return 1.4;
+          } else if (s.variant === Variant.EXPRESSIVE) {
+            return Hct.isYellow(s.neutralPalette.hue) ? 1.6 : 1.3;
+          } else if (s.variant === Variant.VIBRANT) {
+            return 1.15;
+          }
+        }
+        return 1;
+      }
+    });
+    return extendSpecVersion(super.surfaceContainer(), '2025', color2025);
+  }
+  surfaceContainerHigh() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'surface_container_high',
+      palette: s => s.neutralPalette,
+      tone: s => {
+        if (s.platform === 'phone') {
+          if (s.isDark) {
+            return 12;
+          } else {
+            if (Hct.isYellow(s.neutralPalette.hue)) {
+              return 94;
+            } else if (s.variant === Variant.VIBRANT) {
+              return 90;
+            } else {
+              return 92;
+            }
+          }
+        } else {
+          return 25;
+        }
+      },
+      isBackground: true,
+      chromaMultiplier: s => {
+        if (s.platform === 'phone') {
+          if (s.variant === Variant.NEUTRAL) {
+            return 1.9;
+          } else if (s.variant === Variant.TONAL_SPOT) {
+            return 1.5;
+          } else if (s.variant === Variant.EXPRESSIVE) {
+            return Hct.isYellow(s.neutralPalette.hue) ? 1.95 : 1.45;
+          } else if (s.variant === Variant.VIBRANT) {
+            return 1.22;
+          }
+        }
+        return 1;
+      }
+    });
+    return extendSpecVersion(super.surfaceContainerHigh(), '2025', color2025);
+  }
+  surfaceContainerHighest() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'surface_container_highest',
+      palette: s => s.neutralPalette,
+      tone: s => {
+        if (s.isDark) {
+          return 15;
+        } else {
+          if (Hct.isYellow(s.neutralPalette.hue)) {
+            return 92;
+          } else if (s.variant === Variant.VIBRANT) {
+            return 88;
+          } else {
+            return 90;
+          }
+        }
+      },
+      isBackground: true,
+      chromaMultiplier: s => {
+        if (s.variant === Variant.NEUTRAL) {
+          return 2.2;
+        } else if (s.variant === Variant.TONAL_SPOT) {
+          return 1.7;
+        } else if (s.variant === Variant.EXPRESSIVE) {
+          return Hct.isYellow(s.neutralPalette.hue) ? 2.3 : 1.6;
+        } else if (s.variant === Variant.VIBRANT) {
+          return 1.29;
+        } else {
+          // default
+          return 1;
+        }
+      }
+    });
+    return extendSpecVersion(super.surfaceContainerHighest(), '2025', color2025);
+  }
+  onSurface() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'on_surface',
+      palette: s => s.neutralPalette,
+      tone: s => {
+        if (s.variant === Variant.VIBRANT) {
+          return tMaxC(s.neutralPalette, 0, 100, 1.1);
+        } else {
+          // For all other variants, the initial tone should be the default
+          // tone, which is the same as the background color.
+          return DynamicColor.getInitialToneFromBackground(s => s.platform === 'phone' ? this.highestSurface(s) : this.surfaceContainerHigh())(s);
+        }
+      },
+      chromaMultiplier: s => {
+        if (s.platform === 'phone') {
+          if (s.variant === Variant.NEUTRAL) {
+            return 2.2;
+          } else if (s.variant === Variant.TONAL_SPOT) {
+            return 1.7;
+          } else if (s.variant === Variant.EXPRESSIVE) {
+            return Hct.isYellow(s.neutralPalette.hue) ? s.isDark ? 3.0 : 2.3 : 1.6;
+          }
+        }
+        return 1;
+      },
+      background: s => s.platform === 'phone' ? this.highestSurface(s) : this.surfaceContainerHigh(),
+      contrastCurve: s => s.isDark && s.platform === 'phone' ? getCurve(11) : getCurve(9)
+    });
+    return extendSpecVersion(super.onSurface(), '2025', color2025);
+  }
+  onSurfaceVariant() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'on_surface_variant',
+      palette: s => s.neutralPalette,
+      chromaMultiplier: s => {
+        if (s.platform === 'phone') {
+          if (s.variant === Variant.NEUTRAL) {
+            return 2.2;
+          } else if (s.variant === Variant.TONAL_SPOT) {
+            return 1.7;
+          } else if (s.variant === Variant.EXPRESSIVE) {
+            return Hct.isYellow(s.neutralPalette.hue) ? s.isDark ? 3.0 : 2.3 : 1.6;
+          }
+        }
+        return 1;
+      },
+      background: s => s.platform === 'phone' ? this.highestSurface(s) : this.surfaceContainerHigh(),
+      contrastCurve: s => s.platform === 'phone' ? s.isDark ? getCurve(6) : getCurve(4.5) : getCurve(7)
+    });
+    return extendSpecVersion(super.onSurfaceVariant(), '2025', color2025);
+  }
+  outline() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'outline',
+      palette: s => s.neutralPalette,
+      chromaMultiplier: s => {
+        if (s.platform === 'phone') {
+          if (s.variant === Variant.NEUTRAL) {
+            return 2.2;
+          } else if (s.variant === Variant.TONAL_SPOT) {
+            return 1.7;
+          } else if (s.variant === Variant.EXPRESSIVE) {
+            return Hct.isYellow(s.neutralPalette.hue) ? s.isDark ? 3.0 : 2.3 : 1.6;
+          }
+        }
+        return 1;
+      },
+      background: s => s.platform === 'phone' ? this.highestSurface(s) : this.surfaceContainerHigh(),
+      contrastCurve: s => s.platform === 'phone' ? getCurve(3) : getCurve(4.5)
+    });
+    return extendSpecVersion(super.outline(), '2025', color2025);
+  }
+  outlineVariant() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'outline_variant',
+      palette: s => s.neutralPalette,
+      chromaMultiplier: s => {
+        if (s.platform === 'phone') {
+          if (s.variant === Variant.NEUTRAL) {
+            return 2.2;
+          } else if (s.variant === Variant.TONAL_SPOT) {
+            return 1.7;
+          } else if (s.variant === Variant.EXPRESSIVE) {
+            return Hct.isYellow(s.neutralPalette.hue) ? s.isDark ? 3.0 : 2.3 : 1.6;
+          }
+        }
+        return 1;
+      },
+      background: s => s.platform === 'phone' ? this.highestSurface(s) : this.surfaceContainerHigh(),
+      contrastCurve: s => s.platform === 'phone' ? getCurve(1.5) : getCurve(3)
+    });
+    return extendSpecVersion(super.outlineVariant(), '2025', color2025);
+  }
+  inverseSurface() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'inverse_surface',
+      palette: s => s.neutralPalette,
+      tone: s => s.isDark ? 98 : 4,
+      isBackground: true
+    });
+    return extendSpecVersion(super.inverseSurface(), '2025', color2025);
+  }
+  inverseOnSurface() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'inverse_on_surface',
+      palette: s => s.neutralPalette,
+      background: s => this.inverseSurface(),
+      contrastCurve: s => getCurve(7)
+    });
+    return extendSpecVersion(super.inverseOnSurface(), '2025', color2025);
+  }
+  ////////////////////////////////////////////////////////////////
+  // Primaries [P]                                              //
+  ////////////////////////////////////////////////////////////////
+  primary() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'primary',
+      palette: s => s.primaryPalette,
+      tone: s => {
+        if (s.variant === Variant.NEUTRAL) {
+          if (s.platform === 'phone') {
+            return s.isDark ? 80 : 40;
+          } else {
+            return 90;
+          }
+        } else if (s.variant === Variant.TONAL_SPOT) {
+          if (s.platform === 'phone') {
+            if (s.isDark) {
+              return 80;
+            } else {
+              return tMaxC(s.primaryPalette);
+            }
+          } else {
+            return tMaxC(s.primaryPalette, 0, 90);
+          }
+        } else if (s.variant === Variant.EXPRESSIVE) {
+          if (s.platform === 'phone') {
+            return tMaxC(s.primaryPalette, 0, Hct.isYellow(s.primaryPalette.hue) ? 25 : Hct.isCyan(s.primaryPalette.hue) ? 88 : 98);
+          } else {
+            // WATCH
+            return tMaxC(s.primaryPalette);
+          }
+        } else {
+          // VIBRANT
+          if (s.platform === 'phone') {
+            return tMaxC(s.primaryPalette, 0, Hct.isCyan(s.primaryPalette.hue) ? 88 : 98);
+          } else {
+            // WATCH
+            return tMaxC(s.primaryPalette);
+          }
+        }
+      },
+      isBackground: true,
+      background: s => s.platform === 'phone' ? this.highestSurface(s) : this.surfaceContainerHigh(),
+      contrastCurve: s => s.platform === 'phone' ? getCurve(4.5) : getCurve(7),
+      toneDeltaPair: s => s.platform === 'phone' ? new ToneDeltaPair(this.primaryContainer(), this.primary(), 5, 'relative_lighter', true, 'farther') : undefined
+    });
+    return extendSpecVersion(super.primary(), '2025', color2025);
+  }
+  primaryDim() {
+    return DynamicColor.fromPalette({
+      name: 'primary_dim',
+      palette: s => s.primaryPalette,
+      tone: s => {
+        if (s.variant === Variant.NEUTRAL) {
+          return 85;
+        } else if (s.variant === Variant.TONAL_SPOT) {
+          return tMaxC(s.primaryPalette, 0, 90);
+        } else {
+          return tMaxC(s.primaryPalette);
+        }
+      },
+      isBackground: true,
+      background: s => this.surfaceContainerHigh(),
+      contrastCurve: s => getCurve(4.5),
+      toneDeltaPair: s => new ToneDeltaPair(this.primaryDim(), this.primary(), 5, 'darker', true, 'farther')
+    });
+  }
+  onPrimary() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'on_primary',
+      palette: s => s.primaryPalette,
+      background: s => s.platform === 'phone' ? this.primary() : this.primaryDim(),
+      contrastCurve: s => s.platform === 'phone' ? getCurve(6) : getCurve(7)
+    });
+    return extendSpecVersion(super.onPrimary(), '2025', color2025);
+  }
+  primaryContainer() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'primary_container',
+      palette: s => s.primaryPalette,
+      tone: s => {
+        if (s.platform === 'watch') {
+          return 30;
+        } else if (s.variant === Variant.NEUTRAL) {
+          return s.isDark ? 30 : 90;
+        } else if (s.variant === Variant.TONAL_SPOT) {
+          return s.isDark ? tMinC(s.primaryPalette, 35, 93) : tMaxC(s.primaryPalette, 0, 90);
+        } else if (s.variant === Variant.EXPRESSIVE) {
+          return s.isDark ? tMaxC(s.primaryPalette, 30, 93) : tMaxC(s.primaryPalette, 78, Hct.isCyan(s.primaryPalette.hue) ? 88 : 90);
+        } else {
+          // VIBRANT
+          return s.isDark ? tMinC(s.primaryPalette, 66, 93) : tMaxC(s.primaryPalette, 66, Hct.isCyan(s.primaryPalette.hue) ? 88 : 93);
+        }
+      },
+      isBackground: true,
+      background: s => s.platform === 'phone' ? this.highestSurface(s) : undefined,
+      toneDeltaPair: s => s.platform === 'phone' ? undefined : new ToneDeltaPair(this.primaryContainer(), this.primaryDim(), 10, 'darker', true, 'farther'),
+      contrastCurve: s => s.platform === 'phone' && s.contrastLevel > 0 ? getCurve(1.5) : undefined
+    });
+    return extendSpecVersion(super.primaryContainer(), '2025', color2025);
+  }
+  onPrimaryContainer() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'on_primary_container',
+      palette: s => s.primaryPalette,
+      background: s => this.primaryContainer(),
+      contrastCurve: s => s.platform === 'phone' ? getCurve(6) : getCurve(7)
+    });
+    return extendSpecVersion(super.onPrimaryContainer(), '2025', color2025);
+  }
+  primaryFixed() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'primary_fixed',
+      palette: s => s.primaryPalette,
+      tone: s => {
+        let tempS = Object.assign({}, s, {
+          isDark: false,
+          contrastLevel: 0
+        });
+        return this.primaryContainer().getTone(tempS);
+      },
+      isBackground: true,
+      background: s => s.platform === 'phone' ? this.highestSurface(s) : undefined,
+      contrastCurve: s => s.platform === 'phone' && s.contrastLevel > 0 ? getCurve(1.5) : undefined
+    });
+    return extendSpecVersion(super.primaryFixed(), '2025', color2025);
+  }
+  primaryFixedDim() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'primary_fixed_dim',
+      palette: s => s.primaryPalette,
+      tone: s => this.primaryFixed().getTone(s),
+      isBackground: true,
+      toneDeltaPair: s => new ToneDeltaPair(this.primaryFixedDim(), this.primaryFixed(), 5, 'darker', true, 'exact')
+    });
+    return extendSpecVersion(super.primaryFixedDim(), '2025', color2025);
+  }
+  onPrimaryFixed() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'on_primary_fixed',
+      palette: s => s.primaryPalette,
+      background: s => this.primaryFixedDim(),
+      contrastCurve: s => getCurve(7)
+    });
+    return extendSpecVersion(super.onPrimaryFixed(), '2025', color2025);
+  }
+  onPrimaryFixedVariant() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'on_primary_fixed_variant',
+      palette: s => s.primaryPalette,
+      background: s => this.primaryFixedDim(),
+      contrastCurve: s => getCurve(4.5)
+    });
+    return extendSpecVersion(super.onPrimaryFixedVariant(), '2025', color2025);
+  }
+  inversePrimary() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'inverse_primary',
+      palette: s => s.primaryPalette,
+      tone: s => tMaxC(s.primaryPalette),
+      background: s => this.inverseSurface(),
+      contrastCurve: s => s.platform === 'phone' ? getCurve(6) : getCurve(7)
+    });
+    return extendSpecVersion(super.inversePrimary(), '2025', color2025);
+  }
+  ////////////////////////////////////////////////////////////////
+  // Secondaries [Q]                                            //
+  ////////////////////////////////////////////////////////////////
+  secondary() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'secondary',
+      palette: s => s.secondaryPalette,
+      tone: s => {
+        if (s.platform === 'watch') {
+          return s.variant === Variant.NEUTRAL ? 90 : tMaxC(s.secondaryPalette, 0, 90);
+        } else if (s.variant === Variant.NEUTRAL) {
+          return s.isDark ? tMinC(s.secondaryPalette, 0, 98) : tMaxC(s.secondaryPalette);
+        } else if (s.variant === Variant.VIBRANT) {
+          return tMaxC(s.secondaryPalette, 0, s.isDark ? 90 : 98);
+        } else {
+          // EXPRESSIVE and TONAL_SPOT
+          return s.isDark ? 80 : tMaxC(s.secondaryPalette);
+        }
+      },
+      isBackground: true,
+      background: s => s.platform === 'phone' ? this.highestSurface(s) : this.surfaceContainerHigh(),
+      contrastCurve: s => s.platform === 'phone' ? getCurve(4.5) : getCurve(7),
+      toneDeltaPair: s => s.platform === 'phone' ? new ToneDeltaPair(this.secondaryContainer(), this.secondary(), 5, 'relative_lighter', true, 'farther') : undefined
+    });
+    return extendSpecVersion(super.secondary(), '2025', color2025);
+  }
+  secondaryDim() {
+    return DynamicColor.fromPalette({
+      name: 'secondary_dim',
+      palette: s => s.secondaryPalette,
+      tone: s => {
+        if (s.variant === Variant.NEUTRAL) {
+          return 85;
+        } else {
+          return tMaxC(s.secondaryPalette, 0, 90);
+        }
+      },
+      isBackground: true,
+      background: s => this.surfaceContainerHigh(),
+      contrastCurve: s => getCurve(4.5),
+      toneDeltaPair: s => new ToneDeltaPair(this.secondaryDim(), this.secondary(), 5, 'darker', true, 'farther')
+    });
+  }
+  onSecondary() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'on_secondary',
+      palette: s => s.secondaryPalette,
+      background: s => s.platform === 'phone' ? this.secondary() : this.secondaryDim(),
+      contrastCurve: s => s.platform === 'phone' ? getCurve(6) : getCurve(7)
+    });
+    return extendSpecVersion(super.onSecondary(), '2025', color2025);
+  }
+  secondaryContainer() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'secondary_container',
+      palette: s => s.secondaryPalette,
+      tone: s => {
+        if (s.platform === 'watch') {
+          return 30;
+        } else if (s.variant === Variant.VIBRANT) {
+          return s.isDark ? tMinC(s.secondaryPalette, 30, 40) : tMaxC(s.secondaryPalette, 84, 90);
+        } else if (s.variant === Variant.EXPRESSIVE) {
+          return s.isDark ? 15 : tMaxC(s.secondaryPalette, 90, 95);
+        } else {
+          return s.isDark ? 25 : 90;
+        }
+      },
+      isBackground: true,
+      background: s => s.platform === 'phone' ? this.highestSurface(s) : undefined,
+      toneDeltaPair: s => s.platform === 'watch' ? new ToneDeltaPair(this.secondaryContainer(), this.secondaryDim(), 10, 'darker', true, 'farther') : undefined,
+      contrastCurve: s => s.platform === 'phone' && s.contrastLevel > 0 ? getCurve(1.5) : undefined
+    });
+    return extendSpecVersion(super.secondaryContainer(), '2025', color2025);
+  }
+  onSecondaryContainer() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'on_secondary_container',
+      palette: s => s.secondaryPalette,
+      background: s => this.secondaryContainer(),
+      contrastCurve: s => s.platform === 'phone' ? getCurve(6) : getCurve(7)
+    });
+    return extendSpecVersion(super.onSecondaryContainer(), '2025', color2025);
+  }
+  secondaryFixed() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'secondary_fixed',
+      palette: s => s.secondaryPalette,
+      tone: s => {
+        let tempS = Object.assign({}, s, {
+          isDark: false,
+          contrastLevel: 0
+        });
+        return this.secondaryContainer().getTone(tempS);
+      },
+      isBackground: true,
+      background: s => s.platform === 'phone' ? this.highestSurface(s) : undefined,
+      contrastCurve: s => s.platform === 'phone' && s.contrastLevel > 0 ? getCurve(1.5) : undefined
+    });
+    return extendSpecVersion(super.secondaryFixed(), '2025', color2025);
+  }
+  secondaryFixedDim() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'secondary_fixed_dim',
+      palette: s => s.secondaryPalette,
+      tone: s => this.secondaryFixed().getTone(s),
+      isBackground: true,
+      toneDeltaPair: s => new ToneDeltaPair(this.secondaryFixedDim(), this.secondaryFixed(), 5, 'darker', true, 'exact')
+    });
+    return extendSpecVersion(super.secondaryFixedDim(), '2025', color2025);
+  }
+  onSecondaryFixed() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'on_secondary_fixed',
+      palette: s => s.secondaryPalette,
+      background: s => this.secondaryFixedDim(),
+      contrastCurve: s => getCurve(7)
+    });
+    return extendSpecVersion(super.onSecondaryFixed(), '2025', color2025);
+  }
+  onSecondaryFixedVariant() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'on_secondary_fixed_variant',
+      palette: s => s.secondaryPalette,
+      background: s => this.secondaryFixedDim(),
+      contrastCurve: s => getCurve(4.5)
+    });
+    return extendSpecVersion(super.onSecondaryFixedVariant(), '2025', color2025);
+  }
+  ////////////////////////////////////////////////////////////////
+  // Tertiaries [T]                                             //
+  ////////////////////////////////////////////////////////////////
+  tertiary() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'tertiary',
+      palette: s => s.tertiaryPalette,
+      tone: s => {
+        if (s.platform === 'watch') {
+          return s.variant === Variant.TONAL_SPOT ? tMaxC(s.tertiaryPalette, 0, 90) : tMaxC(s.tertiaryPalette);
+        } else if (s.variant === Variant.EXPRESSIVE || s.variant === Variant.VIBRANT) {
+          return tMaxC(s.tertiaryPalette, 0, Hct.isCyan(s.tertiaryPalette.hue) ? 88 : s.isDark ? 98 : 100);
+        } else {
+          // NEUTRAL and TONAL_SPOT
+          return s.isDark ? tMaxC(s.tertiaryPalette, 0, 98) : tMaxC(s.tertiaryPalette);
+        }
+      },
+      isBackground: true,
+      background: s => s.platform === 'phone' ? this.highestSurface(s) : this.surfaceContainerHigh(),
+      contrastCurve: s => s.platform === 'phone' ? getCurve(4.5) : getCurve(7),
+      toneDeltaPair: s => s.platform === 'phone' ? new ToneDeltaPair(this.tertiaryContainer(), this.tertiary(), 5, 'relative_lighter', true, 'farther') : undefined
+    });
+    return extendSpecVersion(super.tertiary(), '2025', color2025);
+  }
+  tertiaryDim() {
+    return DynamicColor.fromPalette({
+      name: 'tertiary_dim',
+      palette: s => s.tertiaryPalette,
+      tone: s => {
+        if (s.variant === Variant.TONAL_SPOT) {
+          return tMaxC(s.tertiaryPalette, 0, 90);
+        } else {
+          return tMaxC(s.tertiaryPalette);
+        }
+      },
+      isBackground: true,
+      background: s => this.surfaceContainerHigh(),
+      contrastCurve: s => getCurve(4.5),
+      toneDeltaPair: s => new ToneDeltaPair(this.tertiaryDim(), this.tertiary(), 5, 'darker', true, 'farther')
+    });
+  }
+  onTertiary() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'on_tertiary',
+      palette: s => s.tertiaryPalette,
+      background: s => s.platform === 'phone' ? this.tertiary() : this.tertiaryDim(),
+      contrastCurve: s => s.platform === 'phone' ? getCurve(6) : getCurve(7)
+    });
+    return extendSpecVersion(super.onTertiary(), '2025', color2025);
+  }
+  tertiaryContainer() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'tertiary_container',
+      palette: s => s.tertiaryPalette,
+      tone: s => {
+        if (s.platform === 'watch') {
+          return s.variant === Variant.TONAL_SPOT ? tMaxC(s.tertiaryPalette, 0, 90) : tMaxC(s.tertiaryPalette);
+        } else {
+          if (s.variant === Variant.NEUTRAL) {
+            return s.isDark ? tMaxC(s.tertiaryPalette, 0, 93) : tMaxC(s.tertiaryPalette, 0, 96);
+          } else if (s.variant === Variant.TONAL_SPOT) {
+            return tMaxC(s.tertiaryPalette, 0, s.isDark ? 93 : 100);
+          } else if (s.variant === Variant.EXPRESSIVE) {
+            return tMaxC(s.tertiaryPalette, 75, Hct.isCyan(s.tertiaryPalette.hue) ? 88 : s.isDark ? 93 : 100);
+          } else {
+            // VIBRANT
+            return s.isDark ? tMaxC(s.tertiaryPalette, 0, 93) : tMaxC(s.tertiaryPalette, 72, 100);
+          }
+        }
+      },
+      isBackground: true,
+      background: s => s.platform === 'phone' ? this.highestSurface(s) : undefined,
+      toneDeltaPair: s => s.platform === 'watch' ? new ToneDeltaPair(this.tertiaryContainer(), this.tertiaryDim(), 10, 'darker', true, 'farther') : undefined,
+      contrastCurve: s => s.platform === 'phone' && s.contrastLevel > 0 ? getCurve(1.5) : undefined
+    });
+    return extendSpecVersion(super.tertiaryContainer(), '2025', color2025);
+  }
+  onTertiaryContainer() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'on_tertiary_container',
+      palette: s => s.tertiaryPalette,
+      background: s => this.tertiaryContainer(),
+      contrastCurve: s => s.platform === 'phone' ? getCurve(6) : getCurve(7)
+    });
+    return extendSpecVersion(super.onTertiaryContainer(), '2025', color2025);
+  }
+  tertiaryFixed() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'tertiary_fixed',
+      palette: s => s.tertiaryPalette,
+      tone: s => {
+        let tempS = Object.assign({}, s, {
+          isDark: false,
+          contrastLevel: 0
+        });
+        return this.tertiaryContainer().getTone(tempS);
+      },
+      isBackground: true,
+      background: s => s.platform === 'phone' ? this.highestSurface(s) : undefined,
+      contrastCurve: s => s.platform === 'phone' && s.contrastLevel > 0 ? getCurve(1.5) : undefined
+    });
+    return extendSpecVersion(super.tertiaryFixed(), '2025', color2025);
+  }
+  tertiaryFixedDim() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'tertiary_fixed_dim',
+      palette: s => s.tertiaryPalette,
+      tone: s => this.tertiaryFixed().getTone(s),
+      isBackground: true,
+      toneDeltaPair: s => new ToneDeltaPair(this.tertiaryFixedDim(), this.tertiaryFixed(), 5, 'darker', true, 'exact')
+    });
+    return extendSpecVersion(super.tertiaryFixedDim(), '2025', color2025);
+  }
+  onTertiaryFixed() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'on_tertiary_fixed',
+      palette: s => s.tertiaryPalette,
+      background: s => this.tertiaryFixedDim(),
+      contrastCurve: s => getCurve(7)
+    });
+    return extendSpecVersion(super.onTertiaryFixed(), '2025', color2025);
+  }
+  onTertiaryFixedVariant() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'on_tertiary_fixed_variant',
+      palette: s => s.tertiaryPalette,
+      background: s => this.tertiaryFixedDim(),
+      contrastCurve: s => getCurve(4.5)
+    });
+    return extendSpecVersion(super.onTertiaryFixedVariant(), '2025', color2025);
+  }
+  ////////////////////////////////////////////////////////////////
+  // Errors [E]                                                 //
+  ////////////////////////////////////////////////////////////////
+  error() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'error',
+      palette: s => s.errorPalette,
+      tone: s => {
+        if (s.platform === 'phone') {
+          return s.isDark ? tMinC(s.errorPalette, 0, 98) : tMaxC(s.errorPalette);
+        } else {
+          return tMinC(s.errorPalette);
+        }
+      },
+      isBackground: true,
+      background: s => s.platform === 'phone' ? this.highestSurface(s) : this.surfaceContainerHigh(),
+      contrastCurve: s => s.platform === 'phone' ? getCurve(4.5) : getCurve(7),
+      toneDeltaPair: s => s.platform === 'phone' ? new ToneDeltaPair(this.errorContainer(), this.error(), 5, 'relative_lighter', true, 'farther') : undefined
+    });
+    return extendSpecVersion(super.error(), '2025', color2025);
+  }
+  errorDim() {
+    return DynamicColor.fromPalette({
+      name: 'error_dim',
+      palette: s => s.errorPalette,
+      tone: s => tMinC(s.errorPalette),
+      isBackground: true,
+      background: s => this.surfaceContainerHigh(),
+      contrastCurve: s => getCurve(4.5),
+      toneDeltaPair: s => new ToneDeltaPair(this.errorDim(), this.error(), 5, 'darker', true, 'farther')
+    });
+  }
+  onError() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'on_error',
+      palette: s => s.errorPalette,
+      background: s => s.platform === 'phone' ? this.error() : this.errorDim(),
+      contrastCurve: s => s.platform === 'phone' ? getCurve(6) : getCurve(7)
+    });
+    return extendSpecVersion(super.onError(), '2025', color2025);
+  }
+  errorContainer() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'error_container',
+      palette: s => s.errorPalette,
+      tone: s => {
+        if (s.platform === 'watch') {
+          return 30;
+        } else {
+          return s.isDark ? tMinC(s.errorPalette, 30, 93) : tMaxC(s.errorPalette, 0, 90);
+        }
+      },
+      isBackground: true,
+      background: s => s.platform === 'phone' ? this.highestSurface(s) : undefined,
+      toneDeltaPair: s => s.platform === 'watch' ? new ToneDeltaPair(this.errorContainer(), this.errorDim(), 10, 'darker', true, 'farther') : undefined,
+      contrastCurve: s => s.platform === 'phone' && s.contrastLevel > 0 ? getCurve(1.5) : undefined
+    });
+    return extendSpecVersion(super.errorContainer(), '2025', color2025);
+  }
+  onErrorContainer() {
+    const color2025 = DynamicColor.fromPalette({
+      name: 'on_error_container',
+      palette: s => s.errorPalette,
+      background: s => this.errorContainer(),
+      contrastCurve: s => s.platform === 'phone' ? getCurve(4.5) : getCurve(7)
+    });
+    return extendSpecVersion(super.onErrorContainer(), '2025', color2025);
+  }
+  /////////////////////////////////////////////////////////////////
+  // Remapped Colors                                             //
+  /////////////////////////////////////////////////////////////////
+  surfaceVariant() {
+    const color2025 = Object.assign(this.surfaceContainerHighest().clone(), {
+      name: 'surface_variant'
+    });
+    return extendSpecVersion(super.surfaceVariant(), '2025', color2025);
+  }
+  surfaceTint() {
+    const color2025 = Object.assign(this.primary().clone(), {
+      name: 'surface_tint'
+    });
+    return extendSpecVersion(super.surfaceTint(), '2025', color2025);
+  }
+  background() {
+    const color2025 = Object.assign(this.surface().clone(), {
+      name: 'background'
+    });
+    return extendSpecVersion(super.background(), '2025', color2025);
+  }
+  onBackground() {
+    const color2025 = Object.assign(this.onSurface().clone(), {
+      name: 'on_background',
+      tone: s => {
+        return s.platform === 'watch' ? 100.0 : this.onSurface().getTone(s);
+      }
+    });
+    return extendSpecVersion(super.onBackground(), '2025', color2025);
+  }
+}
+
+/**
+ * @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.
+ */
+/**
+ * DynamicColors for the colors in the Material Design system.
+ */
+// Material Color Utilities namespaces the various utilities it provides.
+// tslint:disable-next-line:class-as-namespace
+class MaterialDynamicColors {
+  constructor() {
+    ////////////////////////////////////////////////////////////////
+    // All Colors                                                 //
+    ////////////////////////////////////////////////////////////////
+    this.allColors = [this.background(), this.onBackground(), this.surface(), this.surfaceDim(), this.surfaceBright(), this.surfaceContainerLowest(), this.surfaceContainerLow(), this.surfaceContainer(), this.surfaceContainerHigh(), this.surfaceContainerHighest(), this.onSurface(), this.onSurfaceVariant(), this.outline(), this.outlineVariant(), this.inverseSurface(), this.inverseOnSurface(), this.primary(), this.primaryDim(), this.onPrimary(), this.primaryContainer(), this.onPrimaryContainer(), this.primaryFixed(), this.primaryFixedDim(), this.onPrimaryFixed(), this.onPrimaryFixedVariant(), this.inversePrimary(), this.secondary(), this.secondaryDim(), this.onSecondary(), this.secondaryContainer(), this.onSecondaryContainer(), this.secondaryFixed(), this.secondaryFixedDim(), this.onSecondaryFixed(), this.onSecondaryFixedVariant(), this.tertiary(), this.tertiaryDim(), this.onTertiary(), this.tertiaryContainer(), this.onTertiaryContainer(), this.tertiaryFixed(), this.tertiaryFixedDim(), this.onTertiaryFixed(), this.onTertiaryFixedVariant(), this.error(), this.errorDim(), this.onError(), this.errorContainer(), this.onErrorContainer()].filter(c => c !== undefined);
+  }
+  highestSurface(s) {
+    return MaterialDynamicColors.colorSpec.highestSurface(s);
+  }
+  ////////////////////////////////////////////////////////////////
+  // Main Palettes                                              //
+  ////////////////////////////////////////////////////////////////
+  primaryPaletteKeyColor() {
+    return MaterialDynamicColors.colorSpec.primaryPaletteKeyColor();
+  }
+  secondaryPaletteKeyColor() {
+    return MaterialDynamicColors.colorSpec.secondaryPaletteKeyColor();
+  }
+  tertiaryPaletteKeyColor() {
+    return MaterialDynamicColors.colorSpec.tertiaryPaletteKeyColor();
+  }
+  neutralPaletteKeyColor() {
+    return MaterialDynamicColors.colorSpec.neutralPaletteKeyColor();
+  }
+  neutralVariantPaletteKeyColor() {
+    return MaterialDynamicColors.colorSpec.neutralVariantPaletteKeyColor();
+  }
+  errorPaletteKeyColor() {
+    return MaterialDynamicColors.colorSpec.errorPaletteKeyColor();
+  }
+  ////////////////////////////////////////////////////////////////
+  // Surfaces [S]                                               //
+  ////////////////////////////////////////////////////////////////
+  background() {
+    return MaterialDynamicColors.colorSpec.background();
+  }
+  onBackground() {
+    return MaterialDynamicColors.colorSpec.onBackground();
+  }
+  surface() {
+    return MaterialDynamicColors.colorSpec.surface();
+  }
+  surfaceDim() {
+    return MaterialDynamicColors.colorSpec.surfaceDim();
+  }
+  surfaceBright() {
+    return MaterialDynamicColors.colorSpec.surfaceBright();
+  }
+  surfaceContainerLowest() {
+    return MaterialDynamicColors.colorSpec.surfaceContainerLowest();
+  }
+  surfaceContainerLow() {
+    return MaterialDynamicColors.colorSpec.surfaceContainerLow();
+  }
+  surfaceContainer() {
+    return MaterialDynamicColors.colorSpec.surfaceContainer();
+  }
+  surfaceContainerHigh() {
+    return MaterialDynamicColors.colorSpec.surfaceContainerHigh();
+  }
+  surfaceContainerHighest() {
+    return MaterialDynamicColors.colorSpec.surfaceContainerHighest();
+  }
+  onSurface() {
+    return MaterialDynamicColors.colorSpec.onSurface();
+  }
+  surfaceVariant() {
+    return MaterialDynamicColors.colorSpec.surfaceVariant();
+  }
+  onSurfaceVariant() {
+    return MaterialDynamicColors.colorSpec.onSurfaceVariant();
+  }
+  outline() {
+    return MaterialDynamicColors.colorSpec.outline();
+  }
+  outlineVariant() {
+    return MaterialDynamicColors.colorSpec.outlineVariant();
+  }
+  inverseSurface() {
+    return MaterialDynamicColors.colorSpec.inverseSurface();
+  }
+  inverseOnSurface() {
+    return MaterialDynamicColors.colorSpec.inverseOnSurface();
+  }
+  shadow() {
+    return MaterialDynamicColors.colorSpec.shadow();
+  }
+  scrim() {
+    return MaterialDynamicColors.colorSpec.scrim();
+  }
+  surfaceTint() {
+    return MaterialDynamicColors.colorSpec.surfaceTint();
+  }
+  ////////////////////////////////////////////////////////////////
+  // Primaries [P]                                              //
+  ////////////////////////////////////////////////////////////////
+  primary() {
+    return MaterialDynamicColors.colorSpec.primary();
+  }
+  primaryDim() {
+    return MaterialDynamicColors.colorSpec.primaryDim();
+  }
+  onPrimary() {
+    return MaterialDynamicColors.colorSpec.onPrimary();
+  }
+  primaryContainer() {
+    return MaterialDynamicColors.colorSpec.primaryContainer();
+  }
+  onPrimaryContainer() {
+    return MaterialDynamicColors.colorSpec.onPrimaryContainer();
+  }
+  inversePrimary() {
+    return MaterialDynamicColors.colorSpec.inversePrimary();
+  }
+  /////////////////////////////////////////////////////////////////
+  // Primary Fixed [PF]                                          //
+  /////////////////////////////////////////////////////////////////
+  primaryFixed() {
+    return MaterialDynamicColors.colorSpec.primaryFixed();
+  }
+  primaryFixedDim() {
+    return MaterialDynamicColors.colorSpec.primaryFixedDim();
+  }
+  onPrimaryFixed() {
+    return MaterialDynamicColors.colorSpec.onPrimaryFixed();
+  }
+  onPrimaryFixedVariant() {
+    return MaterialDynamicColors.colorSpec.onPrimaryFixedVariant();
+  }
+  ////////////////////////////////////////////////////////////////
+  // Secondaries [Q]                                            //
+  ////////////////////////////////////////////////////////////////
+  secondary() {
+    return MaterialDynamicColors.colorSpec.secondary();
+  }
+  secondaryDim() {
+    return MaterialDynamicColors.colorSpec.secondaryDim();
+  }
+  onSecondary() {
+    return MaterialDynamicColors.colorSpec.onSecondary();
+  }
+  secondaryContainer() {
+    return MaterialDynamicColors.colorSpec.secondaryContainer();
+  }
+  onSecondaryContainer() {
+    return MaterialDynamicColors.colorSpec.onSecondaryContainer();
+  }
+  /////////////////////////////////////////////////////////////////
+  // Secondary Fixed [QF]                                        //
+  /////////////////////////////////////////////////////////////////
+  secondaryFixed() {
+    return MaterialDynamicColors.colorSpec.secondaryFixed();
+  }
+  secondaryFixedDim() {
+    return MaterialDynamicColors.colorSpec.secondaryFixedDim();
+  }
+  onSecondaryFixed() {
+    return MaterialDynamicColors.colorSpec.onSecondaryFixed();
+  }
+  onSecondaryFixedVariant() {
+    return MaterialDynamicColors.colorSpec.onSecondaryFixedVariant();
+  }
+  ////////////////////////////////////////////////////////////////
+  // Tertiaries [T]                                             //
+  ////////////////////////////////////////////////////////////////
+  tertiary() {
+    return MaterialDynamicColors.colorSpec.tertiary();
+  }
+  tertiaryDim() {
+    return MaterialDynamicColors.colorSpec.tertiaryDim();
+  }
+  onTertiary() {
+    return MaterialDynamicColors.colorSpec.onTertiary();
+  }
+  tertiaryContainer() {
+    return MaterialDynamicColors.colorSpec.tertiaryContainer();
+  }
+  onTertiaryContainer() {
+    return MaterialDynamicColors.colorSpec.onTertiaryContainer();
+  }
+  /////////////////////////////////////////////////////////////////
+  // Tertiary Fixed [TF]                                         //
+  /////////////////////////////////////////////////////////////////
+  tertiaryFixed() {
+    return MaterialDynamicColors.colorSpec.tertiaryFixed();
+  }
+  tertiaryFixedDim() {
+    return MaterialDynamicColors.colorSpec.tertiaryFixedDim();
+  }
+  onTertiaryFixed() {
+    return MaterialDynamicColors.colorSpec.onTertiaryFixed();
+  }
+  onTertiaryFixedVariant() {
+    return MaterialDynamicColors.colorSpec.onTertiaryFixedVariant();
+  }
+  ////////////////////////////////////////////////////////////////
+  // Errors [E]                                                 //
+  ////////////////////////////////////////////////////////////////
+  error() {
+    return MaterialDynamicColors.colorSpec.error();
+  }
+  errorDim() {
+    return MaterialDynamicColors.colorSpec.errorDim();
+  }
+  onError() {
+    return MaterialDynamicColors.colorSpec.onError();
+  }
+  errorContainer() {
+    return MaterialDynamicColors.colorSpec.errorContainer();
+  }
+  onErrorContainer() {
+    return MaterialDynamicColors.colorSpec.onErrorContainer();
+  }
+  // Static variables are deprecated. Use the instance methods to get correct
+  // specs based on request.
+  /** @deprecated Use highestSurface() instead. */
+  static highestSurface(s) {
+    return MaterialDynamicColors.colorSpec.highestSurface(s);
+  }
+}
+MaterialDynamicColors.contentAccentToneDelta = 15.0;
+MaterialDynamicColors.colorSpec = new ColorSpecDelegateImpl2025();
+/** @deprecated Use primaryPaletteKeyColor() instead. */
+MaterialDynamicColors.primaryPaletteKeyColor = MaterialDynamicColors.colorSpec.primaryPaletteKeyColor();
+/** @deprecated Use secondaryPaletteKeyColor() instead. */
+MaterialDynamicColors.secondaryPaletteKeyColor = MaterialDynamicColors.colorSpec.secondaryPaletteKeyColor();
+/** @deprecated Use tertiaryPaletteKeyColor() instead. */
+MaterialDynamicColors.tertiaryPaletteKeyColor = MaterialDynamicColors.colorSpec.tertiaryPaletteKeyColor();
+/** @deprecated Use neutralPaletteKeyColor() instead. */
+MaterialDynamicColors.neutralPaletteKeyColor = MaterialDynamicColors.colorSpec.neutralPaletteKeyColor();
+/** @deprecated Use neutralVariantPaletteKeyColor() instead. */
+MaterialDynamicColors.neutralVariantPaletteKeyColor = MaterialDynamicColors.colorSpec.neutralVariantPaletteKeyColor();
+/** @deprecated Use background() instead. */
+MaterialDynamicColors.background = MaterialDynamicColors.colorSpec.background();
+/** @deprecated Use background() instead. */
+MaterialDynamicColors.onBackground = MaterialDynamicColors.colorSpec.onBackground();
+/** @deprecated Use surface() instead. */
+MaterialDynamicColors.surface = MaterialDynamicColors.colorSpec.surface();
+/** @deprecated Use surfaceDim() instead. */
+MaterialDynamicColors.surfaceDim = MaterialDynamicColors.colorSpec.surfaceDim();
+/** @deprecated Use surfaceBright() instead. */
+MaterialDynamicColors.surfaceBright = MaterialDynamicColors.colorSpec.surfaceBright();
+/** @deprecated Use surfaceContainerLowest() instead. */
+MaterialDynamicColors.surfaceContainerLowest = MaterialDynamicColors.colorSpec.surfaceContainerLowest();
+/** @deprecated Use surfaceContainerLow() instead. */
+MaterialDynamicColors.surfaceContainerLow = MaterialDynamicColors.colorSpec.surfaceContainerLow();
+/** @deprecated Use surfaceContainer() instead. */
+MaterialDynamicColors.surfaceContainer = MaterialDynamicColors.colorSpec.surfaceContainer();
+/** @deprecated Use surfaceContainerHigh() instead. */
+MaterialDynamicColors.surfaceContainerHigh = MaterialDynamicColors.colorSpec.surfaceContainerHigh();
+/** @deprecated Use surfaceContainerHighest() instead. */
+MaterialDynamicColors.surfaceContainerHighest = MaterialDynamicColors.colorSpec.surfaceContainerHighest();
+/** @deprecated Use onSurface() instead. */
+MaterialDynamicColors.onSurface = MaterialDynamicColors.colorSpec.onSurface();
+/** @deprecated Use surfaceVariant() instead. */
+MaterialDynamicColors.surfaceVariant = MaterialDynamicColors.colorSpec.surfaceVariant();
+/** @deprecated Use onSurfaceVariant() instead. */
+MaterialDynamicColors.onSurfaceVariant = MaterialDynamicColors.colorSpec.onSurfaceVariant();
+/** @deprecated Use inverseSurface() instead. */
+MaterialDynamicColors.inverseSurface = MaterialDynamicColors.colorSpec.inverseSurface();
+/** @deprecated Use inverseOnSurface() instead. */
+MaterialDynamicColors.inverseOnSurface = MaterialDynamicColors.colorSpec.inverseOnSurface();
+/** @deprecated Use outline() instead. */
+MaterialDynamicColors.outline = MaterialDynamicColors.colorSpec.outline();
+/** @deprecated Use outlineVariant() instead. */
+MaterialDynamicColors.outlineVariant = MaterialDynamicColors.colorSpec.outlineVariant();
+/** @deprecated Use shadow() instead. */
+MaterialDynamicColors.shadow = MaterialDynamicColors.colorSpec.shadow();
+/** @deprecated Use scrim() instead. */
+MaterialDynamicColors.scrim = MaterialDynamicColors.colorSpec.scrim();
+/** @deprecated Use surfaceTint() instead. */
+MaterialDynamicColors.surfaceTint = MaterialDynamicColors.colorSpec.surfaceTint();
+/** @deprecated Use primary() instead. */
+MaterialDynamicColors.primary = MaterialDynamicColors.colorSpec.primary();
+/** @deprecated Use onPrimary() instead. */
+MaterialDynamicColors.onPrimary = MaterialDynamicColors.colorSpec.onPrimary();
+/** @deprecated Use primaryContainer() instead. */
+MaterialDynamicColors.primaryContainer = MaterialDynamicColors.colorSpec.primaryContainer();
+/** @deprecated Use onPrimaryContainer() instead. */
+MaterialDynamicColors.onPrimaryContainer = MaterialDynamicColors.colorSpec.onPrimaryContainer();
+/** @deprecated Use inversePrimary() instead. */
+MaterialDynamicColors.inversePrimary = MaterialDynamicColors.colorSpec.inversePrimary();
+/** @deprecated Use secondary() instead. */
+MaterialDynamicColors.secondary = MaterialDynamicColors.colorSpec.secondary();
+/** @deprecated Use onSecondary() instead. */
+MaterialDynamicColors.onSecondary = MaterialDynamicColors.colorSpec.onSecondary();
+/** @deprecated Use secondaryContainer() instead. */
+MaterialDynamicColors.secondaryContainer = MaterialDynamicColors.colorSpec.secondaryContainer();
+/** @deprecated Use onSecondaryContainer() instead. */
+MaterialDynamicColors.onSecondaryContainer = MaterialDynamicColors.colorSpec.onSecondaryContainer();
+/** @deprecated Use tertiary() instead. */
+MaterialDynamicColors.tertiary = MaterialDynamicColors.colorSpec.tertiary();
+/** @deprecated Use onTertiary() instead. */
+MaterialDynamicColors.onTertiary = MaterialDynamicColors.colorSpec.onTertiary();
+/** @deprecated Use tertiaryContainer() instead. */
+MaterialDynamicColors.tertiaryContainer = MaterialDynamicColors.colorSpec.tertiaryContainer();
+/** @deprecated Use onTertiaryContainer() instead. */
+MaterialDynamicColors.onTertiaryContainer = MaterialDynamicColors.colorSpec.onTertiaryContainer();
+/** @deprecated Use error() instead. */
+MaterialDynamicColors.error = MaterialDynamicColors.colorSpec.error();
+/** @deprecated Use onError() instead. */
+MaterialDynamicColors.onError = MaterialDynamicColors.colorSpec.onError();
+/** @deprecated Use errorContainer() instead. */
+MaterialDynamicColors.errorContainer = MaterialDynamicColors.colorSpec.errorContainer();
+/** @deprecated Use onErrorContainer() instead. */
+MaterialDynamicColors.onErrorContainer = MaterialDynamicColors.colorSpec.onErrorContainer();
+/** @deprecated Use primaryFixed() instead. */
+MaterialDynamicColors.primaryFixed = MaterialDynamicColors.colorSpec.primaryFixed();
+/** @deprecated Use primaryFixedDim() instead. */
+MaterialDynamicColors.primaryFixedDim = MaterialDynamicColors.colorSpec.primaryFixedDim();
+/** @deprecated Use onPrimaryFixed() instead. */
+MaterialDynamicColors.onPrimaryFixed = MaterialDynamicColors.colorSpec.onPrimaryFixed();
+/** @deprecated Use onPrimaryFixedVariant() instead. */
+MaterialDynamicColors.onPrimaryFixedVariant = MaterialDynamicColors.colorSpec.onPrimaryFixedVariant();
+/** @deprecated Use secondaryFixed() instead. */
+MaterialDynamicColors.secondaryFixed = MaterialDynamicColors.colorSpec.secondaryFixed();
+/** @deprecated Use secondaryFixedDim() instead. */
+MaterialDynamicColors.secondaryFixedDim = MaterialDynamicColors.colorSpec.secondaryFixedDim();
+/** @deprecated Use onSecondaryFixed() instead. */
+MaterialDynamicColors.onSecondaryFixed = MaterialDynamicColors.colorSpec.onSecondaryFixed();
+/** @deprecated Use onSecondaryFixedVariant() instead. */
+MaterialDynamicColors.onSecondaryFixedVariant = MaterialDynamicColors.colorSpec.onSecondaryFixedVariant();
+/** @deprecated Use tertiaryFixed() instead. */
+MaterialDynamicColors.tertiaryFixed = MaterialDynamicColors.colorSpec.tertiaryFixed();
+/** @deprecated Use tertiaryFixedDim() instead. */
+MaterialDynamicColors.tertiaryFixedDim = MaterialDynamicColors.colorSpec.tertiaryFixedDim();
+/** @deprecated Use onTertiaryFixed() instead. */
+MaterialDynamicColors.onTertiaryFixed = MaterialDynamicColors.colorSpec.onTertiaryFixed();
+/** @deprecated Use onTertiaryFixedVariant() instead. */
+MaterialDynamicColors.onTertiaryFixedVariant = MaterialDynamicColors.colorSpec.onTertiaryFixedVariant();
 
 /**
  * @license
@@ -2654,218 +4793,552 @@ MaterialDynamicColors.onTertiaryFixedVariant = DynamicColor.fromPalette({
  * with the theme style. Used by DynamicColor to resolve into a color.
  */
 class DynamicScheme {
+  static maybeFallbackSpecVersion(specVersion, variant) {
+    switch (variant) {
+      case Variant.EXPRESSIVE:
+      case Variant.VIBRANT:
+      case Variant.TONAL_SPOT:
+      case Variant.NEUTRAL:
+        return specVersion;
+      default:
+        return '2021';
+    }
+  }
   constructor(args) {
-    this.sourceColorArgb = args.sourceColorArgb;
+    this.sourceColorArgb = args.sourceColorHct.toInt();
     this.variant = args.variant;
     this.contrastLevel = args.contrastLevel;
     this.isDark = args.isDark;
-    this.sourceColorHct = Hct.fromInt(args.sourceColorArgb);
-    this.primaryPalette = args.primaryPalette;
-    this.secondaryPalette = args.secondaryPalette;
-    this.tertiaryPalette = args.tertiaryPalette;
-    this.neutralPalette = args.neutralPalette;
-    this.neutralVariantPalette = args.neutralVariantPalette;
-    this.errorPalette = TonalPalette.fromHueAndChroma(25.0, 84.0);
+    this.platform = args.platform ?? 'phone';
+    this.specVersion = DynamicScheme.maybeFallbackSpecVersion(args.specVersion ?? '2021', this.variant);
+    this.sourceColorHct = args.sourceColorHct;
+    this.primaryPalette = args.primaryPalette ?? getSpec(this.specVersion).getPrimaryPalette(this.variant, args.sourceColorHct, this.isDark, this.platform, this.contrastLevel);
+    this.secondaryPalette = args.secondaryPalette ?? getSpec(this.specVersion).getSecondaryPalette(this.variant, args.sourceColorHct, this.isDark, this.platform, this.contrastLevel);
+    this.tertiaryPalette = args.tertiaryPalette ?? getSpec(this.specVersion).getTertiaryPalette(this.variant, args.sourceColorHct, this.isDark, this.platform, this.contrastLevel);
+    this.neutralPalette = args.neutralPalette ?? getSpec(this.specVersion).getNeutralPalette(this.variant, args.sourceColorHct, this.isDark, this.platform, this.contrastLevel);
+    this.neutralVariantPalette = args.neutralVariantPalette ?? getSpec(this.specVersion).getNeutralVariantPalette(this.variant, args.sourceColorHct, this.isDark, this.platform, this.contrastLevel);
+    this.errorPalette = args.errorPalette ?? getSpec(this.specVersion).getErrorPalette(this.variant, args.sourceColorHct, this.isDark, this.platform, this.contrastLevel) ?? TonalPalette.fromHueAndChroma(25.0, 84.0);
+    this.colors = new MaterialDynamicColors();
+  }
+  toString() {
+    return `Scheme: ` + `variant=${Variant[this.variant]}, ` + `mode=${this.isDark ? 'dark' : 'light'}, ` + `platform=${this.platform}, ` + `contrastLevel=${this.contrastLevel.toFixed(1)}, ` + `seed=${this.sourceColorHct.toString()}, ` + `specVersion=${this.specVersion}`;
   }
   /**
-   * Support design spec'ing Dynamic Color by schemes that specify hue
-   * rotations that should be applied at certain breakpoints.
-   * @param sourceColor the source color of the theme, in HCT.
-   * @param hues The "breakpoints", i.e. the hues at which a rotation should
-   * be apply.
-   * @param rotations The rotation that should be applied when source color's
-   * hue is >= the same index in hues array, and <= the hue at the next index
-   * in hues array.
+   * Returns a new hue based on a piecewise function and input color hue.
+   *
+   * For example, for the following function:
+   * result = 26 if 0 <= hue < 101
+   * result = 39 if 101 <= hue < 210
+   * result = 28 if 210 <= hue < 360
+   *
+   * call the function as:
+   *
+   * const hueBreakpoints = [0, 101, 210, 360];
+   * const hues = [26, 39, 28];
+   * const result = scheme.piecewise(hue, hueBreakpoints, hues);
+   *
+   * @param sourceColorHct The input value.
+   * @param hueBreakpoints The breakpoints, in sorted order. No default lower or
+   *     upper bounds are assumed.
+   * @param hues The hues that should be applied when source color's hue is >=
+   *     the same index in hueBrakpoints array, and < the hue at the next index
+   *     in hueBrakpoints array. Otherwise, the source color's hue is returned.
    */
-  static getRotatedHue(sourceColor, hues, rotations) {
-    const sourceHue = sourceColor.hue;
-    if (hues.length !== rotations.length) {
-      throw new Error(`mismatch between hue length ${hues.length} & rotations ${rotations.length}`);
-    }
-    if (rotations.length === 1) {
-      return sanitizeDegreesDouble(sourceColor.hue + rotations[0]);
-    }
-    const size = hues.length;
-    for (let i = 0; i <= size - 2; i++) {
-      const thisHue = hues[i];
-      const nextHue = hues[i + 1];
-      if (thisHue < sourceHue && sourceHue < nextHue) {
-        return sanitizeDegreesDouble(sourceHue + rotations[i]);
+  static getPiecewiseHue(sourceColorHct, hueBreakpoints, hues) {
+    const size = Math.min(hueBreakpoints.length - 1, hues.length);
+    const sourceHue = sourceColorHct.hue;
+    for (let i = 0; i < size; i++) {
+      if (sourceHue >= hueBreakpoints[i] && sourceHue < hueBreakpoints[i + 1]) {
+        return sanitizeDegreesDouble(hues[i]);
       }
     }
-    // If this statement executes, something is wrong, there should have been a
-    // rotation found using the arrays.
+    // No condition matched, return the source hue.
     return sourceHue;
   }
+  /**
+   * Returns a shifted hue based on a piecewise function and input color hue.
+   *
+   * For example, for the following function:
+   * result = hue + 26 if 0 <= hue < 101
+   * result = hue - 39 if 101 <= hue < 210
+   * result = hue + 28 if 210 <= hue < 360
+   *
+   * call the function as:
+   *
+   * const hueBreakpoints = [0, 101, 210, 360];
+   * const hues = [26, -39, 28];
+   * const result = scheme.getRotatedHue(hue, hueBreakpoints, hues);
+   *
+   * @param sourceColorHct the source color of the theme, in HCT.
+   * @param hueBreakpoints The "breakpoints", i.e. the hues at which a rotation
+   *     should be apply. No default lower or upper bounds are assumed.
+   * @param rotations The rotation that should be applied when source color's
+   *     hue is >= the same index in hues array, and < the hue at the next
+   *     index in hues array. Otherwise, the source color's hue is returned.
+   */
+  static getRotatedHue(sourceColorHct, hueBreakpoints, rotations) {
+    let rotation = DynamicScheme.getPiecewiseHue(sourceColorHct, hueBreakpoints, rotations);
+    if (Math.min(hueBreakpoints.length - 1, rotations.length) <= 0) {
+      // No condition matched, return the source hue.
+      rotation = 0;
+    }
+    return sanitizeDegreesDouble(sourceColorHct.hue + rotation);
+  }
   getArgb(dynamicColor) {
     return dynamicColor.getArgb(this);
   }
   getHct(dynamicColor) {
     return dynamicColor.getHct(this);
   }
+  // Palette key colors
   get primaryPaletteKeyColor() {
-    return this.getArgb(MaterialDynamicColors.primaryPaletteKeyColor);
+    return this.getArgb(this.colors.primaryPaletteKeyColor());
   }
   get secondaryPaletteKeyColor() {
-    return this.getArgb(MaterialDynamicColors.secondaryPaletteKeyColor);
+    return this.getArgb(this.colors.secondaryPaletteKeyColor());
   }
   get tertiaryPaletteKeyColor() {
-    return this.getArgb(MaterialDynamicColors.tertiaryPaletteKeyColor);
+    return this.getArgb(this.colors.tertiaryPaletteKeyColor());
   }
   get neutralPaletteKeyColor() {
-    return this.getArgb(MaterialDynamicColors.neutralPaletteKeyColor);
+    return this.getArgb(this.colors.neutralPaletteKeyColor());
   }
   get neutralVariantPaletteKeyColor() {
-    return this.getArgb(MaterialDynamicColors.neutralVariantPaletteKeyColor);
+    return this.getArgb(this.colors.neutralVariantPaletteKeyColor());
+  }
+  get errorPaletteKeyColor() {
+    return this.getArgb(this.colors.errorPaletteKeyColor());
   }
+  // Surface colors
   get background() {
-    return this.getArgb(MaterialDynamicColors.background);
+    return this.getArgb(this.colors.background());
   }
   get onBackground() {
-    return this.getArgb(MaterialDynamicColors.onBackground);
+    return this.getArgb(this.colors.onBackground());
   }
   get surface() {
-    return this.getArgb(MaterialDynamicColors.surface);
+    return this.getArgb(this.colors.surface());
   }
   get surfaceDim() {
-    return this.getArgb(MaterialDynamicColors.surfaceDim);
+    return this.getArgb(this.colors.surfaceDim());
   }
   get surfaceBright() {
-    return this.getArgb(MaterialDynamicColors.surfaceBright);
+    return this.getArgb(this.colors.surfaceBright());
   }
   get surfaceContainerLowest() {
-    return this.getArgb(MaterialDynamicColors.surfaceContainerLowest);
+    return this.getArgb(this.colors.surfaceContainerLowest());
   }
   get surfaceContainerLow() {
-    return this.getArgb(MaterialDynamicColors.surfaceContainerLow);
+    return this.getArgb(this.colors.surfaceContainerLow());
   }
   get surfaceContainer() {
-    return this.getArgb(MaterialDynamicColors.surfaceContainer);
+    return this.getArgb(this.colors.surfaceContainer());
   }
   get surfaceContainerHigh() {
-    return this.getArgb(MaterialDynamicColors.surfaceContainerHigh);
+    return this.getArgb(this.colors.surfaceContainerHigh());
   }
   get surfaceContainerHighest() {
-    return this.getArgb(MaterialDynamicColors.surfaceContainerHighest);
+    return this.getArgb(this.colors.surfaceContainerHighest());
   }
   get onSurface() {
-    return this.getArgb(MaterialDynamicColors.onSurface);
+    return this.getArgb(this.colors.onSurface());
   }
   get surfaceVariant() {
-    return this.getArgb(MaterialDynamicColors.surfaceVariant);
+    return this.getArgb(this.colors.surfaceVariant());
   }
   get onSurfaceVariant() {
-    return this.getArgb(MaterialDynamicColors.onSurfaceVariant);
+    return this.getArgb(this.colors.onSurfaceVariant());
   }
   get inverseSurface() {
-    return this.getArgb(MaterialDynamicColors.inverseSurface);
+    return this.getArgb(this.colors.inverseSurface());
   }
   get inverseOnSurface() {
-    return this.getArgb(MaterialDynamicColors.inverseOnSurface);
+    return this.getArgb(this.colors.inverseOnSurface());
   }
   get outline() {
-    return this.getArgb(MaterialDynamicColors.outline);
+    return this.getArgb(this.colors.outline());
   }
   get outlineVariant() {
-    return this.getArgb(MaterialDynamicColors.outlineVariant);
+    return this.getArgb(this.colors.outlineVariant());
   }
   get shadow() {
-    return this.getArgb(MaterialDynamicColors.shadow);
+    return this.getArgb(this.colors.shadow());
   }
   get scrim() {
-    return this.getArgb(MaterialDynamicColors.scrim);
+    return this.getArgb(this.colors.scrim());
   }
   get surfaceTint() {
-    return this.getArgb(MaterialDynamicColors.surfaceTint);
+    return this.getArgb(this.colors.surfaceTint());
   }
+  // Primary colors
   get primary() {
-    return this.getArgb(MaterialDynamicColors.primary);
+    return this.getArgb(this.colors.primary());
+  }
+  get primaryDim() {
+    const primaryDim = this.colors.primaryDim();
+    if (primaryDim === undefined) {
+      throw new Error('`primaryDim` color is undefined prior to 2025 spec.');
+    }
+    return this.getArgb(primaryDim);
   }
   get onPrimary() {
-    return this.getArgb(MaterialDynamicColors.onPrimary);
+    return this.getArgb(this.colors.onPrimary());
   }
   get primaryContainer() {
-    return this.getArgb(MaterialDynamicColors.primaryContainer);
+    return this.getArgb(this.colors.primaryContainer());
   }
   get onPrimaryContainer() {
-    return this.getArgb(MaterialDynamicColors.onPrimaryContainer);
+    return this.getArgb(this.colors.onPrimaryContainer());
+  }
+  get primaryFixed() {
+    return this.getArgb(this.colors.primaryFixed());
+  }
+  get primaryFixedDim() {
+    return this.getArgb(this.colors.primaryFixedDim());
+  }
+  get onPrimaryFixed() {
+    return this.getArgb(this.colors.onPrimaryFixed());
+  }
+  get onPrimaryFixedVariant() {
+    return this.getArgb(this.colors.onPrimaryFixedVariant());
   }
   get inversePrimary() {
-    return this.getArgb(MaterialDynamicColors.inversePrimary);
+    return this.getArgb(this.colors.inversePrimary());
   }
+  // Secondary colors
   get secondary() {
-    return this.getArgb(MaterialDynamicColors.secondary);
+    return this.getArgb(this.colors.secondary());
+  }
+  get secondaryDim() {
+    const secondaryDim = this.colors.secondaryDim();
+    if (secondaryDim === undefined) {
+      throw new Error('`secondaryDim` color is undefined prior to 2025 spec.');
+    }
+    return this.getArgb(secondaryDim);
   }
   get onSecondary() {
-    return this.getArgb(MaterialDynamicColors.onSecondary);
+    return this.getArgb(this.colors.onSecondary());
   }
   get secondaryContainer() {
-    return this.getArgb(MaterialDynamicColors.secondaryContainer);
+    return this.getArgb(this.colors.secondaryContainer());
   }
   get onSecondaryContainer() {
-    return this.getArgb(MaterialDynamicColors.onSecondaryContainer);
+    return this.getArgb(this.colors.onSecondaryContainer());
+  }
+  get secondaryFixed() {
+    return this.getArgb(this.colors.secondaryFixed());
+  }
+  get secondaryFixedDim() {
+    return this.getArgb(this.colors.secondaryFixedDim());
+  }
+  get onSecondaryFixed() {
+    return this.getArgb(this.colors.onSecondaryFixed());
   }
+  get onSecondaryFixedVariant() {
+    return this.getArgb(this.colors.onSecondaryFixedVariant());
+  }
+  // Tertiary colors
   get tertiary() {
-    return this.getArgb(MaterialDynamicColors.tertiary);
+    return this.getArgb(this.colors.tertiary());
+  }
+  get tertiaryDim() {
+    const tertiaryDim = this.colors.tertiaryDim();
+    if (tertiaryDim === undefined) {
+      throw new Error('`tertiaryDim` color is undefined prior to 2025 spec.');
+    }
+    return this.getArgb(tertiaryDim);
   }
   get onTertiary() {
-    return this.getArgb(MaterialDynamicColors.onTertiary);
+    return this.getArgb(this.colors.onTertiary());
   }
   get tertiaryContainer() {
-    return this.getArgb(MaterialDynamicColors.tertiaryContainer);
+    return this.getArgb(this.colors.tertiaryContainer());
   }
   get onTertiaryContainer() {
-    return this.getArgb(MaterialDynamicColors.onTertiaryContainer);
+    return this.getArgb(this.colors.onTertiaryContainer());
+  }
+  get tertiaryFixed() {
+    return this.getArgb(this.colors.tertiaryFixed());
+  }
+  get tertiaryFixedDim() {
+    return this.getArgb(this.colors.tertiaryFixedDim());
   }
+  get onTertiaryFixed() {
+    return this.getArgb(this.colors.onTertiaryFixed());
+  }
+  get onTertiaryFixedVariant() {
+    return this.getArgb(this.colors.onTertiaryFixedVariant());
+  }
+  // Error colors
   get error() {
-    return this.getArgb(MaterialDynamicColors.error);
+    return this.getArgb(this.colors.error());
+  }
+  get errorDim() {
+    const errorDim = this.colors.errorDim();
+    if (errorDim === undefined) {
+      throw new Error('`errorDim` color is undefined prior to 2025 spec.');
+    }
+    return this.getArgb(errorDim);
   }
   get onError() {
-    return this.getArgb(MaterialDynamicColors.onError);
+    return this.getArgb(this.colors.onError());
   }
   get errorContainer() {
-    return this.getArgb(MaterialDynamicColors.errorContainer);
+    return this.getArgb(this.colors.errorContainer());
   }
   get onErrorContainer() {
-    return this.getArgb(MaterialDynamicColors.onErrorContainer);
+    return this.getArgb(this.colors.onErrorContainer());
   }
-  get primaryFixed() {
-    return this.getArgb(MaterialDynamicColors.primaryFixed);
+}
+DynamicScheme.DEFAULT_SPEC_VERSION = '2021';
+DynamicScheme.DEFAULT_PLATFORM = 'phone';
+/**
+ * A delegate for the palettes of a DynamicScheme in the 2021 spec.
+ */
+class DynamicSchemePalettesDelegateImpl2021 {
+  //////////////////////////////////////////////////////////////////
+  // Scheme Palettes                                              //
+  //////////////////////////////////////////////////////////////////
+  getPrimaryPalette(variant, sourceColorHct, isDark, platform, contrastLevel) {
+    switch (variant) {
+      case Variant.CONTENT:
+      case Variant.FIDELITY:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, sourceColorHct.chroma);
+      case Variant.FRUIT_SALAD:
+        return TonalPalette.fromHueAndChroma(sanitizeDegreesDouble(sourceColorHct.hue - 50.0), 48.0);
+      case Variant.MONOCHROME:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, 0.0);
+      case Variant.NEUTRAL:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, 12.0);
+      case Variant.RAINBOW:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, 48.0);
+      case Variant.TONAL_SPOT:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, 36.0);
+      case Variant.EXPRESSIVE:
+        return TonalPalette.fromHueAndChroma(sanitizeDegreesDouble(sourceColorHct.hue + 240), 40);
+      case Variant.VIBRANT:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, 200.0);
+      default:
+        throw new Error(`Unsupported variant: ${variant}`);
+    }
   }
-  get primaryFixedDim() {
-    return this.getArgb(MaterialDynamicColors.primaryFixedDim);
+  getSecondaryPalette(variant, sourceColorHct, isDark, platform, contrastLevel) {
+    switch (variant) {
+      case Variant.CONTENT:
+      case Variant.FIDELITY:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, Math.max(sourceColorHct.chroma - 32.0, sourceColorHct.chroma * 0.5));
+      case Variant.FRUIT_SALAD:
+        return TonalPalette.fromHueAndChroma(sanitizeDegreesDouble(sourceColorHct.hue - 50.0), 36.0);
+      case Variant.MONOCHROME:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, 0.0);
+      case Variant.NEUTRAL:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, 8.0);
+      case Variant.RAINBOW:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, 16.0);
+      case Variant.TONAL_SPOT:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, 16.0);
+      case Variant.EXPRESSIVE:
+        return TonalPalette.fromHueAndChroma(DynamicScheme.getRotatedHue(sourceColorHct, [0, 21, 51, 121, 151, 191, 271, 321, 360], [45, 95, 45, 20, 45, 90, 45, 45, 45]), 24.0);
+      case Variant.VIBRANT:
+        return TonalPalette.fromHueAndChroma(DynamicScheme.getRotatedHue(sourceColorHct, [0, 41, 61, 101, 131, 181, 251, 301, 360], [18, 15, 10, 12, 15, 18, 15, 12, 12]), 24.0);
+      default:
+        throw new Error(`Unsupported variant: ${variant}`);
+    }
   }
-  get onPrimaryFixed() {
-    return this.getArgb(MaterialDynamicColors.onPrimaryFixed);
+  getTertiaryPalette(variant, sourceColorHct, isDark, platform, contrastLevel) {
+    switch (variant) {
+      case Variant.CONTENT:
+        return TonalPalette.fromHct(DislikeAnalyzer.fixIfDisliked(new TemperatureCache(sourceColorHct).analogous(/* count= */3, /* divisions= */6)[2]));
+      case Variant.FIDELITY:
+        return TonalPalette.fromHct(DislikeAnalyzer.fixIfDisliked(new TemperatureCache(sourceColorHct).complement));
+      case Variant.FRUIT_SALAD:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, 36.0);
+      case Variant.MONOCHROME:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, 0.0);
+      case Variant.NEUTRAL:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, 16.0);
+      case Variant.RAINBOW:
+      case Variant.TONAL_SPOT:
+        return TonalPalette.fromHueAndChroma(sanitizeDegreesDouble(sourceColorHct.hue + 60.0), 24.0);
+      case Variant.EXPRESSIVE:
+        return TonalPalette.fromHueAndChroma(DynamicScheme.getRotatedHue(sourceColorHct, [0, 21, 51, 121, 151, 191, 271, 321, 360], [120, 120, 20, 45, 20, 15, 20, 120, 120]), 32.0);
+      case Variant.VIBRANT:
+        return TonalPalette.fromHueAndChroma(DynamicScheme.getRotatedHue(sourceColorHct, [0, 41, 61, 101, 131, 181, 251, 301, 360], [35, 30, 20, 25, 30, 35, 30, 25, 25]), 32.0);
+      default:
+        throw new Error(`Unsupported variant: ${variant}`);
+    }
   }
-  get onPrimaryFixedVariant() {
-    return this.getArgb(MaterialDynamicColors.onPrimaryFixedVariant);
+  getNeutralPalette(variant, sourceColorHct, isDark, platform, contrastLevel) {
+    switch (variant) {
+      case Variant.CONTENT:
+      case Variant.FIDELITY:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, sourceColorHct.chroma / 8.0);
+      case Variant.FRUIT_SALAD:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, 10.0);
+      case Variant.MONOCHROME:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, 0.0);
+      case Variant.NEUTRAL:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, 2.0);
+      case Variant.RAINBOW:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, 0.0);
+      case Variant.TONAL_SPOT:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, 6.0);
+      case Variant.EXPRESSIVE:
+        return TonalPalette.fromHueAndChroma(sanitizeDegreesDouble(sourceColorHct.hue + 15), 8);
+      case Variant.VIBRANT:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, 10);
+      default:
+        throw new Error(`Unsupported variant: ${variant}`);
+    }
   }
-  get secondaryFixed() {
-    return this.getArgb(MaterialDynamicColors.secondaryFixed);
+  getNeutralVariantPalette(variant, sourceColorHct, isDark, platform, contrastLevel) {
+    switch (variant) {
+      case Variant.CONTENT:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, sourceColorHct.chroma / 8.0 + 4.0);
+      case Variant.FIDELITY:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, sourceColorHct.chroma / 8.0 + 4.0);
+      case Variant.FRUIT_SALAD:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, 16.0);
+      case Variant.MONOCHROME:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, 0.0);
+      case Variant.NEUTRAL:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, 2.0);
+      case Variant.RAINBOW:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, 0.0);
+      case Variant.TONAL_SPOT:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, 8.0);
+      case Variant.EXPRESSIVE:
+        return TonalPalette.fromHueAndChroma(sanitizeDegreesDouble(sourceColorHct.hue + 15), 12);
+      case Variant.VIBRANT:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, 12);
+      default:
+        throw new Error(`Unsupported variant: ${variant}`);
+    }
   }
-  get secondaryFixedDim() {
-    return this.getArgb(MaterialDynamicColors.secondaryFixedDim);
+  getErrorPalette(variant, sourceColorHct, isDark, platform, contrastLevel) {
+    return undefined;
   }
-  get onSecondaryFixed() {
-    return this.getArgb(MaterialDynamicColors.onSecondaryFixed);
+}
+/**
+ * A delegate for the palettes of a DynamicScheme in the 2025 spec.
+ */
+class DynamicSchemePalettesDelegateImpl2025 extends DynamicSchemePalettesDelegateImpl2021 {
+  //////////////////////////////////////////////////////////////////
+  // Scheme Palettes                                              //
+  //////////////////////////////////////////////////////////////////
+  getPrimaryPalette(variant, sourceColorHct, isDark, platform, contrastLevel) {
+    switch (variant) {
+      case Variant.NEUTRAL:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, platform === 'phone' ? Hct.isBlue(sourceColorHct.hue) ? 12 : 8 : Hct.isBlue(sourceColorHct.hue) ? 16 : 12);
+      case Variant.TONAL_SPOT:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, platform === 'phone' && isDark ? 26 : 32);
+      case Variant.EXPRESSIVE:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, platform === 'phone' ? isDark ? 36 : 48 : 40);
+      case Variant.VIBRANT:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, platform === 'phone' ? 74 : 56);
+      default:
+        return super.getPrimaryPalette(variant, sourceColorHct, isDark, platform, contrastLevel);
+    }
   }
-  get onSecondaryFixedVariant() {
-    return this.getArgb(MaterialDynamicColors.onSecondaryFixedVariant);
+  getSecondaryPalette(variant, sourceColorHct, isDark, platform, contrastLevel) {
+    switch (variant) {
+      case Variant.NEUTRAL:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, platform === 'phone' ? Hct.isBlue(sourceColorHct.hue) ? 6 : 4 : Hct.isBlue(sourceColorHct.hue) ? 10 : 6);
+      case Variant.TONAL_SPOT:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, 16);
+      case Variant.EXPRESSIVE:
+        return TonalPalette.fromHueAndChroma(DynamicScheme.getRotatedHue(sourceColorHct, [0, 105, 140, 204, 253, 278, 300, 333, 360], [-160, 155, -100, 96, -96, -156, -165, -160]), platform === 'phone' ? isDark ? 16 : 24 : 24);
+      case Variant.VIBRANT:
+        return TonalPalette.fromHueAndChroma(DynamicScheme.getRotatedHue(sourceColorHct, [0, 38, 105, 140, 333, 360], [-14, 10, -14, 10, -14]), platform === 'phone' ? 56 : 36);
+      default:
+        return super.getSecondaryPalette(variant, sourceColorHct, isDark, platform, contrastLevel);
+    }
   }
-  get tertiaryFixed() {
-    return this.getArgb(MaterialDynamicColors.tertiaryFixed);
+  getTertiaryPalette(variant, sourceColorHct, isDark, platform, contrastLevel) {
+    switch (variant) {
+      case Variant.NEUTRAL:
+        return TonalPalette.fromHueAndChroma(DynamicScheme.getRotatedHue(sourceColorHct, [0, 38, 105, 161, 204, 278, 333, 360], [-32, 26, 10, -39, 24, -15, -32]), platform === 'phone' ? 20 : 36);
+      case Variant.TONAL_SPOT:
+        return TonalPalette.fromHueAndChroma(DynamicScheme.getRotatedHue(sourceColorHct, [0, 20, 71, 161, 333, 360], [-40, 48, -32, 40, -32]), platform === 'phone' ? 28 : 32);
+      case Variant.EXPRESSIVE:
+        return TonalPalette.fromHueAndChroma(DynamicScheme.getRotatedHue(sourceColorHct, [0, 105, 140, 204, 253, 278, 300, 333, 360], [-165, 160, -105, 101, -101, -160, -170, -165]), 48);
+      case Variant.VIBRANT:
+        return TonalPalette.fromHueAndChroma(DynamicScheme.getRotatedHue(sourceColorHct, [0, 38, 71, 105, 140, 161, 253, 333, 360], [-72, 35, 24, -24, 62, 50, 62, -72]), 56);
+      default:
+        return super.getTertiaryPalette(variant, sourceColorHct, isDark, platform, contrastLevel);
+    }
   }
-  get tertiaryFixedDim() {
-    return this.getArgb(MaterialDynamicColors.tertiaryFixedDim);
+  static getExpressiveNeutralHue(sourceColorHct) {
+    const hue = DynamicScheme.getRotatedHue(sourceColorHct, [0, 71, 124, 253, 278, 300, 360], [10, 0, 10, 0, 10, 0]);
+    return hue;
+  }
+  static getExpressiveNeutralChroma(sourceColorHct, isDark, platform) {
+    const neutralHue = DynamicSchemePalettesDelegateImpl2025.getExpressiveNeutralHue(sourceColorHct);
+    return platform === 'phone' ? isDark ? Hct.isYellow(neutralHue) ? 6 : 14 : 18 : 12;
+  }
+  static getVibrantNeutralHue(sourceColorHct) {
+    return DynamicScheme.getRotatedHue(sourceColorHct, [0, 38, 105, 140, 333, 360], [-14, 10, -14, 10, -14]);
+  }
+  static getVibrantNeutralChroma(sourceColorHct, platform) {
+    const neutralHue = DynamicSchemePalettesDelegateImpl2025.getVibrantNeutralHue(sourceColorHct);
+    return platform === 'phone' ? 28 : Hct.isBlue(neutralHue) ? 28 : 20;
+  }
+  getNeutralPalette(variant, sourceColorHct, isDark, platform, contrastLevel) {
+    switch (variant) {
+      case Variant.NEUTRAL:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, platform === 'phone' ? 1.4 : 6);
+      case Variant.TONAL_SPOT:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, platform === 'phone' ? 5 : 10);
+      case Variant.EXPRESSIVE:
+        return TonalPalette.fromHueAndChroma(DynamicSchemePalettesDelegateImpl2025.getExpressiveNeutralHue(sourceColorHct), DynamicSchemePalettesDelegateImpl2025.getExpressiveNeutralChroma(sourceColorHct, isDark, platform));
+      case Variant.VIBRANT:
+        return TonalPalette.fromHueAndChroma(DynamicSchemePalettesDelegateImpl2025.getVibrantNeutralHue(sourceColorHct), DynamicSchemePalettesDelegateImpl2025.getVibrantNeutralChroma(sourceColorHct, platform));
+      default:
+        return super.getNeutralPalette(variant, sourceColorHct, isDark, platform, contrastLevel);
+    }
   }
-  get onTertiaryFixed() {
-    return this.getArgb(MaterialDynamicColors.onTertiaryFixed);
+  getNeutralVariantPalette(variant, sourceColorHct, isDark, platform, contrastLevel) {
+    switch (variant) {
+      case Variant.NEUTRAL:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, (platform === 'phone' ? 1.4 : 6) * 2.2);
+      case Variant.TONAL_SPOT:
+        return TonalPalette.fromHueAndChroma(sourceColorHct.hue, (platform === 'phone' ? 5 : 10) * 1.7);
+      case Variant.EXPRESSIVE:
+        const expressiveNeutralHue = DynamicSchemePalettesDelegateImpl2025.getExpressiveNeutralHue(sourceColorHct);
+        const expressiveNeutralChroma = DynamicSchemePalettesDelegateImpl2025.getExpressiveNeutralChroma(sourceColorHct, isDark, platform);
+        return TonalPalette.fromHueAndChroma(expressiveNeutralHue, expressiveNeutralChroma * (expressiveNeutralHue >= 105 && expressiveNeutralHue < 125 ? 1.6 : 2.3));
+      case Variant.VIBRANT:
+        const vibrantNeutralHue = DynamicSchemePalettesDelegateImpl2025.getVibrantNeutralHue(sourceColorHct);
+        const vibrantNeutralChroma = DynamicSchemePalettesDelegateImpl2025.getVibrantNeutralChroma(sourceColorHct, platform);
+        return TonalPalette.fromHueAndChroma(vibrantNeutralHue, vibrantNeutralChroma * 1.29);
+      default:
+        return super.getNeutralVariantPalette(variant, sourceColorHct, isDark, platform, contrastLevel);
+    }
   }
-  get onTertiaryFixedVariant() {
-    return this.getArgb(MaterialDynamicColors.onTertiaryFixedVariant);
+  getErrorPalette(variant, sourceColorHct, isDark, platform, contrastLevel) {
+    const errorHue = DynamicScheme.getPiecewiseHue(sourceColorHct, [0, 3, 13, 23, 33, 43, 153, 273, 360], [12, 22, 32, 12, 22, 32, 22, 12]);
+    switch (variant) {
+      case Variant.NEUTRAL:
+        return TonalPalette.fromHueAndChroma(errorHue, platform === 'phone' ? 50 : 40);
+      case Variant.TONAL_SPOT:
+        return TonalPalette.fromHueAndChroma(errorHue, platform === 'phone' ? 60 : 48);
+      case Variant.EXPRESSIVE:
+        return TonalPalette.fromHueAndChroma(errorHue, platform === 'phone' ? 64 : 48);
+      case Variant.VIBRANT:
+        return TonalPalette.fromHueAndChroma(errorHue, platform === 'phone' ? 80 : 60);
+      default:
+        return super.getErrorPalette(variant, sourceColorHct, isDark, platform, contrastLevel);
+    }
   }
 }
+const spec2021 = new DynamicSchemePalettesDelegateImpl2021();
+const spec2025 = new DynamicSchemePalettesDelegateImpl2025();
+/**
+ * Returns the DynamicSchemePalettesDelegate for the given spec version.
+ */
+function getSpec(specVersion) {
+  return specVersion === '2025' ? spec2025 : spec2021;
+}
 
 /**
  * @license
@@ -2887,28 +5360,43 @@ class DynamicScheme {
  * An intermediate concept between the key color for a UI theme, and a full
  * color scheme. 5 sets of tones are generated, all except one use the same hue
  * as the key color, and all vary in chroma.
+ *
+ * @deprecated Use {@link DynamicScheme} for color scheme generation.
+ * Use {@link CorePalettes} for core palettes container class.
  */
 class CorePalette {
   /**
    * @param argb ARGB representation of a color
+   *
+   * @deprecated Use {@link DynamicScheme} for color scheme generation.
+   * Use {@link CorePalettes} for core palettes container class.
    */
   static of(argb) {
     return new CorePalette(argb, false);
   }
   /**
    * @param argb ARGB representation of a color
+   *
+   * @deprecated Use {@link DynamicScheme} for color scheme generation.
+   * Use {@link CorePalettes} for core palettes container class.
    */
   static contentOf(argb) {
     return new CorePalette(argb, true);
   }
   /**
    * Create a [CorePalette] from a set of colors
+   *
+   * @deprecated Use {@link DynamicScheme} for color scheme generation.
+   * Use {@link CorePalettes} for core palettes container class.
    */
   static fromColors(colors) {
     return CorePalette.createPaletteFromColors(false, colors);
   }
   /**
    * Create a content [CorePalette] from a set of colors
+   *
+   * @deprecated Use {@link DynamicScheme} for color scheme generation.
+   * Use {@link CorePalettes} for core palettes container class.
    */
   static contentFromColors(colors) {
     return CorePalette.createPaletteFromColors(true, colors);
@@ -3666,7 +6154,7 @@ class QuantizerCelebi {
 
 /**
  * @license
- * Copyright 2022 Google LLC
+ * 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.
@@ -3680,90 +6168,212 @@ class QuantizerCelebi {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+// This file is automatically generated. Do not modify it.
 /**
- * A Dynamic Color theme that is intentionally detached from the source color.
+ * DEPRECATED. The `Scheme` class is deprecated in favor of `DynamicScheme`.
+ * Please see
+ * https://github.com/material-foundation/material-color-utilities/blob/main/make_schemes.md
+ * for migration guidance.
+ *
+ * Represents a Material color scheme, a mapping of color roles to colors.
  */
-class SchemeExpressive extends DynamicScheme {
-  constructor(sourceColorHct, isDark, contrastLevel) {
-    super({
-      sourceColorArgb: sourceColorHct.toInt(),
-      variant: Variant.EXPRESSIVE,
-      contrastLevel,
-      isDark,
-      primaryPalette: TonalPalette.fromHueAndChroma(sanitizeDegreesDouble(sourceColorHct.hue + 240.0), 40.0),
-      secondaryPalette: TonalPalette.fromHueAndChroma(DynamicScheme.getRotatedHue(sourceColorHct, SchemeExpressive.hues, SchemeExpressive.secondaryRotations), 24.0),
-      tertiaryPalette: TonalPalette.fromHueAndChroma(DynamicScheme.getRotatedHue(sourceColorHct, SchemeExpressive.hues, SchemeExpressive.tertiaryRotations), 32.0),
-      neutralPalette: TonalPalette.fromHueAndChroma(sourceColorHct.hue + 15, 8.0),
-      neutralVariantPalette: TonalPalette.fromHueAndChroma(sourceColorHct.hue + 15, 12.0)
+class Scheme {
+  get primary() {
+    return this.props.primary;
+  }
+  get onPrimary() {
+    return this.props.onPrimary;
+  }
+  get primaryContainer() {
+    return this.props.primaryContainer;
+  }
+  get onPrimaryContainer() {
+    return this.props.onPrimaryContainer;
+  }
+  get secondary() {
+    return this.props.secondary;
+  }
+  get onSecondary() {
+    return this.props.onSecondary;
+  }
+  get secondaryContainer() {
+    return this.props.secondaryContainer;
+  }
+  get onSecondaryContainer() {
+    return this.props.onSecondaryContainer;
+  }
+  get tertiary() {
+    return this.props.tertiary;
+  }
+  get onTertiary() {
+    return this.props.onTertiary;
+  }
+  get tertiaryContainer() {
+    return this.props.tertiaryContainer;
+  }
+  get onTertiaryContainer() {
+    return this.props.onTertiaryContainer;
+  }
+  get error() {
+    return this.props.error;
+  }
+  get onError() {
+    return this.props.onError;
+  }
+  get errorContainer() {
+    return this.props.errorContainer;
+  }
+  get onErrorContainer() {
+    return this.props.onErrorContainer;
+  }
+  get background() {
+    return this.props.background;
+  }
+  get onBackground() {
+    return this.props.onBackground;
+  }
+  get surface() {
+    return this.props.surface;
+  }
+  get onSurface() {
+    return this.props.onSurface;
+  }
+  get surfaceVariant() {
+    return this.props.surfaceVariant;
+  }
+  get onSurfaceVariant() {
+    return this.props.onSurfaceVariant;
+  }
+  get outline() {
+    return this.props.outline;
+  }
+  get outlineVariant() {
+    return this.props.outlineVariant;
+  }
+  get shadow() {
+    return this.props.shadow;
+  }
+  get scrim() {
+    return this.props.scrim;
+  }
+  get inverseSurface() {
+    return this.props.inverseSurface;
+  }
+  get inverseOnSurface() {
+    return this.props.inverseOnSurface;
+  }
+  get inversePrimary() {
+    return this.props.inversePrimary;
+  }
+  /**
+   * @param argb ARGB representation of a color.
+   * @return Light Material color scheme, based on the color's hue.
+   */
+  static light(argb) {
+    return Scheme.lightFromCorePalette(CorePalette.of(argb));
+  }
+  /**
+   * @param argb ARGB representation of a color.
+   * @return Dark Material color scheme, based on the color's hue.
+   */
+  static dark(argb) {
+    return Scheme.darkFromCorePalette(CorePalette.of(argb));
+  }
+  /**
+   * @param argb ARGB representation of a color.
+   * @return Light Material content color scheme, based on the color's hue.
+   */
+  static lightContent(argb) {
+    return Scheme.lightFromCorePalette(CorePalette.contentOf(argb));
+  }
+  /**
+   * @param argb ARGB representation of a color.
+   * @return Dark Material content color scheme, based on the color's hue.
+   */
+  static darkContent(argb) {
+    return Scheme.darkFromCorePalette(CorePalette.contentOf(argb));
+  }
+  /**
+   * Light scheme from core palette
+   */
+  static lightFromCorePalette(core) {
+    return new Scheme({
+      primary: core.a1.tone(40),
+      onPrimary: core.a1.tone(100),
+      primaryContainer: core.a1.tone(90),
+      onPrimaryContainer: core.a1.tone(10),
+      secondary: core.a2.tone(40),
+      onSecondary: core.a2.tone(100),
+      secondaryContainer: core.a2.tone(90),
+      onSecondaryContainer: core.a2.tone(10),
+      tertiary: core.a3.tone(40),
+      onTertiary: core.a3.tone(100),
+      tertiaryContainer: core.a3.tone(90),
+      onTertiaryContainer: core.a3.tone(10),
+      error: core.error.tone(40),
+      onError: core.error.tone(100),
+      errorContainer: core.error.tone(90),
+      onErrorContainer: core.error.tone(10),
+      background: core.n1.tone(99),
+      onBackground: core.n1.tone(10),
+      surface: core.n1.tone(99),
+      onSurface: core.n1.tone(10),
+      surfaceVariant: core.n2.tone(90),
+      onSurfaceVariant: core.n2.tone(30),
+      outline: core.n2.tone(50),
+      outlineVariant: core.n2.tone(80),
+      shadow: core.n1.tone(0),
+      scrim: core.n1.tone(0),
+      inverseSurface: core.n1.tone(20),
+      inverseOnSurface: core.n1.tone(95),
+      inversePrimary: core.a1.tone(80)
     });
   }
-}
-/**
- * Hues (in degrees) used at breakpoints such that designers can specify a
- * hue rotation that occurs at a given break point.
- */
-SchemeExpressive.hues = [0.0, 21.0, 51.0, 121.0, 151.0, 191.0, 271.0, 321.0, 360.0];
-/**
- * Hue rotations (in degrees) of the Secondary [TonalPalette],
- * corresponding to the breakpoints in [hues].
- */
-SchemeExpressive.secondaryRotations = [45.0, 95.0, 45.0, 20.0, 45.0, 90.0, 45.0, 45.0, 45.0];
-/**
- * Hue rotations (in degrees) of the Tertiary [TonalPalette],
- * corresponding to the breakpoints in [hues].
- */
-SchemeExpressive.tertiaryRotations = [120.0, 120.0, 20.0, 45.0, 20.0, 15.0, 20.0, 120.0, 120.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.
- */
-/**
- * A Dynamic Color theme that maxes out colorfulness at each position in the
- * Primary Tonal Palette.
- */
-class SchemeVibrant extends DynamicScheme {
-  constructor(sourceColorHct, isDark, contrastLevel) {
-    super({
-      sourceColorArgb: sourceColorHct.toInt(),
-      variant: Variant.VIBRANT,
-      contrastLevel,
-      isDark,
-      primaryPalette: TonalPalette.fromHueAndChroma(sourceColorHct.hue, 200.0),
-      secondaryPalette: TonalPalette.fromHueAndChroma(DynamicScheme.getRotatedHue(sourceColorHct, SchemeVibrant.hues, SchemeVibrant.secondaryRotations), 24.0),
-      tertiaryPalette: TonalPalette.fromHueAndChroma(DynamicScheme.getRotatedHue(sourceColorHct, SchemeVibrant.hues, SchemeVibrant.tertiaryRotations), 32.0),
-      neutralPalette: TonalPalette.fromHueAndChroma(sourceColorHct.hue, 10.0),
-      neutralVariantPalette: TonalPalette.fromHueAndChroma(sourceColorHct.hue, 12.0)
+  /**
+   * Dark scheme from core palette
+   */
+  static darkFromCorePalette(core) {
+    return new Scheme({
+      primary: core.a1.tone(80),
+      onPrimary: core.a1.tone(20),
+      primaryContainer: core.a1.tone(30),
+      onPrimaryContainer: core.a1.tone(90),
+      secondary: core.a2.tone(80),
+      onSecondary: core.a2.tone(20),
+      secondaryContainer: core.a2.tone(30),
+      onSecondaryContainer: core.a2.tone(90),
+      tertiary: core.a3.tone(80),
+      onTertiary: core.a3.tone(20),
+      tertiaryContainer: core.a3.tone(30),
+      onTertiaryContainer: core.a3.tone(90),
+      error: core.error.tone(80),
+      onError: core.error.tone(20),
+      errorContainer: core.error.tone(30),
+      onErrorContainer: core.error.tone(80),
+      background: core.n1.tone(10),
+      onBackground: core.n1.tone(90),
+      surface: core.n1.tone(10),
+      onSurface: core.n1.tone(90),
+      surfaceVariant: core.n2.tone(30),
+      onSurfaceVariant: core.n2.tone(80),
+      outline: core.n2.tone(60),
+      outlineVariant: core.n2.tone(30),
+      shadow: core.n1.tone(0),
+      scrim: core.n1.tone(0),
+      inverseSurface: core.n1.tone(90),
+      inverseOnSurface: core.n1.tone(20),
+      inversePrimary: core.a1.tone(40)
     });
   }
+  constructor(props) {
+    this.props = props;
+  }
+  toJSON() {
+    return {
+      ...this.props
+    };
+  }
 }
-/**
- * Hues (in degrees) used at breakpoints such that designers can specify a
- * hue rotation that occurs at a given break point.
- */
-SchemeVibrant.hues = [0.0, 41.0, 61.0, 101.0, 131.0, 181.0, 251.0, 301.0, 360.0];
-/**
- * Hue rotations (in degrees) of the Secondary [TonalPalette],
- * corresponding to the breakpoints in [hues].
- */
-SchemeVibrant.secondaryRotations = [18.0, 15.0, 10.0, 12.0, 15.0, 18.0, 15.0, 12.0, 12.0];
-/**
- * Hue rotations (in degrees) of the Tertiary [TonalPalette],
- * corresponding to the breakpoints in [hues].
- */
-SchemeVibrant.tertiaryRotations = [35.0, 30.0, 20.0, 25.0, 30.0, 35.0, 30.0, 25.0, 25.0];
 
 /**
  * @license
@@ -4033,6 +6643,15 @@ async function sourceColorFromImage(image) {
       image.onerror = errorCallback;
     }
   });
+  return sourceColorFromImageBytes(imageBytes);
+}
+/**
+ * Get the source color from image bytes.
+ *
+ * @param imageBytes The image bytes
+ * @return Source color - the color most suitable for creating a UI theme
+ */
+function sourceColorFromImageBytes(imageBytes) {
   // Convert Image data to Pixel Array
   const pixels = [];
   for (let i = 0; i < imageBytes.length; i += 4) {
@@ -4053,6 +6672,84 @@ async function sourceColorFromImage(image) {
   return top;
 }
 
+/**
+ * @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.
+ */
+/**
+ * Generate a theme from a source color
+ *
+ * @param source Source color
+ * @param customColors Array of custom colors
+ * @return Theme object
+ */
+function themeFromSourceColor(source, customColors = []) {
+  const palette = CorePalette.of(source);
+  return {
+    source,
+    schemes: {
+      light: Scheme.light(source),
+      dark: Scheme.dark(source)
+    },
+    palettes: {
+      primary: palette.a1,
+      secondary: palette.a2,
+      tertiary: palette.a3,
+      neutral: palette.n1,
+      neutralVariant: palette.n2,
+      error: palette.error
+    },
+    customColors: customColors.map(c => customColor(source, c))
+  };
+}
+/**
+ * Generate custom color group from source and target color
+ *
+ * @param source Source color
+ * @param color Custom color
+ * @return Custom color group
+ *
+ * @link https://m3.material.io/styles/color/the-color-system/color-roles
+ */
+function customColor(source, color) {
+  let value = color.value;
+  const from = value;
+  const to = source;
+  if (color.blend) {
+    value = Blend.harmonize(from, to);
+  }
+  const palette = CorePalette.of(value);
+  const tones = palette.a1;
+  return {
+    color,
+    value,
+    light: {
+      color: tones.tone(40),
+      onColor: tones.tone(100),
+      colorContainer: tones.tone(90),
+      onColorContainer: tones.tone(10)
+    },
+    dark: {
+      color: tones.tone(80),
+      onColor: tones.tone(20),
+      colorContainer: tones.tone(30),
+      onColorContainer: tones.tone(90)
+    }
+  };
+}
+
 /**
  * Extracts the Material source color from an image and returns it as a hex string.
  * @param {HTMLImageElement} image - A fully loaded image element. Pixel data is sampled to derive the source color.
@@ -4227,26 +6924,26 @@ _M3eThemeElement_colorSchemeChangeHandler = new WeakMap();
 _M3eThemeElement_instances = new WeakSet();
 _M3eThemeElement_apply = function _M3eThemeElement_apply(forceReflow) {
   const color = argbFromHex(this.color);
-  const palette = CorePalette.of(color);
+  const theme = themeFromSourceColor(color);
   const scheme = new DynamicScheme({
-    sourceColorArgb: color,
+    sourceColorHct: Hct.fromInt(color),
     variant: 1,
     contrastLevel: __classPrivateFieldGet(this, _M3eThemeElement_instances, "m", _M3eThemeElement_getContrastLevel).call(this),
     isDark: this.isDark,
-    primaryPalette: palette.a1,
-    secondaryPalette: palette.a2,
-    tertiaryPalette: palette.a3,
-    neutralPalette: palette.n1,
-    neutralVariantPalette: palette.n2
+    primaryPalette: theme.palettes.primary,
+    secondaryPalette: theme.palettes.secondary,
+    tertiaryPalette: theme.palettes.tertiary,
+    neutralPalette: theme.palettes.neutral,
+    neutralVariantPalette: theme.palettes.neutralVariant,
+    errorPalette: theme.palettes.error
   });
   let css = "";
-  for (const key in MaterialDynamicColors) {
-    if (!key.endsWith("PaletteKeyColor")) {
-      const dynamicColor = MaterialDynamicColors[key];
-      if (dynamicColor instanceof DynamicColor) {
-        css += `--md-sys-color-${key.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase()}: ${hexFromArgb(dynamicColor.getArgb(scheme))};`;
-      }
-    }
+  const colors = new MaterialDynamicColors();
+  const allColors = [...colors.allColors, colors.surfaceVariant(), colors.shadow(), colors.scrim(), colors.surfaceTint()];
+  for (const color of allColors) {
+    const token = `--md-sys-color-${color.name.replace(/_/g, "-").toLowerCase()}`;
+    const hex = hexFromArgb(color.getArgb(scheme));
+    css += `${token}: ${hex};`;
   }
   if (this.motion === "expressive") {
     css += "--md-sys-motion-spring-fast-spatial: 350ms cubic-bezier(0.42, 1.67, 0.21, 0.90);";
@@ -4311,6 +7008,55 @@ _M3eThemeElement_getContrastLevel = function _M3eThemeElement_getContrastLevel()
       return 0;
   }
 };
+(() => {
+  if (typeof window !== "undefined") {
+    const composeCss = token => {
+      let css = "";
+      for (const key in token) {
+        const cssVar = token[key].toString();
+        if (!cssVar.startsWith("var(")) continue;
+        const inner = cssVar.trim().slice(4, -1); // remove "var(" and ")"
+        const [prop, fallback] = inner.split(/,(.+)/).map(s => s.trim());
+        if (!prop.startsWith("--") || !fallback) continue;
+        css += `${prop}:${fallback};`;
+      }
+      return css;
+    };
+    const omitKey = (obj, key) => {
+      const {
+        [key]: _unused,
+        ...rest
+      } = obj;
+      return rest;
+    };
+    let css = "";
+    css += composeCss(DesignToken.typescale.standard.display.large);
+    css += composeCss(DesignToken.typescale.standard.display.medium);
+    css += composeCss(DesignToken.typescale.standard.display.small);
+    css += composeCss(DesignToken.typescale.standard.headline.large);
+    css += composeCss(DesignToken.typescale.standard.headline.medium);
+    css += composeCss(DesignToken.typescale.standard.headline.small);
+    css += composeCss(DesignToken.typescale.standard.title.large);
+    css += composeCss(DesignToken.typescale.standard.title.medium);
+    css += composeCss(DesignToken.typescale.standard.title.small);
+    css += composeCss(DesignToken.typescale.standard.label.large);
+    css += composeCss(DesignToken.typescale.standard.label.medium);
+    css += composeCss(DesignToken.typescale.standard.label.small);
+    css += composeCss(DesignToken.typescale.standard.body.large);
+    css += composeCss(DesignToken.typescale.standard.body.medium);
+    css += composeCss(DesignToken.typescale.standard.body.small);
+    css += composeCss(DesignToken.elevation);
+    css += composeCss(DesignToken.shape.corner.value);
+    css += composeCss(omitKey(DesignToken.shape.corner, "value"));
+    css += composeCss(DesignToken.motion.duration);
+    css += composeCss(DesignToken.motion.easing);
+    css += composeCss(DesignToken.motion.spring);
+    css += composeCss(omitKey(DesignToken.density, "calc"));
+    css += composeCss(DesignToken.measurement);
+    css += composeCss(DesignToken.state);
+    registerStyleSheet(unsafeCSS(`html{${css}}`));
+  }
+})();
 /** The styles of the element. */
 M3eThemeElement.styles = css`:host { display: contents; }`;
 __decorate([property()], M3eThemeElement.prototype, "color", void 0);