gradiente 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1430 @@
+//#region src/token.ts
+const TokenKind = {
+	PAREN_OPEN: "paren-open",
+	PAREN_CLOSE: "paren-close",
+	COMMA: "comma",
+	SLASH: "slash",
+	FUNCTION_LINEAR_GRADIENT: "function-linear-gradient",
+	FUNCTION_REPEATING_LINEAR_GRADIENT: "function-repeating-linear-gradient",
+	FUNCTION_RADIAL_GRADIENT: "function-radial-gradient",
+	FUNCTION_REPEATING_RADIAL_GRADIENT: "function-repeating-radial-gradient",
+	FUNCTION_CONIC_GRADIENT: "function-conic-gradient",
+	FUNCTION_REPEATING_CONIC_GRADIENT: "function-repeating-conic-gradient",
+	FUNCTION_DIAMOND_GRADIENT: "function-diamond-gradient",
+	FUNCTION_REPEATING_DIAMOND_GRADIENT: "function-repeating-diamond-gradient",
+	FUNCTION_MESH_GRADIENT: "function-mesh-gradient",
+	TO: "to",
+	TOP: "top",
+	BOTTOM: "bottom",
+	LEFT: "left",
+	RIGHT: "right",
+	AT: "at",
+	FROM: "from",
+	CENTER: "center",
+	CIRCLE: "circle",
+	ELLIPSE: "ellipse",
+	CLOSEST_SIDE: "closest-side",
+	CLOSEST_CORNER: "closest-corner",
+	FARTHEST_SIDE: "farthest-side",
+	FARTHEST_CORNER: "farthest-corner",
+	IN: "in",
+	SHORTER: "shorter",
+	LONGER: "longer",
+	INCREASING: "increasing",
+	DECREASING: "decreasing",
+	HUE: "hue",
+	IDENT: "ident",
+	NUMBER: "number",
+	PERCENTAGE: "percentage",
+	DIMENSION: "dimension",
+	FUNCTION: "function",
+	HASH: "hash",
+	STRING: "string",
+	WHITESPACE: "whitespace",
+	EOF: "eof",
+	UNKNOWN: "unknown"
+};
+const GradientFunctionNameToToken = {
+	"linear-gradient": TokenKind.FUNCTION_LINEAR_GRADIENT,
+	"repeating-linear-gradient": TokenKind.FUNCTION_REPEATING_LINEAR_GRADIENT,
+	"radial-gradient": TokenKind.FUNCTION_RADIAL_GRADIENT,
+	"repeating-radial-gradient": TokenKind.FUNCTION_REPEATING_RADIAL_GRADIENT,
+	"conic-gradient": TokenKind.FUNCTION_CONIC_GRADIENT,
+	"repeating-conic-gradient": TokenKind.FUNCTION_REPEATING_CONIC_GRADIENT,
+	"diamond-gradient": TokenKind.FUNCTION_DIAMOND_GRADIENT,
+	"repeating-diamond-gradient": TokenKind.FUNCTION_REPEATING_DIAMOND_GRADIENT,
+	"mesh-gradient": TokenKind.FUNCTION_MESH_GRADIENT
+};
+const KeywordNameToToken = {
+	to: TokenKind.TO,
+	top: TokenKind.TOP,
+	bottom: TokenKind.BOTTOM,
+	left: TokenKind.LEFT,
+	right: TokenKind.RIGHT,
+	at: TokenKind.AT,
+	from: TokenKind.FROM,
+	center: TokenKind.CENTER,
+	circle: TokenKind.CIRCLE,
+	ellipse: TokenKind.ELLIPSE,
+	"closest-side": TokenKind.CLOSEST_SIDE,
+	"closest-corner": TokenKind.CLOSEST_CORNER,
+	"farthest-side": TokenKind.FARTHEST_SIDE,
+	"farthest-corner": TokenKind.FARTHEST_CORNER,
+	in: TokenKind.IN,
+	shorter: TokenKind.SHORTER,
+	longer: TokenKind.LONGER,
+	increasing: TokenKind.INCREASING,
+	decreasing: TokenKind.DECREASING,
+	hue: TokenKind.HUE
+};
+//#endregion
+//#region src/lexer/base.ts
+function createLexerState(source) {
+	return {
+		source,
+		length: source.length,
+		position: 0
+	};
+}
+function isEnd(state) {
+	return state.position >= state.length;
+}
+function currentChar(state) {
+	if (isEnd(state)) return null;
+	return state.source[state.position] ?? null;
+}
+function peekChar(state, offset = 1) {
+	const index = state.position + offset;
+	if (index < 0 || index >= state.length) return null;
+	return state.source[index] ?? null;
+}
+function advance(state, step = 1) {
+	state.position = Math.max(0, Math.min(state.position + step, state.length));
+}
+function isWhitespaceChar(char) {
+	return char === " " || char === "\n" || char === "\r" || char === "	" || char === "\f";
+}
+function isDigitChar(char) {
+	return char !== null && char >= "0" && char <= "9";
+}
+function isSignChar(char) {
+	return char === "+" || char === "-";
+}
+function isIdentifierStartChar(char) {
+	if (char === null) return false;
+	return char >= "a" && char <= "z" || char >= "A" && char <= "Z" || char === "_" || char === "-";
+}
+function isIdentifierChar(char) {
+	if (char === null) return false;
+	return isIdentifierStartChar(char) || isDigitChar(char);
+}
+function isAlphaChar(char) {
+	if (char === null) return false;
+	return char >= "a" && char <= "z" || char >= "A" && char <= "Z";
+}
+function readWhile(state, predicate) {
+	const start = state.position;
+	while (!isEnd(state) && predicate(currentChar(state))) advance(state);
+	return state.source.slice(start, state.position);
+}
+function createSpan(source, start, end) {
+	return {
+		start,
+		end,
+		raw: source.slice(start, end)
+	};
+}
+//#endregion
+//#region src/lexer/lexer.ts
+function readWhitespaceToken(state) {
+	const start = state.position;
+	readWhile(state, isWhitespaceChar);
+	const span = createSpan(state.source, start, state.position);
+	return {
+		kind: TokenKind.WHITESPACE,
+		start: span.start,
+		end: span.end,
+		raw: span.raw
+	};
+}
+function readPunctuationToken(state) {
+	const start = state.position;
+	const char = currentChar(state);
+	if (char === null) return null;
+	let kind = null;
+	switch (char) {
+		case "(":
+			kind = TokenKind.PAREN_OPEN;
+			break;
+		case ")":
+			kind = TokenKind.PAREN_CLOSE;
+			break;
+		case ",":
+			kind = TokenKind.COMMA;
+			break;
+		case "/":
+			kind = TokenKind.SLASH;
+			break;
+		default:
+			kind = null;
+			break;
+	}
+	if (kind === null) return null;
+	advance(state);
+	const span = createSpan(state.source, start, state.position);
+	return {
+		kind,
+		start: span.start,
+		end: span.end,
+		raw: span.raw
+	};
+}
+function readHashToken(state) {
+	const start = state.position;
+	if (currentChar(state) !== "#") return null;
+	advance(state);
+	const value = readWhile(state, (nextChar) => {
+		if (nextChar === null) return false;
+		return isIdentifierChar(nextChar);
+	});
+	const span = createSpan(state.source, start, state.position);
+	return {
+		kind: TokenKind.HASH,
+		start: span.start,
+		end: span.end,
+		raw: span.raw,
+		value
+	};
+}
+function readIdentifierLikeToken(state) {
+	const start = state.position;
+	if (!isIdentifierStartChar(currentChar(state))) return null;
+	const value = readWhile(state, isIdentifierChar);
+	if (currentChar(state) === "(") {
+		const gradientKind = GradientFunctionNameToToken[value];
+		const span = createSpan(state.source, start, state.position);
+		if (gradientKind !== void 0) return {
+			kind: gradientKind,
+			start: span.start,
+			end: span.end,
+			raw: span.raw,
+			name: value
+		};
+		return {
+			kind: TokenKind.FUNCTION,
+			start: span.start,
+			end: span.end,
+			raw: span.raw,
+			name: value
+		};
+	}
+	const keywordKind = KeywordNameToToken[value];
+	const span = createSpan(state.source, start, state.position);
+	if (keywordKind !== void 0) return {
+		kind: keywordKind,
+		start: span.start,
+		end: span.end,
+		raw: span.raw
+	};
+	return {
+		kind: TokenKind.IDENT,
+		start: span.start,
+		end: span.end,
+		raw: span.raw,
+		value
+	};
+}
+function isNumberStart(state) {
+	const char = currentChar(state);
+	const next = peekChar(state);
+	if (isDigitChar(char)) return true;
+	if (char === "." && isDigitChar(next)) return true;
+	if (isSignChar(char)) {
+		if (isDigitChar(next)) return true;
+		if (next === "." && isDigitChar(peekChar(state, 2))) return true;
+	}
+	return false;
+}
+function readNumberRaw(state) {
+	let sign = 1;
+	if (currentChar(state) === "+") advance(state);
+	else if (currentChar(state) === "-") {
+		sign = -1;
+		advance(state);
+	}
+	const integerPart = readWhile(state, isDigitChar);
+	let fractionPart = "";
+	if (currentChar(state) === "." && isDigitChar(peekChar(state))) {
+		advance(state);
+		fractionPart = readWhile(state, isDigitChar);
+	}
+	const rawNumber = fractionPart.length > 0 ? `${integerPart}.${fractionPart}` : integerPart;
+	const numeric = Number(rawNumber);
+	const value = sign === -1 ? -numeric : numeric;
+	return {
+		rawNumber,
+		sign,
+		value
+	};
+}
+function readNumberLikeToken(state) {
+	if (!isNumberStart(state)) return null;
+	const start = state.position;
+	const { sign, value } = readNumberRaw(state);
+	if (currentChar(state) === "%") {
+		advance(state);
+		const span = createSpan(state.source, start, state.position);
+		return {
+			kind: TokenKind.PERCENTAGE,
+			start: span.start,
+			end: span.end,
+			raw: span.raw,
+			value,
+			sign
+		};
+	}
+	if (isIdentifierStartChar(currentChar(state))) {
+		const unit = readWhile(state, isIdentifierChar);
+		const span = createSpan(state.source, start, state.position);
+		return {
+			kind: TokenKind.DIMENSION,
+			start: span.start,
+			end: span.end,
+			raw: span.raw,
+			value,
+			sign,
+			unit
+		};
+	}
+	const span = createSpan(state.source, start, state.position);
+	return {
+		kind: TokenKind.NUMBER,
+		start: span.start,
+		end: span.end,
+		raw: span.raw,
+		value,
+		sign
+	};
+}
+function readUnknownToken(state) {
+	const start = state.position;
+	advance(state);
+	const span = createSpan(state.source, start, state.position);
+	return {
+		kind: TokenKind.UNKNOWN,
+		start: span.start,
+		end: span.end,
+		raw: span.raw
+	};
+}
+function readEofToken(state) {
+	return {
+		kind: TokenKind.EOF,
+		start: state.position,
+		end: state.position,
+		raw: ""
+	};
+}
+function nextToken(state) {
+	if (isEnd(state)) return readEofToken(state);
+	if (isWhitespaceChar(currentChar(state))) return readWhitespaceToken(state);
+	const punctuationToken = readPunctuationToken(state);
+	if (punctuationToken !== null) return punctuationToken;
+	const hashToken = readHashToken(state);
+	if (hashToken !== null) return hashToken;
+	const numberLikeToken = readNumberLikeToken(state);
+	if (numberLikeToken !== null) return numberLikeToken;
+	const identifierLikeToken = readIdentifierLikeToken(state);
+	if (identifierLikeToken !== null) return identifierLikeToken;
+	return readUnknownToken(state);
+}
+function tokenize(source) {
+	const state = createLexerState(source);
+	const tokens = [];
+	while (true) {
+		const token = nextToken(state);
+		tokens.push(token);
+		if (token.kind === TokenKind.EOF) break;
+	}
+	return tokens;
+}
+//#endregion
+//#region src/guard.ts
+function isGradientFunctionToken(token) {
+	return token.kind === TokenKind.FUNCTION_LINEAR_GRADIENT || token.kind === TokenKind.FUNCTION_REPEATING_LINEAR_GRADIENT || token.kind === TokenKind.FUNCTION_RADIAL_GRADIENT || token.kind === TokenKind.FUNCTION_REPEATING_RADIAL_GRADIENT || token.kind === TokenKind.FUNCTION_CONIC_GRADIENT || token.kind === TokenKind.FUNCTION_REPEATING_CONIC_GRADIENT || token.kind === TokenKind.FUNCTION_DIAMOND_GRADIENT || token.kind === TokenKind.FUNCTION_REPEATING_DIAMOND_GRADIENT || token.kind === TokenKind.FUNCTION_MESH_GRADIENT;
+}
+function isKeywordToken(token) {
+	switch (token.kind) {
+		case TokenKind.TO:
+		case TokenKind.TOP:
+		case TokenKind.BOTTOM:
+		case TokenKind.LEFT:
+		case TokenKind.RIGHT:
+		case TokenKind.AT:
+		case TokenKind.FROM:
+		case TokenKind.CENTER:
+		case TokenKind.CIRCLE:
+		case TokenKind.ELLIPSE:
+		case TokenKind.CLOSEST_SIDE:
+		case TokenKind.CLOSEST_CORNER:
+		case TokenKind.FARTHEST_SIDE:
+		case TokenKind.FARTHEST_CORNER:
+		case TokenKind.IN:
+		case TokenKind.SHORTER:
+		case TokenKind.LONGER:
+		case TokenKind.INCREASING:
+		case TokenKind.DECREASING:
+		case TokenKind.HUE: return true;
+		default: return false;
+	}
+}
+function isNumericToken(token) {
+	return token.kind === TokenKind.NUMBER || token.kind === TokenKind.PERCENTAGE || token.kind === TokenKind.DIMENSION;
+}
+//#endregion
+//#region src/source.ts
+function getSourceSlice(source, start, end) {
+	return source.slice(start, end);
+}
+function getTokenSourceSlice(source, startToken, endToken) {
+	return source.slice(startToken.start, endToken.end);
+}
+function getTokenRangeSourceSlice(source, tokens, startIndex, endIndex) {
+	const startToken = tokens[startIndex];
+	const endToken = tokens[endIndex];
+	if (startToken === void 0 || endToken === void 0) throw new Error(`Invalid token range: ${startIndex}..${endIndex}`);
+	return source.slice(startToken.start, endToken.end);
+}
+function findBalancedFunctionEndIndex(tokens, startIndex) {
+	const startToken = tokens[startIndex];
+	if (startToken === void 0 || !(startToken.kind === TokenKind.FUNCTION || startToken.kind === TokenKind.FUNCTION_LINEAR_GRADIENT || startToken.kind === TokenKind.FUNCTION_REPEATING_LINEAR_GRADIENT || startToken.kind === TokenKind.FUNCTION_RADIAL_GRADIENT || startToken.kind === TokenKind.FUNCTION_REPEATING_RADIAL_GRADIENT || startToken.kind === TokenKind.FUNCTION_CONIC_GRADIENT || startToken.kind === TokenKind.FUNCTION_REPEATING_CONIC_GRADIENT || startToken.kind === TokenKind.FUNCTION_DIAMOND_GRADIENT || startToken.kind === TokenKind.FUNCTION_REPEATING_DIAMOND_GRADIENT || startToken.kind === TokenKind.FUNCTION_MESH_GRADIENT)) throw new Error(`Token at index ${startIndex} is not a function token`);
+	if (tokens[startIndex + 1]?.kind !== TokenKind.PAREN_OPEN) throw new Error(`Expected "(" after function token at index ${startIndex}`);
+	let depth = 0;
+	for (let index = startIndex + 1; index < tokens.length; index++) {
+		const token = tokens[index];
+		if (token === void 0) break;
+		if (token.kind === TokenKind.PAREN_OPEN) {
+			depth += 1;
+			continue;
+		}
+		if (token.kind === TokenKind.PAREN_CLOSE) {
+			depth -= 1;
+			if (depth === 0) return index;
+			continue;
+		}
+	}
+	throw new Error(`Unclosed function starting at token index ${startIndex}`);
+}
+//#endregion
+//#region src/utils/parser-utils.ts
+function isTriviaToken(token) {
+	return token.kind === TokenKind.WHITESPACE;
+}
+function getTokenAt(tokens, index) {
+	return tokens[index] ?? null;
+}
+function findNextNonWhitespaceIndex(tokens, startIndex) {
+	let index = startIndex;
+	while (index < tokens.length) {
+		const token = tokens[index];
+		if (token === void 0) break;
+		if (!isTriviaToken(token)) return index;
+		index += 1;
+	}
+	return -1;
+}
+function getNonWhitespaceTokenAt(tokens, startIndex) {
+	const index = findNextNonWhitespaceIndex(tokens, startIndex);
+	if (index === -1) return null;
+	return tokens[index] ?? null;
+}
+function skipWhitespace(tokens, startIndex) {
+	return findNextNonWhitespaceIndex(tokens, startIndex);
+}
+function consumeIf(tokens, index, kind) {
+	const nextIndex = findNextNonWhitespaceIndex(tokens, index);
+	if (nextIndex === -1) return {
+		matched: false,
+		nextIndex: index,
+		token: null
+	};
+	const token = tokens[nextIndex] ?? null;
+	if (token === null || token.kind !== kind) return {
+		matched: false,
+		nextIndex: index,
+		token: null
+	};
+	return {
+		matched: true,
+		nextIndex: nextIndex + 1,
+		token
+	};
+}
+function expectToken(tokens, index, kind, message) {
+	const nextIndex = findNextNonWhitespaceIndex(tokens, index);
+	if (nextIndex === -1) throw new Error(message ?? `Expected token "${kind}", but reached end of token stream`);
+	const token = tokens[nextIndex];
+	if (token === void 0 || token.kind !== kind) throw new Error(message ?? `Expected token "${kind}", but received "${token?.kind ?? "undefined"}"`);
+	return {
+		token,
+		nextIndex: nextIndex + 1
+	};
+}
+//#endregion
+//#region src/utils/math/base.ts
+function roundTo(value, digits) {
+	const factor = 10 ** digits;
+	return Math.round(value * factor) / factor;
+}
+function floorTo(value, digits) {
+	const factor = 10 ** digits;
+	return Math.floor(value * factor) / factor;
+}
+function ceilTo(value, digits) {
+	const factor = 10 ** digits;
+	return Math.ceil(value * factor) / factor;
+}
+function truncTo(value, digits) {
+	const factor = 10 ** digits;
+	return Math.trunc(value * factor) / factor;
+}
+function clamp(value, min, max) {
+	return Math.min(Math.max(value, min), max);
+}
+function toPercent(value) {
+	return value / 100;
+}
+function fromPercent(value) {
+	return value * 100;
+}
+//#endregion
+//#region src/utils/math/angle.ts
+function isAngleUnit(unit) {
+	return unit === "deg" || unit === "rad" || unit === "turn" || unit === "grad";
+}
+function degToRad(value) {
+	return value * Math.PI / 180;
+}
+function radToDeg(value) {
+	return value * 180 / Math.PI;
+}
+function turnToRad(value) {
+	return value * Math.PI * 2;
+}
+function gradToRad(value) {
+	return value * Math.PI / 200;
+}
+function normalizeAngleDeg(value, digits = 3) {
+	return roundTo((value % 360 + 360) % 360, digits);
+}
+function normalizeAngleRad(value) {
+	const tau = Math.PI * 2;
+	return (value % tau + tau) % tau;
+}
+function toAngleRad(value, unit) {
+	switch (unit) {
+		case "deg": return degToRad(value);
+		case "rad": return value;
+		case "turn": return turnToRad(value);
+		case "grad": return gradToRad(value);
+		default: throw new Error(`Unsupported angle unit: ${String(unit)}`);
+	}
+}
+function normalizeAngle(value, unit, digits = 6) {
+	return roundTo(normalizeAngleRad(toAngleRad(value, unit)), digits);
+}
+function parseAngleFromToken(token) {
+	if (token.kind !== TokenKind.DIMENSION) return null;
+	if (!isAngleUnit(token.unit)) return null;
+	return normalizeAngle(token.value, token.unit);
+}
+//#endregion
+//#region src/parser/helpers/color-helpers.ts
+function parseColorStop(source, tokens, startIndex) {
+	const colorResult = parseColorSource(source, tokens, startIndex);
+	let index = colorResult.nextIndex;
+	const positions = [];
+	while (true) {
+		const nextIndex = findNextNonWhitespaceIndex(tokens, index);
+		if (nextIndex === -1) break;
+		const token = tokens[nextIndex];
+		if (token === void 0) break;
+		if (token.kind === TokenKind.PERCENTAGE || token.kind === TokenKind.DIMENSION) {
+			positions.push(toLengthPercentageNode(token));
+			index = nextIndex + 1;
+			if (positions.length === 2) break;
+			continue;
+		}
+		break;
+	}
+	return {
+		node: {
+			kind: "color-stop",
+			color: colorResult.node,
+			position: positions[0]
+		},
+		nextIndex: index
+	};
+}
+function toLengthPercentageNode(token) {
+	if (token.kind === TokenKind.PERCENTAGE) return {
+		kind: "percentage",
+		value: roundTo(toPercent(token.value), 5)
+	};
+	return {
+		kind: "dimension",
+		value: token.value,
+		unit: token.unit
+	};
+}
+function parseColorSource(source, tokens, startIndex) {
+	const token = tokens[startIndex];
+	if (token === void 0) throw new Error("Expected color token");
+	if (token.kind === TokenKind.IDENT || token.kind === TokenKind.HASH) return {
+		node: token.raw,
+		nextIndex: startIndex + 1
+	};
+	if (token.kind === TokenKind.FUNCTION) {
+		const endIndex = findBalancedFunctionEndIndex$1(tokens, startIndex);
+		return {
+			node: getTokenRangeSourceSlice(source, tokens, startIndex, endIndex),
+			nextIndex: endIndex + 1
+		};
+	}
+	throw new Error(`Expected color source, received "${token.kind}"`);
+}
+function findBalancedFunctionEndIndex$1(tokens, startIndex) {
+	const functionToken = tokens[startIndex];
+	const openParenToken = tokens[startIndex + 1];
+	if (functionToken?.kind !== TokenKind.FUNCTION) throw new Error("Expected generic function token");
+	if (openParenToken?.kind !== TokenKind.PAREN_OPEN) throw new Error("Expected \"(\" after function token");
+	let depth = 0;
+	for (let index = startIndex + 1; index < tokens.length; index += 1) {
+		const token = tokens[index];
+		if (token === void 0) break;
+		if (token.kind === TokenKind.PAREN_OPEN) {
+			depth += 1;
+			continue;
+		}
+		if (token.kind === TokenKind.PAREN_CLOSE) {
+			depth -= 1;
+			if (depth === 0) return index;
+		}
+	}
+	throw new Error("Unclosed function color source");
+}
+//#endregion
+//#region src/parser/helpers/stop-helpers.ts
+function parseGradientStopList(source, tokens, startIndex) {
+	const items = [];
+	let index = startIndex;
+	while (true) {
+		const itemResult = parseGradientStopItem(source, tokens, index);
+		items.push(itemResult.node);
+		index = itemResult.nextIndex;
+		const nextIndex = findNextNonWhitespaceIndex(tokens, index);
+		if (nextIndex === -1) break;
+		const token = tokens[nextIndex];
+		if (token === void 0) break;
+		if (token.kind === TokenKind.COMMA) {
+			index = nextIndex + 1;
+			continue;
+		}
+		if (token.kind === TokenKind.PAREN_CLOSE) break;
+		throw new Error(`Expected comma or ")" in stop list, received "${token.kind}"`);
+	}
+	if (items.length < 2) throw new Error("Linear gradient requires at least two stop items");
+	return {
+		node: normalizeGradientStopList(items),
+		nextIndex: index
+	};
+}
+function parseGradientStopItem(source, tokens, startIndex) {
+	const index = findNextNonWhitespaceIndex(tokens, startIndex);
+	if (index === -1) throw new Error("Expected stop item, but reached end of token stream");
+	if (tokens[index] === void 0) throw new Error("Expected stop item, but token was undefined");
+	return parseColorStop(source, tokens, index);
+}
+function normalizeGradientStopList(items) {
+	const colorStopIndexes = items.flatMap((item, index) => item.kind === "color-stop" ? [index] : []);
+	if (colorStopIndexes.length < 2) return items;
+	const normalized = [...items];
+	const getColorStop = (itemIndex) => {
+		const item = normalized[itemIndex];
+		if (item.kind !== "color-stop") throw new Error("Expected color-stop");
+		return item;
+	};
+	const setColorStopPosition = (itemIndex, value) => {
+		normalized[itemIndex] = {
+			...getColorStop(itemIndex),
+			position: {
+				kind: "percentage",
+				value
+			}
+		};
+	};
+	const getColorStopPosition = (itemIndex) => {
+		const position = getColorStop(itemIndex).position;
+		if (!position) return null;
+		if (position.kind !== "percentage") return null;
+		return position.value;
+	};
+	const firstItemIndex = colorStopIndexes[0];
+	const lastItemIndex = colorStopIndexes[colorStopIndexes.length - 1];
+	if (firstItemIndex !== void 0 && getColorStopPosition(firstItemIndex) === null) setColorStopPosition(firstItemIndex, 0);
+	if (lastItemIndex !== void 0 && getColorStopPosition(lastItemIndex) === null) setColorStopPosition(lastItemIndex, 1);
+	let anchorStart = 0;
+	while (anchorStart < colorStopIndexes.length) {
+		const startItemIndex = colorStopIndexes[anchorStart];
+		if (startItemIndex === void 0) break;
+		const startValue = getColorStopPosition(startItemIndex);
+		if (startValue === null) {
+			anchorStart += 1;
+			continue;
+		}
+		let anchorEnd = anchorStart + 1;
+		while (anchorEnd < colorStopIndexes.length) {
+			const endItemIndex = colorStopIndexes[anchorEnd];
+			if (endItemIndex === void 0) break;
+			const endValue = getColorStopPosition(endItemIndex);
+			if (endValue !== null) {
+				const gapCount = anchorEnd - anchorStart - 1;
+				if (gapCount > 0) {
+					const step = (endValue - startValue) / (gapCount + 1);
+					for (let i = 1; i <= gapCount; i += 1) {
+						const gapItemIndex = colorStopIndexes[anchorStart + i];
+						if (gapItemIndex === void 0) continue;
+						setColorStopPosition(gapItemIndex, startValue + step * i);
+					}
+				}
+				break;
+			}
+			anchorEnd += 1;
+		}
+		anchorStart = anchorEnd;
+	}
+	return normalized;
+}
+//#endregion
+//#region src/parser/linear-gradient/parse-linear-gradient.ts
+function parseLinearGradient(source, tokens, startIndex) {
+	const functionToken = getTokenAt(tokens, startIndex);
+	if (functionToken === null || functionToken.kind !== TokenKind.FUNCTION_LINEAR_GRADIENT && functionToken.kind !== TokenKind.FUNCTION_REPEATING_LINEAR_GRADIENT) throw new Error("Expected linear gradient function token");
+	const repeat = functionToken.kind === TokenKind.FUNCTION_REPEATING_LINEAR_GRADIENT ? "repeating" : "normal";
+	let index = startIndex + 1;
+	index = expectToken(tokens, index, TokenKind.PAREN_OPEN).nextIndex;
+	const directionResult = parseLinearDirection(tokens, index);
+	const direction = directionResult.node ?? createDefaultLinearDirection();
+	index = directionResult.nextIndex;
+	if (directionResult.node !== null) index = expectToken(tokens, index, TokenKind.COMMA).nextIndex;
+	const stopsResult = parseGradientStopList(source, tokens, index);
+	const stops = repeat === "repeating" ? expandColorStops$2(stopsResult.node) : stopsResult.node;
+	index = stopsResult.nextIndex;
+	index = expectToken(tokens, index, TokenKind.PAREN_CLOSE).nextIndex;
+	return {
+		node: {
+			kind: "linear",
+			repeat,
+			direction,
+			stops
+		},
+		nextIndex: index
+	};
+}
+function parseLinearDirection(tokens, startIndex) {
+	const index = findNextNonWhitespaceIndex(tokens, startIndex);
+	if (index === -1) return {
+		node: null,
+		nextIndex: startIndex
+	};
+	const token = tokens[index];
+	if (token === void 0) return {
+		node: null,
+		nextIndex: startIndex
+	};
+	if (token.kind === TokenKind.TO) return parseLinearDirectionFromKeywords(tokens, index);
+	const angle = parseAngleFromToken(token);
+	if (angle !== null) {
+		TokenKind.DIMENSION;
+		const dimensionToken = token;
+		return {
+			node: createLinearDirectionFromAngle(dimensionToken.value, dimensionToken.unit, angle),
+			nextIndex: index + 1
+		};
+	}
+	return {
+		node: null,
+		nextIndex: startIndex
+	};
+}
+function parseLinearDirectionFromKeywords(tokens, startIndex) {
+	let index = startIndex;
+	index = expectToken(tokens, index, TokenKind.TO).nextIndex;
+	const keywords = [];
+	while (true) {
+		const nextIndex = findNextNonWhitespaceIndex(tokens, index);
+		if (nextIndex === -1) break;
+		const token = tokens[nextIndex];
+		if (token === void 0) break;
+		if (token.kind === TokenKind.TOP || token.kind === TokenKind.BOTTOM || token.kind === TokenKind.LEFT || token.kind === TokenKind.RIGHT) {
+			keywords.push(token.kind);
+			index = nextIndex + 1;
+			continue;
+		}
+		break;
+	}
+	if (keywords.length === 0) throw new Error("Expected at least one direction keyword after \"to\"");
+	return {
+		node: createLinearDirectionFromKeywords(["to", ...keywords]),
+		nextIndex: index
+	};
+}
+function createLinearDirectionFromKeywords(keywords) {
+	const deg = parseKeywordsToDeg(keywords);
+	if (deg === null) throw new Error("Invalid direction keywords");
+	const rad = roundTo(degToRad(deg), 6);
+	return {
+		kind: "angle",
+		value: {
+			kind: "dimension",
+			value: deg,
+			unit: "deg"
+		},
+		valueRaw: {
+			kind: "dimension",
+			value: rad,
+			unit: "rad"
+		},
+		keywords: [...keywords]
+	};
+}
+function createLinearDirectionFromAngle(value, unit, normalizedRad) {
+	const fixedRad = roundTo(normalizedRad, 6);
+	return {
+		kind: "angle",
+		value: {
+			kind: "dimension",
+			value,
+			unit
+		},
+		valueRaw: {
+			kind: "dimension",
+			value: fixedRad,
+			unit: "rad"
+		},
+		keywords: parseRadToKeywords(fixedRad)
+	};
+}
+function createDefaultLinearDirection() {
+	return createLinearDirectionFromKeywords(["to", "top"]);
+}
+function parseKeywordsToDeg(keywords) {
+	if (keywords.length === 0 || keywords[0] !== "to") return null;
+	switch ([...keywords.slice(1)].sort().join("-")) {
+		case "top": return 0;
+		case "right": return 90;
+		case "left": return 270;
+		case "bottom": return 180;
+		case "bottom-right":
+		case "right-bottom": return 135;
+		case "bottom-left":
+		case "left-bottom": return 225;
+		case "top-right":
+		case "right-top": return 45;
+		case "top-left":
+		case "left-top": return 315;
+		default: return null;
+	}
+}
+function parseDegToKeywords(angle) {
+	switch (normalizeAngleDeg(angle)) {
+		case 0: return ["to", "top"];
+		case 45: return [
+			"to",
+			"top",
+			"right"
+		];
+		case 90: return ["to", "right"];
+		case 135: return [
+			"to",
+			"bottom",
+			"right"
+		];
+		case 180: return ["to", "bottom"];
+		case 225: return [
+			"to",
+			"bottom",
+			"left"
+		];
+		case 270: return ["to", "left"];
+		case 315: return [
+			"to",
+			"top",
+			"left"
+		];
+		default: return [];
+	}
+}
+function parseRadToKeywords(angle) {
+	return parseDegToKeywords(radToDeg(angle));
+}
+function expandColorStops$2(stops) {
+	if (stops.length < 2) return stops;
+	const lastPosition = stops[stops.length - 1]?.position;
+	if (!lastPosition || lastPosition.kind !== "percentage") return stops;
+	if (lastPosition.value >= 1) return stops;
+	const percentageSum = roundTo(stops.reduce((sum, stop) => {
+		const position = stop.position;
+		if (!position || position.kind !== "percentage") return sum;
+		return sum + position.value;
+	}, 0), 3);
+	if (percentageSum <= 0) return stops;
+	const newStops = [...stops];
+	let offset = percentageSum;
+	while (true) {
+		let shouldContinue = false;
+		for (let i = 0; i < stops.length; i++) {
+			const stop = stops[i];
+			const position = stop.position;
+			if (!position || position.kind !== "percentage") continue;
+			const nextValue = roundTo(position.value + offset, 3);
+			newStops.push({
+				...stop,
+				position: {
+					kind: "percentage",
+					value: nextValue
+				}
+			});
+			if (nextValue <= 1) shouldContinue = true;
+		}
+		const lastGeneratedPosition = newStops[newStops.length - 1]?.position;
+		if (!lastGeneratedPosition || lastGeneratedPosition.kind !== "percentage" || lastGeneratedPosition.value > 1) break;
+		if (!shouldContinue) break;
+		offset = roundTo(offset + percentageSum, 3);
+	}
+	return newStops;
+}
+//#endregion
+//#region src/parser/radial-gradient/parse-radial-gradient.ts
+function parseRadialGradient(source, tokens, startIndex) {
+	const functionToken = getTokenAt(tokens, startIndex);
+	if (functionToken === null || functionToken.kind !== TokenKind.FUNCTION_RADIAL_GRADIENT && functionToken.kind !== TokenKind.FUNCTION_REPEATING_RADIAL_GRADIENT) throw new Error("Expected radial gradient function token");
+	const repeat = functionToken.kind === TokenKind.FUNCTION_REPEATING_RADIAL_GRADIENT ? "repeating" : "normal";
+	let index = startIndex + 1;
+	index = expectToken(tokens, index, TokenKind.PAREN_OPEN).nextIndex;
+	const configResult = parseRadialConfig(tokens, index);
+	const config = configResult.node ?? createDefaultRadialConfig();
+	index = configResult.nextIndex;
+	if (configResult.node !== null) index = expectToken(tokens, index, TokenKind.COMMA).nextIndex;
+	const stopsResult = parseGradientStopList(source, tokens, index);
+	const stops = repeat === "repeating" ? expandColorStops$1(stopsResult.node) : stopsResult.node;
+	index = stopsResult.nextIndex;
+	index = expectToken(tokens, index, TokenKind.PAREN_CLOSE).nextIndex;
+	return {
+		node: {
+			kind: "radial",
+			repeat,
+			shape: config.shape,
+			size: config.size,
+			position: config.position,
+			stops
+		},
+		nextIndex: index
+	};
+}
+function parseRadialConfig(tokens, startIndex) {
+	let index = findNextNonWhitespaceIndex(tokens, startIndex);
+	if (index === -1) return {
+		node: null,
+		nextIndex: startIndex
+	};
+	const shapeResult = parseRadialShape(tokens, index);
+	const shape = shapeResult.node ?? "ellipse";
+	index = shapeResult.nextIndex;
+	const sizeResult = parseRadialSize(tokens, index, shape);
+	const size = sizeResult.node ?? createDefaultRadialSize(shape);
+	index = sizeResult.nextIndex;
+	const positionResult = parseRadialPosition(tokens, index);
+	const position = positionResult.node ?? createDefaultRadialPosition();
+	index = positionResult.nextIndex;
+	if (!(shapeResult.node !== null || sizeResult.node !== null || positionResult.node !== null)) return {
+		node: null,
+		nextIndex: startIndex
+	};
+	return {
+		node: {
+			shape,
+			size,
+			position
+		},
+		nextIndex: index
+	};
+}
+function parseRadialShape(tokens, startIndex) {
+	const index = findNextNonWhitespaceIndex(tokens, startIndex);
+	if (index === -1) return {
+		node: null,
+		nextIndex: startIndex
+	};
+	const token = tokens[index];
+	if (token === void 0) return {
+		node: null,
+		nextIndex: startIndex
+	};
+	if (token.kind === TokenKind.CIRCLE) return {
+		node: "circle",
+		nextIndex: index + 1
+	};
+	if (token.kind === TokenKind.ELLIPSE) return {
+		node: "ellipse",
+		nextIndex: index + 1
+	};
+	return {
+		node: null,
+		nextIndex: startIndex
+	};
+}
+function parseRadialSize(tokens, startIndex, shape) {
+	const index = findNextNonWhitespaceIndex(tokens, startIndex);
+	if (index === -1) return {
+		node: null,
+		nextIndex: startIndex
+	};
+	const token = tokens[index];
+	if (token === void 0) return {
+		node: null,
+		nextIndex: startIndex
+	};
+	const keyword = parseRadialSizeKeyword(token.kind);
+	if (keyword !== null) return {
+		node: createRadialSizeFromKeyword(shape, keyword),
+		nextIndex: index + 1
+	};
+	const firstSize = parseLengthPercentageToken$1(token);
+	if (firstSize === null) return {
+		node: null,
+		nextIndex: startIndex
+	};
+	let nextIndex = findNextNonWhitespaceIndex(tokens, index + 1);
+	let secondSize = null;
+	if (nextIndex !== -1) {
+		const nextToken = tokens[nextIndex];
+		if (nextToken !== void 0) secondSize = parseLengthPercentageToken$1(nextToken);
+	}
+	if (shape === "circle") return {
+		node: createRadialSizeFromRadii(shape, firstSize, firstSize),
+		nextIndex: index + 1
+	};
+	if (secondSize !== null && nextIndex !== -1) return {
+		node: createRadialSizeFromRadii(shape, firstSize, secondSize),
+		nextIndex
+	};
+	return {
+		node: createRadialSizeFromRadii(shape, firstSize, firstSize),
+		nextIndex: index + 1
+	};
+}
+function parseRadialPosition(tokens, startIndex) {
+	let index = findNextNonWhitespaceIndex(tokens, startIndex);
+	if (index === -1) return {
+		node: null,
+		nextIndex: startIndex
+	};
+	const atToken = tokens[index];
+	if (atToken === void 0 || atToken.kind !== TokenKind.AT) return {
+		node: null,
+		nextIndex: startIndex
+	};
+	index += 1;
+	const keywords = [];
+	let x = null;
+	let y = null;
+	while (true) {
+		const nextIndex = findNextNonWhitespaceIndex(tokens, index);
+		if (nextIndex === -1) break;
+		const token = tokens[nextIndex];
+		if (token === void 0) break;
+		const lengthPercentage = parseLengthPercentageToken$1(token);
+		if (lengthPercentage !== null) {
+			if (x === null) x = lengthPercentage;
+			else if (y === null) y = lengthPercentage;
+			else break;
+			index = nextIndex + 1;
+			continue;
+		}
+		if (token.kind === TokenKind.LEFT || token.kind === TokenKind.RIGHT || token.kind === TokenKind.TOP || token.kind === TokenKind.BOTTOM || token.kind === TokenKind.CENTER) {
+			keywords.push(token.kind);
+			index = nextIndex + 1;
+			continue;
+		}
+		break;
+	}
+	return {
+		node: createRadialPositionNode(x, y, keywords),
+		nextIndex: index
+	};
+}
+function createDefaultRadialConfig() {
+	return {
+		shape: "ellipse",
+		size: createDefaultRadialSize("ellipse"),
+		position: createDefaultRadialPosition()
+	};
+}
+function createDefaultRadialSize(shape) {
+	return createRadialSizeFromKeyword(shape, "farthest-corner");
+}
+function createDefaultRadialPosition() {
+	return {
+		kind: "position",
+		x: {
+			kind: "percentage",
+			value: .5
+		},
+		y: {
+			kind: "percentage",
+			value: .5
+		},
+		keywords: ["center"]
+	};
+}
+function createRadialPositionNode(x, y, keywords) {
+	if (keywords.length > 0 && x === null && y === null) return {
+		kind: "position",
+		x: {
+			kind: "percentage",
+			value: .5
+		},
+		y: {
+			kind: "percentage",
+			value: .5
+		},
+		keywords
+	};
+	return {
+		kind: "position",
+		x: x ?? {
+			kind: "percentage",
+			value: .5
+		},
+		y: y ?? {
+			kind: "percentage",
+			value: .5
+		},
+		keywords
+	};
+}
+function createRadialSizeFromKeyword(shape, keyword) {
+	return {
+		kind: "size",
+		shape,
+		keyword,
+		radiusX: {
+			kind: "percentage",
+			value: 1
+		},
+		radiusY: {
+			kind: "percentage",
+			value: shape === "circle" ? 1 : 1
+		}
+	};
+}
+function createRadialSizeFromRadii(shape, radiusX, radiusY) {
+	return {
+		kind: "size",
+		shape,
+		keyword: "farthest-corner",
+		radiusX,
+		radiusY
+	};
+}
+function parseRadialSizeKeyword(kind) {
+	switch (kind) {
+		case TokenKind.CLOSEST_SIDE: return "closest-side";
+		case TokenKind.CLOSEST_CORNER: return "closest-corner";
+		case TokenKind.FARTHEST_SIDE: return "farthest-side";
+		case TokenKind.FARTHEST_CORNER: return "farthest-corner";
+		default: return null;
+	}
+}
+function parseLengthPercentageToken$1(token) {
+	if (token.kind === TokenKind.PERCENTAGE) return {
+		kind: "percentage",
+		value: token.value
+	};
+	if (token.kind === TokenKind.DIMENSION) return {
+		kind: "dimension",
+		value: token.value,
+		unit: token.unit
+	};
+	return null;
+}
+function expandColorStops$1(stops) {
+	if (stops.length < 2) return stops;
+	const lastPosition = stops[stops.length - 1]?.position;
+	if (!lastPosition || lastPosition.kind !== "percentage") return stops;
+	if (lastPosition.value >= 1) return stops;
+	const percentageSum = stops.reduce((sum, stop) => {
+		const position = stop.position;
+		if (!position || position.kind !== "percentage") return sum;
+		return sum + position.value;
+	}, 0);
+	if (percentageSum <= 0) return stops;
+	const newStops = [...stops];
+	let offset = percentageSum;
+	while ((newStops[newStops.length - 1]?.position.value ?? 0) <= 1) {
+		for (const stop of stops) {
+			const position = stop.position;
+			if (!position || position.kind !== "percentage") continue;
+			newStops.push({
+				...stop,
+				position: {
+					kind: "percentage",
+					value: position.value + offset
+				}
+			});
+		}
+		offset += percentageSum;
+	}
+	return newStops;
+}
+//#endregion
+//#region src/parser/conic-gradient/parse-conic-gradient.ts
+function parseConicGradient(source, tokens, startIndex) {
+	const functionToken = getTokenAt(tokens, startIndex);
+	if (functionToken === null || functionToken.kind !== TokenKind.FUNCTION_CONIC_GRADIENT && functionToken.kind !== TokenKind.FUNCTION_REPEATING_CONIC_GRADIENT) throw new Error("Expected conic gradient function token");
+	const repeat = functionToken.kind === TokenKind.FUNCTION_REPEATING_CONIC_GRADIENT ? "repeating" : "normal";
+	let index = startIndex + 1;
+	index = expectToken(tokens, index, TokenKind.PAREN_OPEN).nextIndex;
+	const preludeResult = parseConicPrelude(tokens, index);
+	const prelude = preludeResult.node ?? createDefaultConicPrelude();
+	index = preludeResult.nextIndex;
+	if (preludeResult.node !== null) index = expectToken(tokens, index, TokenKind.COMMA).nextIndex;
+	const stopsResult = parseGradientStopList(source, tokens, index);
+	const stops = repeat === "repeating" ? expandColorStops(stopsResult.node) : stopsResult.node;
+	index = stopsResult.nextIndex;
+	index = expectToken(tokens, index, TokenKind.PAREN_CLOSE).nextIndex;
+	return {
+		node: {
+			kind: "conic",
+			repeat,
+			from: prelude.from,
+			position: prelude.position,
+			stops
+		},
+		nextIndex: index
+	};
+}
+function parseConicPrelude(tokens, startIndex) {
+	let index = startIndex;
+	const fromResult = parseConicFrom(tokens, index);
+	const from = fromResult.node ?? createDefaultConicFrom();
+	index = fromResult.nextIndex;
+	const positionResult = parseConicPosition(tokens, index);
+	const position = positionResult.node ?? createDefaultConicPosition();
+	index = positionResult.nextIndex;
+	if (!(fromResult.node !== null || positionResult.node !== null)) return {
+		node: null,
+		nextIndex: startIndex
+	};
+	return {
+		node: {
+			from,
+			position
+		},
+		nextIndex: index
+	};
+}
+function parseConicFrom(tokens, startIndex) {
+	let index = findNextNonWhitespaceIndex(tokens, startIndex);
+	if (index === -1) return {
+		node: null,
+		nextIndex: startIndex
+	};
+	const fromToken = tokens[index];
+	if (fromToken === void 0 || fromToken.kind !== TokenKind.FROM) return {
+		node: null,
+		nextIndex: startIndex
+	};
+	index += 1;
+	const angleIndex = findNextNonWhitespaceIndex(tokens, index);
+	if (angleIndex === -1) throw new Error("Expected angle after \"from\"");
+	const angleToken = tokens[angleIndex];
+	if (angleToken === void 0) throw new Error("Expected angle token after \"from\"");
+	const angleRad = parseAngleFromToken(angleToken);
+	if (angleRad === null) throw new Error("Expected valid angle after \"from\"");
+	if (angleToken.kind !== TokenKind.DIMENSION) throw new Error("Expected dimension token for conic angle");
+	return {
+		node: createConicFromNode(angleToken.value, angleToken.unit, angleRad),
+		nextIndex: angleIndex + 1
+	};
+}
+function parseConicPosition(tokens, startIndex) {
+	let index = findNextNonWhitespaceIndex(tokens, startIndex);
+	if (index === -1) return {
+		node: null,
+		nextIndex: startIndex
+	};
+	const atToken = tokens[index];
+	if (atToken === void 0 || atToken.kind !== TokenKind.AT) return {
+		node: null,
+		nextIndex: startIndex
+	};
+	index += 1;
+	let x = null;
+	let y = null;
+	const keywords = [];
+	while (true) {
+		const nextIndex = findNextNonWhitespaceIndex(tokens, index);
+		if (nextIndex === -1) break;
+		const token = tokens[nextIndex];
+		if (token === void 0) break;
+		const lengthPercentage = parseLengthPercentageToken(token);
+		if (lengthPercentage !== null) {
+			if (x === null) x = lengthPercentage;
+			else if (y === null) y = lengthPercentage;
+			else break;
+			index = nextIndex + 1;
+			continue;
+		}
+		if (token.kind === TokenKind.LEFT || token.kind === TokenKind.RIGHT || token.kind === TokenKind.TOP || token.kind === TokenKind.BOTTOM || token.kind === TokenKind.CENTER) {
+			keywords.push(token.kind);
+			index = nextIndex + 1;
+			continue;
+		}
+		break;
+	}
+	return {
+		node: createConicPositionNode(x, y, keywords),
+		nextIndex: index
+	};
+}
+function createDefaultConicPrelude() {
+	return {
+		from: createDefaultConicFrom(),
+		position: createDefaultConicPosition()
+	};
+}
+function createDefaultConicFrom() {
+	return createConicFromNode(0, "deg", 0);
+}
+function createDefaultConicPosition() {
+	return {
+		kind: "position",
+		x: {
+			kind: "percentage",
+			value: .5
+		},
+		y: {
+			kind: "percentage",
+			value: .5
+		},
+		keywords: ["center"]
+	};
+}
+function createConicFromNode(value, unit, normalizedRad) {
+	return {
+		kind: "angle",
+		value: {
+			kind: "dimension",
+			value,
+			unit
+		},
+		valueRaw: {
+			kind: "dimension",
+			value: roundTo(normalizedRad, 6),
+			unit: "rad"
+		}
+	};
+}
+function createConicPositionNode(x, y, keywords) {
+	if (keywords.length > 0 && x === null && y === null) return {
+		kind: "position",
+		x: {
+			kind: "percentage",
+			value: .5
+		},
+		y: {
+			kind: "percentage",
+			value: .5
+		},
+		keywords: [...keywords]
+	};
+	return {
+		kind: "position",
+		x: x ?? {
+			kind: "percentage",
+			value: .5
+		},
+		y: y ?? {
+			kind: "percentage",
+			value: .5
+		},
+		keywords: [...keywords]
+	};
+}
+function parseLengthPercentageToken(token) {
+	if (token.kind === TokenKind.PERCENTAGE) return {
+		kind: "percentage",
+		value: token.value
+	};
+	if (token.kind === TokenKind.DIMENSION) return {
+		kind: "dimension",
+		value: token.value,
+		unit: token.unit
+	};
+	return null;
+}
+function expandColorStops(stops) {
+	if (stops.length < 2) return stops;
+	const lastPosition = stops[stops.length - 1]?.position;
+	if (!lastPosition || lastPosition.kind !== "percentage") return stops;
+	if (lastPosition.value >= 1) return stops;
+	const percentageSum = roundTo(stops.reduce((sum, stop) => {
+		const position = stop.position;
+		if (!position || position.kind !== "percentage") return sum;
+		return sum + position.value;
+	}, 0), 3);
+	if (percentageSum <= 0) return stops;
+	const newStops = [...stops];
+	let offset = percentageSum;
+	while (true) {
+		let shouldContinue = false;
+		for (const stop of stops) {
+			const position = stop.position;
+			if (!position || position.kind !== "percentage") continue;
+			const nextValue = roundTo(position.value + offset, 3);
+			newStops.push({
+				...stop,
+				position: {
+					kind: "percentage",
+					value: nextValue
+				}
+			});
+			if (nextValue <= 1) shouldContinue = true;
+		}
+		const lastGeneratedPosition = newStops[newStops.length - 1]?.position;
+		if (!lastGeneratedPosition || lastGeneratedPosition.kind !== "percentage" || lastGeneratedPosition.value > 1) break;
+		if (!shouldContinue) break;
+		offset = roundTo(offset + percentageSum, 3);
+	}
+	return newStops;
+}
+//#endregion
+//#region src/parser/parse.ts
+function parse(value) {
+	const tokens = tokenize(value);
+	const firstToken = getTokenAt(tokens, 0);
+	if (firstToken === null) throw new Error("Empty input");
+	switch (firstToken.kind) {
+		case TokenKind.FUNCTION_LINEAR_GRADIENT:
+		case TokenKind.FUNCTION_REPEATING_LINEAR_GRADIENT: return parseLinearGradient(value, tokens, 0).node;
+		case TokenKind.FUNCTION_RADIAL_GRADIENT:
+		case TokenKind.FUNCTION_REPEATING_RADIAL_GRADIENT: return parseRadialGradient(value, tokens, 0).node;
+		case TokenKind.FUNCTION_CONIC_GRADIENT:
+		case TokenKind.FUNCTION_REPEATING_CONIC_GRADIENT: return parseConicGradient(value, tokens, 0).node;
+		default: throw new Error(`Unsupported gradient type: ${firstToken.kind}`);
+	}
+}
+//#endregion
+export { GradientFunctionNameToToken, KeywordNameToToken, TokenKind, advance, ceilTo, clamp, consumeIf, createLexerState, createSpan, currentChar, degToRad, expectToken, findBalancedFunctionEndIndex, findNextNonWhitespaceIndex, floorTo, fromPercent, getNonWhitespaceTokenAt, getSourceSlice, getTokenAt, getTokenRangeSourceSlice, getTokenSourceSlice, gradToRad, isAlphaChar, isAngleUnit, isDigitChar, isEnd, isGradientFunctionToken, isIdentifierChar, isIdentifierStartChar, isKeywordToken, isNumericToken, isSignChar, isTriviaToken, isWhitespaceChar, nextToken, normalizeAngle, normalizeAngleDeg, normalizeAngleRad, parse, parseAngleFromToken, parseColorStop, parseConicGradient, parseGradientStopItem, parseGradientStopList, parseLinearGradient, parseRadialGradient, peekChar, radToDeg, readWhile, roundTo, skipWhitespace, toAngleRad, toPercent, tokenize, truncTo, turnToRad };