gradiente 1.0.2 → 2.0.1

package/dist/index.d.mts

@@ -1,199 +1,3 @@
-//#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;
@@ -214,122 +18,390 @@ 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;
-}
+//#region src/abi.d.ts
+/***************************************************************************************************/
+type AbiInputType = "config" | "color-stop" | "color-hint";
+type GradientAbi = {
+  functionName: string;
+  isRepeating: boolean;
+  inputs: GradientAbiInput[];
+};
+type GradientAbiInput = {
+  type: string;
+  value: string;
+};
+declare function parseStringToAbi(value: string, pattern?: string): GradientAbi;
+declare function isColorHint(value: string): boolean;
+declare function isColorStop(value: string): boolean;
+declare function isConfig(value: string): boolean;
+declare function splitTopLevelByWhitespace(value: string): string[];
 //#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[];
+//#region src/dsl/types.d.ts
+declare enum PatternTokenKind {
+  START = "^",
+  END = ".",
+  GROUP_OPEN = "(",
+  GROUP_CLOSE = ")",
+  COMMA = ",",
+  SEQUENCE_OPEN = "[",
+  SEQUENCE_CLOSE = "]",
+  OR = "|",
+  AND = "&",
+  NOT = "!",
+  REPEAT = "~",
+  CONFIG = "config",
+  COLOR_STOP = "color-stop",
+  COLOR_HINT = "color-hint"
 }
 //#endregion
-//#region src/parser/conic-gradient/parse-conic-gradient.d.ts
-declare function parseConicGradient(source: string, tokens: readonly GradientLexerToken[], startIndex: number): ParseResult<ConicGradientNode>;
+//#region src/dsl/pattern-validator.d.ts
+/********************************************************************/
+/********************************************************************/
+declare function validatePattern(input: string): boolean;
+declare function isPatternValid(input: string): boolean;
+/********************************************************************/
+/********************************************************************/
+declare function validatePatternSyntax(input: string): boolean;
+declare function isPatternSyntaxValid(input: string): boolean;
+declare function validatePatternSemantic(input: string): boolean;
+/********************************************************************/
+/********************************************************************/
+declare function validatePatternStructure(input: string): boolean;
+/********************************************************************/
+/********************************************************************/
+declare function tokenizePattern(input: string): PatternTokenKind[];
+//#endregion
+//#region src/dsl/match.d.ts
+type MatchResult = {
+  matched: boolean;
+  nextInputIndex: number;
+  nextPatternIndex: number;
+};
+declare function matchExpression(classified: GradientAbiInput[], patternTokens: PatternTokenKind[], inputIndex: number, patternIndex: number): MatchResult;
+//#endregion
+//#region src/dsl/index.d.ts
+declare function isValid(input: GradientAbiInput[], pattern: string): boolean;
+declare function validate(classified: GradientAbiInput[], pattern: string): boolean;
+//#endregion
+//#region src/gradients/types.d.ts
+/**
+ * Shared scalar units
+ */
+type GradientAngleUnit = "deg" | "rad" | "turn" | "grad";
+type GradientLengthUnit = "px" | "em" | "rem" | "vw" | "vh" | "vmin" | "vmax" | "cm" | "mm" | "in" | "pt" | "pc";
+type GradientNumberValue = {
+  kind: "number";
+  value: number;
+};
+type GradientPercentValue = {
+  kind: "percent";
+  value: number;
+};
+type GradientLengthValue = {
+  kind: "length";
+  value: number;
+  unit: GradientLengthUnit;
+};
+type GradientAngleValue = {
+  kind: "angle";
+  value: number;
+  unit: GradientAngleUnit;
+};
+type GradientLengthPercentage = GradientLengthValue | GradientPercentValue;
+type GradientPositionKeywordX = "left" | "center" | "right";
+type GradientPositionKeywordY = "top" | "center" | "bottom";
+/**
+ * Position model
+ * Не строка, а нормальная структура.
+ */
+type GradientPosition = {
+  kind: "keywords";
+  x: GradientPositionKeywordX;
+  y: GradientPositionKeywordY;
+} | {
+  kind: "values";
+  x: GradientLengthPercentage;
+  y: GradientLengthPercentage;
+};
+/**
+ * Color interpolation
+ * Вынесено отдельно от geometry.
+ * Это критично для future-proof модели.
+ */
+type GradientHueInterpolationMethod = "shorter" | "longer" | "increasing" | "decreasing";
+type GradientRectangularColorSpace = "srgb" | "srgb-linear" | "display-p3" | "display-p3-linear" | "a98-rgb" | "prophoto-rgb" | "rec2020" | "lab" | "oklab" | "xyz" | "xyz-d50" | "xyz-d65";
+type GradientPolarColorSpace = "hsl" | "hwb" | "lch" | "oklch";
+type GradientColorInterpolation = {
+  kind: "rectangular";
+  space: GradientRectangularColorSpace;
+} | {
+  kind: "polar";
+  space: GradientPolarColorSpace;
+  hueMethod?: GradientHueInterpolationMethod;
+};
+/**
+ * Shared stop model
+ * Твой текущий stop layer сюда ложится нормально.
+ */
+type GradientColorStop = {
+  type: "color-stop";
+  color: string;
+  position: number | null;
+};
+type GradientColorHint = {
+  type: "color-hint";
+  position: number;
+};
+type GradientStop = {
+  type: "color-stop" | "color-hint";
+  value: string;
+  position: number;
+};
+/**
+ * Base config fields common to all gradient classes
+ */
+type GradientCommonConfig = {
+  interpolation?: GradientColorInterpolation | null;
+};
 //#endregion
