@windmorph/react 0.0.0-stage → 0.1.0

package/dist/utils/warn-once.js

@@ -0,0 +1,30 @@
+import { useEffect, useRef } from "react";
+//#region src/utils/warn-once.ts
+const warnedKeys = /* @__PURE__ */ new Set();
+/**
+* Logs a development warning the first time a key is seen, and never again for that key in
+* the page's lifetime. Silent in production. For code that has no component instance to
+* remember the warning, such as a collection builder.
+*/
+function warnOnce(key, ...message) {
+	if (process.env.NODE_ENV === "production" || warnedKeys.has(key)) return;
+	warnedKeys.add(key);
+	console.warn(...message);
+}
+/**
+* Logs a development warning once per component instance, the first time `condition` holds
+* after a render, however often it flips back and forth afterwards. Silent in production.
+* `message` is read when it warns, so it can describe the render that triggered it.
+*/
+function useWarnOnce(condition, ...message) {
+	const warned = useRef(false);
+	useEffect(() => {
+		if (process.env.NODE_ENV === "production" || !condition || warned.current) return;
+		warned.current = true;
+		console.warn(...message);
+	});
+}
+//#endregion
+export { useWarnOnce, warnOnce };
+
+//# sourceMappingURL=warn-once.js.map

package/dist/utils/warn-once.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"warn-once.js","names":[],"sources":["../../src/utils/warn-once.ts"],"sourcesContent":["import { useEffect, useRef } from 'react';\n\nconst warnedKeys = new Set<string>();\n\n/**\n * Logs a development warning the first time a key is seen, and never again for that key in\n * the page's lifetime. Silent in production. For code that has no component instance to\n * remember the warning, such as a collection builder.\n */\nexport function warnOnce(key: string, ...message: unknown[]): void {\n  if (process.env.NODE_ENV === 'production' || warnedKeys.has(key)) return;\n  warnedKeys.add(key);\n  console.warn(...message);\n}\n\n/**\n * Logs a development warning once per component instance, the first time `condition` holds\n * after a render, however often it flips back and forth afterwards. Silent in production.\n * `message` is read when it warns, so it can describe the render that triggered it.\n */\nexport function useWarnOnce(condition: boolean, ...message: unknown[]): void {\n  const warned = useRef(false);\n  // No dependency list: the check is cheap, and it reads the render's own message.\n  useEffect(() => {\n    if (process.env.NODE_ENV === 'production' || !condition || warned.current) return;\n    warned.current = true;\n    console.warn(...message);\n  });\n}\n"],"mappings":";;AAEA,MAAM,6BAAa,IAAI,IAAY;;;;;;AAOnC,SAAgB,SAAS,KAAa,GAAG,SAA0B;CACjE,IAAI,QAAQ,IAAI,aAAa,gBAAgB,WAAW,IAAI,GAAG,GAAG;CAClE,WAAW,IAAI,GAAG;CAClB,QAAQ,KAAK,GAAG,OAAO;AACzB;;;;;;AAOA,SAAgB,YAAY,WAAoB,GAAG,SAA0B;CAC3E,MAAM,SAAS,OAAO,KAAK;CAE3B,gBAAgB;EACd,IAAI,QAAQ,IAAI,aAAa,gBAAgB,CAAC,aAAa,OAAO,SAAS;EAC3E,OAAO,UAAU;EACjB,QAAQ,KAAK,GAAG,OAAO;CACzB,CAAC;AACH"}

package/dist/vendor/material-color-utilities/blend/blend.js

