@udixio/theme 1.0.0-beta.8 → 1.0.0

package/dist/index.js

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