@symblight/md-colors 0.1.1 → 0.2.0

package/dist/client.esm.js

@@ -41,10 +41,6 @@ function sanitizeDegreesDouble(degrees) {
   }
   return degrees;
 }
-function rotationDirection(from, to) {
-  const increasingDifference = sanitizeDegreesDouble(to - from);
-  return increasingDifference <= 180 ? 1 : -1;
-}
 function differenceDegrees(a, b) {
   return 180 - Math.abs(Math.abs(a - b) - 180);
 }
@@ -113,26 +109,6 @@ function xyzFromArgb(argb) {
   const b = linearized(blueFromArgb(argb));
   return matrixMultiply([r2, g, b], SRGB_TO_XYZ);
 }
-function labFromArgb(argb) {
-  const linearR = linearized(redFromArgb(argb));
-  const linearG = linearized(greenFromArgb(argb));
-  const linearB = linearized(blueFromArgb(argb));
-  const matrix = SRGB_TO_XYZ;
-  const x = matrix[0][0] * linearR + matrix[0][1] * linearG + matrix[0][2] * linearB;
-  const y = matrix[1][0] * linearR + matrix[1][1] * linearG + matrix[1][2] * linearB;
-  const z = matrix[2][0] * linearR + matrix[2][1] * linearG + matrix[2][2] * linearB;
-  const whitePoint = WHITE_POINT_D65;
-  const xNormalized = x / whitePoint[0];
-  const yNormalized = y / whitePoint[1];
-  const zNormalized = z / whitePoint[2];
-  const fx = labF(xNormalized);
-  const fy = labF(yNormalized);
-  const fz = labF(zNormalized);
-  const l = 116 * fy - 16;
-  const a = 500 * (fx - fy);
-  const b = 200 * (fy - fz);
-  return [l, a, b];
-}
 function argbFromLstar(lstar) {
   const y = yFromLstar(lstar);
   const component = delinearized(y);
@@ -1276,69 +1252,6 @@ var Hct = class _Hct {
   }
 };
 