@@ -0,0 +1,88 @@
+import { differenceDegrees, rotationDirection, sanitizeDegreesDouble } from "../utils/math_utils.js";
+import { lstarFromArgb } from "../utils/color_utils.js";
+import { Cam16 } from "../hct/cam16.js";
+import { Hct } from "../hct/hct.js";
+//#region ../../node_modules/.pnpm/@material+material-color-utilities@0.4.0/node_modules/@material/material-color-utilities/blend/blend.js
+/**
+* @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.
+*/
+/**
+* Functions for blending in HCT and CAM16.
+*/
+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 differenceDegrees$1 = differenceDegrees(fromHct.hue, toHct.hue);
+		const rotationDegrees = Math.min(differenceDegrees$1 * .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);
+		return Hct.from(ucsCam.hue, fromCam.chroma, lstarFromArgb(from)).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();
+	}
+};
+//#endregion
+export { Blend };
+
+//# sourceMappingURL=blend.js.map

package/dist/vendor/material-color-utilities/blend/blend.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"blend.js","names":["differenceDegrees","mathUtils.differenceDegrees","mathUtils.sanitizeDegreesDouble","mathUtils.rotationDirection","colorUtils.lstarFromArgb"],"sources":["../../../../../../node_modules/.pnpm/@material+material-color-utilities@0.4.0/node_modules/@material/material-color-utilities/blend/blend.js"],"sourcesContent":["/**\n * @license\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n// This file is automatically generated. Do not modify it.\nimport { Cam16 } from '../hct/cam16.js';\nimport { Hct } from '../hct/hct.js';\nimport * as colorUtils from '../utils/color_utils.js';\nimport * as mathUtils from '../utils/math_utils.js';\n// material_color_utilities is designed to have a consistent API across\n// platforms and modular components that can be moved around easily. Using a\n// class as a namespace facilitates this.\n//\n// tslint:disable:class-as-namespace\n/**\n * Functions for blending in HCT and CAM16.\n */\nexport class Blend {\n    /**\n     * Blend the design color's HCT hue towards the key color's HCT\n     * hue, in a way that leaves the original color recognizable and\n     * recognizably shifted towards the key color.\n     *\n     * @param designColor ARGB representation of an arbitrary color.\n     * @param sourceColor ARGB representation of the main theme color.\n     * @return The design color with a hue shifted towards the\n     * system's color, a slightly warmer/cooler variant of the design\n     * color's hue.\n     */\n    static harmonize(designColor, sourceColor) {\n        const fromHct = Hct.fromInt(designColor);\n        const toHct = Hct.fromInt(sourceColor);\n        const differenceDegrees = mathUtils.differenceDegrees(fromHct.hue, toHct.hue);\n        const rotationDegrees = Math.min(differenceDegrees * 0.5, 15.0);\n        const outputHue = mathUtils.sanitizeDegreesDouble(fromHct.hue +\n            rotationDegrees * mathUtils.rotationDirection(fromHct.hue, toHct.hue));\n        return Hct.from(outputHue, fromHct.chroma, fromHct.tone).toInt();\n    }\n    /**\n     * Blends hue from one color into another. The chroma and tone of\n     * the original color are maintained.\n     *\n     * @param from ARGB representation of color\n     * @param to ARGB representation of color\n     * @param amount how much blending to perform; 0.0 >= and <= 1.0\n     * @return from, with a hue blended towards to. Chroma and tone\n     * are constant.\n     */\n    static hctHue(from, to, amount) {\n        const ucs = Blend.cam16Ucs(from, to, amount);\n        const ucsCam = Cam16.fromInt(ucs);\n        const fromCam = Cam16.fromInt(from);\n        const blended = Hct.from(ucsCam.hue, fromCam.chroma, colorUtils.lstarFromArgb(from));\n        return blended.toInt();\n    }\n    /**\n     * Blend in CAM16-UCS space.\n     *\n     * @param from ARGB representation of color\n     * @param to ARGB representation of color\n     * @param amount how much blending to perform; 0.0 >= and <= 1.0\n     * @return from, blended towards to. Hue, chroma, and tone will\n     * change.\n     */\n    static cam16Ucs(from, to, amount) {\n        const fromCam = Cam16.fromInt(from);\n        const toCam = Cam16.fromInt(to);\n        const fromJ = fromCam.jstar;\n        const fromA = fromCam.astar;\n        const fromB = fromCam.bstar;\n        const toJ = toCam.jstar;\n        const toA = toCam.astar;\n        const toB = toCam.bstar;\n        const jstar = fromJ + (toJ - fromJ) * amount;\n        const astar = fromA + (toA - fromA) * amount;\n        const bstar = fromB + (toB - fromB) * amount;\n        return Cam16.fromUcs(jstar, astar, bstar).toInt();\n    }\n}\n//# sourceMappingURL=blend.js.map"],"ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AA6BA,IAAa,QAAb,MAAa,MAAM;;;;;;;;;;;;CAYf,OAAO,UAAU,aAAa,aAAa;EACvC,MAAM,UAAU,IAAI,QAAQ,WAAW;EACvC,MAAM,QAAQ,IAAI,QAAQ,WAAW;EACrC,MAAMA,sBAAoBC,kBAA4B,QAAQ,KAAK,MAAM,GAAG;EAC5E,MAAM,kBAAkB,KAAK,IAAID,sBAAoB,IAAK,EAAI;EAC9D,MAAM,YAAYE,sBAAgC,QAAQ,MACtD,kBAAkBC,kBAA4B,QAAQ,KAAK,MAAM,GAAG,CAAC;EACzE,OAAO,IAAI,KAAK,WAAW,QAAQ,QAAQ,QAAQ,IAAI,CAAC,CAAC,MAAM;CACnE;;;;;;;;;;;CAWA,OAAO,OAAO,MAAM,IAAI,QAAQ;EAC5B,MAAM,MAAM,MAAM,SAAS,MAAM,IAAI,MAAM;EAC3C,MAAM,SAAS,MAAM,QAAQ,GAAG;EAChC,MAAM,UAAU,MAAM,QAAQ,IAAI;EAElC,OADgB,IAAI,KAAK,OAAO,KAAK,QAAQ,QAAQC,cAAyB,IAAI,CACrE,CAAC,CAAC,MAAM;CACzB;;;;;;;;;;CAUA,OAAO,SAAS,MAAM,IAAI,QAAQ;EAC9B,MAAM,UAAU,MAAM,QAAQ,IAAI;EAClC,MAAM,QAAQ,MAAM,QAAQ,EAAE;EAC9B,MAAM,QAAQ,QAAQ;EACtB,MAAM,QAAQ,QAAQ;EACtB,MAAM,QAAQ,QAAQ;EACtB,MAAM,MAAM,MAAM;EAClB,MAAM,MAAM,MAAM;EAClB,MAAM,MAAM,MAAM;EAClB,MAAM,QAAQ,SAAS,MAAM,SAAS;EACtC,MAAM,QAAQ,SAAS,MAAM,SAAS;EACtC,MAAM,QAAQ,SAAS,MAAM,SAAS;EACtC,OAAO,MAAM,QAAQ,OAAO,OAAO,KAAK,CAAC,CAAC,MAAM;CACpD;AACJ"}

