@fast-china/utils 2.0.0 → 2.0.2

package/src/base64/index.ts

@@ -1,374 +0,0 @@
-import { encodeUtf8, getTextDecoder } from "../internal/text.js";
-import { secureRandomInt } from "../number/index.js";
-
-const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-
-/** 内部共享解码器支持的两种字符表规则。 */
-type Base64Variant = "standard" | "url";
-
-/**
- * 创建统一的 Base64 输入错误。
- *
- * @param variant - 当前解析的标准 Base64 或 Base64URL 变体。
- * @returns 带有具体变体名称的 `TypeError`。
- */
-const invalidBase64 = (variant: Base64Variant): TypeError => {
-	return new TypeError(`The value is not valid ${variant === "url" ? "Base64URL" : "Base64"}.`);
-};
-
-/**
- * 校验并规范化 Base64 文本。
- *
- * @remarks 标准 Base64 允许 ASCII 空白，Base64URL 不允许；两者最终都会转换为标准字符表和完整填充。
- * @param value - 原始编码文本。
- * @param variant - 需要应用的字符表与空白规则。
- * @returns 使用标准字符表且长度为 4 倍数的文本。
- * @throws `TypeError` 当字符、填充位置或编码长度非法。
- */
-const normalizeBase64 = (value: string, variant: Base64Variant): string => {
-	const withoutWhitespace = variant === "standard" ? value.replace(/[\t\n\f\r ]+/gu, "") : value;
-	const pattern = variant === "url" ? /^[\w-]*={0,2}$/u : /^[A-Za-z\d+/]*={0,2}$/u;
-	if (!pattern.test(withoutWhitespace) || withoutWhitespace.length % 4 === 1) throw invalidBase64(variant);
-	if (withoutWhitespace.includes("=") && withoutWhitespace.length % 4 !== 0) throw invalidBase64(variant);
-
-	const standard = (variant === "url" ? withoutWhitespace.replace(/-/gu, "+").replace(/_/gu, "/") : withoutWhitespace).replace(/=+$/u, "");
-	return standard.padEnd(Math.ceil(standard.length / 4) * 4, "=");
-};
-
-/**
- * 使用固定字符表编码任意字节。
- *
- * @param bytes - 不会被修改的源字节。
- * @returns 带标准 `=` 填充的 Base64 文本。
- */
-const encodeBytes = (bytes: Uint8Array): string => {
-	let result = "";
-	for (let index = 0; index < bytes.length; index += 3) {
-		const first = bytes[index] ?? 0;
-		const second = bytes[index + 1];
-		const third = bytes[index + 2];
-		const bitmap = (first << 16) | ((second ?? 0) << 8) | (third ?? 0);
-		result += alphabet[(bitmap >> 18) & 63] ?? "";
-		result += alphabet[(bitmap >> 12) & 63] ?? "";
-		result += second === undefined ? "=" : (alphabet[(bitmap >> 6) & 63] ?? "");
-		result += third === undefined ? "=" : (alphabet[bitmap & 63] ?? "");
-	}
-	return result;
-};
-
-/**
- * 把 Base64 或 Base64URL 文本解码为字节。
- *
- * @remarks 最后一组未使用位必须为零，以拒绝同一字节序列的非规范编码。
- * @param value - 待解码文本。
- * @param variant - 输入使用的编码变体。
- * @returns 新建的字节数组。
- * @throws `TypeError` 当输入格式或尾部位非法。
- */
-const decodeBytes = (value: string, variant: Base64Variant): Uint8Array => {
-	const normalized = normalizeBase64(value, variant);
-	if (normalized.length === 0) return new Uint8Array();
-
-	const padding = normalized.endsWith("==") ? 2 : normalized.endsWith("=") ? 1 : 0;
-	const result = new Uint8Array((normalized.length / 4) * 3 - padding);
-	let outputIndex = 0;
-
-	for (let index = 0; index < normalized.length; index += 4) {
-		const first = alphabet.indexOf(normalized[index] ?? "");
-		const second = alphabet.indexOf(normalized[index + 1] ?? "");
-		const thirdCharacter = normalized[index + 2] ?? "=";
-		const fourthCharacter = normalized[index + 3] ?? "=";
-		const third = thirdCharacter === "=" ? 0 : alphabet.indexOf(thirdCharacter);
-		const fourth = fourthCharacter === "=" ? 0 : alphabet.indexOf(fourthCharacter);
-		if (first < 0 || second < 0 || third < 0 || fourth < 0) throw invalidBase64(variant);
-
-		const isLast = index + 4 === normalized.length;
-		// 填充字符对应的未使用低位必须为零，否则不同文本可以解码为同一字节序列。
-		if (isLast && ((padding === 2 && (second & 15) !== 0) || (padding === 1 && (third & 3) !== 0))) {
-			throw invalidBase64(variant);
-		}
-
-		const bitmap = (first << 18) | (second << 12) | (third << 6) | fourth;
-		if (outputIndex < result.length) result[outputIndex++] = (bitmap >> 16) & 255;
-		if (outputIndex < result.length) result[outputIndex++] = (bitmap >> 8) & 255;
-		if (outputIndex < result.length) result[outputIndex++] = bitmap & 255;
-	}
-	return result;
-};
-
-/**
- * 以 Fatal 模式解码 UTF-8。
- *
- * @param bytes - 待解码字节。
- * @returns 解码后的 JavaScript 字符串。
- * @throws `TypeError` 当字节不是有效 UTF-8；原始平台异常保存在 `cause` 中。
- */
-const decodeUtf8 = (bytes: Uint8Array): string => {
-	const textDecoder = getTextDecoder();
-	try {
-		return textDecoder.decode(bytes);
-	} catch (cause) {
-		throw new TypeError("The decoded bytes are not valid UTF-8.", { cause });
-	}
-};
-
-/**
- * 将任意字节编码为标准 Base64。
- *
- * @param bytes - 不会被修改的字节序列。
- * @returns 带标准 `=` 填充的 Base64 文本。
- */
-export function encodeBase64Bytes(bytes: Uint8Array): string {
-	return encodeBytes(bytes);
-}
-
-/**
- * 解码标准 Base64。
- *
- * @remarks 允许省略填充和包含 ASCII 空白，但拒绝非规范尾部位。
- * @param value - Base64 文本。
- * @returns 新建的字节数组。
- * @throws 输入非法时抛出 `TypeError`。
- */
-export function decodeBase64Bytes(value: string): Uint8Array {
-	return decodeBytes(value, "standard");
-}
-
-/**
- * 将 UTF-8 文本编码为标准 Base64。
- *
- * @param value - 任意 Unicode 字符串。
- * @returns 带标准填充的 Base64 文本。
- * @throws 缺少 Encoding API 时抛出 `Error`。
- */
-export function encodeBase64(value: string): string {
-	return encodeBytes(encodeUtf8(value));
-}
-
-/**
- * 将标准 Base64 解码为 UTF-8 文本。
- *
- * @param value - Base64 文本。
- * @returns 解码后的 Unicode 字符串。
- * @throws Base64 或 UTF-8 非法时抛出 `TypeError`；缺少 Encoding API 时抛出 `Error`。
- */
-export function decodeBase64(value: string): string {
-	return decodeUtf8(decodeBase64Bytes(value));
-}
-
-/**
- * 将任意字节编码为无填充 Base64URL。
- *
- * @param bytes - 不会被修改的字节序列。
- * @returns 仅使用 URL 安全字母表的文本。
- */
-export function encodeBase64UrlBytes(bytes: Uint8Array): string {
-	return encodeBytes(bytes).replace(/\+/gu, "-").replace(/\//gu, "_").replace(/=+$/u, "");
-}
-
-/**
- * 解码 Base64URL 字节。
- *
- * @remarks 接受带填充和无填充形式，不接受空白或标准 Base64 的 `+`、`/`。
- * @param value - Base64URL 文本。
- * @returns 新建的字节数组。
- * @throws 输入非法时抛出 `TypeError`。
- */
-export function decodeBase64UrlBytes(value: string): Uint8Array {
-	return decodeBytes(value, "url");
-}
-
-/**
- * 将 UTF-8 文本编码为无填充 Base64URL。
- *
- * @param value - 任意 Unicode 字符串。
- * @returns 仅使用 URL 安全字母表的文本。
- * @throws 缺少 Encoding API 时抛出 `Error`。
- */
-export function encodeBase64Url(value: string): string {
-	return encodeBase64UrlBytes(encodeUtf8(value));
-}
-
-/**
- * 将 Base64URL 解码为 UTF-8 文本。
- *
- * @param value - 带填充或无填充的 Base64URL 文本。
- * @returns 解码后的 Unicode 字符串。
- * @throws Base64URL 或 UTF-8 非法时抛出 `TypeError`；缺少 Encoding API 时抛出 `Error`。
- */
-export function decodeBase64Url(value: string): string {
-	return decodeUtf8(decodeBase64UrlBytes(value));
-}
-
-/**
- * 把 Latin-1 文本编码为标准 Base64。
- *
- * @param value - 每个 UTF-16 码元都必须位于 0–255 的文本。
- * @returns 带标准填充的 Base64 文本。
- * @throws `TypeError` 当文本包含 Latin-1 范围外的码元。
- */
-export function encodeLatin1Base64(value: string): string {
-	const bytes = new Uint8Array(value.length);
-	for (let index = 0; index < value.length; index += 1) {
-		const code = value.charCodeAt(index);
-		if (code > 255) throw new TypeError("The string to be encoded contains characters outside of the Latin-1 range.");
-		bytes[index] = code;
-	}
-	return encodeBase64Bytes(bytes);
-}
-
-/**
- * 把标准 Base64 解码为 Latin-1 文本。
- *
- * @param value - 标准 Base64 文本；允许 ASCII 空白和省略尾部填充。
- * @returns 每个字节直接映射为同值 UTF-16 码元的文本。
- * @throws `TypeError` 当 Base64 格式或尾部位非法。
- */
-export function decodeLatin1Base64(value: string): string {
-	const bytes = decodeBase64Bytes(value);
-	let result = "";
-	for (const byte of bytes) result += String.fromCharCode(byte);
-	return result;
-}
-
-const randomPrefixAlphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
-const defaultRandomPrefixLength = 6;
-
-/** SecureBase64 兼容格式中一组不可变的字符插入位置。 */
-interface Base64PasswordDictionaryEntry {
-	/** 原始载荷中的固定字符索引；超出短载荷长度时忽略当前条目。 */
-	index: number;
-	/** 从原始载荷复制字符的固定索引；数值属于持久化协议，不能重新计算。 */
-	randomIndex: number;
-}
-
-/** 固定 SecureBase64 字典；索引、顺序与映射属于持久化格式，禁止修改。 */
-const base64PasswordDictionary: readonly Readonly<Base64PasswordDictionaryEntry>[] = Object.freeze([
-	{ index: 977, randomIndex: 188 },
-	{ index: 926, randomIndex: 201 },
-	{ index: 851, randomIndex: 225 },
-	{ index: 700, randomIndex: 255 },
-	{ index: 600, randomIndex: 268 },
-	{ index: 500, randomIndex: 277 },
-	{ index: 400, randomIndex: 288 },
-	{ index: 330, randomIndex: 327 },
-	{ index: 300, randomIndex: 180 },
-	{ index: 200, randomIndex: 178 },
-	{ index: 100, randomIndex: 124 },
-	{ index: 98, randomIndex: 95 },
-	{ index: 92, randomIndex: 90 },
-	{ index: 91, randomIndex: 87 },
-	{ index: 88, randomIndex: 84 },
-	{ index: 82, randomIndex: 79 },
-	{ index: 78, randomIndex: 71 },
-	{ index: 72, randomIndex: 69 },
-	{ index: 68, randomIndex: 66 },
-	{ index: 59, randomIndex: 55 },
-	{ index: 48, randomIndex: 43 },
-	{ index: 42, randomIndex: 37 },
-	{ index: 36, randomIndex: 30 },
-	{ index: 33, randomIndex: 27 },
-	{ index: 24, randomIndex: 20 },
-	{ index: 23, randomIndex: 18 },
-	{ index: 21, randomIndex: 16 },
-	{ index: 17, randomIndex: 14 },
-	{ index: 13, randomIndex: 9 },
-	{ index: 7, randomIndex: 4 },
-	{ index: 5, randomIndex: 3 },
-	{ index: 2, randomIndex: 1 },
-]);
-
-/**
- * 校验 SecureBase64 兼容格式的前缀长度。
- *
- * @param length - 待校验的前缀字符数。
- * @throws `RangeError` 当长度不是非负安全整数。
- */
-const assertPrefixLength = (length: number): void => {
-	if (!Number.isSafeInteger(length) || length < 0) throw new RangeError("prefixStrLength must be a non-negative safe integer.");
-};
-
-/**
- * 生成 SecureBase64 兼容格式使用的安全随机前缀。
- *
- * @remarks 前缀字符使用 Web Crypto 均匀生成，用于降低相同明文产生相同载荷的概率；它本身不构成加密。
- * @param length - 需要生成的字符数，调用前必须完成校验。
- * @returns 由历史字母表组成的文本。
- */
-const createRandomPrefix = (length: number): string => {
-	let result = "";
-	for (let index = 0; index < length; index += 1) {
-		result += randomPrefixAlphabet[secureRandomInt(0, randomPrefixAlphabet.length)] ?? "";
-	}
-	return result;
-};
-
-/**
- * 按固定字典向 Base64 文本插入冗余字符。
- *
- * @remarks 字典按高索引到低索引排列，确保插入不会改变尚未处理的位置。
- * @param base64Value - 尚未插入兼容字典字符的 Base64 文本。
- * @returns 与旧持久化格式兼容的 SecureBase64 载荷。
- */
-const insertDictionaryCharacters = (base64Value: string): string => {
-	let result = base64Value;
-	for (const item of base64PasswordDictionary) {
-		if (item.index >= base64Value.length) continue;
-		// 旧字典的 index=100 项会在 101–124 字符载荷中越界；退回末字符可保持单字符插入协议，旧解码器仍能移除。
-		const character = base64Value[item.randomIndex] ?? base64Value.at(-1) ?? "";
-		result = result.slice(0, item.index) + character + result.slice(item.index);
-	}
-	return result;
-};
-
-/**
- * 移除历史字典插入的冗余字符。
- *
- * @param base64Value - 已移除安全随机前缀的 SecureBase64 载荷。
- * @returns 可交给标准 Base64 解码器的文本。
- */
-const removeDictionaryCharacters = (base64Value: string): string => {
-	let result = base64Value;
-	for (let index = base64PasswordDictionary.length - 1; index >= 0; index -= 1) {
-		const item = base64PasswordDictionary[index];
-		if (item !== undefined && item.index < base64Value.length) result = result.slice(0, item.index) + result.slice(item.index + 1);
-	}
-	return result;
-};
-
-/**
- * 使用固定字典和安全随机前缀编码文本。
- *
- * @remarks 给定相同的 6 字符前缀时，默认输出与旧有效载荷逐字符兼容。旧字典在 101–124 字符载荷中引用越界；这里复制末字符作为单字符回退，
- * 使旧删除字典流程仍能解码。传入 `0` 会同时关闭随机前缀与字典插入。
- * 该格式只是可逆编码，不提供加密、完整性或身份认证。
- * @param value - 任意可由 `encodeURIComponent` 处理的 Unicode 文本。
- * @param prefixLength - 随机字母前缀长度；默认 `6`。
- * @returns 带随机前缀和兼容字典字符的 Base64 文本；空输入返回空字符串。
- * @throws `RangeError` 当前缀长度不是非负安全整数；缺少 Web Crypto 或输入包含孤立代理项时保留平台错误。
- */
-export function encodeSecureBase64(value: string, prefixLength: number = defaultRandomPrefixLength): string {
-	if (value.length === 0) return "";
-	assertPrefixLength(prefixLength);
-	const prefix = createRandomPrefix(prefixLength);
-	let encoded = encodeLatin1Base64(encodeURIComponent(value));
-	if (prefixLength !== 0) encoded = insertDictionaryCharacters(encoded);
-	return prefix + encoded;
-}
-
-/**
- * 解码 {@link encodeSecureBase64} 生成的 SecureBase64 兼容格式。
- *
- * @param value - SecureBase64 文本；必须使用与编码时相同的前缀长度。
- * @param prefixLength - 需要移除的前缀长度；默认 `6`，传入 `0` 时不移除字典字符。
- * @returns 解码后的 Unicode 文本；空输入返回空字符串。
- * @throws `RangeError` 当前缀长度不是非负安全整数；载荷、Base64 或 URI 编码非法时抛出 `TypeError` 或 `URIError`。
- */
-export function decodeSecureBase64(value: string, prefixLength: number = defaultRandomPrefixLength): string {
-	if (value.length === 0) return "";
-	assertPrefixLength(prefixLength);
-	if (prefixLength > value.length) throw new TypeError("The Base64 value is shorter than its configured prefix.");
-	let encoded = value.slice(prefixLength);
-	if (prefixLength !== 0) encoded = removeDictionaryCharacters(encoded);
-	return decodeURIComponent(decodeLatin1Base64(encoded));
-}

package/src/color/index.ts

@@ -1,208 +0,0 @@
-/** 0 至 255 范围的 RGB 颜色。 */
-export interface RgbColor {
-	/** 蓝色通道；必须是闭区间 `[0, 255]` 内的有限数，格式化时舍入到整数。 */
-	blue: number;
-	/** 绿色通道；必须是闭区间 `[0, 255]` 内的有限数，格式化时舍入到整数。 */
-	green: number;
-	/** 红色通道；必须是闭区间 `[0, 255]` 内的有限数，格式化时舍入到整数。 */
-	red: number;
-}
-
-/** 带 0 至 1 Alpha 通道的 RGB 颜色。 */
-export interface RgbaColor extends RgbColor {
-	/** 不透明度；必须是闭区间 `[0, 1]` 内的有限数，`0` 完全透明，`1` 完全不透明。 */
-	alpha: number;
-}
-
-/**
- * 校验 RGB 颜色通道。
- *
- * @param value - 待校验通道值。
- * @param channel - 用于错误消息的通道名称。
- * @throws `RangeError` 当值非有限或超出 0 至 255。
- */
-const assertRgbChannel = (value: number, channel: string): void => {
-	if (!Number.isFinite(value) || value < 0 || value > 255) {
-		throw new RangeError(`${channel} must be a finite number from 0 through 255.`);
-	}
-};
-
-/**
- * 校验透明度通道。
- *
- * @param value - 待校验 Alpha 值。
- * @throws `RangeError` 当值非有限或超出闭区间 `[0, 1]`。
- */
-const assertAlpha = (value: number): void => {
-	if (!Number.isFinite(value) || value < 0 || value > 1) {
-		throw new RangeError("alpha must be a finite number from 0 through 1.");
-	}
-};
-
-/**
- * 规范化十六进制颜色文本。
- *
- * @param value - 可带 `#` 的 3、4、6 或 8 位颜色文本。
- * @returns 不带 `#` 的 6 或 8 位文本。
- * @throws `TypeError` 当长度或字符不符合十六进制颜色格式。
- */
-const normalizeHexColor = (value: string): string => {
-	const normalized = value.startsWith("#") ? value.slice(1) : value;
-	if (![3, 4, 6, 8].includes(normalized.length) || !/^[\dA-F]+$/iu.test(normalized)) {
-		throw new TypeError("Expected a 3, 4, 6, or 8 digit hexadecimal color.");
-	}
-	return normalized.length <= 4 ? Array.from(normalized, (character) => `${character}${character}`).join("") : normalized;
-};
-
-/**
- * 格式化单个颜色通道。
- *
- * @param value - 已校验的 0 至 255 通道值。
- * @returns 舍入后的两位小写十六进制文本。
- */
-const formatHexChannel = (value: number): string => Math.round(value).toString(16).padStart(2, "0");
-
-/**
- * 解析可带可不带 `#` 的 `rgb`、`rgba`、`rrggbb` 或 `rrggbbaa`。
- *
- * @param value - 十六进制颜色文本。
- * @returns 标准化的 RGBA 对象；省略 Alpha 时为 1。
- * @throws 输入非法时抛出 `TypeError`。
- */
-export function parseHexColor(value: string): RgbaColor {
-	const normalized = normalizeHexColor(value);
-	return {
-		red: Number.parseInt(normalized.slice(0, 2), 16),
-		green: Number.parseInt(normalized.slice(2, 4), 16),
-		blue: Number.parseInt(normalized.slice(4, 6), 16),
-		alpha: normalized.length === 8 ? Number.parseInt(normalized.slice(6, 8), 16) / 255 : 1,
-	};
-}
-
-/**
- * 把 RGB 或 RGBA 对象格式化为小写十六进制颜色。
- *
- * @param color - 颜色通道；RGB 会四舍五入到最近整数。
- * @param includeAlpha - 是否输出 Alpha；默认只在传入 Alpha 且小于 1 时输出。
- * @returns 小写 `#rrggbb` 或 `#rrggbbaa` 文本。
- * @throws 通道或 Alpha 非法时抛出 `RangeError`。
- */
-export function formatHexColor(color: RgbColor | RgbaColor, includeAlpha: boolean = "alpha" in color && color.alpha < 1): string {
-	assertRgbChannel(color.red, "red");
-	assertRgbChannel(color.green, "green");
-	assertRgbChannel(color.blue, "blue");
-	const alpha = "alpha" in color ? color.alpha : 1;
-	assertAlpha(alpha);
-	const rgb = `${formatHexChannel(color.red)}${formatHexChannel(color.green)}${formatHexChannel(color.blue)}`;
-	return `#${rgb}${includeAlpha ? formatHexChannel(alpha * 255) : ""}`;
-}
-
-/**
- * 线性混合两种十六进制颜色，包括 Alpha 通道。
- *
- * @param first - `amount = 0` 时的颜色。
- * @param second - `amount = 1` 时的颜色。
- * @param amount - 0 至 1 的混合比例。
- * @returns 小写十六进制颜色；任一输入含透明度时保留 Alpha。
- * @throws 颜色非法时抛出 `TypeError`；比例非法时抛出 `RangeError`。
- */
-export function mixHexColors(first: string, second: string, amount: number): string {
-	if (!Number.isFinite(amount) || amount < 0 || amount > 1) {
-		throw new RangeError("amount must be a finite number from 0 through 1.");
-	}
-	const left = parseHexColor(first);
-	const right = parseHexColor(second);
-	/**
-	 * 在单个 RGBA 通道上执行与外层相同权重的线性混合。
-	 *
-	 * @param start - 第一个颜色的通道值。
-	 * @param end - 第二个颜色的通道值。
-	 * @returns 按外层 `amount` 线性混合后的通道值。
-	 */
-	const mix = (start: number, end: number): number => start + (end - start) * amount;
-	return formatHexColor(
-		{
-			red: mix(left.red, right.red),
-			green: mix(left.green, right.green),
-			blue: mix(left.blue, right.blue),
-			alpha: mix(left.alpha, right.alpha),
-		},
-		left.alpha < 1 || right.alpha < 1
-	);
-}
-
-/**
- * 按比例向黑色混合。
- *
- * @param color - 合法十六进制颜色。
- * @param amount - 0 至 1 的混合比例。
- * @returns 混入黑色后的十六进制颜色；参数与异常语义见 {@link mixHexColors}。
- */
-export function mixHexColorWithBlack(color: string, amount: number): string {
-	return mixHexColors(color, "#000000", amount);
-}
-
-/**
- * 按比例向白色混合。
- *
- * @param color - 合法十六进制颜色。
- * @param amount - 0 至 1 的混合比例。
- * @returns 混入白色后的十六进制颜色；参数与异常语义见 {@link mixHexColors}。
- */
-export function mixHexColorWithWhite(color: string, amount: number): string {
-	return mixHexColors(color, "#ffffff", amount);
-}
-
-/**
- * 按 WCAG sRGB 转换曲线线性化颜色通道。
- *
- * @param channel - 已校验的 0 至 255 通道值。
- * @returns 0 至 1 的线性光值。
- */
-const linearizeSrgbChannel = (channel: number): number => {
-	const value = channel / 255;
-	return value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
-};
-
-/**
- * 计算 WCAG sRGB 相对亮度。
- *
- * @remarks Alpha 通道不会参与计算；半透明颜色应先与实际背景混合。
- * @param color - 合法十六进制颜色。
- * @returns 0 至 1 的相对亮度。
- * @throws 输入非法时抛出 `TypeError`。
- */
-export function relativeLuminance(color: string): number {
-	const { red, green, blue } = parseHexColor(color);
-	return 0.2126 * linearizeSrgbChannel(red) + 0.7152 * linearizeSrgbChannel(green) + 0.0722 * linearizeSrgbChannel(blue);
-}
-
-/**
- * 计算两种不透明颜色的 WCAG 对比度，范围 1 至 21。
- *
- * @remarks 返回比值本身，不代表特定字号或 WCAG 等级必然通过。
- * @param first - 第一种十六进制颜色。
- * @param second - 第二种十六进制颜色。
- * @returns 较亮颜色与较暗颜色的对比度。
- * @throws 输入非法时抛出 `TypeError`。
- */
-export function contrastRatio(first: string, second: string): number {
-	const firstLuminance = relativeLuminance(first);
-	const secondLuminance = relativeLuminance(second);
-	const lighter = Math.max(firstLuminance, secondLuminance);
-	const darker = Math.min(firstLuminance, secondLuminance);
-	return (lighter + 0.05) / (darker + 0.05);
-}
-
-/**
- * 从两个候选颜色中选择与背景对比度更高的一项。
- *
- * @param background - 实际不透明背景色。
- * @param first - 第一候选，默认黑色。
- * @param second - 第二候选，默认白色。
- * @returns 对比度较高的原始候选字符串；相同时返回 `first`。
- * @throws 任一颜色非法时抛出 `TypeError`。
- */
-export function pickHigherContrastColor(background: string, first = "#000000", second = "#ffffff"): string {
-	return contrastRatio(background, first) >= contrastRatio(background, second) ? first : second;
-}