@gradient-ui/core 0.2.0

package/dist/default-585QCoXx.js

@@ -0,0 +1,3990 @@
+import { M as Ee, c as yt } from "./camelToKebabCase-KgkZ7-1F.js";
+import { ref as je, shallowRef as Pt, provide as kt, inject as bt } from "vue";
+/**
+ * @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.
+ */
+function j(r) {
+  return r < 0 ? -1 : r === 0 ? 0 : 1;
+}
+function fe(r, e, t) {
+  return (1 - t) * r + t * e;
+}
+function St(r, e, t) {
+  return t < r ? r : t > e ? e : t;
+}
+function U(r, e, t) {
+  return t < r ? r : t > e ? e : t;
+}
+function be(r) {
+  return r = r % 360, r < 0 && (r = r + 360), r;
+}
+function Ct(r, e) {
+  return be(e - r) <= 180 ? 1 : -1;
+}
+function Tt(r, e) {
+  return 180 - Math.abs(Math.abs(r - e) - 180);
+}
+function Le(r, e) {
+  const t = r[0] * e[0][0] + r[1] * e[0][1] + r[2] * e[0][2], n = r[0] * e[1][0] + r[1] * e[1][1] + r[2] * e[1][2], a = r[0] * e[2][0] + r[1] * e[2][1] + r[2] * e[2][2];
+  return [t, n, a];
+}
+/**
+ * @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 vt = [
+  [0.41233895, 0.35762064, 0.18051042],
+  [0.2126, 0.7152, 0.0722],
+  [0.01932141, 0.11916382, 0.95034478]
+], Dt = [
+  [
+    3.2413774792388685,
+    -1.5376652402851851,
+    -0.49885366846268053
+  ],
+  [
+    -0.9691452513005321,
+    1.8758853451067872,
+    0.04156585616912061
+  ],
+  [
+    0.05562093689691305,
+    -0.20395524564742123,
+    1.0571799111220335
+  ]
+], wt = [95.047, 100, 108.883];
+function Se(r, e, t) {
+  return (255 << 24 | (r & 255) << 16 | (e & 255) << 8 | t & 255) >>> 0;
+}
+function Ke(r) {
+  const e = ie(r[0]), t = ie(r[1]), n = ie(r[2]);
+  return Se(e, t, n);
+}
+function at(r) {
+  return r >> 16 & 255;
+}
+function ot(r) {
+  return r >> 8 & 255;
+}
+function it(r) {
+  return r & 255;
+}
+function Ft(r, e, t) {
+  const n = Dt, a = n[0][0] * r + n[0][1] * e + n[0][2] * t, o = n[1][0] * r + n[1][1] * e + n[1][2] * t, i = n[2][0] * r + n[2][1] * e + n[2][2] * t, u = ie(a), l = ie(o), h = ie(i);
+  return Se(u, l, h);
+}
+function xt(r) {
+  const e = le(at(r)), t = le(ot(r)), n = le(it(r));
+  return Le([e, t, n], vt);
+}
+function Mt(r) {
+  const e = ae(r), t = ie(e);
+  return Se(t, t, t);
+}
+function Oe(r) {
+  const e = xt(r)[1];
+  return 116 * st(e / 100) - 16;
+}
+function ae(r) {
+  return 100 * At((r + 16) / 116);
+}
+function Re(r) {
+  return st(r / 100) * 116 - 16;
+}
+function le(r) {
+  const e = r / 255;
+  return e <= 0.040449936 ? e / 12.92 * 100 : Math.pow((e + 0.055) / 1.055, 2.4) * 100;
+}
+function ie(r) {
+  const e = r / 100;
+  let t = 0;
+  return e <= 31308e-7 ? t = e * 12.92 : t = 1.055 * Math.pow(e, 1 / 2.4) - 0.055, St(0, 255, Math.round(t * 255));
+}
+function Bt() {
+  return wt;
+}
+function st(r) {
+  const e = 0.008856451679035631, t = 24389 / 27;
+  return r > e ? Math.pow(r, 1 / 3) : (t * r + 16) / 116;
+}
+function At(r) {
+  const e = 0.008856451679035631, t = 24389 / 27, n = r * r * r;
+  return n > e ? n : (116 * r - 16) / t;
+}
+/**
+ * @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 J {
+  /**
+   * Create ViewingConditions from a simple, physically relevant, set of
+   * parameters.
+   *
+   * @param whitePoint White point, measured in the XYZ color space.
+   *     default = D65, or sunny day afternoon
+   * @param adaptingLuminance The luminance of the adapting field. Informally,
+   *     how bright it is in the room where the color is viewed. Can be
+   *     calculated from lux by multiplying lux by 0.0586. default = 11.72,
+   *     or 200 lux.
+   * @param backgroundLstar The lightness of the area surrounding the color.
+   *     measured by L* in L*a*b*. default = 50.0
+   * @param surround A general description of the lighting surrounding the
+   *     color. 0 is pitch dark, like watching a movie in a theater. 1.0 is a
+   *     dimly light room, like watching TV at home at night. 2.0 means there
+   *     is no difference between the lighting on the color and around it.
+   *     default = 2.0
+   * @param discountingIlluminant Whether the eye accounts for the tint of the
+   *     ambient lighting, such as knowing an apple is still red in green light.
+   *     default = false, the eye does not perform this process on
+   *       self-luminous objects like displays.
+   */
+  static make(e = Bt(), t = 200 / Math.PI * ae(50) / 100, n = 50, a = 2, o = !1) {
+    const i = e, u = i[0] * 0.401288 + i[1] * 0.650173 + i[2] * -0.051461, l = i[0] * -0.250268 + i[1] * 1.204414 + i[2] * 0.045854, h = i[0] * -2079e-6 + i[1] * 0.048952 + i[2] * 0.953127, f = 0.8 + a / 10, g = f >= 0.9 ? fe(0.59, 0.69, (f - 0.9) * 10) : fe(0.525, 0.59, (f - 0.8) * 10);
+    let p = o ? 1 : f * (1 - 1 / 3.6 * Math.exp((-t - 42) / 92));
+    p = p > 1 ? 1 : p < 0 ? 0 : p;
+    const v = f, m = [
+      p * (100 / u) + 1 - p,
+      p * (100 / l) + 1 - p,
+      p * (100 / h) + 1 - p
+    ], P = 1 / (5 * t + 1), k = P * P * P * P, B = 1 - k, x = k * t + 0.1 * B * B * Math.cbrt(5 * t), O = ae(n) / e[1], R = 1.48 + Math.sqrt(O), V = 0.725 / Math.pow(O, 0.2), I = V, F = [
+      Math.pow(x * m[0] * u / 100, 0.42),
+      Math.pow(x * m[1] * l / 100, 0.42),
+      Math.pow(x * m[2] * h / 100, 0.42)
+    ], L = [
+      400 * F[0] / (F[0] + 27.13),
+      400 * F[1] / (F[1] + 27.13),
+      400 * F[2] / (F[2] + 27.13)
+    ], z = (2 * L[0] + L[1] + 0.05 * L[2]) * V;
+    return new J(O, z, V, I, g, v, m, x, Math.pow(x, 0.25), R);
+  }
+  /**
+   * Parameters are intermediate values of the CAM16 conversion process. Their
+   * names are shorthand for technical color science terminology, this class
+   * would not benefit from documenting them individually. A brief overview
+   * is available in the CAM16 specification, and a complete overview requires
+   * a color science textbook, such as Fairchild's Color Appearance Models.
+   */
+  constructor(e, t, n, a, o, i, u, l, h, f) {
+    this.n = e, this.aw = t, this.nbb = n, this.ncb = a, this.c = o, this.nc = i, this.rgbD = u, this.fl = l, this.fLRoot = h, this.z = f;
+  }
+}
+J.DEFAULT = J.make();
+/**
+ * @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 H {
+  /**
+   * All of the CAM16 dimensions can be calculated from 3 of the dimensions, in
+   * the following combinations:
+   *      -  {j or q} and {c, m, or s} and hue
+   *      - jstar, astar, bstar
+   * Prefer using a static method that constructs from 3 of those dimensions.
+   * This constructor is intended for those methods to use to return all
+   * possible dimensions.
+   *
+   * @param hue
+   * @param chroma informally, colorfulness / color intensity. like saturation
+   *     in HSL, except perceptually accurate.
+   * @param j lightness
+   * @param q brightness; ratio of lightness to white point's lightness
+   * @param m colorfulness
+   * @param s saturation; ratio of chroma to white point's chroma
+   * @param jstar CAM16-UCS J coordinate
+   * @param astar CAM16-UCS a coordinate
+   * @param bstar CAM16-UCS b coordinate
+   */
+  constructor(e, t, n, a, o, i, u, l, h) {
+    this.hue = e, this.chroma = t, this.j = n, this.q = a, this.m = o, this.s = i, this.jstar = u, this.astar = l, this.bstar = h;
+  }
+  /**
+   * CAM16 instances also have coordinates in the CAM16-UCS space, called J*,
+   * a*, b*, or jstar, astar, bstar in code. CAM16-UCS is included in the CAM16
+   * specification, and is used to measure distances between colors.
+   */
+  distance(e) {
+    const t = this.jstar - e.jstar, n = this.astar - e.astar, a = this.bstar - e.bstar, o = Math.sqrt(t * t + n * n + a * a);
+    return 1.41 * Math.pow(o, 0.63);
+  }
+  /**
+   * @param argb ARGB representation of a color.
+   * @return CAM16 color, assuming the color was viewed in default viewing
+   *     conditions.
+   */
+  static fromInt(e) {
+    return H.fromIntInViewingConditions(e, J.DEFAULT);
+  }
+  /**
+   * @param argb ARGB representation of a color.
+   * @param viewingConditions Information about the environment where the color
+   *     was observed.
+   * @return CAM16 color.
+   */
+  static fromIntInViewingConditions(e, t) {
+    const n = (e & 16711680) >> 16, a = (e & 65280) >> 8, o = e & 255, i = le(n), u = le(a), l = le(o), h = 0.41233895 * i + 0.35762064 * u + 0.18051042 * l, f = 0.2126 * i + 0.7152 * u + 0.0722 * l, g = 0.01932141 * i + 0.11916382 * u + 0.95034478 * l, p = 0.401288 * h + 0.650173 * f - 0.051461 * g, v = -0.250268 * h + 1.204414 * f + 0.045854 * g, m = -2079e-6 * h + 0.048952 * f + 0.953127 * g, P = t.rgbD[0] * p, k = t.rgbD[1] * v, B = t.rgbD[2] * m, x = Math.pow(t.fl * Math.abs(P) / 100, 0.42), O = Math.pow(t.fl * Math.abs(k) / 100, 0.42), R = Math.pow(t.fl * Math.abs(B) / 100, 0.42), V = j(P) * 400 * x / (x + 27.13), I = j(k) * 400 * O / (O + 27.13), F = j(B) * 400 * R / (R + 27.13), L = (11 * V + -12 * I + F) / 11, z = (V + I - 2 * F) / 9, E = (20 * V + 20 * I + 21 * F) / 20, W = (40 * V + 20 * I + F) / 20, ce = Math.atan2(z, L) * 180 / Math.PI, q = be(ce), me = q * Math.PI / 180, ge = W * t.nbb, re = 100 * Math.pow(ge / t.aw, t.c * t.z), ye = 4 / t.c * Math.sqrt(re / 100) * (t.aw + 4) * t.fLRoot, Te = q < 20.14 ? q + 360 : q, ve = 0.25 * (Math.cos(Te * Math.PI / 180 + 2) + 3.8), we = 5e4 / 13 * ve * t.nc * t.ncb * Math.sqrt(L * L + z * z) / (E + 0.305), Pe = Math.pow(we, 0.9) * Math.pow(1.64 - Math.pow(0.29, t.n), 0.73), Ue = Pe * Math.sqrt(re / 100), $e = Ue * t.fLRoot, dt = 50 * Math.sqrt(Pe * t.c / (t.aw + 4)), pt = (1 + 100 * 7e-3) * re / (1 + 7e-3 * re), Ye = 1 / 0.0228 * Math.log(1 + 0.0228 * $e), mt = Ye * Math.cos(me), gt = Ye * Math.sin(me);
+    return new H(q, Ue, re, ye, $e, dt, pt, mt, gt);
+  }
+  /**
+   * @param j CAM16 lightness
+   * @param c CAM16 chroma
+   * @param h CAM16 hue
+   */
+  static fromJch(e, t, n) {
+    return H.fromJchInViewingConditions(e, t, n, J.DEFAULT);
+  }
+  /**
+   * @param j CAM16 lightness
+   * @param c CAM16 chroma
+   * @param h CAM16 hue
+   * @param viewingConditions Information about the environment where the color
+   *     was observed.
+   */
+  static fromJchInViewingConditions(e, t, n, a) {
+    const o = 4 / a.c * Math.sqrt(e / 100) * (a.aw + 4) * a.fLRoot, i = t * a.fLRoot, u = t / Math.sqrt(e / 100), l = 50 * Math.sqrt(u * a.c / (a.aw + 4)), h = n * Math.PI / 180, f = (1 + 100 * 7e-3) * e / (1 + 7e-3 * e), g = 1 / 0.0228 * Math.log(1 + 0.0228 * i), p = g * Math.cos(h), v = g * Math.sin(h);
+    return new H(n, t, e, o, i, l, f, p, v);
+  }
+  /**
+   * @param jstar CAM16-UCS lightness.
+   * @param astar CAM16-UCS a dimension. Like a* in L*a*b*, it is a Cartesian
+   *     coordinate on the Y axis.
+   * @param bstar CAM16-UCS b dimension. Like a* in L*a*b*, it is a Cartesian
+   *     coordinate on the X axis.
+   */
+  static fromUcs(e, t, n) {
+    return H.fromUcsInViewingConditions(e, t, n, J.DEFAULT);
+  }
+  /**
+   * @param jstar CAM16-UCS lightness.
+   * @param astar CAM16-UCS a dimension. Like a* in L*a*b*, it is a Cartesian
+   *     coordinate on the Y axis.
+   * @param bstar CAM16-UCS b dimension. Like a* in L*a*b*, it is a Cartesian
+   *     coordinate on the X axis.
+   * @param viewingConditions Information about the environment where the color
+   *     was observed.
+   */
+  static fromUcsInViewingConditions(e, t, n, a) {
+    const o = t, i = n, u = Math.sqrt(o * o + i * i), h = (Math.exp(u * 0.0228) - 1) / 0.0228 / a.fLRoot;
+    let f = Math.atan2(i, o) * (180 / Math.PI);
+    f < 0 && (f += 360);
+    const g = e / (1 - (e - 100) * 7e-3);
+    return H.fromJchInViewingConditions(g, h, f, a);
+  }
+  /**
+   *  @return ARGB representation of color, assuming the color was viewed in
+   *     default viewing conditions, which are near-identical to the default
+   *     viewing conditions for sRGB.
+   */
+  toInt() {
+    return this.viewed(J.DEFAULT);
+  }
+  /**
+   * @param viewingConditions Information about the environment where the color
+   *     will be viewed.
+   * @return ARGB representation of color
+   */
+  viewed(e) {
+    const t = this.chroma === 0 || this.j === 0 ? 0 : this.chroma / Math.sqrt(this.j / 100), n = Math.pow(t / Math.pow(1.64 - Math.pow(0.29, e.n), 0.73), 1 / 0.9), a = this.hue * Math.PI / 180, o = 0.25 * (Math.cos(a + 2) + 3.8), i = e.aw * Math.pow(this.j / 100, 1 / e.c / e.z), u = o * (5e4 / 13) * e.nc * e.ncb, l = i / e.nbb, h = Math.sin(a), f = Math.cos(a), g = 23 * (l + 0.305) * n / (23 * u + 11 * n * f + 108 * n * h), p = g * f, v = g * h, m = (460 * l + 451 * p + 288 * v) / 1403, P = (460 * l - 891 * p - 261 * v) / 1403, k = (460 * l - 220 * p - 6300 * v) / 1403, B = Math.max(0, 27.13 * Math.abs(m) / (400 - Math.abs(m))), x = j(m) * (100 / e.fl) * Math.pow(B, 1 / 0.42), O = Math.max(0, 27.13 * Math.abs(P) / (400 - Math.abs(P))), R = j(P) * (100 / e.fl) * Math.pow(O, 1 / 0.42), V = Math.max(0, 27.13 * Math.abs(k) / (400 - Math.abs(k))), I = j(k) * (100 / e.fl) * Math.pow(V, 1 / 0.42), F = x / e.rgbD[0], L = R / e.rgbD[1], z = I / e.rgbD[2], E = 1.86206786 * F - 1.01125463 * L + 0.14918677 * z, W = 0.38752654 * F + 0.62144744 * L - 897398e-8 * z, te = -0.0158415 * F - 0.03412294 * L + 1.04996444 * z;
+    return Ft(E, W, te);
+  }
+  /// Given color expressed in XYZ and viewed in [viewingConditions], convert to
+  /// CAM16.
+  static fromXyzInViewingConditions(e, t, n, a) {
+    const o = 0.401288 * e + 0.650173 * t - 0.051461 * n, i = -0.250268 * e + 1.204414 * t + 0.045854 * n, u = -2079e-6 * e + 0.048952 * t + 0.953127 * n, l = a.rgbD[0] * o, h = a.rgbD[1] * i, f = a.rgbD[2] * u, g = Math.pow(a.fl * Math.abs(l) / 100, 0.42), p = Math.pow(a.fl * Math.abs(h) / 100, 0.42), v = Math.pow(a.fl * Math.abs(f) / 100, 0.42), m = j(l) * 400 * g / (g + 27.13), P = j(h) * 400 * p / (p + 27.13), k = j(f) * 400 * v / (v + 27.13), B = (11 * m + -12 * P + k) / 11, x = (m + P - 2 * k) / 9, O = (20 * m + 20 * P + 21 * k) / 20, R = (40 * m + 20 * P + k) / 20, I = Math.atan2(x, B) * 180 / Math.PI, F = I < 0 ? I + 360 : I >= 360 ? I - 360 : I, L = F * Math.PI / 180, z = R * a.nbb, E = 100 * Math.pow(z / a.aw, a.c * a.z), W = 4 / a.c * Math.sqrt(E / 100) * (a.aw + 4) * a.fLRoot, te = F < 20.14 ? F + 360 : F, ce = 1 / 4 * (Math.cos(te * Math.PI / 180 + 2) + 3.8), me = 5e4 / 13 * ce * a.nc * a.ncb * Math.sqrt(B * B + x * x) / (O + 0.305), ge = Math.pow(me, 0.9) * Math.pow(1.64 - Math.pow(0.29, a.n), 0.73), re = ge * Math.sqrt(E / 100), ye = re * a.fLRoot, Te = 50 * Math.sqrt(ge * a.c / (a.aw + 4)), ve = (1 + 100 * 7e-3) * E / (1 + 7e-3 * E), De = Math.log(1 + 0.0228 * ye) / 0.0228, we = De * Math.cos(L), Pe = De * Math.sin(L);
+    return new H(F, re, E, W, ye, Te, ve, we, Pe);
+  }
+  /// XYZ representation of CAM16 seen in [viewingConditions].
+  xyzInViewingConditions(e) {
+    const t = this.chroma === 0 || this.j === 0 ? 0 : this.chroma / Math.sqrt(this.j / 100), n = Math.pow(t / Math.pow(1.64 - Math.pow(0.29, e.n), 0.73), 1 / 0.9), a = this.hue * Math.PI / 180, o = 0.25 * (Math.cos(a + 2) + 3.8), i = e.aw * Math.pow(this.j / 100, 1 / e.c / e.z), u = o * (5e4 / 13) * e.nc * e.ncb, l = i / e.nbb, h = Math.sin(a), f = Math.cos(a), g = 23 * (l + 0.305) * n / (23 * u + 11 * n * f + 108 * n * h), p = g * f, v = g * h, m = (460 * l + 451 * p + 288 * v) / 1403, P = (460 * l - 891 * p - 261 * v) / 1403, k = (460 * l - 220 * p - 6300 * v) / 1403, B = Math.max(0, 27.13 * Math.abs(m) / (400 - Math.abs(m))), x = j(m) * (100 / e.fl) * Math.pow(B, 1 / 0.42), O = Math.max(0, 27.13 * Math.abs(P) / (400 - Math.abs(P))), R = j(P) * (100 / e.fl) * Math.pow(O, 1 / 0.42), V = Math.max(0, 27.13 * Math.abs(k) / (400 - Math.abs(k))), I = j(k) * (100 / e.fl) * Math.pow(V, 1 / 0.42), F = x / e.rgbD[0], L = R / e.rgbD[1], z = I / e.rgbD[2], E = 1.86206786 * F - 1.01125463 * L + 0.14918677 * z, W = 0.38752654 * F + 0.62144744 * L - 897398e-8 * z, te = -0.0158415 * F - 0.03412294 * L + 1.04996444 * z;
+    return [E, W, te];
+  }
+}
+/**
+ * @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 S {
+  /**
+   * 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(e) {
+    return (e + 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(e) {
+    const t = e / 100;
+    let n = 0;
+    return t <= 31308e-7 ? n = t * 12.92 : n = 1.055 * Math.pow(t, 1 / 2.4) - 0.055, n * 255;
+  }
+  static chromaticAdaptation(e) {
+    const t = Math.pow(Math.abs(e), 0.42);
+    return j(e) * 400 * t / (t + 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(e) {
+    const t = Le(e, S.SCALED_DISCOUNT_FROM_LINRGB), n = S.chromaticAdaptation(t[0]), a = S.chromaticAdaptation(t[1]), o = S.chromaticAdaptation(t[2]), i = (11 * n + -12 * a + o) / 11, u = (n + a - 2 * o) / 9;
+    return Math.atan2(u, i);
+  }
+  static areInCyclicOrder(e, t, n) {
+    const a = S.sanitizeRadians(t - e), o = S.sanitizeRadians(n - e);
+    return a < o;
+  }
+  /**
+   * 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(e, t, n) {
+    return (t - e) / (n - e);
+  }
+  static lerpPoint(e, t, n) {
+    return [
+      e[0] + (n[0] - e[0]) * t,
+      e[1] + (n[1] - e[1]) * t,
+      e[2] + (n[2] - e[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(e, t, n, a) {
+    const o = S.intercept(e[a], t, n[a]);
+    return S.lerpPoint(e, o, n);
+  }
+  static isBounded(e) {
+    return 0 <= e && e <= 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(e, t) {
+    const n = S.Y_FROM_LINRGB[0], a = S.Y_FROM_LINRGB[1], o = S.Y_FROM_LINRGB[2], i = t % 4 <= 1 ? 0 : 100, u = t % 2 === 0 ? 0 : 100;
+    if (t < 4) {
+      const l = i, h = u, f = (e - l * a - h * o) / n;
+      return S.isBounded(f) ? [f, l, h] : [-1, -1, -1];
+    } else if (t < 8) {
+      const l = i, h = u, f = (e - h * n - l * o) / a;
+      return S.isBounded(f) ? [h, f, l] : [-1, -1, -1];
+    } else {
+      const l = i, h = u, f = (e - l * n - h * a) / o;
+      return S.isBounded(f) ? [l, h, f] : [-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(e, t) {
+    let n = [-1, -1, -1], a = n, o = 0, i = 0, u = !1, l = !0;
+    for (let h = 0; h < 12; h++) {
+      const f = S.nthVertex(e, h);
+      if (f[0] < 0)
+        continue;
+      const g = S.hueOf(f);
+      if (!u) {
+        n = f, a = f, o = g, i = g, u = !0;
+        continue;
+      }
+      (l || S.areInCyclicOrder(o, g, i)) && (l = !1, S.areInCyclicOrder(o, t, g) ? (a = f, i = g) : (n = f, o = g));
+    }
+    return [n, a];
+  }
+  static midpoint(e, t) {
+    return [
+      (e[0] + t[0]) / 2,
+      (e[1] + t[1]) / 2,
+      (e[2] + t[2]) / 2
+    ];
+  }
+  static criticalPlaneBelow(e) {
+    return Math.floor(e - 0.5);
+  }
+  static criticalPlaneAbove(e) {
+    return Math.ceil(e - 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(e, t) {
+    const n = S.bisectToSegment(e, t);
+    let a = n[0], o = S.hueOf(a), i = n[1];
+    for (let u = 0; u < 3; u++)
+      if (a[u] !== i[u]) {
+        let l = -1, h = 255;
+        a[u] < i[u] ? (l = S.criticalPlaneBelow(S.trueDelinearized(a[u])), h = S.criticalPlaneAbove(S.trueDelinearized(i[u]))) : (l = S.criticalPlaneAbove(S.trueDelinearized(a[u])), h = S.criticalPlaneBelow(S.trueDelinearized(i[u])));
+        for (let f = 0; f < 8 && !(Math.abs(h - l) <= 1); f++) {
+          const g = Math.floor((l + h) / 2), p = S.CRITICAL_PLANES[g], v = S.setCoordinate(a, p, i, u), m = S.hueOf(v);
+          S.areInCyclicOrder(o, t, m) ? (i = v, h = g) : (a = v, o = m, l = g);
+        }
+      }
+    return S.midpoint(a, i);
+  }
+  static inverseChromaticAdaptation(e) {
+    const t = Math.abs(e), n = Math.max(0, 27.13 * t / (400 - t));
+    return j(e) * Math.pow(n, 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(e, t, n) {
+    let a = Math.sqrt(n) * 11;
+    const o = J.DEFAULT, i = 1 / Math.pow(1.64 - Math.pow(0.29, o.n), 0.73), l = 0.25 * (Math.cos(e + 2) + 3.8) * (5e4 / 13) * o.nc * o.ncb, h = Math.sin(e), f = Math.cos(e);
+    for (let g = 0; g < 5; g++) {
+      const p = a / 100, v = t === 0 || a === 0 ? 0 : t / Math.sqrt(p), m = Math.pow(v * i, 1 / 0.9), k = o.aw * Math.pow(p, 1 / o.c / o.z) / o.nbb, B = 23 * (k + 0.305) * m / (23 * l + 11 * m * f + 108 * m * h), x = B * f, O = B * h, R = (460 * k + 451 * x + 288 * O) / 1403, V = (460 * k - 891 * x - 261 * O) / 1403, I = (460 * k - 220 * x - 6300 * O) / 1403, F = S.inverseChromaticAdaptation(R), L = S.inverseChromaticAdaptation(V), z = S.inverseChromaticAdaptation(I), E = Le([F, L, z], S.LINRGB_FROM_SCALED_DISCOUNT);
+      if (E[0] < 0 || E[1] < 0 || E[2] < 0)
+        return 0;
+      const W = S.Y_FROM_LINRGB[0], te = S.Y_FROM_LINRGB[1], ce = S.Y_FROM_LINRGB[2], q = W * E[0] + te * E[1] + ce * E[2];
+      if (q <= 0)
+        return 0;
+      if (g === 4 || Math.abs(q - n) < 2e-3)
+        return E[0] > 100.01 || E[1] > 100.01 || E[2] > 100.01 ? 0 : Ke(E);
+      a = a - (q - n) * a / (2 * q);
+    }
+    return 0;
+  }
+  /**
+   * 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(e, t, n) {
+    if (t < 1e-4 || n < 1e-4 || n > 99.9999)
+      return Mt(n);
+    e = be(e);
+    const a = e / 180 * Math.PI, o = ae(n), i = S.findResultByJ(a, t, o);
+    if (i !== 0)
+      return i;
+    const u = S.bisectToLimit(o, a);
+    return Ke(u);
+  }
+  /**
+   * 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(e, t, n) {
+    return H.fromInt(S.solveToInt(e, t, n));
+  }
+}
+S.SCALED_DISCOUNT_FROM_LINRGB = [
+  [
+    0.001200833568784504,
+    0.002389694492170889,
+    2795742885861124e-19
+  ],
+  [
+    5891086651375999e-19,
+    0.0029785502573438758,
+    3270666104008398e-19
+  ],
+  [
+    10146692491640572e-20,
+    5364214359186694e-19,
+    0.0032979401770712076
+  ]
+];
+S.LINRGB_FROM_SCALED_DISCOUNT = [
+  [
+    1373.2198709594231,
+    -1100.4251190754821,
+    -7.278681089101213
+  ],
+  [
+    -271.815969077903,
+    559.6580465940733,
+    -32.46047482791194
+  ],
+  [
+    1.9622899599665666,
+    -57.173814538844006,
+    308.7233197812385
+  ]
+];
+S.Y_FROM_LINRGB = [0.2126, 0.7152, 0.0722];
+S.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
+];
+/**
+ * @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 C {
+  static from(e, t, n) {
+    return new C(S.solveToInt(e, t, n));
+  }
+  /**
+   * @param argb ARGB representation of a color.
+   * @return HCT representation of a color in default viewing conditions
+   */
+  static fromInt(e) {
+    return new C(e);
+  }
+  toInt() {
+    return this.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(e) {
+    this.setInternalState(S.solveToInt(e, 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(e) {
+    this.setInternalState(S.solveToInt(this.internalHue, e, 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(e) {
+    this.setInternalState(S.solveToInt(this.internalHue, this.internalChroma, e));
+  }
+  /** Sets a property of the Hct object. */
+  setValue(e, t) {
+    this[e] = t;
+  }
+  toString() {
+    return `HCT(${this.hue.toFixed(0)}, ${this.chroma.toFixed(0)}, ${this.tone.toFixed(0)})`;
+  }
+  static isBlue(e) {
+    return e >= 250 && e < 270;
+  }
+  static isYellow(e) {
+    return e >= 105 && e < 125;
+  }
+  static isCyan(e) {
+    return e >= 170 && e < 207;
+  }
+  constructor(e) {
+    this.argb = e;
+    const t = H.fromInt(e);
+    this.internalHue = t.hue, this.internalChroma = t.chroma, this.internalTone = Oe(e), this.argb = e;
+  }
+  setInternalState(e) {
+    const t = H.fromInt(e);
+    this.internalHue = t.hue, this.internalChroma = t.chroma, this.internalTone = Oe(e), this.argb = e;
+  }
+  /**
+   * 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(e) {
+    const n = H.fromInt(this.toInt()).xyzInViewingConditions(e), a = H.fromXyzInViewingConditions(n[0], n[1], n[2], J.make());
+    return C.from(a.hue, a.chroma, Re(n[1]));
+  }
+}
+/**
+ * @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 Ve {
+  /**
+   * Blend the design color's HCT hue towards the key color's HCT
+   * hue, in a way that leaves the original color recognizable and
+   * recognizably shifted towards the key color.
+   *
+   * @param designColor ARGB representation of an arbitrary color.
+   * @param sourceColor ARGB representation of the main theme color.
+   * @return The design color with a hue shifted towards the
+   * system's color, a slightly warmer/cooler variant of the design
+   * color's hue.
+   */
+  static harmonize(e, t) {
+    const n = C.fromInt(e), a = C.fromInt(t), o = Tt(n.hue, a.hue), i = Math.min(o * 0.5, 15), u = be(n.hue + i * Ct(n.hue, a.hue));
+    return C.from(u, n.chroma, n.tone).toInt();
+  }
+  /**
+   * Blends hue from one color into another. The chroma and tone of
+   * the original color are maintained.
+   *
+   * @param from ARGB representation of color
+   * @param to ARGB representation of color
+   * @param amount how much blending to perform; 0.0 >= and <= 1.0
+   * @return from, with a hue blended towards to. Chroma and tone
+   * are constant.
+   */
+  static hctHue(e, t, n) {
+    const a = Ve.cam16Ucs(e, t, n), o = H.fromInt(a), i = H.fromInt(e);
+    return C.from(o.hue, i.chroma, Oe(e)).toInt();
+  }
+  /**
+   * Blend in CAM16-UCS space.
+   *
+   * @param from ARGB representation of color
+   * @param to ARGB representation of color
+   * @param amount how much blending to perform; 0.0 >= and <= 1.0
+   * @return from, blended towards to. Hue, chroma, and tone will
+   * change.
+   */
+  static cam16Ucs(e, t, n) {
+    const a = H.fromInt(e), o = H.fromInt(t), i = a.jstar, u = a.astar, l = a.bstar, h = o.jstar, f = o.astar, g = o.bstar, p = i + (h - i) * n, v = u + (f - u) * n, m = l + (g - l) * n;
+    return H.fromUcs(p, v, m).toInt();
+  }
+}
+/**
+ * @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 M {
+  /**
+   * Returns a contrast ratio, which ranges from 1 to 21.
+   *
+   * @param toneA Tone between 0 and 100. Values outside will be clamped.
+   * @param toneB Tone between 0 and 100. Values outside will be clamped.
+   */
+  static ratioOfTones(e, t) {
+    return e = U(0, 100, e), t = U(0, 100, t), M.ratioOfYs(ae(e), ae(t));
+  }
+  static ratioOfYs(e, t) {
+    const n = e > t ? e : t, a = n === t ? e : t;
+    return (n + 5) / (a + 5);
+  }
+  /**
+   * Returns a tone >= tone parameter that ensures ratio parameter.
+   * Return value is between 0 and 100.
+   * Returns -1 if ratio cannot be achieved with tone parameter.
+   *
+   * @param tone Tone return value must contrast with.
+   * Range is 0 to 100. Invalid values will result in -1 being returned.
+   * @param ratio Contrast ratio of return value and tone.
+   * Range is 1 to 21, invalid values have undefined behavior.
+   */
+  static lighter(e, t) {
+    if (e < 0 || e > 100)
+      return -1;
+    const n = ae(e), a = t * (n + 5) - 5, o = M.ratioOfYs(a, n), i = Math.abs(o - t);
+    if (o < t && i > 0.04)
+      return -1;
+    const u = Re(a) + 0.4;
+    return u < 0 || u > 100 ? -1 : u;
+  }
+  /**
+   * Returns a tone <= tone parameter that ensures ratio parameter.
+   * Return value is between 0 and 100.
+   * Returns -1 if ratio cannot be achieved with tone parameter.
+   *
+   * @param tone Tone return value must contrast with.
+   * Range is 0 to 100. Invalid values will result in -1 being returned.
+   * @param ratio Contrast ratio of return value and tone.
+   * Range is 1 to 21, invalid values have undefined behavior.
+   */
+  static darker(e, t) {
+    if (e < 0 || e > 100)
+      return -1;
+    const n = ae(e), a = (n + 5) / t - 5, o = M.ratioOfYs(n, a), i = Math.abs(o - t);
+    if (o < t && i > 0.04)
+      return -1;
+    const u = Re(a) - 0.4;
+    return u < 0 || u > 100 ? -1 : u;
+  }
+  /**
+   * Returns a tone >= tone parameter that ensures ratio parameter.
+   * Return value is between 0 and 100.
+   * Returns 100 if ratio cannot be achieved with tone parameter.
+   *
+   * This method is unsafe because the returned value is guaranteed to be in
+   * bounds for tone, i.e. between 0 and 100. However, that value may not reach
+   * the ratio with tone. For example, there is no color lighter than T100.
+   *
+   * @param tone Tone return value must contrast with.
+   * Range is 0 to 100. Invalid values will result in 100 being returned.
+   * @param ratio Desired contrast ratio of return value and tone parameter.
+   * Range is 1 to 21, invalid values have undefined behavior.
+   */
+  static lighterUnsafe(e, t) {
+    const n = M.lighter(e, t);
+    return n < 0 ? 100 : n;
+  }
+  /**
+   * Returns a tone >= tone parameter that ensures ratio parameter.
+   * Return value is between 0 and 100.
+   * Returns 100 if ratio cannot be achieved with tone parameter.
+   *
+   * This method is unsafe because the returned value is guaranteed to be in
+   * bounds for tone, i.e. between 0 and 100. However, that value may not reach
+   * the [ratio with [tone]. For example, there is no color darker than T0.
+   *
+   * @param tone Tone return value must contrast with.
+   * Range is 0 to 100. Invalid values will result in 0 being returned.
+   * @param ratio Desired contrast ratio of return value and tone parameter.
+   * Range is 1 to 21, invalid values have undefined behavior.
+   */
+  static darkerUnsafe(e, t) {
+    const n = M.darker(e, t);
+    return n < 0 ? 0 : n;
+  }
+}
+/**
+ * @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 Ne {
+  /**
+   * Returns true if a color is disliked.
+   *
+   * @param hct A color to be judged.
+   * @return Whether the color is disliked.
+   *
+   * Disliked is defined as a dark yellow-green that is not neutral.
+   */
+  static isDisliked(e) {
+    const t = Math.round(e.hue) >= 90 && Math.round(e.hue) <= 111, n = Math.round(e.chroma) > 16, a = Math.round(e.tone) < 65;
+    return t && n && a;
+  }
+  /**
+   * If a color is disliked, lighten it to make it likable.
+   *
+   * @param hct A color to be judged.
+   * @return A new color if the original color is disliked, or the original
+   *   color if it is acceptable.
+   */
+  static fixIfDisliked(e) {
+    return Ne.isDisliked(e) ? C.from(e.hue, e.chroma, 70) : e;
+  }
+}
+/**
+ * @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 It(r, e, t) {
+  if (r.name !== t.name)
+    throw new Error(`Attempting to extend color ${r.name} with color ${t.name} of different name for spec version ${e}.`);
+  if (r.isBackground !== t.isBackground)
+    throw new Error(`Attempting to extend color ${r.name} as a ${r.isBackground ? "background" : "foreground"} with color ${t.name} as a ${t.isBackground ? "background" : "foreground"} for spec version ${e}.`);
+}
+function T(r, e, t) {
+  return It(r, e, t), c.fromPalette({
+    name: r.name,
+    palette: (n) => n.specVersion === e ? t.palette(n) : r.palette(n),
+    tone: (n) => n.specVersion === e ? t.tone(n) : r.tone(n),
+    isBackground: r.isBackground,
+    chromaMultiplier: (n) => {
+      const a = n.specVersion === e ? t.chromaMultiplier : r.chromaMultiplier;
+      return a !== void 0 ? a(n) : 1;
+    },
+    background: (n) => {
+      const a = n.specVersion === e ? t.background : r.background;
+      return a !== void 0 ? a(n) : void 0;
+    },
+    secondBackground: (n) => {
+      const a = n.specVersion === e ? t.secondBackground : r.secondBackground;
+      return a !== void 0 ? a(n) : void 0;
+    },
+    contrastCurve: (n) => {
+      const a = n.specVersion === e ? t.contrastCurve : r.contrastCurve;
+      return a !== void 0 ? a(n) : void 0;
+    },
+    toneDeltaPair: (n) => {
+      const a = n.specVersion === e ? t.toneDeltaPair : r.toneDeltaPair;
+      return a !== void 0 ? a(n) : void 0;
+    }
+  });
+}
+class c {
+  /**
+   * 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(e) {
+    return new c(e.name ?? "", e.palette, e.tone ?? c.getInitialToneFromBackground(e.background), e.isBackground ?? !1, e.chromaMultiplier, e.background, e.secondBackground, e.contrastCurve, e.toneDeltaPair);
+  }
+  static getInitialToneFromBackground(e) {
+    return e === void 0 ? (t) => 50 : (t) => e(t) ? e(t).getTone(t) : 50;
+  }
+  /**
+   * 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(e, t, n, a, o, i, u, l, h) {
+    if (this.name = e, this.palette = t, this.tone = n, this.isBackground = a, this.chromaMultiplier = o, this.background = i, this.secondBackground = u, this.contrastCurve = l, this.toneDeltaPair = h, this.hctCache = /* @__PURE__ */ new Map(), !i && u)
+      throw new Error(`Color ${e} has secondBackgrounddefined, but background is not defined.`);
+    if (!i && l)
+      throw new Error(`Color ${e} has contrastCurvedefined, but background is not defined.`);
+    if (i && !l)
+      throw new Error(`Color ${e} has backgrounddefined, but contrastCurve is not defined.`);
+  }
+  /**
+   * Returns a deep copy of this DynamicColor.
+   */
+  clone() {
+    return c.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(e) {
+    return this.getHct(e).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(e) {
+    const t = this.hctCache.get(e);
+    if (t != null)
+      return t;
+    const n = qe(e.specVersion).getHct(e, this);
+    return this.hctCache.size > 4 && this.hctCache.clear(), this.hctCache.set(e, n), n;
+  }
+  /**
+   * 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(e) {
+    return qe(e.specVersion).getTone(e, this);
+  }
+  /**
+   * Given a background tone, finds a foreground tone, while ensuring they reach
+   * a contrast ratio that is as close to [ratio] as possible.
+   *
+   * @param bgTone Tone in HCT. Range is 0 to 100, undefined behavior when it
+   *     falls outside that range.
+   * @param ratio The contrast ratio desired between bgTone and the return
+   *     value.
+   */
+  static foregroundTone(e, t) {
+    const n = M.lighterUnsafe(e, t), a = M.darkerUnsafe(e, t), o = M.ratioOfTones(n, e), i = M.ratioOfTones(a, e);
+    if (c.tonePrefersLightForeground(e)) {
+      const l = Math.abs(o - i) < 0.1 && o < t && i < t;
+      return o >= t || o >= i || l ? n : a;
+    } else
+      return i >= t || i >= o ? a : n;
+  }
+  /**
+   * 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(e) {
+    return Math.round(e) < 60;
+  }
+  /**
+   * Returns whether [tone] can reach a contrast ratio of 4.5 with a lighter
+   * color.
+   */
+  static toneAllowsLightForeground(e) {
+    return Math.round(e) <= 49;
+  }
+  /**
+   * Adjusts a tone such that white has 4.5 contrast, if the tone is
+   * reasonably close to supporting it.
+   */
+  static enableLightForeground(e) {
+    return c.tonePrefersLightForeground(e) && !c.toneAllowsLightForeground(e) ? 49 : e;
+  }
+}
+class Et {
+  getHct(e, t) {
+    const n = t.getTone(e);
+    return t.palette(e).getHct(n);
+  }
+  getTone(e, t) {
+    const n = e.contrastLevel < 0, a = t.toneDeltaPair ? t.toneDeltaPair(e) : void 0;
+    if (a) {
+      const o = a.roleA, i = a.roleB, u = a.delta, l = a.polarity, h = a.stayTogether, f = l === "nearer" || l === "lighter" && !e.isDark || l === "darker" && e.isDark, g = f ? o : i, p = f ? i : o, v = t.name === g.name, m = e.isDark ? 1 : -1;
+      let P = g.tone(e), k = p.tone(e);
+      if (t.background && g.contrastCurve && p.contrastCurve) {
+        const B = t.background(e), x = g.contrastCurve(e), O = p.contrastCurve(e);
+        if (B && x && O) {
+          const R = B.getTone(e), V = x.get(e.contrastLevel), I = O.get(e.contrastLevel);
+          M.ratioOfTones(R, P) < V && (P = c.foregroundTone(R, V)), M.ratioOfTones(R, k) < I && (k = c.foregroundTone(R, I)), n && (P = c.foregroundTone(R, V), k = c.foregroundTone(R, I));
+        }
+      }
+      return (k - P) * m < u && (k = U(0, 100, P + u * m), (k - P) * m >= u || (P = U(0, 100, k - u * m))), 50 <= P && P < 60 ? m > 0 ? (P = 60, k = Math.max(k, P + u * m)) : (P = 49, k = Math.min(k, P + u * m)) : 50 <= k && k < 60 && (h ? m > 0 ? (P = 60, k = Math.max(k, P + u * m)) : (P = 49, k = Math.min(k, P + u * m)) : m > 0 ? k = 60 : k = 49), v ? P : k;
+    } else {
+      let o = t.tone(e);
+      if (t.background == null || t.background(e) === void 0 || t.contrastCurve == null || t.contrastCurve(e) === void 0)
+        return o;
+      const i = t.background(e).getTone(e), u = t.contrastCurve(e).get(e.contrastLevel);
+      if (M.ratioOfTones(i, o) >= u || (o = c.foregroundTone(i, u)), n && (o = c.foregroundTone(i, u)), t.isBackground && 50 <= o && o < 60 && (M.ratioOfTones(49, i) >= u ? o = 49 : o = 60), t.secondBackground == null || t.secondBackground(e) === void 0)
+        return o;
+      const [l, h] = [t.background, t.secondBackground], [f, g] = [l(e).getTone(e), h(e).getTone(e)], [p, v] = [Math.max(f, g), Math.min(f, g)];
+      if (M.ratioOfTones(p, o) >= u && M.ratioOfTones(v, o) >= u)
+        return o;
+      const m = M.lighter(p, u), P = M.darker(v, u), k = [];
+      return m !== -1 && k.push(m), P !== -1 && k.push(P), c.tonePrefersLightForeground(f) || c.tonePrefersLightForeground(g) ? m < 0 ? 100 : m : k.length === 1 ? k[0] : P < 0 ? 0 : P;
+    }
+  }
+}
+class Lt {
+  getHct(e, t) {
+    const n = t.palette(e), a = t.getTone(e), o = n.hue, i = n.chroma * (t.chromaMultiplier ? t.chromaMultiplier(e) : 1);
+    return C.from(o, i, a);
+  }
+  getTone(e, t) {
+    const n = t.toneDeltaPair ? t.toneDeltaPair(e) : void 0;
+    if (n) {
+      const a = n.roleA, o = n.roleB, i = n.polarity, u = n.constraint, l = i === "darker" || i === "relative_lighter" && e.isDark || i === "relative_darker" && !e.isDark ? -n.delta : n.delta, h = t.name === a.name, f = h ? a : o, g = h ? o : a;
+      let p = f.tone(e), v = g.getTone(e);
+      const m = l * (h ? 1 : -1);
+      if (u === "exact" ? p = U(0, 100, v + m) : u === "nearer" ? m > 0 ? p = U(0, 100, U(v, v + m, p)) : p = U(0, 100, U(v + m, v, p)) : u === "farther" && (m > 0 ? p = U(v + m, 100, p) : p = U(0, v + m, p)), t.background && t.contrastCurve) {
+        const P = t.background(e), k = t.contrastCurve(e);
+        if (P && k) {
+          const B = P.getTone(e), x = k.get(e.contrastLevel);
+          p = M.ratioOfTones(B, p) >= x && e.contrastLevel >= 0 ? p : c.foregroundTone(B, x);
+        }
+      }
+      return t.isBackground && !t.name.endsWith("_fixed_dim") && (p >= 57 ? p = U(65, 100, p) : p = U(0, 49, p)), p;
+    } else {
+      let a = t.tone(e);
+      if (t.background == null || t.background(e) === void 0 || t.contrastCurve == null || t.contrastCurve(e) === void 0)
+        return a;
+      const o = t.background(e).getTone(e), i = t.contrastCurve(e).get(e.contrastLevel);
+      if (a = M.ratioOfTones(o, a) >= i && e.contrastLevel >= 0 ? a : c.foregroundTone(o, i), t.isBackground && !t.name.endsWith("_fixed_dim") && (a >= 57 ? a = U(65, 100, a) : a = U(0, 49, a)), t.secondBackground == null || t.secondBackground(e) === void 0)
+        return a;
+      const [u, l] = [t.background, t.secondBackground], [h, f] = [u(e).getTone(e), l(e).getTone(e)], [g, p] = [Math.max(h, f), Math.min(h, f)];
+      if (M.ratioOfTones(g, a) >= i && M.ratioOfTones(p, a) >= i)
+        return a;
+      const v = M.lighter(g, i), m = M.darker(p, i), P = [];
+      return v !== -1 && P.push(v), m !== -1 && P.push(m), c.tonePrefersLightForeground(h) || c.tonePrefersLightForeground(f) ? v < 0 ? 100 : v : P.length === 1 ? P[0] : m < 0 ? 0 : m;
+    }
+  }
+}
+const Ot = new Et(), Rt = new Lt();
+function qe(r) {
+  return r === "2025" ? Rt : Ot;
+}
+/**
+ * @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 Y {
+  /**
+   * @param argb ARGB representation of a color
+   * @return Tones matching that color's hue and chroma.
+   */
+  static fromInt(e) {
+    const t = C.fromInt(e);
+    return Y.fromHct(t);
+  }
+  /**
+   * @param hct Hct
+   * @return Tones matching that color's hue and chroma.
+   */
+  static fromHct(e) {
+    return new Y(e.hue, e.chroma, e);
+  }
+  /**
+   * @param hue HCT hue
+   * @param chroma HCT chroma
+   * @return Tones matching hue and chroma.
+   */
+  static fromHueAndChroma(e, t) {
+    const n = new Vt(e, t).create();
+    return new Y(e, t, n);
+  }
+  constructor(e, t, n) {
+    this.hue = e, this.chroma = t, this.keyColor = n, this.cache = /* @__PURE__ */ new Map();
+  }
+  /**
+   * @param tone HCT tone, measured from 0 to 100.
+   * @return ARGB representation of a color with that tone.
+   */
+  tone(e) {
+    let t = this.cache.get(e);
+    return t === void 0 && (e == 99 && C.isYellow(this.hue) ? t = this.averageArgb(this.tone(98), this.tone(100)) : t = C.from(this.hue, this.chroma, e).toInt(), this.cache.set(e, t)), t;
+  }
+  /**
+   * @param tone HCT tone.
+   * @return HCT representation of a color with that tone.
+   */
+  getHct(e) {
+    return C.fromInt(this.tone(e));
+  }
+  averageArgb(e, t) {
+    const n = e >>> 16 & 255, a = e >>> 8 & 255, o = e & 255, i = t >>> 16 & 255, u = t >>> 8 & 255, l = t & 255, h = Math.round((n + i) / 2), f = Math.round((a + u) / 2), g = Math.round((o + l) / 2);
+    return (255 << 24 | (h & 255) << 16 | (f & 255) << 8 | g & 255) >>> 0;
+  }
+}
+class Vt {
+  constructor(e, t) {
+    this.hue = e, this.requestedChroma = t, this.chromaCache = /* @__PURE__ */ new Map(), this.maxChromaValue = 200;
+  }
+  /**
+   * Creates a key color from a [hue] and a [chroma].
+   * The key color is the first tone, starting from T50, matching the given hue
+   * and chroma.
+   *
+   * @return Key color [Hct]
+   */
+  create() {
+    let a = 0, o = 100;
+    for (; a < o; ) {
+      const i = Math.floor((a + o) / 2), u = this.maxChroma(i) < this.maxChroma(i + 1);
+      if (this.maxChroma(i) >= this.requestedChroma - 0.01)
+        if (Math.abs(a - 50) < Math.abs(o - 50))
+          o = i;
+        else {
+          if (a === i)
+            return C.from(this.hue, this.requestedChroma, a);
+          a = i;
+        }
+      else
+        u ? a = i + 1 : o = i;
+    }
+    return C.from(this.hue, this.requestedChroma, a);
+  }
+  // Find the maximum chroma for a given tone
+  maxChroma(e) {
+    if (this.chromaCache.has(e))
+      return this.chromaCache.get(e);
+    const t = C.from(this.hue, this.maxChromaValue, e).chroma;
+    return this.chromaCache.set(e, t), t;
+  }
+}
+/**
+ * @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 y {
+  /**
+   * 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(e, t, n, a) {
+    this.low = e, this.normal = t, this.medium = n, this.high = a;
+  }
+  /**
+   * 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(e) {
+    return e <= -1 ? this.low : e < 0 ? fe(this.low, this.normal, (e - -1) / 1) : e < 0.5 ? fe(this.normal, this.medium, (e - 0) / 0.5) : e < 1 ? fe(this.medium, this.high, (e - 0.5) / 0.5) : this.high;
+  }
+}
+/**
+ * @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 w {
+  /**
+   * 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(e, t, n, a, o, i) {
+    this.roleA = e, this.roleB = t, this.delta = n, this.polarity = a, this.stayTogether = o, this.constraint = i, this.constraint = i ?? "exact";
+  }
+}
+/**
+ * @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.
+ */
+var d;
+(function(r) {
+  r[r.MONOCHROME = 0] = "MONOCHROME", r[r.NEUTRAL = 1] = "NEUTRAL", r[r.TONAL_SPOT = 2] = "TONAL_SPOT", r[r.VIBRANT = 3] = "VIBRANT", r[r.EXPRESSIVE = 4] = "EXPRESSIVE", r[r.FIDELITY = 5] = "FIDELITY", r[r.CONTENT = 6] = "CONTENT", r[r.RAINBOW = 7] = "RAINBOW", r[r.FRUIT_SALAD = 8] = "FRUIT_SALAD";
+})(d || (d = {}));
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function ue(r) {
+  return r.variant === d.FIDELITY || r.variant === d.CONTENT;
+}
+function A(r) {
+  return r.variant === d.MONOCHROME;
+}
+function Nt(r, e, t, n) {
+  let a = t, o = C.from(r, e, t);
+  if (o.chroma < e) {
+    let i = o.chroma;
+    for (; o.chroma < e; ) {
+      a += n ? -1 : 1;
+      const u = C.from(r, e, a);
+      if (i > u.chroma || Math.abs(u.chroma - e) < 0.4)
+        break;
+      const l = Math.abs(u.chroma - e), h = Math.abs(o.chroma - e);
+      l < h && (o = u), i = Math.max(i, u.chroma);
+    }
+  }
+  return a;
+}
+class _t {
+  ////////////////////////////////////////////////////////////////
+  // Main Palettes                                              //
+  ////////////////////////////////////////////////////////////////
+  primaryPaletteKeyColor() {
+    return c.fromPalette({
+      name: "primary_palette_key_color",
+      palette: (e) => e.primaryPalette,
+      tone: (e) => e.primaryPalette.keyColor.tone
+    });
+  }
+  secondaryPaletteKeyColor() {
+    return c.fromPalette({
+      name: "secondary_palette_key_color",
+      palette: (e) => e.secondaryPalette,
+      tone: (e) => e.secondaryPalette.keyColor.tone
+    });
+  }
+  tertiaryPaletteKeyColor() {
+    return c.fromPalette({
+      name: "tertiary_palette_key_color",
+      palette: (e) => e.tertiaryPalette,
+      tone: (e) => e.tertiaryPalette.keyColor.tone
+    });
+  }
+  neutralPaletteKeyColor() {
+    return c.fromPalette({
+      name: "neutral_palette_key_color",
+      palette: (e) => e.neutralPalette,
+      tone: (e) => e.neutralPalette.keyColor.tone
+    });
+  }
+  neutralVariantPaletteKeyColor() {
+    return c.fromPalette({
+      name: "neutral_variant_palette_key_color",
+      palette: (e) => e.neutralVariantPalette,
+      tone: (e) => e.neutralVariantPalette.keyColor.tone
+    });
+  }
+  errorPaletteKeyColor() {
+    return c.fromPalette({
+      name: "error_palette_key_color",
+      palette: (e) => e.errorPalette,
+      tone: (e) => e.errorPalette.keyColor.tone
+    });
+  }
+  ////////////////////////////////////////////////////////////////
+  // Surfaces [S]                                               //
+  ////////////////////////////////////////////////////////////////
+  background() {
+    return c.fromPalette({
+      name: "background",
+      palette: (e) => e.neutralPalette,
+      tone: (e) => e.isDark ? 6 : 98,
+      isBackground: !0
+    });
+  }
+  onBackground() {
+    return c.fromPalette({
+      name: "on_background",
+      palette: (e) => e.neutralPalette,
+      tone: (e) => e.isDark ? 90 : 10,
+      background: (e) => this.background(),
+      contrastCurve: (e) => new y(3, 3, 4.5, 7)
+    });
+  }
+  surface() {
+    return c.fromPalette({
+      name: "surface",
+      palette: (e) => e.neutralPalette,
+      tone: (e) => e.isDark ? 6 : 98,
+      isBackground: !0
+    });
+  }
+  surfaceDim() {
+    return c.fromPalette({
+      name: "surface_dim",
+      palette: (e) => e.neutralPalette,
+      tone: (e) => e.isDark ? 6 : new y(87, 87, 80, 75).get(e.contrastLevel),
+      isBackground: !0
+    });
+  }
+  surfaceBright() {
+    return c.fromPalette({
+      name: "surface_bright",
+      palette: (e) => e.neutralPalette,
+      tone: (e) => e.isDark ? new y(24, 24, 29, 34).get(e.contrastLevel) : 98,
+      isBackground: !0
+    });
+  }
+  surfaceContainerLowest() {
+    return c.fromPalette({
+      name: "surface_container_lowest",
+      palette: (e) => e.neutralPalette,
+      tone: (e) => e.isDark ? new y(4, 4, 2, 0).get(e.contrastLevel) : 100,
+      isBackground: !0
+    });
+  }
+  surfaceContainerLow() {
+    return c.fromPalette({
+      name: "surface_container_low",
+      palette: (e) => e.neutralPalette,
+      tone: (e) => e.isDark ? new y(10, 10, 11, 12).get(e.contrastLevel) : new y(96, 96, 96, 95).get(e.contrastLevel),
+      isBackground: !0
+    });
+  }
+  surfaceContainer() {
+    return c.fromPalette({
+      name: "surface_container",
+      palette: (e) => e.neutralPalette,
+      tone: (e) => e.isDark ? new y(12, 12, 16, 20).get(e.contrastLevel) : new y(94, 94, 92, 90).get(e.contrastLevel),
+      isBackground: !0
+    });
+  }
+  surfaceContainerHigh() {
+    return c.fromPalette({
+      name: "surface_container_high",
+      palette: (e) => e.neutralPalette,
+      tone: (e) => e.isDark ? new y(17, 17, 21, 25).get(e.contrastLevel) : new y(92, 92, 88, 85).get(e.contrastLevel),
+      isBackground: !0
+    });
+  }
+  surfaceContainerHighest() {
+    return c.fromPalette({
+      name: "surface_container_highest",
+      palette: (e) => e.neutralPalette,
+      tone: (e) => e.isDark ? new y(22, 22, 26, 30).get(e.contrastLevel) : new y(90, 90, 84, 80).get(e.contrastLevel),
+      isBackground: !0
+    });
+  }
+  onSurface() {
+    return c.fromPalette({
+      name: "on_surface",
+      palette: (e) => e.neutralPalette,
+      tone: (e) => e.isDark ? 90 : 10,
+      background: (e) => this.highestSurface(e),
+      contrastCurve: (e) => new y(4.5, 7, 11, 21)
+    });
+  }
+  surfaceVariant() {
+    return c.fromPalette({
+      name: "surface_variant",
+      palette: (e) => e.neutralVariantPalette,
+      tone: (e) => e.isDark ? 30 : 90,
+      isBackground: !0
+    });
+  }
+  onSurfaceVariant() {
+    return c.fromPalette({
+      name: "on_surface_variant",
+      palette: (e) => e.neutralVariantPalette,
+      tone: (e) => e.isDark ? 80 : 30,
+      background: (e) => this.highestSurface(e),
+      contrastCurve: (e) => new y(3, 4.5, 7, 11)
+    });
+  }
+  inverseSurface() {
+    return c.fromPalette({
+      name: "inverse_surface",
+      palette: (e) => e.neutralPalette,
+      tone: (e) => e.isDark ? 90 : 20,
+      isBackground: !0
+    });
+  }
+  inverseOnSurface() {
+    return c.fromPalette({
+      name: "inverse_on_surface",
+      palette: (e) => e.neutralPalette,
+      tone: (e) => e.isDark ? 20 : 95,
+      background: (e) => this.inverseSurface(),
+      contrastCurve: (e) => new y(4.5, 7, 11, 21)
+    });
+  }
+  outline() {
+    return c.fromPalette({
+      name: "outline",
+      palette: (e) => e.neutralVariantPalette,
+      tone: (e) => e.isDark ? 60 : 50,
+      background: (e) => this.highestSurface(e),
+      contrastCurve: (e) => new y(1.5, 3, 4.5, 7)
+    });
+  }
+  outlineVariant() {
+    return c.fromPalette({
+      name: "outline_variant",
+      palette: (e) => e.neutralVariantPalette,
+      tone: (e) => e.isDark ? 30 : 80,
+      background: (e) => this.highestSurface(e),
+      contrastCurve: (e) => new y(1, 1, 3, 4.5)
+    });
+  }
+  shadow() {
+    return c.fromPalette({
+      name: "shadow",
+      palette: (e) => e.neutralPalette,
+      tone: (e) => 0
+    });
+  }
+  scrim() {
+    return c.fromPalette({
+      name: "scrim",
+      palette: (e) => e.neutralPalette,
+      tone: (e) => 0
+    });
+  }
+  surfaceTint() {
+    return c.fromPalette({
+      name: "surface_tint",
+      palette: (e) => e.primaryPalette,
+      tone: (e) => e.isDark ? 80 : 40,
+      isBackground: !0
+    });
+  }
+  ////////////////////////////////////////////////////////////////
+  // Primary [P].                                               //
+  ////////////////////////////////////////////////////////////////
+  primary() {
+    return c.fromPalette({
+      name: "primary",
+      palette: (e) => e.primaryPalette,
+      tone: (e) => A(e) ? e.isDark ? 100 : 0 : e.isDark ? 80 : 40,
+      isBackground: !0,
+      background: (e) => this.highestSurface(e),
+      contrastCurve: (e) => new y(3, 4.5, 7, 7),
+      toneDeltaPair: (e) => new w(this.primaryContainer(), this.primary(), 10, "nearer", !1)
+    });
+  }
+  primaryDim() {
+  }
+  onPrimary() {
+    return c.fromPalette({
+      name: "on_primary",
+      palette: (e) => e.primaryPalette,
+      tone: (e) => A(e) ? e.isDark ? 10 : 90 : e.isDark ? 20 : 100,
+      background: (e) => this.primary(),
+      contrastCurve: (e) => new y(4.5, 7, 11, 21)
+    });
+  }
+  primaryContainer() {
+    return c.fromPalette({
+      name: "primary_container",
+      palette: (e) => e.primaryPalette,
+      tone: (e) => ue(e) ? e.sourceColorHct.tone : A(e) ? e.isDark ? 85 : 25 : e.isDark ? 30 : 90,
+      isBackground: !0,
+      background: (e) => this.highestSurface(e),
+      contrastCurve: (e) => new y(1, 1, 3, 4.5),
+      toneDeltaPair: (e) => new w(this.primaryContainer(), this.primary(), 10, "nearer", !1)
+    });
+  }
+  onPrimaryContainer() {
+    return c.fromPalette({
+      name: "on_primary_container",
+      palette: (e) => e.primaryPalette,
+      tone: (e) => ue(e) ? c.foregroundTone(this.primaryContainer().tone(e), 4.5) : A(e) ? e.isDark ? 0 : 100 : e.isDark ? 90 : 30,
+      background: (e) => this.primaryContainer(),
+      contrastCurve: (e) => new y(3, 4.5, 7, 11)
+    });
+  }
+  inversePrimary() {
+    return c.fromPalette({
+      name: "inverse_primary",
+      palette: (e) => e.primaryPalette,
+      tone: (e) => e.isDark ? 40 : 80,
+      background: (e) => this.inverseSurface(),
+      contrastCurve: (e) => new y(3, 4.5, 7, 7)
+    });
+  }
+  /////////////////////////////////////////////////////////////////
+  // Secondary [Q].                                              //
+  /////////////////////////////////////////////////////////////////
+  secondary() {
+    return c.fromPalette({
+      name: "secondary",
+      palette: (e) => e.secondaryPalette,
+      tone: (e) => e.isDark ? 80 : 40,
+      isBackground: !0,
+      background: (e) => this.highestSurface(e),
+      contrastCurve: (e) => new y(3, 4.5, 7, 7),
+      toneDeltaPair: (e) => new w(this.secondaryContainer(), this.secondary(), 10, "nearer", !1)
+    });
+  }
+  secondaryDim() {
+  }
+  onSecondary() {
+    return c.fromPalette({
+      name: "on_secondary",
+      palette: (e) => e.secondaryPalette,
+      tone: (e) => A(e) ? e.isDark ? 10 : 100 : e.isDark ? 20 : 100,
+      background: (e) => this.secondary(),
+      contrastCurve: (e) => new y(4.5, 7, 11, 21)
+    });
+  }
+  secondaryContainer() {
+    return c.fromPalette({
+      name: "secondary_container",
+      palette: (e) => e.secondaryPalette,
+      tone: (e) => {
+        const t = e.isDark ? 30 : 90;
+        return A(e) ? e.isDark ? 30 : 85 : ue(e) ? Nt(e.secondaryPalette.hue, e.secondaryPalette.chroma, t, !e.isDark) : t;
+      },
+      isBackground: !0,
+      background: (e) => this.highestSurface(e),
+      contrastCurve: (e) => new y(1, 1, 3, 4.5),
+      toneDeltaPair: (e) => new w(this.secondaryContainer(), this.secondary(), 10, "nearer", !1)
+    });
+  }
+  onSecondaryContainer() {
+    return c.fromPalette({
+      name: "on_secondary_container",
+      palette: (e) => e.secondaryPalette,
+      tone: (e) => A(e) ? e.isDark ? 90 : 10 : ue(e) ? c.foregroundTone(this.secondaryContainer().tone(e), 4.5) : e.isDark ? 90 : 30,
+      background: (e) => this.secondaryContainer(),
+      contrastCurve: (e) => new y(3, 4.5, 7, 11)
+    });
+  }
+  /////////////////////////////////////////////////////////////////
+  // Tertiary [T].                                               //
+  /////////////////////////////////////////////////////////////////
+  tertiary() {
+    return c.fromPalette({
+      name: "tertiary",
+      palette: (e) => e.tertiaryPalette,
+      tone: (e) => A(e) ? e.isDark ? 90 : 25 : e.isDark ? 80 : 40,
+      isBackground: !0,
+      background: (e) => this.highestSurface(e),
+      contrastCurve: (e) => new y(3, 4.5, 7, 7),
+      toneDeltaPair: (e) => new w(this.tertiaryContainer(), this.tertiary(), 10, "nearer", !1)
+    });
+  }
+  tertiaryDim() {
+  }
+  onTertiary() {
+    return c.fromPalette({
+      name: "on_tertiary",
+      palette: (e) => e.tertiaryPalette,
+      tone: (e) => A(e) ? e.isDark ? 10 : 90 : e.isDark ? 20 : 100,
+      background: (e) => this.tertiary(),
+      contrastCurve: (e) => new y(4.5, 7, 11, 21)
+    });
+  }
+  tertiaryContainer() {
+    return c.fromPalette({
+      name: "tertiary_container",
+      palette: (e) => e.tertiaryPalette,
+      tone: (e) => {
+        if (A(e))
+          return e.isDark ? 60 : 49;
+        if (!ue(e))
+          return e.isDark ? 30 : 90;
+        const t = e.tertiaryPalette.getHct(e.sourceColorHct.tone);
+        return Ne.fixIfDisliked(t).tone;
+      },
+      isBackground: !0,
+      background: (e) => this.highestSurface(e),
+      contrastCurve: (e) => new y(1, 1, 3, 4.5),
+      toneDeltaPair: (e) => new w(this.tertiaryContainer(), this.tertiary(), 10, "nearer", !1)
+    });
+  }
+  onTertiaryContainer() {
+    return c.fromPalette({
+      name: "on_tertiary_container",
+      palette: (e) => e.tertiaryPalette,
+      tone: (e) => A(e) ? e.isDark ? 0 : 100 : ue(e) ? c.foregroundTone(this.tertiaryContainer().tone(e), 4.5) : e.isDark ? 90 : 30,
+      background: (e) => this.tertiaryContainer(),
+      contrastCurve: (e) => new y(3, 4.5, 7, 11)
+    });
+  }
+  //////////////////////////////////////////////////////////////////
+  // Error [E].                                                   //
+  //////////////////////////////////////////////////////////////////
+  error() {
+    return c.fromPalette({
+      name: "error",
+      palette: (e) => e.errorPalette,
+      tone: (e) => e.isDark ? 80 : 40,
+      isBackground: !0,
+      background: (e) => this.highestSurface(e),
+      contrastCurve: (e) => new y(3, 4.5, 7, 7),
+      toneDeltaPair: (e) => new w(this.errorContainer(), this.error(), 10, "nearer", !1)
+    });
+  }
+  errorDim() {
+  }
+  onError() {
+    return c.fromPalette({
+      name: "on_error",
+      palette: (e) => e.errorPalette,
+      tone: (e) => e.isDark ? 20 : 100,
+      background: (e) => this.error(),
+      contrastCurve: (e) => new y(4.5, 7, 11, 21)
+    });
+  }
+  errorContainer() {
+    return c.fromPalette({
+      name: "error_container",
+      palette: (e) => e.errorPalette,
+      tone: (e) => e.isDark ? 30 : 90,
+      isBackground: !0,
+      background: (e) => this.highestSurface(e),
+      contrastCurve: (e) => new y(1, 1, 3, 4.5),
+      toneDeltaPair: (e) => new w(this.errorContainer(), this.error(), 10, "nearer", !1)
+    });
+  }
+  onErrorContainer() {
+    return c.fromPalette({
+      name: "on_error_container",
+      palette: (e) => e.errorPalette,
+      tone: (e) => A(e) ? e.isDark ? 90 : 10 : e.isDark ? 90 : 30,
+      background: (e) => this.errorContainer(),
+      contrastCurve: (e) => new y(3, 4.5, 7, 11)
+    });
+  }
+  //////////////////////////////////////////////////////////////////
+  // Primary Fixed [PF]                                           //
+  //////////////////////////////////////////////////////////////////
+  primaryFixed() {
+    return c.fromPalette({
+      name: "primary_fixed",
+      palette: (e) => e.primaryPalette,
+      tone: (e) => A(e) ? 40 : 90,
+      isBackground: !0,
+      background: (e) => this.highestSurface(e),
+      contrastCurve: (e) => new y(1, 1, 3, 4.5),
+      toneDeltaPair: (e) => new w(this.primaryFixed(), this.primaryFixedDim(), 10, "lighter", !0)
+    });
+  }
+  primaryFixedDim() {
+    return c.fromPalette({
+      name: "primary_fixed_dim",
+      palette: (e) => e.primaryPalette,
+      tone: (e) => A(e) ? 30 : 80,
+      isBackground: !0,
+      background: (e) => this.highestSurface(e),
+      contrastCurve: (e) => new y(1, 1, 3, 4.5),
+      toneDeltaPair: (e) => new w(this.primaryFixed(), this.primaryFixedDim(), 10, "lighter", !0)
+    });
+  }
+  onPrimaryFixed() {
+    return c.fromPalette({
+      name: "on_primary_fixed",
+      palette: (e) => e.primaryPalette,
+      tone: (e) => A(e) ? 100 : 10,
+      background: (e) => this.primaryFixedDim(),
+      secondBackground: (e) => this.primaryFixed(),
+      contrastCurve: (e) => new y(4.5, 7, 11, 21)
+    });
+  }
+  onPrimaryFixedVariant() {
+    return c.fromPalette({
+      name: "on_primary_fixed_variant",
+      palette: (e) => e.primaryPalette,
+      tone: (e) => A(e) ? 90 : 30,
+      background: (e) => this.primaryFixedDim(),
+      secondBackground: (e) => this.primaryFixed(),
+      contrastCurve: (e) => new y(3, 4.5, 7, 11)
+    });
+  }
+  ///////////////////////////////////////////////////////////////////
+  // Secondary Fixed [QF]                                          //
+  ///////////////////////////////////////////////////////////////////
+  secondaryFixed() {
+    return c.fromPalette({
+      name: "secondary_fixed",
+      palette: (e) => e.secondaryPalette,
+      tone: (e) => A(e) ? 80 : 90,
+      isBackground: !0,
+      background: (e) => this.highestSurface(e),
+      contrastCurve: (e) => new y(1, 1, 3, 4.5),
+      toneDeltaPair: (e) => new w(this.secondaryFixed(), this.secondaryFixedDim(), 10, "lighter", !0)
+    });
+  }
+  secondaryFixedDim() {
+    return c.fromPalette({
+      name: "secondary_fixed_dim",
+      palette: (e) => e.secondaryPalette,
+      tone: (e) => A(e) ? 70 : 80,
+      isBackground: !0,
+      background: (e) => this.highestSurface(e),
+      contrastCurve: (e) => new y(1, 1, 3, 4.5),
+      toneDeltaPair: (e) => new w(this.secondaryFixed(), this.secondaryFixedDim(), 10, "lighter", !0)
+    });
+  }
+  onSecondaryFixed() {
+    return c.fromPalette({
+      name: "on_secondary_fixed",
+      palette: (e) => e.secondaryPalette,
+      tone: (e) => 10,
+      background: (e) => this.secondaryFixedDim(),
+      secondBackground: (e) => this.secondaryFixed(),
+      contrastCurve: (e) => new y(4.5, 7, 11, 21)
+    });
+  }
+  onSecondaryFixedVariant() {
+    return c.fromPalette({
+      name: "on_secondary_fixed_variant",
+      palette: (e) => e.secondaryPalette,
+      tone: (e) => A(e) ? 25 : 30,
+      background: (e) => this.secondaryFixedDim(),
+      secondBackground: (e) => this.secondaryFixed(),
+      contrastCurve: (e) => new y(3, 4.5, 7, 11)
+    });
+  }
+  /////////////////////////////////////////////////////////////////
+  // Tertiary Fixed [TF]                                         //
+  /////////////////////////////////////////////////////////////////
+  tertiaryFixed() {
+    return c.fromPalette({
+      name: "tertiary_fixed",
+      palette: (e) => e.tertiaryPalette,
+      tone: (e) => A(e) ? 40 : 90,
+      isBackground: !0,
+      background: (e) => this.highestSurface(e),
+      contrastCurve: (e) => new y(1, 1, 3, 4.5),
+      toneDeltaPair: (e) => new w(this.tertiaryFixed(), this.tertiaryFixedDim(), 10, "lighter", !0)
+    });
+  }
+  tertiaryFixedDim() {
+    return c.fromPalette({
+      name: "tertiary_fixed_dim",
+      palette: (e) => e.tertiaryPalette,
+      tone: (e) => A(e) ? 30 : 80,
+      isBackground: !0,
+      background: (e) => this.highestSurface(e),
+      contrastCurve: (e) => new y(1, 1, 3, 4.5),
+      toneDeltaPair: (e) => new w(this.tertiaryFixed(), this.tertiaryFixedDim(), 10, "lighter", !0)
+    });
+  }
+  onTertiaryFixed() {
+    return c.fromPalette({
+      name: "on_tertiary_fixed",
+      palette: (e) => e.tertiaryPalette,
+      tone: (e) => A(e) ? 100 : 10,
+      background: (e) => this.tertiaryFixedDim(),
+      secondBackground: (e) => this.tertiaryFixed(),
+      contrastCurve: (e) => new y(4.5, 7, 11, 21)
+    });
+  }
+  onTertiaryFixedVariant() {
+    return c.fromPalette({
+      name: "on_tertiary_fixed_variant",
+      palette: (e) => e.tertiaryPalette,
+      tone: (e) => A(e) ? 90 : 30,
+      background: (e) => this.tertiaryFixedDim(),
+      secondBackground: (e) => this.tertiaryFixed(),
+      contrastCurve: (e) => new y(3, 4.5, 7, 11)
+    });
+  }
+  ////////////////////////////////////////////////////////////////
+  // Other                                                      //
+  ////////////////////////////////////////////////////////////////
+  highestSurface(e) {
+    return e.isDark ? this.surfaceBright() : this.surfaceDim();
+  }
+}
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+function D(r, e = 0, t = 100, n = 1) {
+  let a = ct(r.hue, r.chroma * n, 100, !0);
+  return U(e, t, a);
+}
+function ne(r, e = 0, t = 100) {
+  let n = ct(r.hue, r.chroma, 0, !1);
+  return U(e, t, n);
+}
+function ct(r, e, t, n) {
+  let a = t, o = C.from(r, e, a);
+  for (; o.chroma < e && !(t < 0 || t > 100); ) {
+    t += n ? -1 : 1;
+    const i = C.from(r, e, t);
+    o.chroma < i.chroma && (o = i, a = t);
+  }
+  return a;
+}
+function b(r) {
+  return r === 1.5 ? new y(1.5, 1.5, 3, 5.5) : r === 3 ? new y(3, 3, 4.5, 7) : r === 4.5 ? new y(4.5, 4.5, 7, 11) : r === 6 ? new y(6, 6, 7, 11) : r === 7 ? new y(7, 7, 11, 21) : r === 9 ? new y(9, 9, 11, 21) : r === 11 ? new y(11, 11, 21, 21) : r === 21 ? new y(21, 21, 21, 21) : new y(r, r, 7, 21);
+}
+class Ht extends _t {
+  ////////////////////////////////////////////////////////////////
+  // Surfaces [S]                                               //
+  ////////////////////////////////////////////////////////////////
+  surface() {
+    const e = c.fromPalette({
+      name: "surface",
+      palette: (t) => t.neutralPalette,
+      tone: (t) => (super.surface().tone(t), t.platform === "phone" ? t.isDark ? 4 : C.isYellow(t.neutralPalette.hue) ? 99 : t.variant === d.VIBRANT ? 97 : 98 : 0),
+      isBackground: !0
+    });
+    return T(super.surface(), "2025", e);
+  }
+  surfaceDim() {
+    const e = c.fromPalette({
+      name: "surface_dim",
+      palette: (t) => t.neutralPalette,
+      tone: (t) => t.isDark ? 4 : C.isYellow(t.neutralPalette.hue) ? 90 : t.variant === d.VIBRANT ? 85 : 87,
+      isBackground: !0,
+      chromaMultiplier: (t) => {
+        if (!t.isDark) {
+          if (t.variant === d.NEUTRAL)
+            return 2.5;
+          if (t.variant === d.TONAL_SPOT)
+            return 1.7;
+          if (t.variant === d.EXPRESSIVE)
+            return C.isYellow(t.neutralPalette.hue) ? 2.7 : 1.75;
+          if (t.variant === d.VIBRANT)
+            return 1.36;
+        }
+        return 1;
+      }
+    });
+    return T(super.surfaceDim(), "2025", e);
+  }
+  surfaceBright() {
+    const e = c.fromPalette({
+      name: "surface_bright",
+      palette: (t) => t.neutralPalette,
+      tone: (t) => t.isDark ? 18 : C.isYellow(t.neutralPalette.hue) ? 99 : t.variant === d.VIBRANT ? 97 : 98,
+      isBackground: !0,
+      chromaMultiplier: (t) => {
+        if (t.isDark) {
+          if (t.variant === d.NEUTRAL)
+            return 2.5;
+          if (t.variant === d.TONAL_SPOT)
+            return 1.7;
+          if (t.variant === d.EXPRESSIVE)
+            return C.isYellow(t.neutralPalette.hue) ? 2.7 : 1.75;
+          if (t.variant === d.VIBRANT)
+            return 1.36;
+        }
+        return 1;
+      }
+    });
+    return T(super.surfaceBright(), "2025", e);
+  }
+  surfaceContainerLowest() {
+    const e = c.fromPalette({
+      name: "surface_container_lowest",
+      palette: (t) => t.neutralPalette,
+      tone: (t) => t.isDark ? 0 : 100,
+      isBackground: !0
+    });
+    return T(super.surfaceContainerLowest(), "2025", e);
+  }
+  surfaceContainerLow() {
+    const e = c.fromPalette({
+      name: "surface_container_low",
+      palette: (t) => t.neutralPalette,
+      tone: (t) => t.platform === "phone" ? t.isDark ? 6 : C.isYellow(t.neutralPalette.hue) ? 98 : t.variant === d.VIBRANT ? 95 : 96 : 15,
+      isBackground: !0,
+      chromaMultiplier: (t) => {
+        if (t.platform === "phone") {
+          if (t.variant === d.NEUTRAL)
+            return 1.3;
+          if (t.variant === d.TONAL_SPOT)
+            return 1.25;
+          if (t.variant === d.EXPRESSIVE)
+            return C.isYellow(t.neutralPalette.hue) ? 1.3 : 1.15;
+          if (t.variant === d.VIBRANT)
+            return 1.08;
+        }
+        return 1;
+      }
+    });
+    return T(super.surfaceContainerLow(), "2025", e);
+  }
+  surfaceContainer() {
+    const e = c.fromPalette({
+      name: "surface_container",
+      palette: (t) => t.neutralPalette,
+      tone: (t) => t.platform === "phone" ? t.isDark ? 9 : C.isYellow(t.neutralPalette.hue) ? 96 : t.variant === d.VIBRANT ? 92 : 94 : 20,
+      isBackground: !0,
+      chromaMultiplier: (t) => {
+        if (t.platform === "phone") {
+          if (t.variant === d.NEUTRAL)
+            return 1.6;
+          if (t.variant === d.TONAL_SPOT)
+            return 1.4;
+          if (t.variant === d.EXPRESSIVE)
+            return C.isYellow(t.neutralPalette.hue) ? 1.6 : 1.3;
+          if (t.variant === d.VIBRANT)
+            return 1.15;
+        }
+        return 1;
+      }
+    });
+    return T(super.surfaceContainer(), "2025", e);
+  }
+  surfaceContainerHigh() {
+    const e = c.fromPalette({
+      name: "surface_container_high",
+      palette: (t) => t.neutralPalette,
+      tone: (t) => t.platform === "phone" ? t.isDark ? 12 : C.isYellow(t.neutralPalette.hue) ? 94 : t.variant === d.VIBRANT ? 90 : 92 : 25,
+      isBackground: !0,
+      chromaMultiplier: (t) => {
+        if (t.platform === "phone") {
+          if (t.variant === d.NEUTRAL)
+            return 1.9;
+          if (t.variant === d.TONAL_SPOT)
+            return 1.5;
+          if (t.variant === d.EXPRESSIVE)
+            return C.isYellow(t.neutralPalette.hue) ? 1.95 : 1.45;
+          if (t.variant === d.VIBRANT)
+            return 1.22;
+        }
+        return 1;
+      }
+    });
+    return T(super.surfaceContainerHigh(), "2025", e);
+  }
+  surfaceContainerHighest() {
+    const e = c.fromPalette({
+      name: "surface_container_highest",
+      palette: (t) => t.neutralPalette,
+      tone: (t) => t.isDark ? 15 : C.isYellow(t.neutralPalette.hue) ? 92 : t.variant === d.VIBRANT ? 88 : 90,
+      isBackground: !0,
+      chromaMultiplier: (t) => t.variant === d.NEUTRAL ? 2.2 : t.variant === d.TONAL_SPOT ? 1.7 : t.variant === d.EXPRESSIVE ? C.isYellow(t.neutralPalette.hue) ? 2.3 : 1.6 : t.variant === d.VIBRANT ? 1.29 : 1
+    });
+    return T(super.surfaceContainerHighest(), "2025", e);
+  }
+  onSurface() {
+    const e = c.fromPalette({
+      name: "on_surface",
+      palette: (t) => t.neutralPalette,
+      tone: (t) => t.variant === d.VIBRANT ? D(t.neutralPalette, 0, 100, 1.1) : c.getInitialToneFromBackground((n) => n.platform === "phone" ? this.highestSurface(n) : this.surfaceContainerHigh())(t),
+      chromaMultiplier: (t) => {
+        if (t.platform === "phone") {
+          if (t.variant === d.NEUTRAL)
+            return 2.2;
+          if (t.variant === d.TONAL_SPOT)
+            return 1.7;
+          if (t.variant === d.EXPRESSIVE)
+            return C.isYellow(t.neutralPalette.hue) ? t.isDark ? 3 : 2.3 : 1.6;
+        }
+        return 1;
+      },
+      background: (t) => t.platform === "phone" ? this.highestSurface(t) : this.surfaceContainerHigh(),
+      contrastCurve: (t) => t.isDark && t.platform === "phone" ? b(11) : b(9)
+    });
+    return T(super.onSurface(), "2025", e);
+  }
+  onSurfaceVariant() {
+    const e = c.fromPalette({
+      name: "on_surface_variant",
+      palette: (t) => t.neutralPalette,
+      chromaMultiplier: (t) => {
+        if (t.platform === "phone") {
+          if (t.variant === d.NEUTRAL)
+            return 2.2;
+          if (t.variant === d.TONAL_SPOT)
+            return 1.7;
+          if (t.variant === d.EXPRESSIVE)
+            return C.isYellow(t.neutralPalette.hue) ? t.isDark ? 3 : 2.3 : 1.6;
+        }
+        return 1;
+      },
+      background: (t) => t.platform === "phone" ? this.highestSurface(t) : this.surfaceContainerHigh(),
+      contrastCurve: (t) => t.platform === "phone" ? t.isDark ? b(6) : b(4.5) : b(7)
+    });
+    return T(super.onSurfaceVariant(), "2025", e);
+  }
+  outline() {
+    const e = c.fromPalette({
+      name: "outline",
+      palette: (t) => t.neutralPalette,
+      chromaMultiplier: (t) => {
+        if (t.platform === "phone") {
+          if (t.variant === d.NEUTRAL)
+            return 2.2;
+          if (t.variant === d.TONAL_SPOT)
+            return 1.7;
+          if (t.variant === d.EXPRESSIVE)
+            return C.isYellow(t.neutralPalette.hue) ? t.isDark ? 3 : 2.3 : 1.6;
+        }
+        return 1;
+      },
+      background: (t) => t.platform === "phone" ? this.highestSurface(t) : this.surfaceContainerHigh(),
+      contrastCurve: (t) => t.platform === "phone" ? b(3) : b(4.5)
+    });
+    return T(super.outline(), "2025", e);
+  }
+  outlineVariant() {
+    const e = c.fromPalette({
+      name: "outline_variant",
+      palette: (t) => t.neutralPalette,
+      chromaMultiplier: (t) => {
+        if (t.platform === "phone") {
+          if (t.variant === d.NEUTRAL)
+            return 2.2;
+          if (t.variant === d.TONAL_SPOT)
+            return 1.7;
+          if (t.variant === d.EXPRESSIVE)
+            return C.isYellow(t.neutralPalette.hue) ? t.isDark ? 3 : 2.3 : 1.6;
+        }
+        return 1;
+      },
+      background: (t) => t.platform === "phone" ? this.highestSurface(t) : this.surfaceContainerHigh(),
+      contrastCurve: (t) => t.platform === "phone" ? b(1.5) : b(3)
+    });
+    return T(super.outlineVariant(), "2025", e);
+  }
+  inverseSurface() {
+    const e = c.fromPalette({
+      name: "inverse_surface",
+      palette: (t) => t.neutralPalette,
+      tone: (t) => t.isDark ? 98 : 4,
+      isBackground: !0
+    });
+    return T(super.inverseSurface(), "2025", e);
+  }
+  inverseOnSurface() {
+    const e = c.fromPalette({
+      name: "inverse_on_surface",
+      palette: (t) => t.neutralPalette,
+      background: (t) => this.inverseSurface(),
+      contrastCurve: (t) => b(7)
+    });
+    return T(super.inverseOnSurface(), "2025", e);
+  }
+  ////////////////////////////////////////////////////////////////
+  // Primaries [P]                                              //
+  ////////////////////////////////////////////////////////////////
+  primary() {
+    const e = c.fromPalette({
+      name: "primary",
+      palette: (t) => t.primaryPalette,
+      tone: (t) => t.variant === d.NEUTRAL ? t.platform === "phone" ? t.isDark ? 80 : 40 : 90 : t.variant === d.TONAL_SPOT ? t.platform === "phone" ? t.isDark ? 80 : D(t.primaryPalette) : D(t.primaryPalette, 0, 90) : t.variant === d.EXPRESSIVE ? t.platform === "phone" ? D(t.primaryPalette, 0, C.isYellow(t.primaryPalette.hue) ? 25 : C.isCyan(t.primaryPalette.hue) ? 88 : 98) : D(t.primaryPalette) : t.platform === "phone" ? D(t.primaryPalette, 0, C.isCyan(t.primaryPalette.hue) ? 88 : 98) : D(t.primaryPalette),
+      isBackground: !0,
+      background: (t) => t.platform === "phone" ? this.highestSurface(t) : this.surfaceContainerHigh(),
+      contrastCurve: (t) => t.platform === "phone" ? b(4.5) : b(7),
+      toneDeltaPair: (t) => t.platform === "phone" ? new w(this.primaryContainer(), this.primary(), 5, "relative_lighter", !0, "farther") : void 0
+    });
+    return T(super.primary(), "2025", e);
+  }
+  primaryDim() {
+    return c.fromPalette({
+      name: "primary_dim",
+      palette: (e) => e.primaryPalette,
+      tone: (e) => e.variant === d.NEUTRAL ? 85 : e.variant === d.TONAL_SPOT ? D(e.primaryPalette, 0, 90) : D(e.primaryPalette),
+      isBackground: !0,
+      background: (e) => this.surfaceContainerHigh(),
+      contrastCurve: (e) => b(4.5),
+      toneDeltaPair: (e) => new w(this.primaryDim(), this.primary(), 5, "darker", !0, "farther")
+    });
+  }
+  onPrimary() {
+    const e = c.fromPalette({
+      name: "on_primary",
+      palette: (t) => t.primaryPalette,
+      background: (t) => t.platform === "phone" ? this.primary() : this.primaryDim(),
+      contrastCurve: (t) => t.platform === "phone" ? b(6) : b(7)
+    });
+    return T(super.onPrimary(), "2025", e);
+  }
+  primaryContainer() {
+    const e = c.fromPalette({
+      name: "primary_container",
+      palette: (t) => t.primaryPalette,
+      tone: (t) => t.platform === "watch" ? 30 : t.variant === d.NEUTRAL ? t.isDark ? 30 : 90 : t.variant === d.TONAL_SPOT ? t.isDark ? ne(t.primaryPalette, 35, 93) : D(t.primaryPalette, 0, 90) : t.variant === d.EXPRESSIVE ? t.isDark ? D(t.primaryPalette, 30, 93) : D(t.primaryPalette, 78, C.isCyan(t.primaryPalette.hue) ? 88 : 90) : t.isDark ? ne(t.primaryPalette, 66, 93) : D(t.primaryPalette, 66, C.isCyan(t.primaryPalette.hue) ? 88 : 93),
+      isBackground: !0,
+      background: (t) => t.platform === "phone" ? this.highestSurface(t) : void 0,
+      toneDeltaPair: (t) => t.platform === "phone" ? void 0 : new w(this.primaryContainer(), this.primaryDim(), 10, "darker", !0, "farther"),
+      contrastCurve: (t) => t.platform === "phone" && t.contrastLevel > 0 ? b(1.5) : void 0
+    });
+    return T(super.primaryContainer(), "2025", e);
+  }
+  onPrimaryContainer() {
+    const e = c.fromPalette({
+      name: "on_primary_container",
+      palette: (t) => t.primaryPalette,
+      background: (t) => this.primaryContainer(),
+      contrastCurve: (t) => t.platform === "phone" ? b(6) : b(7)
+    });
+    return T(super.onPrimaryContainer(), "2025", e);
+  }
+  primaryFixed() {
+    const e = c.fromPalette({
+      name: "primary_fixed",
+      palette: (t) => t.primaryPalette,
+      tone: (t) => {
+        let n = Object.assign({}, t, { isDark: !1, contrastLevel: 0 });
+        return this.primaryContainer().getTone(n);
+      },
+      isBackground: !0,
+      background: (t) => t.platform === "phone" ? this.highestSurface(t) : void 0,
+      contrastCurve: (t) => t.platform === "phone" && t.contrastLevel > 0 ? b(1.5) : void 0
+    });
+    return T(super.primaryFixed(), "2025", e);
+  }
+  primaryFixedDim() {
+    const e = c.fromPalette({
+      name: "primary_fixed_dim",
+      palette: (t) => t.primaryPalette,
+      tone: (t) => this.primaryFixed().getTone(t),
+      isBackground: !0,
+      toneDeltaPair: (t) => new w(this.primaryFixedDim(), this.primaryFixed(), 5, "darker", !0, "exact")
+    });
+    return T(super.primaryFixedDim(), "2025", e);
+  }
+  onPrimaryFixed() {
+    const e = c.fromPalette({
+      name: "on_primary_fixed",
+      palette: (t) => t.primaryPalette,
+      background: (t) => this.primaryFixedDim(),
+      contrastCurve: (t) => b(7)
+    });
+    return T(super.onPrimaryFixed(), "2025", e);
+  }
+  onPrimaryFixedVariant() {
+    const e = c.fromPalette({
+      name: "on_primary_fixed_variant",
+      palette: (t) => t.primaryPalette,
+      background: (t) => this.primaryFixedDim(),
+      contrastCurve: (t) => b(4.5)
+    });
+    return T(super.onPrimaryFixedVariant(), "2025", e);
+  }
+  inversePrimary() {
+    const e = c.fromPalette({
+      name: "inverse_primary",
+      palette: (t) => t.primaryPalette,
+      tone: (t) => D(t.primaryPalette),
+      background: (t) => this.inverseSurface(),
+      contrastCurve: (t) => t.platform === "phone" ? b(6) : b(7)
+    });
+    return T(super.inversePrimary(), "2025", e);
+  }
+  ////////////////////////////////////////////////////////////////
+  // Secondaries [Q]                                            //
+  ////////////////////////////////////////////////////////////////
+  secondary() {
+    const e = c.fromPalette({
+      name: "secondary",
+      palette: (t) => t.secondaryPalette,
+      tone: (t) => t.platform === "watch" ? t.variant === d.NEUTRAL ? 90 : D(t.secondaryPalette, 0, 90) : t.variant === d.NEUTRAL ? t.isDark ? ne(t.secondaryPalette, 0, 98) : D(t.secondaryPalette) : t.variant === d.VIBRANT ? D(t.secondaryPalette, 0, t.isDark ? 90 : 98) : t.isDark ? 80 : D(t.secondaryPalette),
+      isBackground: !0,
+      background: (t) => t.platform === "phone" ? this.highestSurface(t) : this.surfaceContainerHigh(),
+      contrastCurve: (t) => t.platform === "phone" ? b(4.5) : b(7),
+      toneDeltaPair: (t) => t.platform === "phone" ? new w(this.secondaryContainer(), this.secondary(), 5, "relative_lighter", !0, "farther") : void 0
+    });
+    return T(super.secondary(), "2025", e);
+  }
+  secondaryDim() {
+    return c.fromPalette({
+      name: "secondary_dim",
+      palette: (e) => e.secondaryPalette,
+      tone: (e) => e.variant === d.NEUTRAL ? 85 : D(e.secondaryPalette, 0, 90),
+      isBackground: !0,
+      background: (e) => this.surfaceContainerHigh(),
+      contrastCurve: (e) => b(4.5),
+      toneDeltaPair: (e) => new w(this.secondaryDim(), this.secondary(), 5, "darker", !0, "farther")
+    });
+  }
+  onSecondary() {
+    const e = c.fromPalette({
+      name: "on_secondary",
+      palette: (t) => t.secondaryPalette,
+      background: (t) => t.platform === "phone" ? this.secondary() : this.secondaryDim(),
+      contrastCurve: (t) => t.platform === "phone" ? b(6) : b(7)
+    });
+    return T(super.onSecondary(), "2025", e);
+  }
+  secondaryContainer() {
+    const e = c.fromPalette({
+      name: "secondary_container",
+      palette: (t) => t.secondaryPalette,
+      tone: (t) => t.platform === "watch" ? 30 : t.variant === d.VIBRANT ? t.isDark ? ne(t.secondaryPalette, 30, 40) : D(t.secondaryPalette, 84, 90) : t.variant === d.EXPRESSIVE ? t.isDark ? 15 : D(t.secondaryPalette, 90, 95) : t.isDark ? 25 : 90,
+      isBackground: !0,
+      background: (t) => t.platform === "phone" ? this.highestSurface(t) : void 0,
+      toneDeltaPair: (t) => t.platform === "watch" ? new w(this.secondaryContainer(), this.secondaryDim(), 10, "darker", !0, "farther") : void 0,
+      contrastCurve: (t) => t.platform === "phone" && t.contrastLevel > 0 ? b(1.5) : void 0
+    });
+    return T(super.secondaryContainer(), "2025", e);
+  }
+  onSecondaryContainer() {
+    const e = c.fromPalette({
+      name: "on_secondary_container",
+      palette: (t) => t.secondaryPalette,
+      background: (t) => this.secondaryContainer(),
+      contrastCurve: (t) => t.platform === "phone" ? b(6) : b(7)
+    });
+    return T(super.onSecondaryContainer(), "2025", e);
+  }
+  secondaryFixed() {
+    const e = c.fromPalette({
+      name: "secondary_fixed",
+      palette: (t) => t.secondaryPalette,
+      tone: (t) => {
+        let n = Object.assign({}, t, { isDark: !1, contrastLevel: 0 });
+        return this.secondaryContainer().getTone(n);
+      },
+      isBackground: !0,
+      background: (t) => t.platform === "phone" ? this.highestSurface(t) : void 0,
+      contrastCurve: (t) => t.platform === "phone" && t.contrastLevel > 0 ? b(1.5) : void 0
+    });
+    return T(super.secondaryFixed(), "2025", e);
+  }
+  secondaryFixedDim() {
+    const e = c.fromPalette({
+      name: "secondary_fixed_dim",
+      palette: (t) => t.secondaryPalette,
+      tone: (t) => this.secondaryFixed().getTone(t),
+      isBackground: !0,
+      toneDeltaPair: (t) => new w(this.secondaryFixedDim(), this.secondaryFixed(), 5, "darker", !0, "exact")
+    });
+    return T(super.secondaryFixedDim(), "2025", e);
+  }
+  onSecondaryFixed() {
+    const e = c.fromPalette({
+      name: "on_secondary_fixed",
+      palette: (t) => t.secondaryPalette,
+      background: (t) => this.secondaryFixedDim(),
+      contrastCurve: (t) => b(7)
+    });
+    return T(super.onSecondaryFixed(), "2025", e);
+  }
+  onSecondaryFixedVariant() {
+    const e = c.fromPalette({
+      name: "on_secondary_fixed_variant",
+      palette: (t) => t.secondaryPalette,
+      background: (t) => this.secondaryFixedDim(),
+      contrastCurve: (t) => b(4.5)
+    });
+    return T(super.onSecondaryFixedVariant(), "2025", e);
+  }
+  ////////////////////////////////////////////////////////////////
+  // Tertiaries [T]                                             //
+  ////////////////////////////////////////////////////////////////
+  tertiary() {
+    const e = c.fromPalette({
+      name: "tertiary",
+      palette: (t) => t.tertiaryPalette,
+      tone: (t) => t.platform === "watch" ? t.variant === d.TONAL_SPOT ? D(t.tertiaryPalette, 0, 90) : D(t.tertiaryPalette) : t.variant === d.EXPRESSIVE || t.variant === d.VIBRANT ? D(t.tertiaryPalette, 0, C.isCyan(t.tertiaryPalette.hue) ? 88 : t.isDark ? 98 : 100) : t.isDark ? D(t.tertiaryPalette, 0, 98) : D(t.tertiaryPalette),
+      isBackground: !0,
+      background: (t) => t.platform === "phone" ? this.highestSurface(t) : this.surfaceContainerHigh(),
+      contrastCurve: (t) => t.platform === "phone" ? b(4.5) : b(7),
+      toneDeltaPair: (t) => t.platform === "phone" ? new w(this.tertiaryContainer(), this.tertiary(), 5, "relative_lighter", !0, "farther") : void 0
+    });
+    return T(super.tertiary(), "2025", e);
+  }
+  tertiaryDim() {
+    return c.fromPalette({
+      name: "tertiary_dim",
+      palette: (e) => e.tertiaryPalette,
+      tone: (e) => e.variant === d.TONAL_SPOT ? D(e.tertiaryPalette, 0, 90) : D(e.tertiaryPalette),
+      isBackground: !0,
+      background: (e) => this.surfaceContainerHigh(),
+      contrastCurve: (e) => b(4.5),
+      toneDeltaPair: (e) => new w(this.tertiaryDim(), this.tertiary(), 5, "darker", !0, "farther")
+    });
+  }
+  onTertiary() {
+    const e = c.fromPalette({
+      name: "on_tertiary",
+      palette: (t) => t.tertiaryPalette,
+      background: (t) => t.platform === "phone" ? this.tertiary() : this.tertiaryDim(),
+      contrastCurve: (t) => t.platform === "phone" ? b(6) : b(7)
+    });
+    return T(super.onTertiary(), "2025", e);
+  }
+  tertiaryContainer() {
+    const e = c.fromPalette({
+      name: "tertiary_container",
+      palette: (t) => t.tertiaryPalette,
+      tone: (t) => t.platform === "watch" ? t.variant === d.TONAL_SPOT ? D(t.tertiaryPalette, 0, 90) : D(t.tertiaryPalette) : t.variant === d.NEUTRAL ? t.isDark ? D(t.tertiaryPalette, 0, 93) : D(t.tertiaryPalette, 0, 96) : t.variant === d.TONAL_SPOT ? D(t.tertiaryPalette, 0, t.isDark ? 93 : 100) : t.variant === d.EXPRESSIVE ? D(t.tertiaryPalette, 75, C.isCyan(t.tertiaryPalette.hue) ? 88 : t.isDark ? 93 : 100) : t.isDark ? D(t.tertiaryPalette, 0, 93) : D(t.tertiaryPalette, 72, 100),
+      isBackground: !0,
+      background: (t) => t.platform === "phone" ? this.highestSurface(t) : void 0,
+      toneDeltaPair: (t) => t.platform === "watch" ? new w(this.tertiaryContainer(), this.tertiaryDim(), 10, "darker", !0, "farther") : void 0,
+      contrastCurve: (t) => t.platform === "phone" && t.contrastLevel > 0 ? b(1.5) : void 0
+    });
+    return T(super.tertiaryContainer(), "2025", e);
+  }
+  onTertiaryContainer() {
+    const e = c.fromPalette({
+      name: "on_tertiary_container",
+      palette: (t) => t.tertiaryPalette,
+      background: (t) => this.tertiaryContainer(),
+      contrastCurve: (t) => t.platform === "phone" ? b(6) : b(7)
+    });
+    return T(super.onTertiaryContainer(), "2025", e);
+  }
+  tertiaryFixed() {
+    const e = c.fromPalette({
+      name: "tertiary_fixed",
+      palette: (t) => t.tertiaryPalette,
+      tone: (t) => {
+        let n = Object.assign({}, t, { isDark: !1, contrastLevel: 0 });
+        return this.tertiaryContainer().getTone(n);
+      },
+      isBackground: !0,
+      background: (t) => t.platform === "phone" ? this.highestSurface(t) : void 0,
+      contrastCurve: (t) => t.platform === "phone" && t.contrastLevel > 0 ? b(1.5) : void 0
+    });
+    return T(super.tertiaryFixed(), "2025", e);
+  }
+  tertiaryFixedDim() {
+    const e = c.fromPalette({
+      name: "tertiary_fixed_dim",
+      palette: (t) => t.tertiaryPalette,
+      tone: (t) => this.tertiaryFixed().getTone(t),
+      isBackground: !0,
+      toneDeltaPair: (t) => new w(this.tertiaryFixedDim(), this.tertiaryFixed(), 5, "darker", !0, "exact")
+    });
+    return T(super.tertiaryFixedDim(), "2025", e);
+  }
+  onTertiaryFixed() {
+    const e = c.fromPalette({
+      name: "on_tertiary_fixed",
+      palette: (t) => t.tertiaryPalette,
+      background: (t) => this.tertiaryFixedDim(),
+      contrastCurve: (t) => b(7)
+    });
+    return T(super.onTertiaryFixed(), "2025", e);
+  }
+  onTertiaryFixedVariant() {
+    const e = c.fromPalette({
+      name: "on_tertiary_fixed_variant",
+      palette: (t) => t.tertiaryPalette,
+      background: (t) => this.tertiaryFixedDim(),
+      contrastCurve: (t) => b(4.5)
+    });
+    return T(super.onTertiaryFixedVariant(), "2025", e);
+  }
+  ////////////////////////////////////////////////////////////////
+  // Errors [E]                                                 //
+  ////////////////////////////////////////////////////////////////
+  error() {
+    const e = c.fromPalette({
+      name: "error",
+      palette: (t) => t.errorPalette,
+      tone: (t) => t.platform === "phone" ? t.isDark ? ne(t.errorPalette, 0, 98) : D(t.errorPalette) : ne(t.errorPalette),
+      isBackground: !0,
+      background: (t) => t.platform === "phone" ? this.highestSurface(t) : this.surfaceContainerHigh(),
+      contrastCurve: (t) => t.platform === "phone" ? b(4.5) : b(7),
+      toneDeltaPair: (t) => t.platform === "phone" ? new w(this.errorContainer(), this.error(), 5, "relative_lighter", !0, "farther") : void 0
+    });
+    return T(super.error(), "2025", e);
+  }
+  errorDim() {
+    return c.fromPalette({
+      name: "error_dim",
+      palette: (e) => e.errorPalette,
+      tone: (e) => ne(e.errorPalette),
+      isBackground: !0,
+      background: (e) => this.surfaceContainerHigh(),
+      contrastCurve: (e) => b(4.5),
+      toneDeltaPair: (e) => new w(this.errorDim(), this.error(), 5, "darker", !0, "farther")
+    });
+  }
+  onError() {
+    const e = c.fromPalette({
+      name: "on_error",
+      palette: (t) => t.errorPalette,
+      background: (t) => t.platform === "phone" ? this.error() : this.errorDim(),
+      contrastCurve: (t) => t.platform === "phone" ? b(6) : b(7)
+    });
+    return T(super.onError(), "2025", e);
+  }
+  errorContainer() {
+    const e = c.fromPalette({
+      name: "error_container",
+      palette: (t) => t.errorPalette,
+      tone: (t) => t.platform === "watch" ? 30 : t.isDark ? ne(t.errorPalette, 30, 93) : D(t.errorPalette, 0, 90),
+      isBackground: !0,
+      background: (t) => t.platform === "phone" ? this.highestSurface(t) : void 0,
+      toneDeltaPair: (t) => t.platform === "watch" ? new w(this.errorContainer(), this.errorDim(), 10, "darker", !0, "farther") : void 0,
+      contrastCurve: (t) => t.platform === "phone" && t.contrastLevel > 0 ? b(1.5) : void 0
+    });
+    return T(super.errorContainer(), "2025", e);
+  }
+  onErrorContainer() {
+    const e = c.fromPalette({
+      name: "on_error_container",
+      palette: (t) => t.errorPalette,
+      background: (t) => this.errorContainer(),
+      contrastCurve: (t) => t.platform === "phone" ? b(4.5) : b(7)
+    });
+    return T(super.onErrorContainer(), "2025", e);
+  }
+  /////////////////////////////////////////////////////////////////
+  // Remapped Colors                                             //
+  /////////////////////////////////////////////////////////////////
+  surfaceVariant() {
+    const e = Object.assign(this.surfaceContainerHighest().clone(), { name: "surface_variant" });
+    return T(super.surfaceVariant(), "2025", e);
+  }
+  surfaceTint() {
+    const e = Object.assign(this.primary().clone(), { name: "surface_tint" });
+    return T(super.surfaceTint(), "2025", e);
+  }
+  background() {
+    const e = Object.assign(this.surface().clone(), { name: "background" });
+    return T(super.background(), "2025", e);
+  }
+  onBackground() {
+    const e = Object.assign(this.onSurface().clone(), {
+      name: "on_background",
+      tone: (t) => t.platform === "watch" ? 100 : this.onSurface().getTone(t)
+    });
+    return T(super.onBackground(), "2025", e);
+  }
+}
+/**
+ * @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 s {
+  constructor() {
+    this.allColors = [
+      this.background(),
+      this.onBackground(),
+      this.surface(),
+      this.surfaceDim(),
+      this.surfaceBright(),
+      this.surfaceContainerLowest(),
+      this.surfaceContainerLow(),
+      this.surfaceContainer(),
+      this.surfaceContainerHigh(),
+      this.surfaceContainerHighest(),
+      this.onSurface(),
+      this.onSurfaceVariant(),
+      this.outline(),
+      this.outlineVariant(),
+      this.inverseSurface(),
+      this.inverseOnSurface(),
+      this.primary(),
+      this.primaryDim(),
+      this.onPrimary(),
+      this.primaryContainer(),
+      this.onPrimaryContainer(),
+      this.primaryFixed(),
+      this.primaryFixedDim(),
+      this.onPrimaryFixed(),
+      this.onPrimaryFixedVariant(),
+      this.inversePrimary(),
+      this.secondary(),
+      this.secondaryDim(),
+      this.onSecondary(),
+      this.secondaryContainer(),
+      this.onSecondaryContainer(),
+      this.secondaryFixed(),
+      this.secondaryFixedDim(),
+      this.onSecondaryFixed(),
+      this.onSecondaryFixedVariant(),
+      this.tertiary(),
+      this.tertiaryDim(),
+      this.onTertiary(),
+      this.tertiaryContainer(),
+      this.onTertiaryContainer(),
+      this.tertiaryFixed(),
+      this.tertiaryFixedDim(),
+      this.onTertiaryFixed(),
+      this.onTertiaryFixedVariant(),
+      this.error(),
+      this.errorDim(),
+      this.onError(),
+      this.errorContainer(),
+      this.onErrorContainer()
+    ].filter((e) => e !== void 0);
+  }
+  highestSurface(e) {
+    return s.colorSpec.highestSurface(e);
+  }
+  ////////////////////////////////////////////////////////////////
+  // Main Palettes                                              //
+  ////////////////////////////////////////////////////////////////
+  primaryPaletteKeyColor() {
+    return s.colorSpec.primaryPaletteKeyColor();
+  }
+  secondaryPaletteKeyColor() {
+    return s.colorSpec.secondaryPaletteKeyColor();
+  }
+  tertiaryPaletteKeyColor() {
+    return s.colorSpec.tertiaryPaletteKeyColor();
+  }
+  neutralPaletteKeyColor() {
+    return s.colorSpec.neutralPaletteKeyColor();
+  }
+  neutralVariantPaletteKeyColor() {
+    return s.colorSpec.neutralVariantPaletteKeyColor();
+  }
+  errorPaletteKeyColor() {
+    return s.colorSpec.errorPaletteKeyColor();
+  }
+  ////////////////////////////////////////////////////////////////
+  // Surfaces [S]                                               //
+  ////////////////////////////////////////////////////////////////
+  background() {
+    return s.colorSpec.background();
+  }
+  onBackground() {
+    return s.colorSpec.onBackground();
+  }
+  surface() {
+    return s.colorSpec.surface();
+  }
+  surfaceDim() {
+    return s.colorSpec.surfaceDim();
+  }
+  surfaceBright() {
+    return s.colorSpec.surfaceBright();
+  }
+  surfaceContainerLowest() {
+    return s.colorSpec.surfaceContainerLowest();
+  }
+  surfaceContainerLow() {
+    return s.colorSpec.surfaceContainerLow();
+  }
+  surfaceContainer() {
+    return s.colorSpec.surfaceContainer();
+  }
+  surfaceContainerHigh() {
+    return s.colorSpec.surfaceContainerHigh();
+  }
+  surfaceContainerHighest() {
+    return s.colorSpec.surfaceContainerHighest();
+  }
+  onSurface() {
+    return s.colorSpec.onSurface();
+  }
+  surfaceVariant() {
+    return s.colorSpec.surfaceVariant();
+  }
+  onSurfaceVariant() {
+    return s.colorSpec.onSurfaceVariant();
+  }
+  outline() {
+    return s.colorSpec.outline();
+  }
+  outlineVariant() {
+    return s.colorSpec.outlineVariant();
+  }
+  inverseSurface() {
+    return s.colorSpec.inverseSurface();
+  }
+  inverseOnSurface() {
+    return s.colorSpec.inverseOnSurface();
+  }
+  shadow() {
+    return s.colorSpec.shadow();
+  }
+  scrim() {
+    return s.colorSpec.scrim();
+  }
+  surfaceTint() {
+    return s.colorSpec.surfaceTint();
+  }
+  ////////////////////////////////////////////////////////////////
+  // Primaries [P]                                              //
+  ////////////////////////////////////////////////////////////////
+  primary() {
+    return s.colorSpec.primary();
+  }
+  primaryDim() {
+    return s.colorSpec.primaryDim();
+  }
+  onPrimary() {
+    return s.colorSpec.onPrimary();
+  }
+  primaryContainer() {
+    return s.colorSpec.primaryContainer();
+  }
+  onPrimaryContainer() {
+    return s.colorSpec.onPrimaryContainer();
+  }
+  inversePrimary() {
+    return s.colorSpec.inversePrimary();
+  }
+  /////////////////////////////////////////////////////////////////
+  // Primary Fixed [PF]                                          //
+  /////////////////////////////////////////////////////////////////
+  primaryFixed() {
+    return s.colorSpec.primaryFixed();
+  }
+  primaryFixedDim() {
+    return s.colorSpec.primaryFixedDim();
+  }
+  onPrimaryFixed() {
+    return s.colorSpec.onPrimaryFixed();
+  }
+  onPrimaryFixedVariant() {
+    return s.colorSpec.onPrimaryFixedVariant();
+  }
+  ////////////////////////////////////////////////////////////////
+  // Secondaries [Q]                                            //
+  ////////////////////////////////////////////////////////////////
+  secondary() {
+    return s.colorSpec.secondary();
+  }
+  secondaryDim() {
+    return s.colorSpec.secondaryDim();
+  }
+  onSecondary() {
+    return s.colorSpec.onSecondary();
+  }
+  secondaryContainer() {
+    return s.colorSpec.secondaryContainer();
+  }
+  onSecondaryContainer() {
+    return s.colorSpec.onSecondaryContainer();
+  }
+  /////////////////////////////////////////////////////////////////
+  // Secondary Fixed [QF]                                        //
+  /////////////////////////////////////////////////////////////////
+  secondaryFixed() {
+    return s.colorSpec.secondaryFixed();
+  }
+  secondaryFixedDim() {
+    return s.colorSpec.secondaryFixedDim();
+  }
+  onSecondaryFixed() {
+    return s.colorSpec.onSecondaryFixed();
+  }
+  onSecondaryFixedVariant() {
+    return s.colorSpec.onSecondaryFixedVariant();
+  }
+  ////////////////////////////////////////////////////////////////
+  // Tertiaries [T]                                             //
+  ////////////////////////////////////////////////////////////////
+  tertiary() {
+    return s.colorSpec.tertiary();
+  }
+  tertiaryDim() {
+    return s.colorSpec.tertiaryDim();
+  }
+  onTertiary() {
+    return s.colorSpec.onTertiary();
+  }
+  tertiaryContainer() {
+    return s.colorSpec.tertiaryContainer();
+  }
+  onTertiaryContainer() {
+    return s.colorSpec.onTertiaryContainer();
+  }
+  /////////////////////////////////////////////////////////////////
+  // Tertiary Fixed [TF]                                         //
+  /////////////////////////////////////////////////////////////////
+  tertiaryFixed() {
+    return s.colorSpec.tertiaryFixed();
+  }
+  tertiaryFixedDim() {
+    return s.colorSpec.tertiaryFixedDim();
+  }
+  onTertiaryFixed() {
+    return s.colorSpec.onTertiaryFixed();
+  }
+  onTertiaryFixedVariant() {
+    return s.colorSpec.onTertiaryFixedVariant();
+  }
+  ////////////////////////////////////////////////////////////////
+  // Errors [E]                                                 //
+  ////////////////////////////////////////////////////////////////
+  error() {
+    return s.colorSpec.error();
+  }
+  errorDim() {
+    return s.colorSpec.errorDim();
+  }
+  onError() {
+    return s.colorSpec.onError();
+  }
+  errorContainer() {
+    return s.colorSpec.errorContainer();
+  }
+  onErrorContainer() {
+    return s.colorSpec.onErrorContainer();
+  }
+  // Static variables are deprecated. Use the instance methods to get correct
+  // specs based on request.
+  /** @deprecated Use highestSurface() instead. */
+  static highestSurface(e) {
+    return s.colorSpec.highestSurface(e);
+  }
+}
+s.contentAccentToneDelta = 15;
+s.colorSpec = new Ht();
+s.primaryPaletteKeyColor = s.colorSpec.primaryPaletteKeyColor();
+s.secondaryPaletteKeyColor = s.colorSpec.secondaryPaletteKeyColor();
+s.tertiaryPaletteKeyColor = s.colorSpec.tertiaryPaletteKeyColor();
+s.neutralPaletteKeyColor = s.colorSpec.neutralPaletteKeyColor();
+s.neutralVariantPaletteKeyColor = s.colorSpec.neutralVariantPaletteKeyColor();
+s.background = s.colorSpec.background();
+s.onBackground = s.colorSpec.onBackground();
+s.surface = s.colorSpec.surface();
+s.surfaceDim = s.colorSpec.surfaceDim();
+s.surfaceBright = s.colorSpec.surfaceBright();
+s.surfaceContainerLowest = s.colorSpec.surfaceContainerLowest();
+s.surfaceContainerLow = s.colorSpec.surfaceContainerLow();
+s.surfaceContainer = s.colorSpec.surfaceContainer();
+s.surfaceContainerHigh = s.colorSpec.surfaceContainerHigh();
+s.surfaceContainerHighest = s.colorSpec.surfaceContainerHighest();
+s.onSurface = s.colorSpec.onSurface();
+s.surfaceVariant = s.colorSpec.surfaceVariant();
+s.onSurfaceVariant = s.colorSpec.onSurfaceVariant();
+s.inverseSurface = s.colorSpec.inverseSurface();
+s.inverseOnSurface = s.colorSpec.inverseOnSurface();
+s.outline = s.colorSpec.outline();
+s.outlineVariant = s.colorSpec.outlineVariant();
+s.shadow = s.colorSpec.shadow();
+s.scrim = s.colorSpec.scrim();
+s.surfaceTint = s.colorSpec.surfaceTint();
+s.primary = s.colorSpec.primary();
+s.onPrimary = s.colorSpec.onPrimary();
+s.primaryContainer = s.colorSpec.primaryContainer();
+s.onPrimaryContainer = s.colorSpec.onPrimaryContainer();
+s.inversePrimary = s.colorSpec.inversePrimary();
+s.secondary = s.colorSpec.secondary();
+s.onSecondary = s.colorSpec.onSecondary();
+s.secondaryContainer = s.colorSpec.secondaryContainer();
+s.onSecondaryContainer = s.colorSpec.onSecondaryContainer();
+s.tertiary = s.colorSpec.tertiary();
+s.onTertiary = s.colorSpec.onTertiary();
+s.tertiaryContainer = s.colorSpec.tertiaryContainer();
+s.onTertiaryContainer = s.colorSpec.onTertiaryContainer();
+s.error = s.colorSpec.error();
+s.onError = s.colorSpec.onError();
+s.errorContainer = s.colorSpec.errorContainer();
+s.onErrorContainer = s.colorSpec.onErrorContainer();
+s.primaryFixed = s.colorSpec.primaryFixed();
+s.primaryFixedDim = s.colorSpec.primaryFixedDim();
+s.onPrimaryFixed = s.colorSpec.onPrimaryFixed();
+s.onPrimaryFixedVariant = s.colorSpec.onPrimaryFixedVariant();
+s.secondaryFixed = s.colorSpec.secondaryFixed();
+s.secondaryFixedDim = s.colorSpec.secondaryFixedDim();
+s.onSecondaryFixed = s.colorSpec.onSecondaryFixed();
+s.onSecondaryFixedVariant = s.colorSpec.onSecondaryFixedVariant();
+s.tertiaryFixed = s.colorSpec.tertiaryFixed();
+s.tertiaryFixedDim = s.colorSpec.tertiaryFixedDim();
+s.onTertiaryFixed = s.colorSpec.onTertiaryFixed();
+s.onTertiaryFixedVariant = s.colorSpec.onTertiaryFixedVariant();
+/**
+ * @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 $ {
+  /**
+   * @param argb ARGB representation of a color
+   *
+   * @deprecated Use {@link DynamicScheme} for color scheme generation.
+   * Use {@link CorePalettes} for core palettes container class.
+   */
+  static of(e) {
+    return new $(e, !1);
+  }
+  /**
+   * @param argb ARGB representation of a color
+   *
+   * @deprecated Use {@link DynamicScheme} for color scheme generation.
+   * Use {@link CorePalettes} for core palettes container class.
+   */
+  static contentOf(e) {
+    return new $(e, !0);
+  }
+  /**
+   * Create a [CorePalette] from a set of colors
+   *
+   * @deprecated Use {@link DynamicScheme} for color scheme generation.
+   * Use {@link CorePalettes} for core palettes container class.
+   */
+  static fromColors(e) {
+    return $.createPaletteFromColors(!1, e);
+  }
+  /**
+   * Create a content [CorePalette] from a set of colors
+   *
+   * @deprecated Use {@link DynamicScheme} for color scheme generation.
+   * Use {@link CorePalettes} for core palettes container class.
+   */
+  static contentFromColors(e) {
+    return $.createPaletteFromColors(!0, e);
+  }
+  static createPaletteFromColors(e, t) {
+    const n = new $(t.primary, e);
+    if (t.secondary) {
+      const a = new $(t.secondary, e);
+      n.a2 = a.a1;
+    }
+    if (t.tertiary) {
+      const a = new $(t.tertiary, e);
+      n.a3 = a.a1;
+    }
+    if (t.error) {
+      const a = new $(t.error, e);
+      n.error = a.a1;
+    }
+    if (t.neutral) {
+      const a = new $(t.neutral, e);
+      n.n1 = a.n1;
+    }
+    if (t.neutralVariant) {
+      const a = new $(t.neutralVariant, e);
+      n.n2 = a.n2;
+    }
+    return n;
+  }
+  constructor(e, t) {
+    const n = C.fromInt(e), a = n.hue, o = n.chroma;
+    t ? (this.a1 = Y.fromHueAndChroma(a, o), this.a2 = Y.fromHueAndChroma(a, o / 3), this.a3 = Y.fromHueAndChroma(a + 60, o / 2), this.n1 = Y.fromHueAndChroma(a, Math.min(o / 12, 4)), this.n2 = Y.fromHueAndChroma(a, Math.min(o / 6, 8))) : (this.a1 = Y.fromHueAndChroma(a, Math.max(48, o)), this.a2 = Y.fromHueAndChroma(a, 16), this.a3 = Y.fromHueAndChroma(a + 60, 24), this.n1 = Y.fromHueAndChroma(a, 4), this.n2 = Y.fromHueAndChroma(a, 8)), this.error = Y.fromHueAndChroma(25, 84);
+  }
+}
+/**
+ * @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 ee {
+  get primary() {
+    return this.props.primary;
+  }
+  get onPrimary() {
+    return this.props.onPrimary;
+  }
+  get primaryContainer() {
+    return this.props.primaryContainer;
+  }
+  get onPrimaryContainer() {
+    return this.props.onPrimaryContainer;
+  }
+  get secondary() {
+    return this.props.secondary;
+  }
+  get onSecondary() {
+    return this.props.onSecondary;
+  }
+  get secondaryContainer() {
+    return this.props.secondaryContainer;
+  }
+  get onSecondaryContainer() {
+    return this.props.onSecondaryContainer;
+  }
+  get tertiary() {
+    return this.props.tertiary;
+  }
+  get onTertiary() {
+    return this.props.onTertiary;
+  }
+  get tertiaryContainer() {
+    return this.props.tertiaryContainer;
+  }
+  get onTertiaryContainer() {
+    return this.props.onTertiaryContainer;
+  }
+  get error() {
+    return this.props.error;
+  }
+  get onError() {
+    return this.props.onError;
+  }
+  get errorContainer() {
+    return this.props.errorContainer;
+  }
+  get onErrorContainer() {
+    return this.props.onErrorContainer;
+  }
+  get background() {
+    return this.props.background;
+  }
+  get onBackground() {
+    return this.props.onBackground;
+  }
+  get surface() {
+    return this.props.surface;
+  }
+  get onSurface() {
+    return this.props.onSurface;
+  }
+  get surfaceVariant() {
+    return this.props.surfaceVariant;
+  }
+  get onSurfaceVariant() {
+    return this.props.onSurfaceVariant;
+  }
+  get outline() {
+    return this.props.outline;
+  }
+  get outlineVariant() {
+    return this.props.outlineVariant;
+  }
+  get shadow() {
+    return this.props.shadow;
+  }
+  get scrim() {
+    return this.props.scrim;
+  }
+  get inverseSurface() {
+    return this.props.inverseSurface;
+  }
+  get inverseOnSurface() {
+    return this.props.inverseOnSurface;
+  }
+  get inversePrimary() {
+    return this.props.inversePrimary;
+  }
+  /**
+   * @param argb ARGB representation of a color.
+   * @return Light Material color scheme, based on the color's hue.
+   */
+  static light(e) {
+    return ee.lightFromCorePalette($.of(e));
+  }
+  /**
+   * @param argb ARGB representation of a color.
+   * @return Dark Material color scheme, based on the color's hue.
+   */
+  static dark(e) {
+    return ee.darkFromCorePalette($.of(e));
+  }
+  /**
+   * @param argb ARGB representation of a color.
+   * @return Light Material content color scheme, based on the color's hue.
+   */
+  static lightContent(e) {
+    return ee.lightFromCorePalette($.contentOf(e));
+  }
+  /**
+   * @param argb ARGB representation of a color.
+   * @return Dark Material content color scheme, based on the color's hue.
+   */
+  static darkContent(e) {
+    return ee.darkFromCorePalette($.contentOf(e));
+  }
+  /**
+   * Light scheme from core palette
+   */
+  static lightFromCorePalette(e) {
+    return new ee({
+      primary: e.a1.tone(40),
+      onPrimary: e.a1.tone(100),
+      primaryContainer: e.a1.tone(90),
+      onPrimaryContainer: e.a1.tone(10),
+      secondary: e.a2.tone(40),
+      onSecondary: e.a2.tone(100),
+      secondaryContainer: e.a2.tone(90),
+      onSecondaryContainer: e.a2.tone(10),
+      tertiary: e.a3.tone(40),
+      onTertiary: e.a3.tone(100),
+      tertiaryContainer: e.a3.tone(90),
+      onTertiaryContainer: e.a3.tone(10),
+      error: e.error.tone(40),
+      onError: e.error.tone(100),
+      errorContainer: e.error.tone(90),
+      onErrorContainer: e.error.tone(10),
+      background: e.n1.tone(99),
+      onBackground: e.n1.tone(10),
+      surface: e.n1.tone(99),
+      onSurface: e.n1.tone(10),
+      surfaceVariant: e.n2.tone(90),
+      onSurfaceVariant: e.n2.tone(30),
+      outline: e.n2.tone(50),
+      outlineVariant: e.n2.tone(80),
+      shadow: e.n1.tone(0),
+      scrim: e.n1.tone(0),
+      inverseSurface: e.n1.tone(20),
+      inverseOnSurface: e.n1.tone(95),
+      inversePrimary: e.a1.tone(80)
+    });
+  }
+  /**
+   * Dark scheme from core palette
+   */
+  static darkFromCorePalette(e) {
+    return new ee({
+      primary: e.a1.tone(80),
+      onPrimary: e.a1.tone(20),
+      primaryContainer: e.a1.tone(30),
+      onPrimaryContainer: e.a1.tone(90),
+      secondary: e.a2.tone(80),
+      onSecondary: e.a2.tone(20),
+      secondaryContainer: e.a2.tone(30),
+      onSecondaryContainer: e.a2.tone(90),
+      tertiary: e.a3.tone(80),
+      onTertiary: e.a3.tone(20),
+      tertiaryContainer: e.a3.tone(30),
+      onTertiaryContainer: e.a3.tone(90),
+      error: e.error.tone(80),
+      onError: e.error.tone(20),
+      errorContainer: e.error.tone(30),
+      onErrorContainer: e.error.tone(80),
+      background: e.n1.tone(10),
+      onBackground: e.n1.tone(90),
+      surface: e.n1.tone(10),
+      onSurface: e.n1.tone(90),
+      surfaceVariant: e.n2.tone(30),
+      onSurfaceVariant: e.n2.tone(80),
+      outline: e.n2.tone(60),
+      outlineVariant: e.n2.tone(30),
+      shadow: e.n1.tone(0),
+      scrim: e.n1.tone(0),
+      inverseSurface: e.n1.tone(90),
+      inverseOnSurface: e.n1.tone(20),
+      inversePrimary: e.a1.tone(40)
+    });
+  }
+  constructor(e) {
+    this.props = e;
+  }
+  toJSON() {
+    return {
+      ...this.props
+    };
+  }
+}
+/**
+ * @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.
+ */
+function N(r) {
+  const e = at(r), t = ot(r), n = it(r), a = [e.toString(16), t.toString(16), n.toString(16)];
+  for (const [o, i] of a.entries())
+    i.length === 1 && (a[o] = "0" + i);
+  return "#" + a.join("");
+}
+function Ce(r) {
+  r = r.replace("#", "");
+  const e = r.length === 3, t = r.length === 6, n = r.length === 8;
+  if (!e && !t && !n)
+    throw new Error("unexpected hex " + r);
+  let a = 0, o = 0, i = 0;
+  return e ? (a = Z(r.slice(0, 1).repeat(2)), o = Z(r.slice(1, 2).repeat(2)), i = Z(r.slice(2, 3).repeat(2))) : t ? (a = Z(r.slice(0, 2)), o = Z(r.slice(2, 4)), i = Z(r.slice(4, 6))) : n && (a = Z(r.slice(2, 4)), o = Z(r.slice(4, 6)), i = Z(r.slice(6, 8))), (255 << 24 | (a & 255) << 16 | (o & 255) << 8 | i & 255) >>> 0;
+}
+function Z(r) {
+  return parseInt(r, 16);
+}
+/**
+ * @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.
+ */
+function oe(r, e = []) {
+  const t = $.of(r);
+  return {
+    source: r,
+    schemes: {
+      light: ee.light(r),
+      dark: ee.dark(r)
+    },
+    palettes: {
+      primary: t.a1,
+      secondary: t.a2,
+      tertiary: t.a3,
+      neutral: t.n1,
+      neutralVariant: t.n2,
+      error: t.error
+    },
+    customColors: e.map((n) => zt(r, n))
+  };
+}
+function zt(r, e) {
+  let t = e.value;
+  const n = t, a = r;
+  e.blend && (t = Ve.harmonize(n, a));
+  const i = $.of(t).a1;
+  return {
+    color: e,
+    value: t,
+    light: {
+      color: i.tone(40),
+      onColor: i.tone(100),
+      colorContainer: i.tone(90),
+      onColorContainer: i.tone(10)
+    },
+    dark: {
+      color: i.tone(80),
+      onColor: i.tone(20),
+      colorContainer: i.tone(30),
+      onColorContainer: i.tone(90)
+    }
+  };
+}
+function Fe(r, e) {
+  const t = C.fromInt(Ce(r)), n = C.from(t.hue, t.chroma, e);
+  return N(n.toInt());
+}
+function Ut(r) {
+  const e = C.fromInt(Ce(r)), t = (e.hue + 110) % 360, n = Math.min(e.chroma * 1.2, 100), a = e.tone < 50 ? 65 : Math.min(e.tone + 10, 75);
+  return N(C.from(t, n, a).toInt());
+}
+function $t(r) {
+  const e = Ut(r);
+  return {
+    0: Fe(e, 95),
+    25: e,
+    50: r,
+    75: Fe(r, 80),
+    100: Fe(r, 20)
+  };
+}
+function he(r, e) {
+  const t = $t(r);
+  let n = `linear-gradient(${e}deg, `;
+  for (const a of Object.keys(t))
+    n += `${t[a]} ${a}%, `;
+  return n.slice(0, -2) + ")";
+}
+function Yt(r, e = 135) {
+  const t = {};
+  return Xe(t, "source", r, e), Object.entries(Ee).forEach(([n, a]) => {
+    Xe(t, n, a, e);
+  }), t;
+}
+function Xe(r, e, t, n) {
+  const o = oe(Ce(t)).palettes.primary;
+  for (let i = 10; i <= 100; i += 10) {
+    const u = N(o.tone(i));
+    r[`${e}${i}`] = he(u, n);
+  }
+}
+function X(r) {
+  const e = parseInt(r.slice(1, 3), 16), t = parseInt(r.slice(3, 5), 16), n = parseInt(r.slice(5, 7), 16);
+  return `${e}, ${t}, ${n}`;
+}
+function jt(r) {
+  const e = {};
+  return Ge(e, "source", r), Object.entries(Ee).forEach(([t]) => {
+    Ge(e, t, Ee[t]);
+  }), e;
+}
+function Ge(r, e, t) {
+  const a = oe(Ce(t)).palettes.primary;
+  for (let o = 10; o <= 100; o += 10) {
+    const i = N(a.tone(o)), u = o >= 60 ? 10 : 100, l = N(a.tone(u)), h = X(i), f = X(l);
+    r[`${e}${o}`] = h, r[`on${Kt(e)}${o}`] = f;
+  }
+}
+function Kt(r) {
+  return r.charAt(0).toUpperCase() + r.slice(1);
+}
+var qt = { grad: 0.9, turn: 360, rad: 360 / (2 * Math.PI) }, Q = function(r) {
+  return typeof r == "string" ? r.length > 0 : typeof r == "number";
+}, _ = function(r, e, t) {
+  return e === void 0 && (e = 0), t === void 0 && (t = Math.pow(10, e)), Math.round(t * r) / t + 0;
+}, K = function(r, e, t) {
+  return e === void 0 && (e = 0), t === void 0 && (t = 1), r > t ? t : r > e ? r : e;
+}, ut = function(r) {
+  return (r = isFinite(r) ? r % 360 : 0) > 0 ? r : r + 360;
+}, Je = function(r) {
+  return { r: K(r.r, 0, 255), g: K(r.g, 0, 255), b: K(r.b, 0, 255), a: K(r.a) };
+}, xe = function(r) {
+  return { r: _(r.r), g: _(r.g), b: _(r.b), a: _(r.a, 3) };
+}, Xt = /^#([0-9a-f]{3,8})$/i, ke = function(r) {
+  var e = r.toString(16);
+  return e.length < 2 ? "0" + e : e;
+}, lt = function(r) {
+  var e = r.r, t = r.g, n = r.b, a = r.a, o = Math.max(e, t, n), i = o - Math.min(e, t, n), u = i ? o === e ? (t - n) / i : o === t ? 2 + (n - e) / i : 4 + (e - t) / i : 0;
+  return { h: 60 * (u < 0 ? u + 6 : u), s: o ? i / o * 100 : 0, v: o / 255 * 100, a };
+}, ht = function(r) {
+  var e = r.h, t = r.s, n = r.v, a = r.a;
+  e = e / 360 * 6, t /= 100, n /= 100;
+  var o = Math.floor(e), i = n * (1 - t), u = n * (1 - (e - o) * t), l = n * (1 - (1 - e + o) * t), h = o % 6;
+  return { r: 255 * [n, u, i, i, l, n][h], g: 255 * [l, n, n, u, i, i][h], b: 255 * [i, i, l, n, n, u][h], a };
+}, We = function(r) {
+  return { h: ut(r.h), s: K(r.s, 0, 100), l: K(r.l, 0, 100), a: K(r.a) };
+}, Ze = function(r) {
+  return { h: _(r.h), s: _(r.s), l: _(r.l), a: _(r.a, 3) };
+}, Qe = function(r) {
+  return ht((t = (e = r).s, { h: e.h, s: (t *= ((n = e.l) < 50 ? n : 100 - n) / 100) > 0 ? 2 * t / (n + t) * 100 : 0, v: n + t, a: e.a }));
+  var e, t, n;
+}, de = function(r) {
+  return { h: (e = lt(r)).h, s: (a = (200 - (t = e.s)) * (n = e.v) / 100) > 0 && a < 200 ? t * n / 100 / (a <= 100 ? a : 200 - a) * 100 : 0, l: a / 2, a: e.a };
+  var e, t, n, a;
+}, Gt = /^hsla?\(\s*([+-]?\d*\.?\d+)(deg|rad|grad|turn)?\s*,\s*([+-]?\d*\.?\d+)%\s*,\s*([+-]?\d*\.?\d+)%\s*(?:,\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i, Jt = /^hsla?\(\s*([+-]?\d*\.?\d+)(deg|rad|grad|turn)?\s+([+-]?\d*\.?\d+)%\s+([+-]?\d*\.?\d+)%\s*(?:\/\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i, Wt = /^rgba?\(\s*([+-]?\d*\.?\d+)(%)?\s*,\s*([+-]?\d*\.?\d+)(%)?\s*,\s*([+-]?\d*\.?\d+)(%)?\s*(?:,\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i, Zt = /^rgba?\(\s*([+-]?\d*\.?\d+)(%)?\s+([+-]?\d*\.?\d+)(%)?\s+([+-]?\d*\.?\d+)(%)?\s*(?:\/\s*([+-]?\d*\.?\d+)(%)?\s*)?\)$/i, et = { string: [[function(r) {
+  var e = Xt.exec(r);
+  return e ? (r = e[1]).length <= 4 ? { r: parseInt(r[0] + r[0], 16), g: parseInt(r[1] + r[1], 16), b: parseInt(r[2] + r[2], 16), a: r.length === 4 ? _(parseInt(r[3] + r[3], 16) / 255, 2) : 1 } : r.length === 6 || r.length === 8 ? { r: parseInt(r.substr(0, 2), 16), g: parseInt(r.substr(2, 2), 16), b: parseInt(r.substr(4, 2), 16), a: r.length === 8 ? _(parseInt(r.substr(6, 2), 16) / 255, 2) : 1 } : null : null;
+}, "hex"], [function(r) {
+  var e = Wt.exec(r) || Zt.exec(r);
+  return e ? e[2] !== e[4] || e[4] !== e[6] ? null : Je({ r: Number(e[1]) / (e[2] ? 100 / 255 : 1), g: Number(e[3]) / (e[4] ? 100 / 255 : 1), b: Number(e[5]) / (e[6] ? 100 / 255 : 1), a: e[7] === void 0 ? 1 : Number(e[7]) / (e[8] ? 100 : 1) }) : null;
+}, "rgb"], [function(r) {
+  var e = Gt.exec(r) || Jt.exec(r);
+  if (!e) return null;
+  var t, n, a = We({ h: (t = e[1], n = e[2], n === void 0 && (n = "deg"), Number(t) * (qt[n] || 1)), s: Number(e[3]), l: Number(e[4]), a: e[5] === void 0 ? 1 : Number(e[5]) / (e[6] ? 100 : 1) });
+  return Qe(a);
+}, "hsl"]], object: [[function(r) {
+  var e = r.r, t = r.g, n = r.b, a = r.a, o = a === void 0 ? 1 : a;
+  return Q(e) && Q(t) && Q(n) ? Je({ r: Number(e), g: Number(t), b: Number(n), a: Number(o) }) : null;
+}, "rgb"], [function(r) {
+  var e = r.h, t = r.s, n = r.l, a = r.a, o = a === void 0 ? 1 : a;
+  if (!Q(e) || !Q(t) || !Q(n)) return null;
+  var i = We({ h: Number(e), s: Number(t), l: Number(n), a: Number(o) });
+  return Qe(i);
+}, "hsl"], [function(r) {
+  var e = r.h, t = r.s, n = r.v, a = r.a, o = a === void 0 ? 1 : a;
+  if (!Q(e) || !Q(t) || !Q(n)) return null;
+  var i = function(u) {
+    return { h: ut(u.h), s: K(u.s, 0, 100), v: K(u.v, 0, 100), a: K(u.a) };
+  }({ h: Number(e), s: Number(t), v: Number(n), a: Number(o) });
+  return ht(i);
+}, "hsv"]] }, tt = function(r, e) {
+  for (var t = 0; t < e.length; t++) {
+    var n = e[t][0](r);
+    if (n) return [n, e[t][1]];
+  }
+  return [null, void 0];
+}, Qt = function(r) {
+  return typeof r == "string" ? tt(r.trim(), et.string) : typeof r == "object" && r !== null ? tt(r, et.object) : [null, void 0];
+}, Me = function(r, e) {
+  var t = de(r);
+  return { h: t.h, s: K(t.s + 100 * e, 0, 100), l: t.l, a: t.a };
+}, Be = function(r) {
+  return (299 * r.r + 587 * r.g + 114 * r.b) / 1e3 / 255;
+}, rt = function(r, e) {
+  var t = de(r);
+  return { h: t.h, s: t.s, l: K(t.l + 100 * e, 0, 100), a: t.a };
+}, nt = function() {
+  function r(e) {
+    this.parsed = Qt(e)[0], this.rgba = this.parsed || { r: 0, g: 0, b: 0, a: 1 };
+  }
+  return r.prototype.isValid = function() {
+    return this.parsed !== null;
+  }, r.prototype.brightness = function() {
+    return _(Be(this.rgba), 2);
+  }, r.prototype.isDark = function() {
+    return Be(this.rgba) < 0.5;
+  }, r.prototype.isLight = function() {
+    return Be(this.rgba) >= 0.5;
+  }, r.prototype.toHex = function() {
+    return e = xe(this.rgba), t = e.r, n = e.g, a = e.b, i = (o = e.a) < 1 ? ke(_(255 * o)) : "", "#" + ke(t) + ke(n) + ke(a) + i;
+    var e, t, n, a, o, i;
+  }, r.prototype.toRgb = function() {
+    return xe(this.rgba);
+  }, r.prototype.toRgbString = function() {
+    return e = xe(this.rgba), t = e.r, n = e.g, a = e.b, (o = e.a) < 1 ? "rgba(" + t + ", " + n + ", " + a + ", " + o + ")" : "rgb(" + t + ", " + n + ", " + a + ")";
+    var e, t, n, a, o;
+  }, r.prototype.toHsl = function() {
+    return Ze(de(this.rgba));
+  }, r.prototype.toHslString = function() {
+    return e = Ze(de(this.rgba)), t = e.h, n = e.s, a = e.l, (o = e.a) < 1 ? "hsla(" + t + ", " + n + "%, " + a + "%, " + o + ")" : "hsl(" + t + ", " + n + "%, " + a + "%)";
+    var e, t, n, a, o;
+  }, r.prototype.toHsv = function() {
+    return e = lt(this.rgba), { h: _(e.h), s: _(e.s), v: _(e.v), a: _(e.a, 3) };
+    var e;
+  }, r.prototype.invert = function() {
+    return G({ r: 255 - (e = this.rgba).r, g: 255 - e.g, b: 255 - e.b, a: e.a });
+    var e;
+  }, r.prototype.saturate = function(e) {
+    return e === void 0 && (e = 0.1), G(Me(this.rgba, e));
+  }, r.prototype.desaturate = function(e) {
+    return e === void 0 && (e = 0.1), G(Me(this.rgba, -e));
+  }, r.prototype.grayscale = function() {
+    return G(Me(this.rgba, -1));
+  }, r.prototype.lighten = function(e) {
+    return e === void 0 && (e = 0.1), G(rt(this.rgba, e));
+  }, r.prototype.darken = function(e) {
+    return e === void 0 && (e = 0.1), G(rt(this.rgba, -e));
+  }, r.prototype.rotate = function(e) {
+    return e === void 0 && (e = 15), this.hue(this.hue() + e);
+  }, r.prototype.alpha = function(e) {
+    return typeof e == "number" ? G({ r: (t = this.rgba).r, g: t.g, b: t.b, a: e }) : _(this.rgba.a, 3);
+    var t;
+  }, r.prototype.hue = function(e) {
+    var t = de(this.rgba);
+    return typeof e == "number" ? G({ h: e, s: t.s, l: t.l, a: t.a }) : _(t.h);
+  }, r.prototype.isEqual = function(e) {
+    return this.toHex() === G(e).toHex();
+  }, r;
+}(), G = function(r) {
+  return r instanceof nt ? r : new nt(r);
+};
+function se(r, e) {
+  if (typeof r == "number")
+    return r > 16777215 ? r : 4278190080 | r;
+  const t = r.trim();
+  if (t === "currentColor")
+    return null;
+  if (t.startsWith("var("))
+    return t.slice(4, -1).trim(), null;
+  const n = G(t);
+  if (n.isValid()) {
+    const { r: a, g: o, b: i } = n.toRgb();
+    return Se(a, o, i);
+  }
+  return null;
+}
+const pe = "#4e51ff", ft = "g-theme--material", Ae = "g-theme--", _e = Symbol("gradient-theme");
+function er(r) {
+  const e = se("#FFC107"), t = se("#4CAF50");
+  if (e == null || t == null)
+    throw new Error("Failed to normalize semantic seed color.");
+  const n = r === "dark" ? "dark" : "light", a = oe(e).schemes[n].toJSON(), o = oe(t).schemes[n].toJSON();
+  return {
+    warning: X(N(a.primary)),
+    onWarning: X(N(a.onPrimary)),
+    warningContainer: X(
+      N(a.primaryContainer)
+    ),
+    onWarningContainer: X(
+      N(a.onPrimaryContainer)
+    ),
+    success: X(N(o.primary)),
+    onSuccess: X(N(o.onPrimary)),
+    successContainer: X(
+      N(o.primaryContainer)
+    ),
+    onSuccessContainer: X(
+      N(o.onPrimaryContainer)
+    )
+  };
+}
+function tr(r, e) {
+  const t = He(r), n = se(t);
+  if (n == null)
+    throw new Error("Failed to normalize seed color.");
+  const a = oe(n), o = e === "dark" ? "dark" : "light", i = a.schemes[o].toJSON(), u = {};
+  return Object.entries(i).forEach(([l, h]) => {
+    const f = N(h), g = X(f);
+    u[l] = g;
+  }), {
+    ...u,
+    ...er(e)
+  };
+}
+function rr(r) {
+  const e = He(r), t = se(e), n = se("#FFC107"), a = se("#4CAF50");
+  if (t == null || n == null || a == null)
+    throw new Error("Failed to normalize gradient seed color.");
+  const o = oe(t), i = oe(n), u = oe(a), l = o.schemes.light.toJSON(), h = i.schemes.light.toJSON(), f = u.schemes.light.toJSON(), g = N(l.error), p = N(h.primary), v = N(f.primary);
+  return {
+    ...Yt(e, 135),
+    main: he(e, 135),
+    error: he(g, 135),
+    warning: he(p, 135),
+    success: he(v, 135)
+  };
+}
+function He(r) {
+  const e = se(r);
+  return e == null ? pe : N(e);
+}
+function Ie(r, e) {
+  let t = `.${ft} {
+`;
+  for (const [a, o] of Object.entries(r))
+    t += `  --g-${e}-${yt(a)}: ${o};
+`;
+  t += "}";
+  let n = document.getElementById(
+    `g-${e}-style`
+  );
+  return n || (n = document.createElement("style"), n.id = `g-${e}-style`, document.head.appendChild(n)), n.textContent = t, n;
+}
+function ir(r = pe) {
+  return ze(r, "light");
+}
+function sr(r = pe) {
+  return ze(r, "dark");
+}
+function ze(r = pe, e = "light") {
+  const t = document.documentElement;
+  t.classList.add(ft), t.classList.remove(
+    `${Ae}light`,
+    `${Ae}dark`
+  ), t.classList.add(`${Ae}${e}`);
+  const n = He(r), a = {
+    theme: tr(n, e),
+    colors: jt(n),
+    gradient: rr(n)
+  };
+  return {
+    tokens: a,
+    themeCSS: Ie(a.theme, "theme"),
+    colorsCSS: Ie(a.colors, "color"),
+    gradientCSS: Ie(a.gradient, "gradient")
+  };
+}
+function nr(r = {}) {
+  const e = je(r.seed ?? pe), t = je(r.mode ?? "light"), n = Pt(
+    null
+  ), a = () => typeof window > "u" ? null : (n.value = ze(e.value, t.value), n.value), o = (l) => (e.value = l, a()), i = (l) => (t.value = l, a()), u = () => (t.value = t.value === "dark" ? "light" : "dark", a());
+  return r.autoApply !== !1 && a(), {
+    seed: e,
+    mode: t,
+    result: n,
+    apply: a,
+    setSeed: o,
+    setMode: i,
+    toggleMode: u
+  };
+}
+function cr(r = nr()) {
+  return kt(_e, r), r;
+}
+function ur(r, e) {
+  r.provide(_e, e);
+}
+function lr() {
+  return bt(_e, null);
+}
+export {
+  pe as D,
+  ir as a,
+  ze as b,
+  sr as c,
+  nr as d,
+  ur as i,
+  cr as p,
+  lr as u
+};