gradiente 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Flowscape UI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,307 @@
+![gradiente](./assets/logo.svg)
+
+# Gradiente
+
+**Gradiente** is a lightweight gradient engine for turning CSS gradients into clean, normalized data structures.
+
+It is built for rendering systems, visual editors, and developer tools where gradients need to be more than just strings.
+
+> **Gradients as data, not strings.**
+
+---
+
+## Why
+
+CSS gradients are expressive, but difficult to work with programmatically.
+
+They are usually:
+
+* string-based
+* hard to normalize
+* full of implicit behavior
+* awkward to use in renderers and editors
+
+Gradiente solves that by parsing gradients into a predictable internal model that is easy to inspect, transform, render, and extend.
+
+---
+
+## Installation
+
+```bash
+npm install gradiente
+```
+
+---
+
+## Quick Example
+
+```ts
+import { parse } from 'gradiente';
+
+const gradient = parse('linear-gradient(red, blue)');
+```
+
+Result:
+
+```ts
+{
+  kind: 'linear',
+  repeat: 'normal',
+  direction: {
+    kind: 'angle',
+    value: { kind: 'dimension', value: 0, unit: 'deg' },
+    valueRaw: { kind: 'dimension', value: 0, unit: 'rad' },
+    keywords: ['to', 'top']
+  },
+  stops: [
+    {
+      kind: 'color-stop',
+      color: 'red',
+      position: { kind: 'percentage', value: 0 }
+    },
+    {
+      kind: 'color-stop',
+      color: 'blue',
+      position: { kind: 'percentage', value: 1 }
+    }
+  ]
+}
+```
+
+---
+
+## Supported Gradients
+
+Gradiente currently supports:
+
+```ts
+parse('linear-gradient(...)')
+parse('repeating-linear-gradient(...)')
+
+parse('radial-gradient(...)')
+parse('repeating-radial-gradient(...)')
+
+parse('conic-gradient(...)')
+parse('repeating-conic-gradient(...)')
+```
+
+---
+
+## What Gradiente Does
+
+### Parses gradients into structured objects
+
+```ts
+import { parse } from 'gradiente';
+
+const gradient = parse('conic-gradient(from 45deg, red, blue)');
+```
+
+Instead of getting a raw string you have to manually interpret, you get real data you can work with.
+
+---
+
+### Normalizes missing stop positions
+
+```ts
+parse('linear-gradient(red, blue)')
+```
+
+becomes:
+
+```ts
+red 0%
+blue 100%
+```
+
+That means your renderer or editor does not need to guess defaults later.
+
+---
+
+### Expands repeating gradients into actual stops
+
+```ts
+parse('repeating-linear-gradient(red 10%, blue 20%)')
+```
+
+produces a stop list that continues until the gradient pattern fills `100%+`.
+
+This makes repeating gradients much easier to render and inspect.
+
+---
+
+### Keeps values renderer-friendly
+
+Angles and positions are normalized into a stable internal representation so they are easier to use in:
+
+* Canvas
+* WebGL
+* Pixi
+* Konva
+* custom graphics engines
+
+---
+
+## Public API
+
+### `parse(value: string)`
+
+Parses any supported gradient string into a normalized gradient node.
+
+```ts
+import { parse } from 'gradiente';
+
+const gradient = parse('radial-gradient(circle at center, red, blue)');
+```
+
+---
+
+## Output Shape
+
+All parsed gradients follow a predictable structure:
+
+```ts
+type GradientNode =
+  | LinearGradientNode
+  | RadialGradientNode
+  | ConicGradientNode;
+```
+
+Each gradient contains:
+
+```ts
+{
+  kind: 'linear' | 'radial' | 'conic',
+  repeat: 'normal' | 'repeating',
+  stops: GradientColorStopNode[]
+}
+```
+
+---
+
+## Stop Format
+
+Gradiente resolves gradients into a clean stop model:
+
+```ts
+{
+  kind: 'color-stop',
+  color: string,
+  position: {
+    kind: 'percentage',
+    value: number
+  }
+}
+```
+
+This makes the data much easier to use in custom pipelines.
+
+---
+
+## Examples
+
+### Linear
+
+```ts
+parse('linear-gradient(to right, red, blue)')
+```
+
+### Repeating Linear
+
+```ts
+parse('repeating-linear-gradient(red 10%, blue 20%)')
+```
+
+### Radial
+
+```ts
+parse('radial-gradient(circle at center, red, blue)')
+```
+
+### Repeating Radial
+
+```ts
+parse('repeating-radial-gradient(circle at center, red 10%, blue 20%)')
+```
+
+### Conic
+
+```ts
+parse('conic-gradient(from 45deg at center, red, blue)')
+```
+
+### Repeating Conic
+
+```ts
+parse('repeating-conic-gradient(from 45deg at center, red 10%, blue 20%)')
+```
+
+---
+
+## Design Goals
+
+Gradiente is built around a few core ideas:
+
+* **Simple external API**
+* **Normalized internal model**
+* **Predictable stop data**
+* **Useful for real rendering systems**
+* **Easy to extend for future gradient types**
+
+It is not trying to be a full browser CSS engine.
+
+It is trying to be a practical gradient engine for developers.
+
+---
+
+## Built For
+
+Gradiente is especially useful for:
+
+* design tools
+* visual editors
+* whiteboards
+* canvas engines
+* procedural graphics
+* charting and data visualization systems
+* custom render pipelines
+
+---
+
+## Current Status
+
+Implemented:
+
+* linear gradients
+* repeating linear gradients
+* radial gradients
+* repeating radial gradients
+* conic gradients
+* repeating conic gradients
+* stop normalization
+* repeating stop expansion
+
+Planned:
+
+* gradient serialization
+* gradient sampling
+* playground / live preview
+* docs website
+
+---
+
+## Philosophy
+
+Gradiente treats gradients as a structured graphics primitive.
+
+Not a string to preserve.
+Not a browser quirk to emulate.
+A piece of graphics data you can actually use.
+
+> **Build gradients like an engine, not like a stylesheet.**
+
+---
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,335 @@
+//#region src/token.d.ts
+declare const TokenKind: {
+  readonly PAREN_OPEN: 'paren-open';
+  readonly PAREN_CLOSE: 'paren-close';
+  readonly COMMA: 'comma';
+  readonly SLASH: 'slash';
+  readonly FUNCTION_LINEAR_GRADIENT: 'function-linear-gradient';
+  readonly FUNCTION_REPEATING_LINEAR_GRADIENT: 'function-repeating-linear-gradient';
+  readonly FUNCTION_RADIAL_GRADIENT: 'function-radial-gradient';
+  readonly FUNCTION_REPEATING_RADIAL_GRADIENT: 'function-repeating-radial-gradient';
+  readonly FUNCTION_CONIC_GRADIENT: 'function-conic-gradient';
+  readonly FUNCTION_REPEATING_CONIC_GRADIENT: 'function-repeating-conic-gradient';
+  readonly FUNCTION_DIAMOND_GRADIENT: 'function-diamond-gradient';
+  readonly FUNCTION_REPEATING_DIAMOND_GRADIENT: 'function-repeating-diamond-gradient';
+  readonly FUNCTION_MESH_GRADIENT: 'function-mesh-gradient';
+  readonly TO: 'to';
+  readonly TOP: 'top';
+  readonly BOTTOM: 'bottom';
+  readonly LEFT: 'left';
+  readonly RIGHT: 'right';
+  readonly AT: 'at';
+  readonly FROM: 'from';
+  readonly CENTER: 'center';
+  readonly CIRCLE: 'circle';
+  readonly ELLIPSE: 'ellipse';
+  readonly CLOSEST_SIDE: 'closest-side';
+  readonly CLOSEST_CORNER: 'closest-corner';
+  readonly FARTHEST_SIDE: 'farthest-side';
+  readonly FARTHEST_CORNER: 'farthest-corner';
+  readonly IN: 'in';
+  readonly SHORTER: 'shorter';
+  readonly LONGER: 'longer';
+  readonly INCREASING: 'increasing';
+  readonly DECREASING: 'decreasing';
+  readonly HUE: 'hue';
+  readonly IDENT: 'ident';
+  readonly NUMBER: 'number';
+  readonly PERCENTAGE: 'percentage';
+  readonly DIMENSION: 'dimension';
+  readonly FUNCTION: 'function';
+  readonly HASH: 'hash';
+  readonly STRING: 'string';
+  readonly WHITESPACE: 'whitespace';
+  readonly EOF: 'eof';
+  readonly UNKNOWN: 'unknown';
+};
+type TokenKind = (typeof TokenKind)[keyof typeof TokenKind];
+interface TokenBase {
+  kind: TokenKind;
+  start: number;
+  end: number;
+  raw: string;
+}
+interface PunctuationToken extends TokenBase {
+  kind: typeof TokenKind.PAREN_OPEN | typeof TokenKind.PAREN_CLOSE | typeof TokenKind.COMMA | typeof TokenKind.SLASH;
+}
+interface KeywordToken extends TokenBase {
+  kind: typeof TokenKind.TO | typeof TokenKind.TOP | typeof TokenKind.BOTTOM | typeof TokenKind.LEFT | typeof TokenKind.RIGHT | typeof TokenKind.AT | typeof TokenKind.FROM | typeof TokenKind.CENTER | typeof TokenKind.CIRCLE | typeof TokenKind.ELLIPSE | typeof TokenKind.CLOSEST_SIDE | typeof TokenKind.CLOSEST_CORNER | typeof TokenKind.FARTHEST_SIDE | typeof TokenKind.FARTHEST_CORNER | typeof TokenKind.IN | typeof TokenKind.SHORTER | typeof TokenKind.LONGER | typeof TokenKind.INCREASING | typeof TokenKind.DECREASING | typeof TokenKind.HUE;
+}
+interface GradientFunctionToken extends TokenBase {
+  kind: typeof TokenKind.FUNCTION_LINEAR_GRADIENT | typeof TokenKind.FUNCTION_REPEATING_LINEAR_GRADIENT | typeof TokenKind.FUNCTION_RADIAL_GRADIENT | typeof TokenKind.FUNCTION_REPEATING_RADIAL_GRADIENT | typeof TokenKind.FUNCTION_CONIC_GRADIENT | typeof TokenKind.FUNCTION_REPEATING_CONIC_GRADIENT | typeof TokenKind.FUNCTION_DIAMOND_GRADIENT | typeof TokenKind.FUNCTION_REPEATING_DIAMOND_GRADIENT | typeof TokenKind.FUNCTION_MESH_GRADIENT;
+  name: string;
+}
+interface FunctionToken extends TokenBase {
+  kind: typeof TokenKind.FUNCTION;
+  name: string;
+}
+interface IdentToken extends TokenBase {
+  kind: typeof TokenKind.IDENT;
+  value: string;
+}
+interface NumberToken extends TokenBase {
+  kind: typeof TokenKind.NUMBER;
+  value: number;
+  sign: -1 | 1;
+}
+interface PercentageToken extends TokenBase {
+  kind: typeof TokenKind.PERCENTAGE;
+  value: number;
+  sign: -1 | 1;
+}
+interface DimensionToken extends TokenBase {
+  kind: typeof TokenKind.DIMENSION;
+  value: number;
+  sign: -1 | 1;
+  unit: string;
+}
+interface HashToken extends TokenBase {
+  kind: typeof TokenKind.HASH;
+  value: string;
+}
+interface StringToken extends TokenBase {
+  kind: typeof TokenKind.STRING;
+  value: string;
+  quote: '"' | "'";
+}
+interface WhitespaceToken extends TokenBase {
+  kind: typeof TokenKind.WHITESPACE;
+}
+interface EofToken extends TokenBase {
+  kind: typeof TokenKind.EOF;
+}
+interface UnknownToken extends TokenBase {
+  kind: typeof TokenKind.UNKNOWN;
+}
+type GradientLexerToken = PunctuationToken | KeywordToken | GradientFunctionToken | FunctionToken | IdentToken | NumberToken | PercentageToken | DimensionToken | HashToken | StringToken | WhitespaceToken | EofToken | UnknownToken;
+declare const GradientFunctionNameToToken: {
+  readonly 'linear-gradient': "function-linear-gradient";
+  readonly 'repeating-linear-gradient': "function-repeating-linear-gradient";
+  readonly 'radial-gradient': "function-radial-gradient";
+  readonly 'repeating-radial-gradient': "function-repeating-radial-gradient";
+  readonly 'conic-gradient': "function-conic-gradient";
+  readonly 'repeating-conic-gradient': "function-repeating-conic-gradient";
+  readonly 'diamond-gradient': "function-diamond-gradient";
+  readonly 'repeating-diamond-gradient': "function-repeating-diamond-gradient";
+  readonly 'mesh-gradient': "function-mesh-gradient";
+};
+declare const KeywordNameToToken: {
+  readonly to: "to";
+  readonly top: "top";
+  readonly bottom: "bottom";
+  readonly left: "left";
+  readonly right: "right";
+  readonly at: "at";
+  readonly from: "from";
+  readonly center: "center";
+  readonly circle: "circle";
+  readonly ellipse: "ellipse";
+  readonly 'closest-side': "closest-side";
+  readonly 'closest-corner': "closest-corner";
+  readonly 'farthest-side': "farthest-side";
+  readonly 'farthest-corner': "farthest-corner";
+  readonly in: "in";
+  readonly shorter: "shorter";
+  readonly longer: "longer";
+  readonly increasing: "increasing";
+  readonly decreasing: "decreasing";
+  readonly hue: "hue";
+};
+//#endregion
+//#region src/lexer/base.d.ts
+interface LexerState {
+  source: string;
+  length: number;
+  position: number;
+}
+interface SourceSpan {
+  start: number;
+  end: number;
+  raw: string;
+}
+declare function createLexerState(source: string): LexerState;
+declare function isEnd(state: LexerState): boolean;
+declare function currentChar(state: LexerState): string | null;
+declare function peekChar(state: LexerState, offset?: number): string | null;
+declare function advance(state: LexerState, step?: number): void;
+declare function isWhitespaceChar(char: string | null): boolean;
+declare function isDigitChar(char: string | null): boolean;
+declare function isSignChar(char: string | null): boolean;
+declare function isIdentifierStartChar(char: string | null): boolean;
+declare function isIdentifierChar(char: string | null): boolean;
+declare function isAlphaChar(char: string | null): boolean;
+declare function readWhile(state: LexerState, predicate: (char: string | null) => boolean): string;
+declare function createSpan(source: string, start: number, end: number): SourceSpan;
+//#endregion
+//#region src/lexer/lexer.d.ts
+declare function nextToken(state: LexerState): GradientLexerToken;
+declare function tokenize(source: string): GradientLexerToken[];
+//#endregion
+//#region src/guard.d.ts
+declare function isGradientFunctionToken(token: GradientLexerToken): boolean;
+declare function isKeywordToken(token: GradientLexerToken): boolean;
+declare function isNumericToken(token: GradientLexerToken): boolean;
+//#endregion
+//#region src/source.d.ts
+declare function getSourceSlice(source: string, start: number, end: number): string;
+declare function getTokenSourceSlice(source: string, startToken: GradientLexerToken, endToken: GradientLexerToken): string;
+declare function getTokenRangeSourceSlice(source: string, tokens: readonly GradientLexerToken[], startIndex: number, endIndex: number): string;
+declare function findBalancedFunctionEndIndex(tokens: readonly GradientLexerToken[], startIndex: number): number;
+//#endregion
+//#region src/utils/parser-utils.d.ts
+declare function isTriviaToken(token: GradientLexerToken): boolean;
+declare function getTokenAt(tokens: readonly GradientLexerToken[], index: number): GradientLexerToken | null;
+declare function findNextNonWhitespaceIndex(tokens: readonly GradientLexerToken[], startIndex: number): number;
+declare function getNonWhitespaceTokenAt(tokens: readonly GradientLexerToken[], startIndex: number): GradientLexerToken | null;
+declare function skipWhitespace(tokens: readonly GradientLexerToken[], startIndex: number): number;
+declare function consumeIf(tokens: readonly GradientLexerToken[], index: number, kind: GradientLexerToken['kind']): {
+  matched: boolean;
+  nextIndex: number;
+  token: GradientLexerToken | null;
+};
+declare function expectToken(tokens: readonly GradientLexerToken[], index: number, kind: GradientLexerToken['kind'], message?: string): {
+  token: GradientLexerToken;
+  nextIndex: number;
+};
+//#endregion
+//#region src/utils/math/base.d.ts
+declare function roundTo(value: number, digits: number): number;
+declare function floorTo(value: number, digits: number): number;
+declare function ceilTo(value: number, digits: number): number;
+declare function truncTo(value: number, digits: number): number;
+declare function clamp(value: number, min: number, max: number): number;
+declare function toPercent(value: number): number;
+declare function fromPercent(value: number): number;
+//#endregion
+//#region src/utils/math/angle.d.ts
+type AngleUnit = 'deg' | 'rad' | 'turn' | 'grad';
+declare function isAngleUnit(unit: string): unit is AngleUnit;
+declare function degToRad(value: number): number;
+declare function radToDeg(value: number): number;
+declare function turnToRad(value: number): number;
+declare function gradToRad(value: number): number;
+declare function normalizeAngleDeg(value: number, digits?: number): number;
+declare function normalizeAngleRad(value: number): number;
+declare function toAngleRad(value: number, unit: AngleUnit): number;
+declare function normalizeAngle(value: number, unit: AngleUnit, digits?: number): number;
+declare function parseAngleFromToken(token: GradientLexerToken): number | null;
+//#endregion
+//#region src/parser/types.d.ts
+interface ParseResult<T> {
+  node: T;
+  nextIndex: number;
+}
+//#endregion
+//#region src/parser/conic-gradient/types.d.ts
+interface ConicGradientFromNode {
+  kind: 'angle';
+  value: GradientDimensionNode;
+  valueRaw: GradientDimensionNode;
+}
+interface ConicGradientPositionNode {
+  kind: 'position';
+  x: GradientLengthPercentageNode;
+  y: GradientLengthPercentageNode;
+  keywords: readonly ('left' | 'right' | 'top' | 'bottom' | 'center')[];
+}
+interface ConicGradientNode extends GradientNodeBase {
+  kind: 'conic';
+  from: ConicGradientFromNode;
+  position: ConicGradientPositionNode;
+  stops: readonly GradientColorStopNode[];
+}
+//#endregion
+//#region src/parser/conic-gradient/parse-conic-gradient.d.ts
+declare function parseConicGradient(source: string, tokens: readonly GradientLexerToken[], startIndex: number): ParseResult<ConicGradientNode>;
+//#endregion
+//#region src/parser/linear-gradient/types.d.ts
+interface LinearGradientDirectionNode {
+  kind: 'angle';
+  value: GradientDimensionNode;
+  valueRaw: GradientDimensionNode;
+  keywords: readonly ('to' | 'top' | 'bottom' | 'left' | 'right')[];
+}
+interface LinearGradientNode extends GradientNodeBase {
+  kind: 'linear';
+  direction: LinearGradientDirectionNode | null;
+  stops: readonly GradientStopItemNode[];
+}
+//#endregion
+//#region src/parser/linear-gradient/parse-linear-gradient.d.ts
+declare function parseLinearGradient(source: string, tokens: readonly GradientLexerToken[], startIndex: number): ParseResult<LinearGradientNode>;
+//#endregion
+//#region src/parser/radial-gradient/types.d.ts
+type RadialGradientShape = 'circle' | 'ellipse';
+type RadialGradientSizeKeyword = 'closest-side' | 'closest-corner' | 'farthest-side' | 'farthest-corner';
+interface RadialGradientPositionNode {
+  kind: 'position';
+  x: GradientLengthPercentageNode;
+  y: GradientLengthPercentageNode;
+  keywords: readonly string[];
+}
+interface RadialGradientSizeNode {
+  kind: 'size';
+  shape: RadialGradientShape;
+  keyword: RadialGradientSizeKeyword;
+  radiusX: GradientLengthPercentageNode;
+  radiusY: GradientLengthPercentageNode;
+}
+interface RadialGradientNode extends GradientNodeBase {
+  kind: 'radial';
+  shape: RadialGradientShape;
+  size: RadialGradientSizeNode;
+  position: RadialGradientPositionNode;
+  stops: readonly GradientColorStopNode[];
+}
+//#endregion
+//#region src/parser/radial-gradient/parse-radial-gradient.d.ts
+declare function parseRadialGradient(source: string, tokens: readonly GradientLexerToken[], startIndex: number): ParseResult<RadialGradientNode>;
+//#endregion
+//#region src/parser/ast.d.ts
+type GradientKind = 'linear' | 'radial' | 'conic' | 'diamond' | 'mesh';
+type GradientRepeatMode = 'normal' | 'repeating';
+interface GradientNodeBase {
+  kind: GradientKind;
+  repeat: GradientRepeatMode;
+}
+interface GradientColorStopNode {
+  kind: 'color-stop';
+  color: string;
+  position: GradientLengthPercentageNode;
+}
+type GradientStopItemNode = GradientColorStopNode;
+interface GradientNumberNode {
+  kind: 'number';
+  value: number;
+}
+interface GradientPercentageNode {
+  kind: 'percentage';
+  value: number;
+}
+interface GradientDimensionNode {
+  kind: 'dimension';
+  value: number;
+  unit: string;
+}
+type GradientNumericNode = GradientNumberNode | GradientPercentageNode | GradientDimensionNode;
+type GradientLengthPercentageNode = GradientPercentageNode | GradientDimensionNode;
+interface GradientPositionNode {
+  x: GradientLengthPercentageNode | null;
+  y: GradientLengthPercentageNode | null;
+  keywords: readonly string[];
+}
+type GradientNode = LinearGradientNode | RadialGradientNode | ConicGradientNode;
+//#endregion
+//#region src/parser/helpers/color-helpers.d.ts
+declare function parseColorStop(source: string, tokens: readonly GradientLexerToken[], startIndex: number): ParseResult<GradientColorStopNode>;
+//#endregion
+//#region src/parser/helpers/stop-helpers.d.ts
+declare function parseGradientStopList(source: string, tokens: readonly GradientLexerToken[], startIndex: number): ParseResult<readonly GradientStopItemNode[]>;
+declare function parseGradientStopItem(source: string, tokens: readonly GradientLexerToken[], startIndex: number): ParseResult<GradientStopItemNode>;
+//#endregion
+//#region src/parser/parse.d.ts
+declare function parse(value: string): GradientNode;
+//#endregion
+export { AngleUnit, ConicGradientFromNode, ConicGradientNode, ConicGradientPositionNode, DimensionToken, EofToken, FunctionToken, GradientColorStopNode, GradientDimensionNode, GradientFunctionNameToToken, GradientFunctionToken, GradientKind, GradientLengthPercentageNode, GradientLexerToken, GradientNode, GradientNodeBase, GradientNumberNode, GradientNumericNode, GradientPercentageNode, GradientPositionNode, GradientRepeatMode, GradientStopItemNode, HashToken, IdentToken, KeywordNameToToken, KeywordToken, LexerState, LinearGradientDirectionNode, LinearGradientNode, NumberToken, ParseResult, PercentageToken, PunctuationToken, RadialGradientNode, RadialGradientPositionNode, RadialGradientShape, RadialGradientSizeKeyword, RadialGradientSizeNode, SourceSpan, StringToken, TokenBase, TokenKind, UnknownToken, WhitespaceToken, 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 };