-//#region src/parser/linear-gradient/types.d.ts
-interface LinearGradientDirectionNode {
-  kind: 'angle';
-  value: GradientDimensionNode;
-  valueRaw: GradientDimensionNode;
-  keywords: readonly ('to' | 'top' | 'bottom' | 'left' | 'right')[];
+//#region src/gradients/GradientBase.d.ts
+type GradientType = string;
+interface GradientData<TConfig = unknown> {
+  isRepeating: boolean;
+  config: TConfig;
+  stops: GradientStop[];
 }
-interface LinearGradientNode extends GradientNodeBase {
-  kind: 'linear';
-  direction: LinearGradientDirectionNode | null;
-  stops: readonly GradientStopItemNode[];
+interface IGradientBase<TConfig = unknown> {
+  readonly type: GradientType;
+  readonly isRepeating: boolean;
+  readonly config: TConfig;
+  readonly stops: GradientStop[];
+  clone(): this;
+  toString(): string;
+  toJSON(): GradientData<TConfig>;
+  addStop(stop: GradientStop): void;
+  removeStop(index: number): void;
+  equals(other: IGradientBase<TConfig>): boolean;
+}
+declare abstract class GradientBase<TConfig = unknown> implements IGradientBase<TConfig> {
+  abstract readonly type: GradientType;
+  private _isRepeating;
+  private _config;
+  private _stops;
+  constructor(options: GradientData<TConfig>);
+  get isRepeating(): boolean;
+  get config(): TConfig;
+  get stops(): GradientStop[];
+  abstract clone(): this;
+  abstract toString(): string;
+  toJSON(): GradientData<TConfig> & {
+    type: GradientType;
+  };
+  addStop(stop: GradientStop): void;
+  static fromString(_: string): void;
+  static fromAbi(_: GradientAbi): void;
+  removeStop(index: number): void;
+  equals(other: IGradientBase<TConfig>): boolean;
+  protected _minColorStopsCount(): number;
+  protected _getSortedStops(stops: GradientStop[]): GradientStop[];
+  protected abstract _validateConfig(value: TConfig): void;
+  private _validateStops;
+  protected _validateStopsShape(value: GradientStop[]): void;
+  protected _validateStopsSequence(value: GradientStop[]): void;
+  private _cloneStops;
+  private _cloneConfig;
+  protected _buildSerializedStopTokens(): Array<{
+    type: 'color-hint';
+    position: number;
+  } | {
+    type: 'color-stop';
+    value: string;
+    positions: [number] | [number, number];
+  }>;
+  protected _canOmitAllStopPositions(tokens: Array<{
+    type: 'color-hint';
+    position: number;
+  } | {
+    type: 'color-stop';
+    value: string;
+    positions: [number] | [number, number];
+  }>): boolean;
+  protected _serializeStopsCompact(): string[];
+  protected _formatPercent(value: number): number;
+  protected static _normalizeAbiInputsToStops(inputs: GradientAbiInput[]): GradientStop[];
+  private static _parsePosition;
+  private static _parseColorStopInput;
+  private static _resolvePendingStops;
 }
 //#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[];
+//#region src/gradients/LinearGradient.d.ts
+type LinearGradientConfig = GradientCommonConfig & {
+  angle: number;
+};
+declare class LinearGradient extends GradientBase<LinearGradientConfig> {
+  readonly type = "linear-gradient";
+  constructor(config: GradientData<LinearGradientConfig>);
+  static normalizeConfig(value: {
+    value: number;
+    unit: AngleUnit;
+  } | string): LinearGradientConfig;
+  static fromString(input: string): LinearGradient;
+  static fromAbi(abi: GradientAbi): LinearGradient;
+  clone(): this;
+  toString(): string;
+  protected _validateConfig(_: LinearGradientConfig): void;
 }
-interface RadialGradientSizeNode {
-  kind: 'size';
+//#endregion
+//#region src/gradients/RadialGradient.d.ts
+type RadialGradientShape = "circle" | "ellipse";
+type RadialGradientExtent = "closest-side" | "closest-corner" | "farthest-side" | "farthest-corner";
+type RadialGradientSize = {
+  kind: "extent";
+  value: RadialGradientExtent;
+} | {
+  kind: "explicit";
+  x: GradientLengthPercentage;
+  y?: GradientLengthPercentage;
+};
+type RadialGradientConfig = GradientCommonConfig & {
   shape: RadialGradientShape;
-  keyword: RadialGradientSizeKeyword;
-  radiusX: GradientLengthPercentageNode;
-  radiusY: GradientLengthPercentageNode;
+  size: RadialGradientSize;
+  position: GradientPosition;
+};
+declare class RadialGradient extends GradientBase<RadialGradientConfig> {
+  readonly type = "radial-gradient";
+  constructor(config: GradientData<RadialGradientConfig>);
+  static fromString(input: string): RadialGradient;
+  static fromAbi(abi: GradientAbi): RadialGradient;
+  clone(): this;
+  toString(): string;
+  protected _validateConfig(config: RadialGradientConfig): void;
+  private _serializeRadialConfig;
+  private _serializePosition;
+  private _formatLengthPercentage;
+  private static _parseConfig;
+  private static _parseLengthPercentage;
 }
-interface RadialGradientNode extends GradientNodeBase {
-  kind: 'radial';
-  shape: RadialGradientShape;
-  size: RadialGradientSizeNode;
-  position: RadialGradientPositionNode;
-  stops: readonly GradientColorStopNode[];
+//#endregion
+//#region src/gradients/ConicGradient.d.ts
+type ConicGradientConfig = GradientCommonConfig & {
+  from: GradientAngleValue;
+  position: GradientPosition;
+};
+declare class ConicGradient extends GradientBase<ConicGradientConfig> {
+  readonly type = "conic-gradient";
+  constructor(config: GradientData<ConicGradientConfig>);
+  clone(): this;
+  toString(): string;
+  static fromString(input: string): ConicGradient;
+  static fromAbi(abi: GradientAbi): ConicGradient;
+  protected _validateConfig(config: ConicGradientConfig): void;
+  private _serializeConfig;
+  private _serializePosition;
+  private _formatLengthPercentage;
+  private static _parseConfig;
+  private static _parseLengthPercentage;
+  private static _parseAngle;
 }
 //#endregion
-//#region src/parser/radial-gradient/parse-radial-gradient.d.ts
-declare function parseRadialGradient(source: string, tokens: readonly GradientLexerToken[], startIndex: number): ParseResult<RadialGradientNode>;
+//#region src/gradients/GradientFactory.d.ts
+interface IGradientStatic<TGradient extends GradientBase = GradientBase> {
+  fromAbi(abi: GradientAbi): TGradient;
+  fromString(input: string): TGradient;
+}
+declare class GradientFactory {
+  private static readonly _registry;
+  private static _initialized;
+  static add(type: string, value: IGradientStatic): void;
+  static get(functionName: string): IGradientStatic | null;
+  static remove(functionName: string): boolean;
+  static create(input: string | GradientAbi): IGradientBase<any>;
+  static isValid(input: string): boolean;
+  private static _ensureInitialized;
+}
+type AnyGradient = LinearGradient | RadialGradient | ConicGradient;
+declare function parse(input: string): AnyGradient;
+declare function isGradient(input: string): boolean;
+declare function format(input: string | AnyGradient): string;
+declare function transformTo(target: string, input: string | GradientBase<any>): unknown;
+declare function transformFrom<TInput = unknown>(target: string, gradientType: string, input: TInput): GradientBase<any>;
 //#endregion
-//#region src/parser/ast.d.ts
-type GradientKind = 'linear' | 'radial' | 'conic' | 'diamond' | 'mesh';
-type GradientRepeatMode = 'normal' | 'repeating';
-interface GradientNodeBase {
-  kind: GradientKind;
-  repeat: GradientRepeatMode;
+//#region src/gradient-transformer/modules/types.d.ts
+interface IGradientTransformerModule<TOutput = unknown> {
+  readonly target: string;
+  readonly gradientType: string;
+  to(input: GradientBase<any>): TOutput;
+  from?(input: TOutput): GradientBase<any>;
 }
-interface GradientColorStopNode {
-  kind: 'color-stop';
-  color: string;
-  position: GradientLengthPercentageNode;
+interface ICanvasPaintResult {
+  draw(ctx: CanvasRenderingContext2D, width: number, height: number): void;
 }
-type GradientStopItemNode = GradientColorStopNode;
-interface GradientNumberNode {
-  kind: 'number';
-  value: number;
+//#endregion
+//#region src/gradient-transformer/GradientTransformer.d.ts
+declare class GradientTransformer {
+  private static readonly _modules;
+  private static _initialized;
+  static add(module: IGradientTransformerModule): void;
+  static get(target: string, gradientType: string): IGradientTransformerModule | null;
+  static remove(target: string, gradientType: string): boolean;
+  static to<TOutput = unknown>(target: string, input: string | GradientBase<any>): TOutput;
+  static from<TOutput = unknown>(target: string, gradientType: string, input: TOutput): GradientBase<any>;
+  private static _ensureInitialized;
+  private static _getKey;
 }
-interface GradientPercentageNode {
-  kind: 'percentage';
-  value: number;
+//#endregion
+//#region src/gradient-transformer/modules/css/ModuleTransformerLinearGradientToCss.d.ts
+declare class ModuleTransformerLinearGradientToCss implements IGradientTransformerModule<string> {
+  readonly target = "css";
+  readonly gradientType = "linear-gradient";
+  to(input: GradientBase<any>): string;
 }
-interface GradientDimensionNode {
-  kind: 'dimension';
-  value: number;
-  unit: string;
+//#endregion
+//#region src/gradient-transformer/modules/css/ModuleTransformerRadialGradientToCss.d.ts
+declare class ModuleTransformerRadialGradientToCss implements IGradientTransformerModule<string> {
+  readonly target = "css";
+  readonly gradientType = "radial-gradient";
+  to(input: GradientBase<any>): string;
 }
-type GradientNumericNode = GradientNumberNode | GradientPercentageNode | GradientDimensionNode;
-type GradientLengthPercentageNode = GradientPercentageNode | GradientDimensionNode;
-interface GradientPositionNode {
-  x: GradientLengthPercentageNode | null;
-  y: GradientLengthPercentageNode | null;
-  keywords: readonly string[];
+//#endregion
+//#region src/gradient-transformer/modules/css/ModuleTransformerConicGradientToCss.d.ts
+declare class ModuleTransformerConicGradientToCss implements IGradientTransformerModule<string> {
+  readonly target = "css";
+  readonly gradientType = "conic-gradient";
+  to(input: GradientBase<any>): 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>;
+//#region src/gradient-transformer/modules/canvas/ModuleTransformerLinearGradientToCanvas.d.ts
+declare class ModuleTransformerLinearGradientToCanvas implements IGradientTransformerModule<ICanvasPaintResult> {
+  readonly target = "canvas";
+  readonly gradientType = "linear-gradient";
+  to(input: GradientBase<any>): ICanvasPaintResult;
+}
 //#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>;
+//#region src/gradient-transformer/modules/canvas/ModuleTransformerRadialGradientToCanvas.d.ts
+declare class ModuleTransformerRadialGradientToCanvas implements IGradientTransformerModule<ICanvasPaintResult> {
+  readonly target = "canvas";
+  readonly gradientType = "radial-gradient";
+  to(input: GradientBase<any>): ICanvasPaintResult;
+  private _resolve;
+}
 //#endregion
-//#region src/parser/parse.d.ts
-declare function parse(value: string): GradientNode;
+//#region src/gradient-transformer/modules/canvas/ModuleTransformerConicGradientToCanvas.d.ts
+declare class ModuleTransformerConicGradientToCanvas implements IGradientTransformerModule<ICanvasPaintResult> {
+  readonly target = "canvas";
+  readonly gradientType = "conic-gradient";
+  to(input: GradientBase<any>): ICanvasPaintResult;
+  private _resolvePosition;
+  private _resolve;
+  private _resolveKeywordX;
+  private _resolveKeywordY;
+  private _toRad;
+  private _normalizeStops;
+  private _sampleColor;
+  private _mixColor;
+  private _parseColor;
+  private _clamp01;
+}
 //#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 };
+export { AbiInputType, AngleUnit, AnyGradient, ConicGradient, ConicGradientConfig, GradientAbi, GradientAbiInput, GradientAngleUnit, GradientAngleValue, GradientBase, GradientColorHint, GradientColorInterpolation, GradientColorStop, GradientCommonConfig, GradientData, GradientFactory, GradientHueInterpolationMethod, GradientLengthPercentage, GradientLengthUnit, GradientLengthValue, GradientNumberValue, GradientPercentValue, GradientPolarColorSpace, GradientPosition, GradientPositionKeywordX, GradientPositionKeywordY, GradientRectangularColorSpace, GradientStop, GradientTransformer, GradientType, ICanvasPaintResult, IGradientBase, IGradientStatic, IGradientTransformerModule, LinearGradient, LinearGradientConfig, ModuleTransformerConicGradientToCanvas, ModuleTransformerConicGradientToCss, ModuleTransformerLinearGradientToCanvas, ModuleTransformerLinearGradientToCss, ModuleTransformerRadialGradientToCanvas, ModuleTransformerRadialGradientToCss, PatternTokenKind, RadialGradient, RadialGradientConfig, RadialGradientExtent, RadialGradientShape, RadialGradientSize, ceilTo, clamp, degToRad, floorTo, format, fromPercent, gradToRad, isAngleUnit, isColorHint, isColorStop, isConfig, isGradient, isPatternSyntaxValid, isPatternValid, isValid, matchExpression, normalizeAngle, normalizeAngleDeg, normalizeAngleRad, parse, parseStringToAbi, radToDeg, roundTo, splitTopLevelByWhitespace, toAngleRad, toPercent, tokenizePattern, transformFrom, transformTo, truncTo, turnToRad, validate, validatePattern, validatePatternSemantic, validatePatternStructure, validatePatternSyntax };