@udixio/theme 1.3.1 → 2.1.0

package/dist/loader-C8_TyOuS.js

@@ -1,2698 +0,0 @@
-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";
-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.
- */
-class DynamicColor {
-  /**
-   * The base constructor for DynamicColor.
-   *
-   * _Strongly_ prefer using one of the convenience constructors. This class is
-   * arguably too flexible to ensure it can support any scenario. Functional
-   * arguments allow  overriding without risks that come with subclasses.
-   *
-   * For example, the default behavior of adjust tone at max contrast
-   * to be at a 7.0 ratio with its background is principled and
-   * matches accessibility guidance. That does not mean it's the desired
-   * approach for _every_ design system, and every color pairing,
-   * always, in every case.
-   *
-   * @param name The name of the dynamic color. Defaults to empty.
-   * @param palette Function that provides a TonalPalette given DynamicScheme. A
-   *     TonalPalette is defined by a hue and chroma, so this replaces the need
-   *     to specify hue/chroma. By providing a tonal palette, when contrast
-   *     adjustments are made, intended chroma can be preserved.
-   * @param tone Function that provides a tone, given a DynamicScheme.
-   * @param isBackground Whether this dynamic color is a background, with some
-   *     other color as the foreground. Defaults to false.
-   * @param chromaMultiplier A factor that multiplies the chroma for this color.
-   * @param background The background of the dynamic color (as a function of a
-   *     `DynamicScheme`), if it exists.
-   * @param secondBackground A second background of the dynamic color (as a
-   *     function of a `DynamicScheme`), if it exists.
-   * @param contrastCurve A `ContrastCurve` object specifying how its contrast
-   *     against its background should behave in various contrast levels
-   *     options.
-   * @param adjustTone A `AdjustTone` object specifying a tone delta
-   *     constraint between two colors. One of them must be the color being
-   *     constructed.
-   */
-  constructor(name, palette, tone, isBackground, chromaMultiplier, background, secondBackground, contrastCurve, adjustTone) {
-    __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.adjustTone = adjustTone;
-    if (!background && secondBackground) {
-      throw new Error(
-        `Color ${name} has secondBackgrounddefined, but background is not defined.`
-      );
-    }
-    if (!background && contrastCurve) {
-      throw new Error(
-        `Color ${name} has contrastCurvedefined, but background is not defined.`
-      );
-    }
-    if (background && !contrastCurve) {
-      throw new Error(
-        `Color ${name} has backgrounddefined, but contrastCurve is not defined.`
-      );
-    }
-  }
-  /**
-   * Create a DynamicColor defined by a TonalPalette and HCT tone.
-   *
-   * @param args Functions with DynamicScheme as input. Must provide a palette
-   *     and tone. May provide a background DynamicColor and ToneDeltaPair.
-   */
-  static fromPalette(args) {
-    return new DynamicColor(
-      args.name ?? "",
-      args.palette,
-      args.tone ?? DynamicColor.getInitialToneFromBackground(args.background),
-      args.isBackground ?? false,
-      args.chromaMultiplier,
-      args.background,
-      args.secondBackground,
-      args.contrastCurve,
-      args.adjustTone
-    );
-  }
-  static getInitialToneFromBackground(background) {
-    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,
-      adjustTone: this.adjustTone
-    });
-  }
-  /**
-   * 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 adjustTone = this.adjustTone ? this.adjustTone(scheme) : void 0;
-    if (adjustTone) {
-      return adjustTone({ scheme, dynamicColor: this });
-    } else {
-      let answer = this.tone(scheme);
-      if (this.background == void 0 || this.background(scheme) === void 0 || this.contrastCurve == void 0 || this.contrastCurve(scheme) === void 0) {
-        return answer;
-      }
-      const bgTone = this.background(scheme).getTone(scheme);
-      const desiredRatio = this.contrastCurve(scheme).get(
-        scheme.contrastLevel
-      );
-      answer = Contrast.ratioOfTones(bgTone, answer) >= desiredRatio && scheme.contrastLevel >= 0 ? answer : DynamicColor.foregroundTone(bgTone, desiredRatio);
-      if (this.isBackground && !this.name.endsWith("_fixed_dim")) {
-        if (answer >= 57) {
-          answer = clampDouble(65, 100, answer);
-        } else {
-          answer = clampDouble(0, 49, answer);
-        }
-      }
-      if (this.secondBackground == void 0 || this.secondBackground(scheme) === void 0) {
-        return answer;
-      }
-      const [bg1, bg2] = [this.background, this.secondBackground];
-      const [bgTone1, bgTone2] = [
-        bg1(scheme).getTone(scheme),
-        bg2(scheme).getTone(scheme)
-      ];
-      const [upper, lower] = [
-        Math.max(bgTone1, bgTone2),
-        Math.min(bgTone1, bgTone2)
-      ];
-      if (Contrast.ratioOfTones(upper, answer) >= desiredRatio && Contrast.ratioOfTones(lower, answer) >= desiredRatio) {
-        return answer;
-      }
-      const lightOption = Contrast.lighter(upper, desiredRatio);
-      const darkOption = Contrast.darker(lower, desiredRatio);
-      const availables = [];
-      if (lightOption !== -1) availables.push(lightOption);
-      if (darkOption !== -1) availables.push(darkOption);
-      const prefersLight = DynamicColor.tonePrefersLightForeground(bgTone1) || DynamicColor.tonePrefersLightForeground(bgTone2);
-      if (prefersLight) {
-        return lightOption < 0 ? 100 : lightOption;
-      }
-      if (availables.length === 1) {
-        return availables[0];
-      }
-      return darkOption < 0 ? 0 : darkOption;
-    }
-  }
-}
-/**
- * @license
- * Copyright 2023 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-class ToneDeltaPair {
-  /**
-   * Documents a constraint in tone distance between two DynamicColors.
-   *
-   * The polarity is an adjective that describes "A", compared to "B".
-   *
-   * For instance, ToneDeltaPair(A, B, 15, 'darker', 'exact') states that
-   * A's tone should be exactly 15 darker than B's.
-   *
-   * 'relative_darker' and 'relative_lighter' describes the tone adjustment
-   * relative to the surface color trend (white in light mode; black in dark
-   * mode). For instance, ToneDeltaPair(A, B, 10, 'relative_lighter',
-   * 'farther') states that A should be at least 10 lighter than B in light
-   * mode, and at least 10 darker than B in dark mode.
-   *
-   * @param roleA The first role in a pair.
-   * @param roleB The second role in a pair.
-   * @param delta Required difference between tones. Absolute value, negative
-   * values have undefined behavior.
-   * @param polarity The relative relation between tones of roleA and roleB,
-   * as described above.
-   * @param constraint How to fulfill the tone delta pair constraint.
-   * @param stayTogether Whether these two roles should stay on the same side
-   * of the "awkward zone" (T50-59). This is necessary for certain cases where
-   * one role has two backgrounds.
-   */
-  constructor(roleA, roleB, delta, polarity, stayTogether, constraint) {
-    this.roleA = roleA;
-    this.roleB = roleB;
-    this.delta = delta;
-    this.polarity = polarity;
-    this.stayTogether = stayTogether;
-    this.constraint = constraint;
-    this.constraint = constraint ?? "exact";
-  }
-  adjustedTone({
-    scheme,
-    dynamicColor
-  }) {
-    const roleA = this.roleA;
-    const roleB = this.roleB;
-    const polarity = this.polarity;
-    const constraint = this.constraint;
-    const absoluteDelta = polarity === "darker" || polarity === "relative_lighter" && scheme.isDark || polarity === "relative_darker" && !scheme.isDark ? -this.delta : this.delta;
-    const amRoleA = dynamicColor.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 (dynamicColor.background && dynamicColor.contrastCurve) {
-      const background = dynamicColor.background(scheme);
-      const contrastCurve = dynamicColor.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 (dynamicColor.isBackground && !dynamicColor.name.endsWith("_fixed_dim")) {
-      if (selfTone >= 57) {
-        selfTone = clampDouble(65, 100, selfTone);
-      } else {
-        selfTone = clampDouble(0, 49, selfTone);
-      }
-    }
-    return selfTone;
-  }
-}
-const toneDeltaPair = (...params) => {
-  return (args) => new ToneDeltaPair(...params).adjustedTone(args);
-};
-function argbToRgb(argb) {
-  return {
-    r: argb >> 16 & 255,
-    g: argb >> 8 & 255,
-    b: argb & 255
-  };
-}
-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),
-      adjustTone: (s) => 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),
-      adjustTone: (s) => 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),
-      adjustTone: (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,
-      adjustTone: (s) => 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();
-  // }
-  get sourceColorHex() {
-    return this.schemeManager.get().sourceColorHct;
-  }
-  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 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 inverseTone = (tone) => {
-  return 100 - tone;
-};
-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 (s.variant == "fidelity") {
-            return 100;
-          }
-          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 if (s.variant == "fidelity") {
-          return s.sourceColorHct.tone;
-        } 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),
-      adjustTone: (s) => s.variant == "fidelity" ? () => {
-        const surfaceTone = colorService.getColor("surface").getMaterialColor().tone(s);
-        const primaryTone = colorService.getColor("primary").getMaterialColor().tone(s);
-        let selfTone = primaryTone;
-        if (Contrast.ratioOfTones(surfaceTone, selfTone) < 3) {
-          const result = inverseTone(primaryTone);
-          if (Contrast.ratioOfTones(surfaceTone, result) >= 3) {
-            selfTone = result;
-          }
-        }
-        return selfTone;
-      } : 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),
-      adjustTone: (s) => 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
-          );
-        }
-        if (s.variant == "fidelity") {
-          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),
-      adjustTone: (s) => s.variant == "fidelity" ? toneDeltaPair(
-        colorService.getColor("primary").getMaterialColor(),
-        colorService.getColor("primaryContainer").getMaterialColor(),
-        15,
-        "relative_darker",
-        true,
-        "farther"
-      ) : 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,
-      adjustTone: (s) => 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),
-      adjustTone: (s) => 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),
-      adjustTone: (s) => 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),
-      adjustTone: (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,
-      adjustTone: (s) => 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),
-      adjustTone: (s) => 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),
-      adjustTone: (s) => 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),
-      adjustTone: (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,
-      adjustTone: (s) => 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),
-      adjustTone: (s) => 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),
-      adjustTone: (s) => 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),
-      adjustTone: (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;
-  }
-  async load() {
-    return this.plugins.loadPlugins();
-  }
-}
-const AppModule = {
-  api: asClass(API).singleton()
-};
-class PluginApi {
-  constructor() {
-    __publicField(this, "plugins", /* @__PURE__ */ new Map());
-  }
-  addPlugin(plugin) {
-    this.plugins.set(plugin.name, plugin);
-  }
-  initPlugins(api) {
-    const plugins = new Map(this.plugins);
-    let size = 0;
-    this.plugins = /* @__PURE__ */ new Map();
-    do {
-      size = plugins.size;
-      plugins.forEach((plugin, key) => {
-        const deps = plugin.dependencies.filter(
-          (dep) => !this.plugins.has(new dep().name)
-        );
-        if (deps.length === 0) {
-          this.plugins.set(plugin.name, plugin.init(api));
-          plugins.delete(key);
-        }
-      });
-    } while (plugins.size != 0 && plugins.size < size);
-    if (plugins.size > 0)
-      throw new Error(
-        "Some plugins couldn't be loaded due to missing dependencies: " + Array.from(plugins.keys())
-      );
-  }
-  async loadPlugins() {
-    var _a, _b;
-    for (const plugin of this.plugins.values()) {
-      await ((_b = (_a = plugin.getInstance()).onLoad) == null ? void 0 : _b.call(_a));
-    }
-  }
-  getPlugin(plugin) {
-    const pluginInstance = this.plugins.get(new plugin().name);
-    if (!pluginInstance) throw new Error(`Plugin ${plugin.name} not found`);
-    return pluginInstance;
-  }
-}
-const PluginModule = {
-  pluginApi: asClass(PluginApi).singleton()
-};
-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");
-}
-const initializeApi = () => {
-  const api = bootstrap();
-  registerModule({
-    adapter: asValue(void 0)
-  });
-  return api;
-};
-const loader = async (config) => {
-  const api = initializeApi();
-  const init = () => {
-    const {
-      sourceColor,
-      contrastLevel = 0,
-      isDark = false,
-      variant = tonalSpotVariant,
-      palettes,
-      colors,
-      useDefaultColors = true,
-      plugins
-    } = config;
-    api.themes.create({
-      contrastLevel,
-      isDark,
-      sourceColorHex: sourceColor,
-      variant
-    });
-    if (palettes) {
-      Object.entries(palettes).forEach(
-        ([key, value]) => api.themes.addCustomPalette(key, value)
-      );
-    }
-    if (useDefaultColors) {
-      api.colors.addColors(defaultColors);
-    }
-    if (colors) {
-      api.colors.addColors(colors);
-    }
-    if (plugins) {
-      plugins.forEach((plugin) => {
-        api.plugins.addPlugin(plugin);
-      });
-      api.plugins.initPlugins(api);
-    }
-  };
-  init();
-  await api.load();
-  return api;
-};
-export {
-  AppContainer as A,
-  ColorApi as C,
-  DynamicColor as D,
-  Hct as H,
-  PluginModule as P,
-  SchemeManager as S,
-  ThemeModule as T,
-  Variant as V,
-  AppModule as a,
-  API as b,
-  ColorManager as c,
-  ColorModule as d,
-  ConfigurableColor as e,
-  defaultColors as f,
-  bootstrap as g,
-  highestSurface as h,
-  ContrastCurve as i,
-  PluginApi as j,
-  tonalSpotVariant as k,
-  loader as l,
-  Scheme as m,
-  ThemeApi as n,
-  getPiecewiseHue as o,
-  getRotatedHue as p,
-  VariantManager as q,
-  registerModule as r,
-  toneDeltaPair as t
-};