package/dist/vendor/material-color-utilities/contrast/contrast.js

@@ -0,0 +1,131 @@
+import { clampDouble } from "../utils/math_utils.js";
+import { lstarFromY, yFromLstar } from "../utils/color_utils.js";
+//#region ../../node_modules/.pnpm/@material+material-color-utilities@0.4.0/node_modules/@material/material-color-utilities/contrast/contrast.js
+/**
+* @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.
+*/
+/**
+* Utility methods for calculating contrast given two colors, or calculating a
+* color given one color and a contrast ratio.
+*
+* Contrast ratio is calculated using XYZ's Y. When linearized to match human
+* perception, Y becomes HCT's tone and L*a*b*'s' L*. Informally, this is the
+* lightness of a color.
+*
+* Methods refer to tone, T in the the HCT color space.
+* Tone is equivalent to L* in the L*a*b* color space, or L in the LCH color
+* space.
+*/
+var Contrast = class Contrast {
+	/**
+	* 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(toneA, toneB) {
+		toneA = clampDouble(0, 100, toneA);
+		toneB = clampDouble(0, 100, toneB);
+		return Contrast.ratioOfYs(yFromLstar(toneA), yFromLstar(toneB));
+	}
+	static ratioOfYs(y1, y2) {
+		const lighter = y1 > y2 ? y1 : y2;
+		const darker = lighter === y2 ? y1 : y2;
+		return (lighter + 5) / (darker + 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(tone, ratio) {
+		if (tone < 0 || tone > 100) return -1;
+		const darkY = yFromLstar(tone);
+		const lightY = ratio * (darkY + 5) - 5;
+		const realContrast = Contrast.ratioOfYs(lightY, darkY);
+		const delta = Math.abs(realContrast - ratio);
+		if (realContrast < ratio && delta > .04) return -1;
+		const returnValue = lstarFromY(lightY) + .4;
+		if (returnValue < 0 || returnValue > 100) return -1;
+		return returnValue;
+	}
+	/**
+	* 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(tone, ratio) {
+		if (tone < 0 || tone > 100) return -1;
+		const lightY = yFromLstar(tone);
+		const darkY = (lightY + 5) / ratio - 5;
+		const realContrast = Contrast.ratioOfYs(lightY, darkY);
+		const delta = Math.abs(realContrast - ratio);
+		if (realContrast < ratio && delta > .04) return -1;
+		const returnValue = lstarFromY(darkY) - .4;
+		if (returnValue < 0 || returnValue > 100) return -1;
+		return returnValue;
+	}
+	/**
+	* 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(tone, ratio) {
+		const lighterSafe = Contrast.lighter(tone, ratio);
+		return lighterSafe < 0 ? 100 : lighterSafe;
+	}
+	/**
+	* 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(tone, ratio) {
+		const darkerSafe = Contrast.darker(tone, ratio);
+		return darkerSafe < 0 ? 0 : darkerSafe;
+	}
+};
+//#endregion
+export { Contrast };
+
+//# sourceMappingURL=contrast.js.map

package/dist/vendor/material-color-utilities/contrast/contrast.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contrast.js","names":["math.clampDouble","utils.yFromLstar","utils.lstarFromY"],"sources":["../../../../../../node_modules/.pnpm/@material+material-color-utilities@0.4.0/node_modules/@material/material-color-utilities/contrast/contrast.js"],"sourcesContent":["/**\n * @license\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n// material_color_utilities is designed to have a consistent API across\n// platforms and modular components that can be moved around easily. Using a\n// class as a namespace facilitates this.\n//\n// tslint:disable:class-as-namespace\nimport * as utils from '../utils/color_utils.js';\nimport * as math from '../utils/math_utils.js';\n/**\n * Utility methods for calculating contrast given two colors, or calculating a\n * color given one color and a contrast ratio.\n *\n * Contrast ratio is calculated using XYZ's Y. When linearized to match human\n * perception, Y becomes HCT's tone and L*a*b*'s' L*. Informally, this is the\n * lightness of a color.\n *\n * Methods refer to tone, T in the the HCT color space.\n * Tone is equivalent to L* in the L*a*b* color space, or L in the LCH color\n * space.\n */\nexport class Contrast {\n    /**\n     * Returns a contrast ratio, which ranges from 1 to 21.\n     *\n     * @param toneA Tone between 0 and 100. Values outside will be clamped.\n     * @param toneB Tone between 0 and 100. Values outside will be clamped.\n     */\n    static ratioOfTones(toneA, toneB) {\n        toneA = math.clampDouble(0.0, 100.0, toneA);\n        toneB = math.clampDouble(0.0, 100.0, toneB);\n        return Contrast.ratioOfYs(utils.yFromLstar(toneA), utils.yFromLstar(toneB));\n    }\n    static ratioOfYs(y1, y2) {\n        const lighter = y1 > y2 ? y1 : y2;\n        const darker = (lighter === y2) ? y1 : y2;\n        return (lighter + 5.0) / (darker + 5.0);\n    }\n    /**\n     * Returns a tone >= tone parameter that ensures ratio parameter.\n     * Return value is between 0 and 100.\n     * Returns -1 if ratio cannot be achieved with tone parameter.\n     *\n     * @param tone Tone return value must contrast with.\n     * Range is 0 to 100. Invalid values will result in -1 being returned.\n     * @param ratio Contrast ratio of return value and tone.\n     * Range is 1 to 21, invalid values have undefined behavior.\n     */\n    static lighter(tone, ratio) {\n        if (tone < 0.0 || tone > 100.0) {\n            return -1.0;\n        }\n        const darkY = utils.yFromLstar(tone);\n        const lightY = ratio * (darkY + 5.0) - 5.0;\n        const realContrast = Contrast.ratioOfYs(lightY, darkY);\n        const delta = Math.abs(realContrast - ratio);\n        if (realContrast < ratio && delta > 0.04) {\n            return -1;\n        }\n        // Ensure gamut mapping, which requires a 'range' on tone, will still result\n        // the correct ratio by darkening slightly.\n        const returnValue = utils.lstarFromY(lightY) + 0.4;\n        if (returnValue < 0 || returnValue > 100) {\n            return -1;\n        }\n        return returnValue;\n    }\n    /**\n     * Returns a tone <= tone parameter that ensures ratio parameter.\n     * Return value is between 0 and 100.\n     * Returns -1 if ratio cannot be achieved with tone parameter.\n     *\n     * @param tone Tone return value must contrast with.\n     * Range is 0 to 100. Invalid values will result in -1 being returned.\n     * @param ratio Contrast ratio of return value and tone.\n     * Range is 1 to 21, invalid values have undefined behavior.\n     */\n    static darker(tone, ratio) {\n        if (tone < 0.0 || tone > 100.0) {\n            return -1.0;\n        }\n        const lightY = utils.yFromLstar(tone);\n        const darkY = ((lightY + 5.0) / ratio) - 5.0;\n        const realContrast = Contrast.ratioOfYs(lightY, darkY);\n        const delta = Math.abs(realContrast - ratio);\n        if (realContrast < ratio && delta > 0.04) {\n            return -1;\n        }\n        // Ensure gamut mapping, which requires a 'range' on tone, will still result\n        // the correct ratio by darkening slightly.\n        const returnValue = utils.lstarFromY(darkY) - 0.4;\n        if (returnValue < 0 || returnValue > 100) {\n            return -1;\n        }\n        return returnValue;\n    }\n    /**\n     * Returns a tone >= tone parameter that ensures ratio parameter.\n     * Return value is between 0 and 100.\n     * Returns 100 if ratio cannot be achieved with tone parameter.\n     *\n     * This method is unsafe because the returned value is guaranteed to be in\n     * bounds for tone, i.e. between 0 and 100. However, that value may not reach\n     * the ratio with tone. For example, there is no color lighter than T100.\n     *\n     * @param tone Tone return value must contrast with.\n     * Range is 0 to 100. Invalid values will result in 100 being returned.\n     * @param ratio Desired contrast ratio of return value and tone parameter.\n     * Range is 1 to 21, invalid values have undefined behavior.\n     */\n    static lighterUnsafe(tone, ratio) {\n        const lighterSafe = Contrast.lighter(tone, ratio);\n        return (lighterSafe < 0.0) ? 100.0 : lighterSafe;\n    }\n    /**\n     * Returns a tone >= tone parameter that ensures ratio parameter.\n     * Return value is between 0 and 100.\n     * Returns 100 if ratio cannot be achieved with tone parameter.\n     *\n     * This method is unsafe because the returned value is guaranteed to be in\n     * bounds for tone, i.e. between 0 and 100. However, that value may not reach\n     * the [ratio with [tone]. For example, there is no color darker than T0.\n     *\n     * @param tone Tone return value must contrast with.\n     * Range is 0 to 100. Invalid values will result in 0 being returned.\n     * @param ratio Desired contrast ratio of return value and tone parameter.\n     * Range is 1 to 21, invalid values have undefined behavior.\n     */\n    static darkerUnsafe(tone, ratio) {\n        const darkerSafe = Contrast.darker(tone, ratio);\n        return (darkerSafe < 0.0) ? 0.0 : darkerSafe;\n    }\n}\n//# sourceMappingURL=contrast.js.map"],"ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,IAAa,WAAb,MAAa,SAAS;;;;;;;CAOlB,OAAO,aAAa,OAAO,OAAO;EAC9B,QAAQA,YAAiB,GAAK,KAAO,KAAK;EAC1C,QAAQA,YAAiB,GAAK,KAAO,KAAK;EAC1C,OAAO,SAAS,UAAUC,WAAiB,KAAK,GAAGA,WAAiB,KAAK,CAAC;CAC9E;CACA,OAAO,UAAU,IAAI,IAAI;EACrB,MAAM,UAAU,KAAK,KAAK,KAAK;EAC/B,MAAM,SAAU,YAAY,KAAM,KAAK;EACvC,QAAQ,UAAU,MAAQ,SAAS;CACvC;;;;;;;;;;;CAWA,OAAO,QAAQ,MAAM,OAAO;EACxB,IAAI,OAAO,KAAO,OAAO,KACrB,OAAO;EAEX,MAAM,QAAQA,WAAiB,IAAI;EACnC,MAAM,SAAS,SAAS,QAAQ,KAAO;EACvC,MAAM,eAAe,SAAS,UAAU,QAAQ,KAAK;EACrD,MAAM,QAAQ,KAAK,IAAI,eAAe,KAAK;EAC3C,IAAI,eAAe,SAAS,QAAQ,KAChC,OAAO;EAIX,MAAM,cAAcC,WAAiB,MAAM,IAAI;EAC/C,IAAI,cAAc,KAAK,cAAc,KACjC,OAAO;EAEX,OAAO;CACX;;;;;;;;;;;CAWA,OAAO,OAAO,MAAM,OAAO;EACvB,IAAI,OAAO,KAAO,OAAO,KACrB,OAAO;EAEX,MAAM,SAASD,WAAiB,IAAI;EACpC,MAAM,SAAU,SAAS,KAAO,QAAS;EACzC,MAAM,eAAe,SAAS,UAAU,QAAQ,KAAK;EACrD,MAAM,QAAQ,KAAK,IAAI,eAAe,KAAK;EAC3C,IAAI,eAAe,SAAS,QAAQ,KAChC,OAAO;EAIX,MAAM,cAAcC,WAAiB,KAAK,IAAI;EAC9C,IAAI,cAAc,KAAK,cAAc,KACjC,OAAO;EAEX,OAAO;CACX;;;;;;;;;;;;;;;CAeA,OAAO,cAAc,MAAM,OAAO;EAC9B,MAAM,cAAc,SAAS,QAAQ,MAAM,KAAK;EAChD,OAAQ,cAAc,IAAO,MAAQ;CACzC;;;;;;;;;;;;;;;CAeA,OAAO,aAAa,MAAM,OAAO;EAC7B,MAAM,aAAa,SAAS,OAAO,MAAM,KAAK;EAC9C,OAAQ,aAAa,IAAO,IAAM;CACtC;AACJ"}

package/dist/vendor/material-color-utilities/dislike/dislike_analyzer.js

@@ -0,0 +1,58 @@
+import { Hct } from "../hct/hct.js";
+//#region ../../node_modules/.pnpm/@material+material-color-utilities@0.4.0/node_modules/@material/material-color-utilities/dislike/dislike_analyzer.js
+/**
+* @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.
+*/
+/**
+* Check and/or fix universally disliked colors.
+* Color science studies of color preference indicate universal distaste for
+* dark yellow-greens, and also show this is correlated to distate for
+* biological waste and rotting food.
+*
+* See Palmer and Schloss, 2010 or Schloss and Palmer's Chapter 21 in Handbook
+* of Color Psychology (2015).
+*/
+var DislikeAnalyzer = class DislikeAnalyzer {
+	/**
+	* 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(hct) {
+		const huePasses = Math.round(hct.hue) >= 90 && Math.round(hct.hue) <= 111;
+		const chromaPasses = Math.round(hct.chroma) > 16;
+		const tonePasses = Math.round(hct.tone) < 65;
+		return huePasses && chromaPasses && tonePasses;
+	}
+	/**
+	* 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(hct) {
+		if (DislikeAnalyzer.isDisliked(hct)) return Hct.from(hct.hue, hct.chroma, 70);
+		return hct;
+	}
+};
+//#endregion
+export { DislikeAnalyzer };
+
+//# sourceMappingURL=dislike_analyzer.js.map

package/dist/vendor/material-color-utilities/dislike/dislike_analyzer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dislike_analyzer.js","names":[],"sources":["../../../../../../node_modules/.pnpm/@material+material-color-utilities@0.4.0/node_modules/@material/material-color-utilities/dislike/dislike_analyzer.js"],"sourcesContent":["/**\n * @license\n * Copyright 2023 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *      http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { Hct } from '../hct/hct.js';\n// material_color_utilities is designed to have a consistent API across\n// platforms and modular components that can be moved around easily. Using a\n// class as a namespace facilitates this.\n//\n// tslint:disable:class-as-namespace\n/**\n * Check and/or fix universally disliked colors.\n * Color science studies of color preference indicate universal distaste for\n * dark yellow-greens, and also show this is correlated to distate for\n * biological waste and rotting food.\n *\n * See Palmer and Schloss, 2010 or Schloss and Palmer's Chapter 21 in Handbook\n * of Color Psychology (2015).\n */\nexport class DislikeAnalyzer {\n    /**\n     * Returns true if a color is disliked.\n     *\n     * @param hct A color to be judged.\n     * @return Whether the color is disliked.\n     *\n     * Disliked is defined as a dark yellow-green that is not neutral.\n     */\n    static isDisliked(hct) {\n        const huePasses = Math.round(hct.hue) >= 90.0 && Math.round(hct.hue) <= 111.0;\n        const chromaPasses = Math.round(hct.chroma) > 16.0;\n        const tonePasses = Math.round(hct.tone) < 65.0;\n        return huePasses && chromaPasses && tonePasses;\n    }\n    /**\n     * If a color is disliked, lighten it to make it likable.\n     *\n     * @param hct A color to be judged.\n     * @return A new color if the original color is disliked, or the original\n     *   color if it is acceptable.\n     */\n    static fixIfDisliked(hct) {\n        if (DislikeAnalyzer.isDisliked(hct)) {\n            return Hct.from(hct.hue, hct.chroma, 70.0);\n        }\n        return hct;\n    }\n}\n//# sourceMappingURL=dislike_analyzer.js.map"],"ignoreList":[0],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,IAAa,kBAAb,MAAa,gBAAgB;;;;;;;;;CASzB,OAAO,WAAW,KAAK;EACnB,MAAM,YAAY,KAAK,MAAM,IAAI,GAAG,KAAK,MAAQ,KAAK,MAAM,IAAI,GAAG,KAAK;EACxE,MAAM,eAAe,KAAK,MAAM,IAAI,MAAM,IAAI;EAC9C,MAAM,aAAa,KAAK,MAAM,IAAI,IAAI,IAAI;EAC1C,OAAO,aAAa,gBAAgB;CACxC;;;;;;;;CAQA,OAAO,cAAc,KAAK;EACtB,IAAI,gBAAgB,WAAW,GAAG,GAC9B,OAAO,IAAI,KAAK,IAAI,KAAK,IAAI,QAAQ,EAAI;EAE7C,OAAO;CACX;AACJ"}