-// ../../node_modules/.pnpm/@material+material-color-utilities@0.3.0/node_modules/@material/material-color-utilities/blend/blend.js
-var Blend = class _Blend {
-  /**
-   * Blend the design color's HCT hue towards the key color's HCT
-   * hue, in a way that leaves the original color recognizable and
-   * recognizably shifted towards the key color.
-   *
-   * @param designColor ARGB representation of an arbitrary color.
-   * @param sourceColor ARGB representation of the main theme color.
-   * @return The design color with a hue shifted towards the
-   * system's color, a slightly warmer/cooler variant of the design
-   * color's hue.
-   */
-  static harmonize(designColor, sourceColor) {
-    const fromHct = Hct.fromInt(designColor);
-    const toHct = Hct.fromInt(sourceColor);
-    const differenceDegrees2 = differenceDegrees(fromHct.hue, toHct.hue);
-    const rotationDegrees = Math.min(differenceDegrees2 * 0.5, 15);
-    const outputHue = sanitizeDegreesDouble(fromHct.hue + rotationDegrees * rotationDirection(fromHct.hue, toHct.hue));
-    return Hct.from(outputHue, fromHct.chroma, fromHct.tone).toInt();
-  }
-  /**
-   * Blends hue from one color into another. The chroma and tone of
-   * the original color are maintained.
-   *
-   * @param from ARGB representation of color
-   * @param to ARGB representation of color
-   * @param amount how much blending to perform; 0.0 >= and <= 1.0
-   * @return from, with a hue blended towards to. Chroma and tone
-   * are constant.
-   */
-  static hctHue(from, to, amount) {
-    const ucs = _Blend.cam16Ucs(from, to, amount);
-    const ucsCam = Cam16.fromInt(ucs);
-    const fromCam = Cam16.fromInt(from);
-    const blended = Hct.from(ucsCam.hue, fromCam.chroma, lstarFromArgb(from));
-    return blended.toInt();
-  }
-  /**
-   * Blend in CAM16-UCS space.
-   *
-   * @param from ARGB representation of color
-   * @param to ARGB representation of color
-   * @param amount how much blending to perform; 0.0 >= and <= 1.0
-   * @return from, blended towards to. Hue, chroma, and tone will
-   * change.
-   */
-  static cam16Ucs(from, to, amount) {
-    const fromCam = Cam16.fromInt(from);
-    const toCam = Cam16.fromInt(to);
-    const fromJ = fromCam.jstar;
-    const fromA = fromCam.astar;
-    const fromB = fromCam.bstar;
-    const toJ = toCam.jstar;
-    const toA = toCam.astar;
-    const toB = toCam.bstar;
-    const jstar = fromJ + (toJ - fromJ) * amount;
-    const astar = fromA + (toA - fromA) * amount;
-    const bstar = fromB + (toB - fromB) * amount;
-    return Cam16.fromUcs(jstar, astar, bstar).toInt();
-  }
-};
-
 // ../../node_modules/.pnpm/@material+material-color-utilities@0.3.0/node_modules/@material/material-color-utilities/contrast/contrast.js
 var Contrast = class _Contrast {
   /**
@@ -2653,522 +2566,6 @@ var DynamicScheme = class {
   }
 };
 
-// ../../node_modules/.pnpm/@material+material-color-utilities@0.3.0/node_modules/@material/material-color-utilities/palettes/core_palette.js
-var CorePalette = class _CorePalette {
-  /**
-   * @param argb ARGB representation of a color
-   */
-  static of(argb) {
-    return new _CorePalette(argb, false);
-  }
-  /**
-   * @param argb ARGB representation of a color
-   */
-  static contentOf(argb) {
-    return new _CorePalette(argb, true);
-  }
-  /**
-   * Create a [CorePalette] from a set of colors
-   */
-  static fromColors(colors) {
-    return _CorePalette.createPaletteFromColors(false, colors);
-  }
-  /**
-   * Create a content [CorePalette] from a set of colors
-   */
-  static contentFromColors(colors) {
-    return _CorePalette.createPaletteFromColors(true, colors);
-  }
-  static createPaletteFromColors(content, colors) {
-    const palette = new _CorePalette(colors.primary, content);
-    if (colors.secondary) {
-      const p4 = new _CorePalette(colors.secondary, content);
-      palette.a2 = p4.a1;
-    }
-    if (colors.tertiary) {
-      const p4 = new _CorePalette(colors.tertiary, content);
-      palette.a3 = p4.a1;
-    }
-    if (colors.error) {
-      const p4 = new _CorePalette(colors.error, content);
-      palette.error = p4.a1;
-    }
-    if (colors.neutral) {
-      const p4 = new _CorePalette(colors.neutral, content);
-      palette.n1 = p4.n1;
-    }
-    if (colors.neutralVariant) {
-      const p4 = new _CorePalette(colors.neutralVariant, content);
-      palette.n2 = p4.n2;
-    }
-    return palette;
-  }
-  constructor(argb, isContent) {
-    const hct = Hct.fromInt(argb);
-    const hue3 = hct.hue;
-    const chroma = hct.chroma;
-    if (isContent) {
-      this.a1 = TonalPalette.fromHueAndChroma(hue3, chroma);
-      this.a2 = TonalPalette.fromHueAndChroma(hue3, chroma / 3);
-      this.a3 = TonalPalette.fromHueAndChroma(hue3 + 60, chroma / 2);
-      this.n1 = TonalPalette.fromHueAndChroma(hue3, Math.min(chroma / 12, 4));
-      this.n2 = TonalPalette.fromHueAndChroma(hue3, Math.min(chroma / 6, 8));
-    } else {
-      this.a1 = TonalPalette.fromHueAndChroma(hue3, Math.max(48, chroma));
-      this.a2 = TonalPalette.fromHueAndChroma(hue3, 16);
-      this.a3 = TonalPalette.fromHueAndChroma(hue3 + 60, 24);
-      this.n1 = TonalPalette.fromHueAndChroma(hue3, 4);
-      this.n2 = TonalPalette.fromHueAndChroma(hue3, 8);
-    }
-    this.error = TonalPalette.fromHueAndChroma(25, 84);
-  }
-};
-
-// ../../node_modules/.pnpm/@material+material-color-utilities@0.3.0/node_modules/@material/material-color-utilities/scheme/scheme.js
-var Scheme = class _Scheme {
-  get primary() {
-    return this.props.primary;
-  }
-  get onPrimary() {
-    return this.props.onPrimary;
-  }
-  get primaryContainer() {
-    return this.props.primaryContainer;
-  }
-  get onPrimaryContainer() {
-    return this.props.onPrimaryContainer;
-  }
-  get secondary() {
-    return this.props.secondary;
-  }
-  get onSecondary() {
-    return this.props.onSecondary;
-  }
-  get secondaryContainer() {
-    return this.props.secondaryContainer;
-  }
-  get onSecondaryContainer() {
-    return this.props.onSecondaryContainer;
-  }
-  get tertiary() {
-    return this.props.tertiary;
-  }
-  get onTertiary() {
-    return this.props.onTertiary;
-  }
-  get tertiaryContainer() {
-    return this.props.tertiaryContainer;
-  }
-  get onTertiaryContainer() {
-    return this.props.onTertiaryContainer;
-  }
-  get error() {
-    return this.props.error;
-  }
-  get onError() {
-    return this.props.onError;
-  }
-  get errorContainer() {
-    return this.props.errorContainer;
-  }
-  get onErrorContainer() {
-    return this.props.onErrorContainer;
-  }
-  get background() {
-    return this.props.background;
-  }
-  get onBackground() {
-    return this.props.onBackground;
-  }
-  get surface() {
-    return this.props.surface;
-  }
-  get onSurface() {
-    return this.props.onSurface;
-  }
-  get surfaceVariant() {
-    return this.props.surfaceVariant;
-  }
-  get onSurfaceVariant() {
-    return this.props.onSurfaceVariant;
-  }
-  get outline() {
-    return this.props.outline;
-  }
-  get outlineVariant() {
-    return this.props.outlineVariant;
-  }
-  get shadow() {
-    return this.props.shadow;
-  }
-  get scrim() {
-    return this.props.scrim;
-  }
-  get inverseSurface() {
-    return this.props.inverseSurface;
-  }
-  get inverseOnSurface() {
-    return this.props.inverseOnSurface;
-  }
-  get inversePrimary() {
-    return this.props.inversePrimary;
-  }
-  /**
-   * @param argb ARGB representation of a color.
-   * @return Light Material color scheme, based on the color's hue.
-   */
-  static light(argb) {
-    return _Scheme.lightFromCorePalette(CorePalette.of(argb));
-  }
-  /**
-   * @param argb ARGB representation of a color.
-   * @return Dark Material color scheme, based on the color's hue.
-   */
-  static dark(argb) {
-    return _Scheme.darkFromCorePalette(CorePalette.of(argb));
-  }
-  /**
-   * @param argb ARGB representation of a color.
-   * @return Light Material content color scheme, based on the color's hue.
-   */
-  static lightContent(argb) {
-    return _Scheme.lightFromCorePalette(CorePalette.contentOf(argb));
-  }
-  /**
-   * @param argb ARGB representation of a color.
-   * @return Dark Material content color scheme, based on the color's hue.
-   */
-  static darkContent(argb) {
-    return _Scheme.darkFromCorePalette(CorePalette.contentOf(argb));
-  }
-  /**
-   * Light scheme from core palette
-   */
-  static lightFromCorePalette(core) {
-    return new _Scheme({
-      primary: core.a1.tone(40),
-      onPrimary: core.a1.tone(100),
-      primaryContainer: core.a1.tone(90),
-      onPrimaryContainer: core.a1.tone(10),
-      secondary: core.a2.tone(40),
-      onSecondary: core.a2.tone(100),
-      secondaryContainer: core.a2.tone(90),
-      onSecondaryContainer: core.a2.tone(10),
-      tertiary: core.a3.tone(40),
-      onTertiary: core.a3.tone(100),
-      tertiaryContainer: core.a3.tone(90),
-      onTertiaryContainer: core.a3.tone(10),
-      error: core.error.tone(40),
-      onError: core.error.tone(100),
-      errorContainer: core.error.tone(90),
-      onErrorContainer: core.error.tone(10),
-      background: core.n1.tone(99),
-      onBackground: core.n1.tone(10),
-      surface: core.n1.tone(99),
-      onSurface: core.n1.tone(10),
-      surfaceVariant: core.n2.tone(90),
-      onSurfaceVariant: core.n2.tone(30),
-      outline: core.n2.tone(50),
-      outlineVariant: core.n2.tone(80),
-      shadow: core.n1.tone(0),
-      scrim: core.n1.tone(0),
-      inverseSurface: core.n1.tone(20),
-      inverseOnSurface: core.n1.tone(95),
-      inversePrimary: core.a1.tone(80)
-    });
-  }
-  /**
-   * Dark scheme from core palette
-   */
-  static darkFromCorePalette(core) {
-    return new _Scheme({
-      primary: core.a1.tone(80),
-      onPrimary: core.a1.tone(20),
-      primaryContainer: core.a1.tone(30),
-      onPrimaryContainer: core.a1.tone(90),
-      secondary: core.a2.tone(80),
-      onSecondary: core.a2.tone(20),
-      secondaryContainer: core.a2.tone(30),
-      onSecondaryContainer: core.a2.tone(90),
-      tertiary: core.a3.tone(80),
-      onTertiary: core.a3.tone(20),
-      tertiaryContainer: core.a3.tone(30),
-      onTertiaryContainer: core.a3.tone(90),
-      error: core.error.tone(80),
-      onError: core.error.tone(20),
-      errorContainer: core.error.tone(30),
-      onErrorContainer: core.error.tone(80),
-      background: core.n1.tone(10),
-      onBackground: core.n1.tone(90),
-      surface: core.n1.tone(10),
-      onSurface: core.n1.tone(90),
-      surfaceVariant: core.n2.tone(30),
-      onSurfaceVariant: core.n2.tone(80),
-      outline: core.n2.tone(60),
-      outlineVariant: core.n2.tone(30),
-      shadow: core.n1.tone(0),
-      scrim: core.n1.tone(0),
-      inverseSurface: core.n1.tone(90),
-      inverseOnSurface: core.n1.tone(20),
-      inversePrimary: core.a1.tone(40)
-    });
-  }
-  constructor(props) {
-    this.props = props;
-  }
-  toJSON() {
-    return {
-      ...this.props
-    };
-  }
-};
-
-// ../../node_modules/.pnpm/@material+material-color-utilities@0.3.0/node_modules/@material/material-color-utilities/temperature/temperature_cache.js
-var TemperatureCache = class _TemperatureCache {
-  constructor(input) {
-    this.input = input;
-    this.hctsByTempCache = [];
-    this.hctsByHueCache = [];
-    this.tempsByHctCache = /* @__PURE__ */ new Map();
-    this.inputRelativeTemperatureCache = -1;
-    this.complementCache = null;
-  }
-  get hctsByTemp() {
-    if (this.hctsByTempCache.length > 0) {
-      return this.hctsByTempCache;
-    }
-    const hcts = this.hctsByHue.concat([this.input]);
-    const temperaturesByHct = this.tempsByHct;
-    hcts.sort((a, b) => temperaturesByHct.get(a) - temperaturesByHct.get(b));
-    this.hctsByTempCache = hcts;
-    return hcts;
-  }
-  get warmest() {
-    return this.hctsByTemp[this.hctsByTemp.length - 1];
-  }
-  get coldest() {
-    return this.hctsByTemp[0];
-  }
-  /**
-   * A set of colors with differing hues, equidistant in temperature.
-   *
-   * In art, this is usually described as a set of 5 colors on a color wheel
-   * divided into 12 sections. This method allows provision of either of those
-   * values.
-   *
-   * Behavior is undefined when [count] or [divisions] is 0.
-   * When divisions < count, colors repeat.
-   *
-   * [count] The number of colors to return, includes the input color.
-   * [divisions] The number of divisions on the color wheel.
-   */
-  analogous(count = 5, divisions = 12) {
-    const startHue = Math.round(this.input.hue);
-    const startHct = this.hctsByHue[startHue];
-    let lastTemp = this.relativeTemperature(startHct);
-    const allColors = [startHct];
-    let absoluteTotalTempDelta = 0;
-    for (let i = 0; i < 360; i++) {
-      const hue3 = sanitizeDegreesInt(startHue + i);
-      const hct = this.hctsByHue[hue3];
-      const temp = this.relativeTemperature(hct);
-      const tempDelta = Math.abs(temp - lastTemp);
-      lastTemp = temp;
-      absoluteTotalTempDelta += tempDelta;
-    }
-    let hueAddend = 1;
-    const tempStep = absoluteTotalTempDelta / divisions;
-    let totalTempDelta = 0;
-    lastTemp = this.relativeTemperature(startHct);
-    while (allColors.length < divisions) {
-      const hue3 = sanitizeDegreesInt(startHue + hueAddend);
-      const hct = this.hctsByHue[hue3];
-      const temp = this.relativeTemperature(hct);
-      const tempDelta = Math.abs(temp - lastTemp);
-      totalTempDelta += tempDelta;
-      const desiredTotalTempDeltaForIndex = allColors.length * tempStep;
-      let indexSatisfied = totalTempDelta >= desiredTotalTempDeltaForIndex;
-      let indexAddend = 1;
-      while (indexSatisfied && allColors.length < divisions) {
-        allColors.push(hct);
-        const desiredTotalTempDeltaForIndex2 = (allColors.length + indexAddend) * tempStep;
-        indexSatisfied = totalTempDelta >= desiredTotalTempDeltaForIndex2;
-        indexAddend++;
-      }
-      lastTemp = temp;
-      hueAddend++;
-      if (hueAddend > 360) {
-        while (allColors.length < divisions) {
-          allColors.push(hct);
-        }
-        break;
-      }
-    }
-    const answers = [this.input];
-    const increaseHueCount = Math.floor((count - 1) / 2);
-    for (let i = 1; i < increaseHueCount + 1; i++) {
-      let index = 0 - i;
-      while (index < 0) {
-        index = allColors.length + index;
-      }
-      if (index >= allColors.length) {
-        index = index % allColors.length;
-      }
-      answers.splice(0, 0, allColors[index]);
-    }
-    const decreaseHueCount = count - increaseHueCount - 1;
-    for (let i = 1; i < decreaseHueCount + 1; i++) {
-      let index = i;
-      while (index < 0) {
-        index = allColors.length + index;
-      }
-      if (index >= allColors.length) {
-        index = index % allColors.length;
-      }
-      answers.push(allColors[index]);
-    }
-    return answers;
-  }
-  /**
-   * A color that complements the input color aesthetically.
-   *
-   * In art, this is usually described as being across the color wheel.
-   * History of this shows intent as a color that is just as cool-warm as the
-   * input color is warm-cool.
-   */
-  get complement() {
-    if (this.complementCache != null) {
-      return this.complementCache;
-    }
-    const coldestHue = this.coldest.hue;
-    const coldestTemp = this.tempsByHct.get(this.coldest);
-    const warmestHue = this.warmest.hue;
-    const warmestTemp = this.tempsByHct.get(this.warmest);
-    const range = warmestTemp - coldestTemp;
-    const startHueIsColdestToWarmest = _TemperatureCache.isBetween(this.input.hue, coldestHue, warmestHue);
-    const startHue = startHueIsColdestToWarmest ? warmestHue : coldestHue;
-    const endHue = startHueIsColdestToWarmest ? coldestHue : warmestHue;
-    const directionOfRotation = 1;
-    let smallestError = 1e3;
-    let answer = this.hctsByHue[Math.round(this.input.hue)];
-    const complementRelativeTemp = 1 - this.inputRelativeTemperature;
-    for (let hueAddend = 0; hueAddend <= 360; hueAddend += 1) {
-      const hue3 = sanitizeDegreesDouble(startHue + directionOfRotation * hueAddend);
-      if (!_TemperatureCache.isBetween(hue3, startHue, endHue)) {
-        continue;
-      }
-      const possibleAnswer = this.hctsByHue[Math.round(hue3)];
-      const relativeTemp = (this.tempsByHct.get(possibleAnswer) - coldestTemp) / range;
-      const error = Math.abs(complementRelativeTemp - relativeTemp);
-      if (error < smallestError) {
-        smallestError = error;
-        answer = possibleAnswer;
-      }
-    }
-    this.complementCache = answer;
-    return this.complementCache;
-  }
-  /**
-   * Temperature relative to all colors with the same chroma and tone.
-   * Value on a scale from 0 to 1.
-   */
-  relativeTemperature(hct) {
-    const range = this.tempsByHct.get(this.warmest) - this.tempsByHct.get(this.coldest);
-    const differenceFromColdest = this.tempsByHct.get(hct) - this.tempsByHct.get(this.coldest);
-    if (range === 0) {
-      return 0.5;
-    }
-    return differenceFromColdest / range;
-  }
-  /** Relative temperature of the input color. See [relativeTemperature]. */
-  get inputRelativeTemperature() {
-    if (this.inputRelativeTemperatureCache >= 0) {
-      return this.inputRelativeTemperatureCache;
-    }
-    this.inputRelativeTemperatureCache = this.relativeTemperature(this.input);
-    return this.inputRelativeTemperatureCache;
-  }
-  /** A Map with keys of HCTs in [hctsByTemp], values of raw temperature. */
-  get tempsByHct() {
-    if (this.tempsByHctCache.size > 0) {
-      return this.tempsByHctCache;
-    }
-    const allHcts = this.hctsByHue.concat([this.input]);
-    const temperaturesByHct = /* @__PURE__ */ new Map();
-    for (const e4 of allHcts) {
-      temperaturesByHct.set(e4, _TemperatureCache.rawTemperature(e4));
-    }
-    this.tempsByHctCache = temperaturesByHct;
-    return temperaturesByHct;
-  }
-  /**
-   * HCTs for all hues, with the same chroma/tone as the input.
-   * Sorted ascending, hue 0 to 360.
-   */
-  get hctsByHue() {
-    if (this.hctsByHueCache.length > 0) {
-      return this.hctsByHueCache;
-    }
-    const hcts = [];
-    for (let hue3 = 0; hue3 <= 360; hue3 += 1) {
-      const colorAtHue = Hct.from(hue3, this.input.chroma, this.input.tone);
-      hcts.push(colorAtHue);
-    }
-    this.hctsByHueCache = hcts;
-    return this.hctsByHueCache;
-  }
-  /** Determines if an angle is between two other angles, rotating clockwise. */
-  static isBetween(angle, a, b) {
-    if (a < b) {
-      return a <= angle && angle <= b;
-    }
-    return a <= angle || angle <= b;
-  }
-  /**
-   * Value representing cool-warm factor of a color.
-   * Values below 0 are considered cool, above, warm.
-   *
-   * Color science has researched emotion and harmony, which art uses to select
-   * colors. Warm-cool is the foundation of analogous and complementary colors.
-   * See:
-   * - Li-Chen Ou's Chapter 19 in Handbook of Color Psychology (2015).
-   * - Josef Albers' Interaction of Color chapters 19 and 21.
-   *
-   * Implementation of Ou, Woodcock and Wright's algorithm, which uses
-   * L*a*b* / LCH color space.
-   * Return value has these properties:
-   * - Values below 0 are cool, above 0 are warm.
-   * - Lower bound: -0.52 - (chroma ^ 1.07 / 20). L*a*b* chroma is infinite.
-   *   Assuming max of 130 chroma, -9.66.
-   * - Upper bound: -0.52 + (chroma ^ 1.07 / 20). L*a*b* chroma is infinite.
-   *   Assuming max of 130 chroma, 8.61.
-   */
-  static rawTemperature(color) {
-    const lab2 = labFromArgb(color.toInt());
-    const hue3 = sanitizeDegreesDouble(Math.atan2(lab2[2], lab2[1]) * 180 / Math.PI);
-    const chroma = Math.sqrt(lab2[1] * lab2[1] + lab2[2] * lab2[2]);
-    const temperature = -0.5 + 0.02 * Math.pow(chroma, 1.07) * Math.cos(sanitizeDegreesDouble(hue3 - 50) * Math.PI / 180);
-    return temperature;
-  }
-};
-
-// ../../node_modules/.pnpm/@material+material-color-utilities@0.3.0/node_modules/@material/material-color-utilities/scheme/scheme_content.js
-var SchemeContent = class extends DynamicScheme {
-  constructor(sourceColorHct, isDark, contrastLevel) {
-    super({
-      sourceColorArgb: sourceColorHct.toInt(),
-      variant: Variant.CONTENT,
-      contrastLevel,
-      isDark,
-      primaryPalette: TonalPalette.fromHueAndChroma(sourceColorHct.hue, sourceColorHct.chroma),
-      secondaryPalette: TonalPalette.fromHueAndChroma(sourceColorHct.hue, Math.max(sourceColorHct.chroma - 32, sourceColorHct.chroma * 0.5)),
-      tertiaryPalette: TonalPalette.fromInt(DislikeAnalyzer.fixIfDisliked(new TemperatureCache(sourceColorHct).analogous(3, 6)[2]).toInt()),
-      neutralPalette: TonalPalette.fromHueAndChroma(sourceColorHct.hue, sourceColorHct.chroma / 8),
-      neutralVariantPalette: TonalPalette.fromHueAndChroma(sourceColorHct.hue, sourceColorHct.chroma / 8 + 4)
-    });
-  }
-};
-
 // ../../node_modules/.pnpm/@material+material-color-utilities@0.3.0/node_modules/@material/material-color-utilities/scheme/scheme_expressive.js
 var SchemeExpressive = class _SchemeExpressive extends DynamicScheme {
   constructor(sourceColorHct, isDark, contrastLevel) {
@@ -3219,6 +2616,23 @@ SchemeExpressive.tertiaryRotations = [
   120
 ];
 
+// ../../node_modules/.pnpm/@material+material-color-utilities@0.3.0/node_modules/@material/material-color-utilities/scheme/scheme_tonal_spot.js
+var SchemeTonalSpot = class extends DynamicScheme {
+  constructor(sourceColorHct, isDark, contrastLevel) {
+    super({
+      sourceColorArgb: sourceColorHct.toInt(),
+      variant: Variant.TONAL_SPOT,
+      contrastLevel,
+      isDark,
+      primaryPalette: TonalPalette.fromHueAndChroma(sourceColorHct.hue, 36),
+      secondaryPalette: TonalPalette.fromHueAndChroma(sourceColorHct.hue, 16),
+      tertiaryPalette: TonalPalette.fromHueAndChroma(sanitizeDegreesDouble(sourceColorHct.hue + 60), 24),
+      neutralPalette: TonalPalette.fromHueAndChroma(sourceColorHct.hue, 6),
+      neutralVariantPalette: TonalPalette.fromHueAndChroma(sourceColorHct.hue, 8)
+    });
+  }
+};
+
 // ../../node_modules/.pnpm/@material+material-color-utilities@0.3.0/node_modules/@material/material-color-utilities/scheme/scheme_vibrant.js
 var SchemeVibrant = class _SchemeVibrant extends DynamicScheme {
   constructor(sourceColorHct, isDark, contrastLevel) {
@@ -3410,53 +2824,6 @@ function parseIntHex(value) {
   return parseInt(value, 16);
 }
 
-// ../../node_modules/.pnpm/@material+material-color-utilities@0.3.0/node_modules/@material/material-color-utilities/utils/theme_utils.js
-function themeFromSourceColor(source, customColors = []) {
-  const palette = CorePalette.of(source);
-  return {
-    source,
-    schemes: {
-      light: Scheme.light(source),
-      dark: Scheme.dark(source)
-    },
-    palettes: {
-      primary: palette.a1,
-      secondary: palette.a2,
-      tertiary: palette.a3,
-      neutral: palette.n1,
-      neutralVariant: palette.n2,
-      error: palette.error
-    },
-    customColors: customColors.map((c2) => customColor(source, c2))
-  };
-}
-function customColor(source, color) {
-  let value = color.value;
-  const from = value;
-  const to = source;
-  if (color.blend) {
-    value = Blend.harmonize(from, to);
-  }
-  const palette = CorePalette.of(value);
-  const tones = palette.a1;
-  return {
-    color,
-    value,
-    light: {
-      color: tones.tone(40),
-      onColor: tones.tone(100),
-      colorContainer: tones.tone(90),
-      onColorContainer: tones.tone(10)
-    },
-    dark: {
-      color: tones.tone(80),
-      onColor: tones.tone(20),
-      colorContainer: tones.tone(30),
-      onColorContainer: tones.tone(90)
-    }
-  };
-}
-
 // ../../node_modules/.pnpm/culori@4.0.2/node_modules/culori/src/rgb/parseNumber.js
 var parseNumber = (color, len) => {
   if (typeof color !== "number") return;
@@ -6902,14 +6269,74 @@ var yiq = useMode(definition_default28);
 
 // tokens.mjs
 var oklch2 = converter_default("oklch");
-var materialColors = {
-  "surface-container-highest": MaterialDynamicColors.surfaceContainerHighest,
-  "surface-container-high": MaterialDynamicColors.surfaceContainerHigh,
-  "surface-dim": MaterialDynamicColors.surfaceDim,
-  "surface-bright": MaterialDynamicColors.surfaceBright,
-  "surface-container-lowest": MaterialDynamicColors.surfaceContainerLowest,
-  "surface-container-low": MaterialDynamicColors.surfaceContainerLow
-};
+var DEFAULT_SOURCE_COLOR = "#1D5D78";
+var HEX_RE = /^#(?:[0-9a-f]{3}|[0-9a-f]{6})$/i;
+var COLOR_ROLES = (
+  /** @type {const} */
+  [
+    "primary",
+    "onPrimary",
+    "primaryContainer",
+    "onPrimaryContainer",
+    "inversePrimary",
+    "primaryFixed",
+    "primaryFixedDim",
+    "onPrimaryFixed",
+    "onPrimaryFixedVariant",
+    "secondary",
+    "onSecondary",
+    "secondaryContainer",
+    "onSecondaryContainer",
+    "secondaryFixed",
+    "secondaryFixedDim",
+    "onSecondaryFixed",
+    "onSecondaryFixedVariant",
+    "tertiary",
+    "onTertiary",
+    "tertiaryContainer",
+    "onTertiaryContainer",
+    "tertiaryFixed",
+    "tertiaryFixedDim",
+    "onTertiaryFixed",
+    "onTertiaryFixedVariant",
+    "error",
+    "onError",
+    "errorContainer",
+    "onErrorContainer",
+    "surface",
+    "onSurface",
+    "surfaceVariant",
+    "onSurfaceVariant",
+    "surfaceDim",
+    "surfaceBright",
+    "surfaceContainerLowest",
+    "surfaceContainerLow",
+    "surfaceContainer",
+    "surfaceContainerHigh",
+    "surfaceContainerHighest",
+    "surfaceTint",
+    "inverseSurface",
+    "inverseOnSurface",
+    "outline",
+    "outlineVariant",
+    "shadow",
+    "scrim",
+    "background",
+    "onBackground"
+  ]
+);
+function resolveConfig({ sourceColor = DEFAULT_SOURCE_COLOR, scheme = "light" } = {}) {
+  if (typeof sourceColor !== "string" || !HEX_RE.test(sourceColor)) {
+    throw new TypeError(`sourceColor must be a hex color like "#6750A4", got ${JSON.stringify(sourceColor)}`);
+  }
+  if (scheme !== "light" && scheme !== "dark") {
+    throw new TypeError(`scheme must be "light" or "dark", got ${JSON.stringify(scheme)}`);
+  }
+  return { sourceColor, scheme: (
+    /** @type {ColorScheme} */
+    scheme
+  ) };
+}
 function setSchemeProperties(scheme, suffix = "") {
   let result = {};
   for (const [key, value] of Object.entries(scheme)) {
@@ -6922,25 +6349,23 @@ function setSchemeProperties(scheme, suffix = "") {
   }
   return result;
 }
-function generateTokens(config = { scheme: "light", sourceColor: "#1D5D78" }) {
-  const theme = themeFromSourceColor(argbFromHex(config.sourceColor), []);
-  const scheme = new SchemeContent(
-    Hct.fromInt(argbFromHex(config.sourceColor)),
-    config.scheme === "dark",
+function generateTokens(config = {}) {
+  const { sourceColor, scheme } = resolveConfig(config);
+  const dynamicScheme = new SchemeTonalSpot(
+    Hct.fromInt(argbFromHex(sourceColor)),
+    scheme === "dark",
     0
   );
   let palette = {};
-  for (const [key, value] of Object.entries(materialColors)) {
-    palette[key] = value.getArgb(scheme);
+  for (const role of COLOR_ROLES) {
+    palette[role] = MaterialDynamicColors[role].getArgb(dynamicScheme);
   }
-  const currentTheme = theme.schemes[config.scheme].toJSON();
-  const tokens = setSchemeProperties({ ...currentTheme, ...palette });
-  return tokens;
+  return setSchemeProperties(palette);
 }
 
 // client.mjs
-function generateTheme({ sourceColor, scheme = "light" } = {}) {
-  const tokens = generateTokens({ sourceColor, scheme });
+function generateTheme(options = {}) {
+  const tokens = generateTokens(options);
   const root = document.documentElement;
   for (const [variable, value] of Object.entries(tokens)) {
     root.style.setProperty(variable, value);