modern-idoc 0.5.6 → 0.6.1

package/dist/index.d.mts

@@ -1,12 +1,10 @@
 import { Colord } from 'colord';
 
-type None = 'none';
-
-interface AudioDeclaration {
+interface NormalizedAudio {
     src: string;
 }
-type AudioProperty = None | string | AudioDeclaration;
-declare function normalizeAudio(audio?: AudioProperty): AudioDeclaration | undefined;
+type Audio = string | NormalizedAudio;
+declare function normalizeAudio(audio: Audio): NormalizedAudio | undefined;
 
 interface RgbColor {
     r: number;
@@ -64,25 +62,180 @@ type LchaColor = WithAlpha<LchColor>;
 type CmykaColor = WithAlpha<CmykColor>;
 type ObjectColor = RgbColor | RgbaColor | HslColor | HslaColor | HsvColor | HsvaColor | HwbColor | HwbaColor | XyzColor | XyzaColor | LabColor | LabaColor | LchColor | LchaColor | CmykColor | CmykaColor;
 type Uint32Color = number;
-type Color = None | Uint32Color | ObjectColor | string;
+type Color = Uint32Color | ObjectColor | string;
 type Hex8Color = string;
-type ColorDeclaration = Hex8Color;
+type NormalizedColor = Hex8Color;
 declare function parseColor(color: Color): Colord;
-declare function normalizeColor(color?: Color, orFail?: boolean): ColorDeclaration | undefined;
+declare const defaultColor: NormalizedColor;
+declare function isColor(value: string): boolean;
+declare function normalizeColor(color: Color, orFail?: boolean): NormalizedColor;
+
+interface ColorStop {
+    offset: number;
+    color: NormalizedColor;
+}
+interface LinearGradient {
+    type: 'linear-gradient';
+    angle: number;
+    stops: ColorStop[];
+    repeat?: boolean;
+}
+interface RadialGradient {
+    type: 'radial-gradient';
+    stops: ColorStop[];
+    repeat?: boolean;
+}
+declare function isGradient(cssText: string): boolean;
+declare function normalizeGradient(cssText: string): (LinearGradient | RadialGradient)[];
+
+interface LinearGradientNode {
+  type: 'linear-gradient'
+  orientation?: DirectionalNode | AngularNode | undefined
+  colorStops: ColorStopNode[]
+}
+
+interface RepeatingLinearGradientNode {
+  type: 'repeating-linear-gradient'
+  orientation?: DirectionalNode | AngularNode | undefined
+  colorStops: ColorStopNode[]
+}
+
+interface RadialGradientNode {
+  type: 'radial-gradient'
+  orientation?: (ShapeNode | DefaultRadialNode | ExtentKeywordNode)[] | undefined
+  colorStops: ColorStopNode[]
+}
+
+interface RepeatingRadialGradientNode {
+  type: 'repeating-radial-gradient'
+  orientation?: (ShapeNode | DefaultRadialNode | ExtentKeywordNode)[] | undefined
+  colorStops: ColorStopNode[]
+}
+
+interface DirectionalNode {
+  type: 'directional'
+  value:
+    | 'left'
+    | 'top'
+    | 'bottom'
+    | 'right'
+    | 'left top'
+    | 'top left'
+    | 'left bottom'
+    | 'bottom left'
+    | 'right top'
+    | 'top right'
+    | 'right bottom'
+    | 'bottom right'
+}
+
+interface AngularNode {
+  type: 'angular'
+  value: string
+}
+
+interface LiteralNode {
+  type: 'literal'
+  value: string
+  length?: PxNode | EmNode | PercentNode | undefined
+}
+
+interface HexNode {
+  type: 'hex'
+  value: string
+  length?: PxNode | EmNode | PercentNode | undefined
+}
+
+interface RgbNode {
+  type: 'rgb'
+  value: [string, string, string]
+  length?: PxNode | EmNode | PercentNode | undefined
+}
+
+interface RgbaNode {
+  type: 'rgba'
+  value: [string, string, string, string?]
+  length?: PxNode | EmNode | PercentNode | undefined
+}
+
+interface ShapeNode {
+  type: 'shape'
+  style?: ExtentKeywordNode | PxNode | EmNode | PercentNode | PositionKeywordNode | undefined
+  value: 'ellipse' | 'circle'
+  at?: PositionNode | undefined
+}
+
+interface DefaultRadialNode {
+  type: 'default-radial'
+  at: PositionNode
+}
+
+interface PositionKeywordNode {
+  type: 'position-keyword'
+  value: 'center' | 'left' | 'top' | 'bottom' | 'right'
+}
+
+interface PositionNode {
+  type: 'position'
+  value: {
+    x: ExtentKeywordNode | PxNode | EmNode | PercentNode | PositionKeywordNode
+    y: ExtentKeywordNode | PxNode | EmNode | PercentNode | PositionKeywordNode
+  }
+}
+
+interface ExtentKeywordNode {
+  type: 'extent-keyword'
+  value: 'closest-side' | 'closest-corner' | 'farthest-side' | 'farthest-corner' | 'contain' | 'cover'
+  at?: PositionNode | undefined
+}
+
+interface PxNode {
+  type: 'px'
+  value: string
+}
+
+interface EmNode {
+  type: 'em'
+  value: string
+}
+
+interface PercentNode {
+  type: '%'
+  value: string
+}
+
+type ColorStopNode = LiteralNode | HexNode | RgbNode | RgbaNode
+type GradientNode = LinearGradientNode | RepeatingLinearGradientNode | RadialGradientNode | RepeatingRadialGradientNode
 
-interface GradientFillDeclaration {
+declare function parseGradient(cssText: string): GradientNode[]
+declare function stringifyGradient(ast: GradientNode[]): string
+
+interface ColorFillObject {
+    color: Color;
 }
+type ColorFill = string | ColorFillObject;
+interface NormalizedColorFill {
+    color: NormalizedColor;
+}
+declare function normalizeColorFill(fill: ColorFill): NormalizedColorFill;
 
-interface SolidFillDeclaration {
-    color: ColorDeclaration;
+interface GradientFillObject {
+    image: string;
 }
+type GradientFill = string | GradientFillObject;
+interface NormalizedGradientFill {
+    linearGradient?: LinearGradient;
+    radialGradient?: RadialGradient;
+    rotateWithShape?: boolean;
+}
+declare function normalizeGradientFill(fill: GradientFill): NormalizedGradientFill;
 
 /**
  * 0    -0.5   0
  * -0.5        -0.5
  * 0    -0.5   0
  */
-interface TextureFillSourceRect {
+interface ImageFillCropRect {
     left?: number;
     top?: number;
     bottom?: number;
@@ -93,16 +246,13 @@ interface TextureFillSourceRect {
  * 0.5        0.5
  * 0    0.5   0
  */
-interface TextureFillStretchRect {
+interface ImageFillStretchRect {
     left?: number;
     top?: number;
     bottom?: number;
     right?: number;
 }
-interface TextureFillStretch {
-    rect?: TextureFillStretchRect;
-}
-interface TextureFillTile {
+interface ImageFillTile {
     alignment?: string;
     scaleX?: number;
     scaleY?: number;
@@ -110,123 +260,102 @@ interface TextureFillTile {
     translateY?: number;
     flip?: string;
 }
-type TextureFillSourceURL = string;
-interface TextureFillDeclaration {
-    src: TextureFillSourceURL;
-    srcRect?: TextureFillSourceRect;
+interface ImageFillObject {
+    image: string;
+    cropRect?: ImageFillCropRect;
+    stretchRect?: ImageFillStretchRect;
+    tile?: ImageFillTile;
     dpi?: number;
-    stretch?: TextureFillStretch;
-    tile?: TextureFillTile;
     opacity?: number;
     rotateWithShape?: boolean;
 }
+interface NormalizedImageFill extends ImageFillObject {
+}
+declare function normalizeImageFill(fill: ImageFillObject): NormalizedImageFill;
 
-type FillDeclaration = Partial<TextureFillDeclaration> & Partial<SolidFillDeclaration> & Partial<GradientFillDeclaration>;
-type FillPropertyObject = FillDeclaration & {
-    color?: Color;
-};
-type FillProperty = None | string | FillPropertyObject;
-declare function normalizeFill(fill?: FillProperty): FillDeclaration | undefined;
+type None = undefined | null | 'none';
+type WithNone<T> = T | None;
 
-interface BaseBackgroundDeclaration {
-    withGeometry?: boolean;
+interface PresetFillObject {
+    preset: string;
+    foregroundColor?: WithNone<Color>;
+    backgroundColor?: WithNone<Color>;
+}
+type PresetFill = string | PresetFillObject;
+interface NormalizedPresetFill extends PresetFillObject {
+    foregroundColor?: NormalizedColor;
+    backgroundColor?: NormalizedColor;
 }
-type BackgroundDeclaration = BaseBackgroundDeclaration & FillDeclaration;
-type BackgroundPropertyObject = BaseBackgroundDeclaration & FillPropertyObject;
-type BackgroundProperty = None | string | BackgroundPropertyObject;
-declare function normalizeBackground(background?: BackgroundProperty): BackgroundDeclaration | undefined;
+declare function normalizePresetFill(fill: PresetFill): NormalizedPresetFill;
 
-interface InnerShadowDeclaration {
-    color: ColorDeclaration;
+type FillObject = Partial<ColorFillObject> & Partial<GradientFillObject> & Partial<ImageFillObject> & Partial<PresetFillObject>;
+type Fill = string | FillObject;
+type NormalizedFill = Partial<NormalizedColorFill> & Partial<NormalizedGradientFill> & Partial<NormalizedImageFill> & Partial<NormalizedPresetFill>;
+declare function normalizeFill(fill: Fill): NormalizedFill;
+
+interface NormalizedBaseBackground {
+    fillWithShape: boolean;
+}
+type NormalizedBackground = NormalizedBaseBackground & NormalizedFill;
+type BackgroundObject = Partial<NormalizedBaseBackground> & FillObject;
+type Background = string | BackgroundObject;
+declare function normalizeBackground(background: Background): NormalizedBackground;
+
+interface NormalizedInnerShadow {
+    color: NormalizedColor;
     offsetX: number;
     offsetY: number;
     blurRadius: number;
 }
-type InnerShadowPropertyObject = Partial<InnerShadowDeclaration> & {
-    color: Color;
+type InnerShadowObject = Partial<NormalizedInnerShadow> & {
+    color: WithNone<Color>;
 };
-type InnerShadowProperty = None | InnerShadowPropertyObject;
-declare function getDefaultInnerShadow(): InnerShadowDeclaration;
-declare function normalizeInnerShadow(shadow?: InnerShadowProperty): InnerShadowDeclaration | undefined;
+type InnerShadow = InnerShadowObject;
+declare function getDefaultInnerShadow(): NormalizedInnerShadow;
+declare function normalizeInnerShadow(shadow: InnerShadow): NormalizedInnerShadow;
 
-interface BaseOuterShadowDeclaration {
+interface NormalizedBaseOuterShadow {
     scaleX: number;
     scaleY: number;
 }
-type OuterShadowDeclaration = BaseOuterShadowDeclaration & InnerShadowDeclaration;
-type OuterShadowPropertyObject = Partial<BaseOuterShadowDeclaration> & InnerShadowPropertyObject;
-type OuterShadowProperty = None | OuterShadowPropertyObject;
-declare function getDefaultOuterShadow(): OuterShadowDeclaration;
-declare function normalizeOuterShadow(shadow?: OuterShadowProperty): OuterShadowDeclaration | undefined;
+type NormalizedOuterShadow = NormalizedBaseOuterShadow & NormalizedInnerShadow;
+type OuterShadowObject = Partial<NormalizedBaseOuterShadow> & InnerShadowObject;
+type OuterShadow = OuterShadowObject;
+declare function getDefaultOuterShadow(): NormalizedOuterShadow;
+declare function normalizeOuterShadow(shadow: OuterShadow): NormalizedOuterShadow;
 
-interface SoftEdgeDeclaration {
+interface NormalizedSoftEdge {
     radius: number;
 }
-type SoftEdgeProperty = None | SoftEdgeDeclaration;
-declare function normalizeSoftEdge(softEdge?: SoftEdgeProperty): SoftEdgeDeclaration | undefined;
+type SoftEdge = NormalizedSoftEdge;
+declare function normalizeSoftEdge(softEdge: SoftEdge): NormalizedSoftEdge;
 
-interface EffectDeclaration {
-    innerShadow?: InnerShadowDeclaration;
-    outerShadow?: OuterShadowDeclaration;
-    softEdge?: SoftEdgeDeclaration;
+interface NormalizedEffect {
+    innerShadow?: NormalizedInnerShadow;
+    outerShadow?: NormalizedOuterShadow;
+    softEdge?: NormalizedSoftEdge;
 }
-interface EffectPropertyObject {
-    innerShadow?: InnerShadowProperty;
-    outerShadow?: OuterShadowProperty;
-    softEdge?: SoftEdgeProperty;
+interface EffectObject {
+    innerShadow: WithNone<InnerShadow>;
+    outerShadow: WithNone<OuterShadow>;
+    softEdge: WithNone<SoftEdge>;
 }
-type EffectProperty = None | EffectPropertyObject;
-declare function normalizeEffect(effect?: EffectProperty): EffectDeclaration | undefined;
+type Effect = EffectObject;
+declare function normalizeEffect(effect: Effect): NormalizedEffect;
 
-interface BaseForegroundDeclaration {
-    withGeometry?: boolean;
+interface NormalizedBaseForeground {
+    fillWithShape: boolean;
 }
-type ForegroundDeclaration = BaseForegroundDeclaration & FillDeclaration;
-type ForegroundPropertyObject = BaseForegroundDeclaration & FillPropertyObject;
-type ForegroundProperty = None | string | ForegroundPropertyObject;
-declare function normalizeForeground(foreground?: ForegroundProperty): ForegroundDeclaration | undefined;
+type NormalizedForeground = NormalizedBaseForeground & NormalizedFill;
+type ForegroundObject = Partial<NormalizedBaseForeground> & FillObject;
+type Foreground = string | ForegroundObject;
+declare function normalizeForeground(foreground: Foreground): NormalizedForeground | undefined;
 
-type SVGPathData = string;
-type FillRule = 'nonzero' | 'evenodd';
-type StrokeLinecap = 'butt' | 'round' | 'square';
-type StrokeLinejoin = 'arcs' | 'bevel' | 'miter' | 'miter-clip' | 'round';
-interface GeometryPathStyle {
-    [key: string]: any;
-    opacity: number;
-    visibility: string;
-    shadowColor: ColorDeclaration;
-    shadowOffsetX: number;
-    shadowOffsetY: number;
-    shadowBlur: number;
-    fill: string;
-    fillOpacity: number;
-    fillRule: FillRule;
-    stroke: string;
-    strokeOpacity: number;
-    strokeWidth: number;
-    strokeLinecap: StrokeLinecap;
-    strokeLinejoin: StrokeLinejoin;
-    strokeMiterlimit: number;
-    strokeDasharray: number[];
-    strokeDashoffset: number;
-}
-interface GeometryPathDeclaration extends Partial<GeometryPathStyle> {
-    data: SVGPathData;
-}
-interface GeometryDeclaration {
-    name?: string;
-    svg?: string;
-    viewBox?: number[];
-    paths?: GeometryPathDeclaration[];
-}
-type GeometryProperty = None | SVGPathData | SVGPathData[] | GeometryPathDeclaration[] | GeometryDeclaration;
-declare function normalizeGeometry(geometry?: GeometryProperty): GeometryDeclaration | undefined;
-
-interface MetaProperty {
+interface Meta {
     [key: string]: any;
 }
 
-interface Node<T = MetaProperty> {
+interface Node<T = Meta> {
     name?: string;
     children?: Node[];
     meta?: T;
@@ -237,51 +366,86 @@ type LineEndSize = 'sm' | 'md' | 'lg';
 
 interface HeadEnd {
     type: LineEndType;
-    width?: None | LineEndSize;
-    height?: None | LineEndSize;
+    width?: WithNone<LineEndSize>;
+    height?: WithNone<LineEndSize>;
 }
 
 interface TailEnd {
     type: LineEndType;
-    width?: None | LineEndSize;
-    height?: None | LineEndSize;
+    width?: WithNone<LineEndSize>;
+    height?: WithNone<LineEndSize>;
 }
 
-type OutlineFillDeclaration = Partial<SolidFillDeclaration> & Partial<GradientFillDeclaration>;
+type NormalizedOutlineFill = Partial<NormalizedColorFill> & Partial<NormalizedGradientFill>;
 type OutlineStyle = 'dashed' | 'solid' | string;
-interface OutlineDeclaration extends OutlineFillDeclaration {
+interface NormalizedOutline extends NormalizedOutlineFill {
     width?: number;
-    color?: ColorDeclaration;
+    color?: NormalizedColor;
     style?: OutlineStyle;
     headEnd?: HeadEnd;
     tailEnd?: TailEnd;
 }
-type OutlinePropertyObject = Partial<OutlineDeclaration> & {
-    color?: Color;
+type OutlineObject = Partial<NormalizedOutline> & {
+    color: WithNone<Color>;
 };
-type OutlineProperty = None | string | OutlinePropertyObject;
-declare function normalizeOutline(outline?: OutlineProperty): OutlineDeclaration | undefined;
+type Outline = string | OutlineObject;
+declare function normalizeOutline(outline: Outline): NormalizedOutline;
 
-type BoxShadow = None | string;
-interface ShadowDeclaration {
-    color: ColorDeclaration;
+type BoxShadow = string;
+interface NormalizedShadow {
+    color: NormalizedColor;
     offsetX?: number;
     offsetY?: number;
     blur?: number;
 }
-type ShadowPropertyObject = Partial<ShadowDeclaration> & {
-    color?: Color;
+type ShadowObject = Partial<NormalizedShadow> & {
+    color: WithNone<Color>;
 };
-type ShadowProperty = None | BoxShadow | ShadowPropertyObject;
-declare function normalizeShadow(shadow?: ShadowProperty): ShadowDeclaration | undefined;
-interface ShadowStyleDeclaration {
+type Shadow = BoxShadow | ShadowObject;
+declare function normalizeShadow(shadow: Shadow): NormalizedShadow;
+interface NormalizedShadowStyle {
     boxShadow: BoxShadow;
-    shadowColor?: ColorDeclaration;
+    shadowColor?: NormalizedColor;
     shadowOffsetX?: number;
     shadowOffsetY?: number;
     shadowBlur?: number;
 }
-declare function getDefaultShadowStyle(): ShadowStyleDeclaration;
+declare function getDefaultShadowStyle(): NormalizedShadowStyle;
+
+type SVGPathData = string;
+type FillRule = 'nonzero' | 'evenodd';
+type StrokeLinecap = 'butt' | 'round' | 'square';
+type StrokeLinejoin = 'arcs' | 'bevel' | 'miter' | 'miter-clip' | 'round';
+interface ShapePathStyle {
+    [key: string]: any;
+    opacity: number;
+    visibility: string;
+    shadowColor: NormalizedColor;
+    shadowOffsetX: number;
+    shadowOffsetY: number;
+    shadowBlur: number;
+    fill: string;
+    fillOpacity: number;
+    fillRule: FillRule;
+    stroke: string;
+    strokeOpacity: number;
+    strokeWidth: number;
+    strokeLinecap: StrokeLinecap;
+    strokeLinejoin: StrokeLinejoin;
+    strokeMiterlimit: number;
+    strokeDasharray: number[];
+    strokeDashoffset: number;
+}
+interface ShapePath extends Partial<ShapePathStyle> {
+    data: SVGPathData;
+}
+interface NormalizedShape {
+    preset?: string;
+    viewBox?: number[];
+    paths?: ShapePath[];
+}
+type Shape = SVGPathData | SVGPathData[] | ShapePath[] | NormalizedShape;
+declare function normalizeShape(shape: Shape): NormalizedShape;
 
 type StyleUnit = `${number}%` | number;
 type Display = 'flex' | 'contents';
@@ -290,12 +454,12 @@ type Overflow = 'hidden' | 'visible';
 type Visibility = 'hidden' | 'visible';
 type FontWeight = 'normal' | 'bold' | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900;
 type FontStyle = 'normal' | 'italic' | 'oblique' | `oblique ${string}`;
-type FontKerning = None | 'auto' | 'normal';
+type FontKerning = WithNone<'auto' | 'normal'>;
 type TextWrap = 'wrap' | 'nowrap';
-type TextAlign = None | 'center' | 'end' | 'left' | 'right' | 'start' | 'justify';
-type TextTransform = None | 'uppercase' | 'lowercase';
+type TextAlign = WithNone<'center' | 'end' | 'left' | 'right' | 'start' | 'justify'>;
+type TextTransform = WithNone<'uppercase' | 'lowercase'>;
 type TextOrientation = 'mixed' | 'upright' | 'sideways-right' | 'sideways';
-type TextDecoration = None | 'underline' | 'line-through' | 'overline';
+type TextDecoration = WithNone<'underline' | 'line-through' | 'overline'>;
 type VerticalAlign = 'baseline' | 'top' | 'middle' | 'bottom' | 'sub' | 'super' | 'text-top' | 'text-bottom';
 type WritingMode = 'horizontal-tb' | 'vertical-lr' | 'vertical-rl';
 type Align = 'auto' | 'flex-start' | 'center' | 'flex-end' | 'stretch' | 'baseline' | 'space-between' | 'space-around' | 'space-evenly';
@@ -303,22 +467,22 @@ type FlexDirection = 'column' | 'column-reverse' | 'row' | 'row-reverse';
 type FlexWrap = 'nowrap' | 'wrap' | 'Wrap-reverse';
 type Justify = 'flex-start' | 'center' | 'flex-end' | 'space-between' | 'space-around' | 'space-evenly';
 type Position = 'static' | 'relative' | 'absolute';
-type BorderStyle = None | 'dashed' | 'solid';
+type BorderStyle = WithNone<'dashed' | 'solid'>;
 type BoxSizing = 'border-box' | 'content-box';
 type PointerEvents = 'auto' | 'none';
-type ListStyleType = None | 'disc';
-type ListStyleImage = None | string;
-type ListStyleColormap = None | Record<string, string>;
+type ListStyleType = WithNone<'disc'>;
+type ListStyleImage = WithNone<string>;
+type ListStyleColormap = WithNone<Record<string, string>>;
 type ListStyleSize = StyleUnit | `${number}rem` | 'cover';
 type ListStylePosition = 'inside' | 'outside';
 type HighlightLine = TextDecoration | 'outline';
-type HighlightImage = None | string;
-type HighlightReferImage = None | string;
-type HighlightColormap = None | Record<string, string>;
+type HighlightImage = WithNone<string>;
+type HighlightReferImage = WithNone<string>;
+type HighlightColormap = WithNone<Record<string, string>>;
 type HighlightSize = StyleUnit | `${number}rem` | 'cover';
 type HighlightThickness = StyleUnit;
 
-interface LayoutStyleDeclaration {
+interface NormalizedLayoutStyle {
     overflow: Overflow;
     direction: Direction;
     display: Display;
@@ -351,20 +515,20 @@ interface LayoutStyleDeclaration {
     alignSelf: Align;
     justifyContent: Justify;
     gap: StyleUnit;
-    marginTop: None | StyleUnit | 'auto';
-    marginLeft: None | StyleUnit | 'auto';
-    marginRight: None | StyleUnit | 'auto';
-    marginBottom: None | StyleUnit | 'auto';
-    margin: None | StyleUnit | 'auto';
+    marginTop: WithNone<StyleUnit | 'auto'>;
+    marginLeft: WithNone<StyleUnit | 'auto'>;
+    marginRight: WithNone<StyleUnit | 'auto'>;
+    marginBottom: WithNone<StyleUnit | 'auto'>;
+    margin: WithNone<StyleUnit | 'auto'>;
     paddingTop: StyleUnit;
     paddingLeft: StyleUnit;
     paddingRight: StyleUnit;
     paddingBottom: StyleUnit;
     padding: StyleUnit;
 }
-declare function getDefaultLayoutStyle(): Partial<LayoutStyleDeclaration>;
+declare function getDefaultLayoutStyle(): Partial<NormalizedLayoutStyle>;
 
-interface TransformStyleDeclaration {
+interface NormalizedTransformStyle {
     rotate: number;
     scaleX: number;
     scaleY: number;
@@ -372,33 +536,33 @@ interface TransformStyleDeclaration {
     skewY: number;
     translateX: number;
     translateY: number;
-    transform: None | string;
+    transform: WithNone<string>;
     transformOrigin: string;
 }
-declare function getDefaultTransformStyle(): TransformStyleDeclaration;
+declare function getDefaultTransformStyle(): NormalizedTransformStyle;
 
 type BackgroundSize = 'contain' | 'cover' | string | 'stretch' | 'rigid';
-type ElementStyleDeclaration = Partial<LayoutStyleDeclaration> & TransformStyleDeclaration & ShadowStyleDeclaration & {
-    backgroundImage: None | string;
+type NormalizedElementStyle = Partial<NormalizedLayoutStyle> & NormalizedTransformStyle & NormalizedShadowStyle & {
+    backgroundImage: WithNone<string>;
     backgroundSize: BackgroundSize;
-    backgroundColor: None | ColorDeclaration;
-    backgroundColormap: None | Record<string, string>;
+    backgroundColor: WithNone<NormalizedColor>;
+    backgroundColormap: WithNone<Record<string, string>>;
     borderRadius: number;
-    borderColor: None | ColorDeclaration;
+    borderColor: WithNone<NormalizedColor>;
     borderStyle: BorderStyle;
     outlineWidth: number;
     outlineOffset: number;
-    outlineColor: None | ColorDeclaration;
+    outlineColor: WithNone<NormalizedColor>;
     outlineStyle: string;
     visibility: Visibility;
     filter: string;
     opacity: number;
     pointerEvents: PointerEvents;
-    maskImage: None | string;
+    maskImage: WithNone<string>;
 };
-declare function getDefaultElementStyle(): ElementStyleDeclaration;
+declare function getDefaultElementStyle(): NormalizedElementStyle;
 
-interface HighlightDeclaration {
+interface NormalizedHighlight {
     image: HighlightImage;
     referImage: HighlightReferImage;
     colormap: HighlightColormap;
@@ -406,8 +570,8 @@ interface HighlightDeclaration {
     size: HighlightSize;
     thickness: HighlightThickness;
 }
-interface HighlightStyleDeclaration {
-    highlight: Partial<HighlightDeclaration>;
+interface NormalizedHighlightStyle {
+    highlight: Partial<NormalizedHighlight>;
     highlightImage: HighlightImage;
     highlightReferImage: HighlightReferImage;
     highlightColormap: HighlightColormap;
@@ -415,27 +579,27 @@ interface HighlightStyleDeclaration {
     highlightSize: HighlightSize;
     highlightThickness: HighlightThickness;
 }
-declare function getDefaultHighlightStyle(): Required<HighlightStyleDeclaration>;
+declare function getDefaultHighlightStyle(): Required<NormalizedHighlightStyle>;
 
-interface ListStyleDeclaration {
+interface NormalizedListStyle {
     type: ListStyleType;
     image: ListStyleImage;
     colormap: ListStyleColormap;
     size: ListStyleSize;
     position: ListStylePosition;
 }
-interface ListStyleStyleDeclaration {
-    listStyle: Partial<ListStyleDeclaration>;
+interface NormalizedListStyleStyle {
+    listStyle: Partial<NormalizedListStyle>;
     listStyleType: ListStyleType;
     listStyleImage: ListStyleImage;
     listStyleColormap: ListStyleColormap;
     listStyleSize: ListStyleSize;
     listStylePosition: ListStylePosition;
 }
-declare function getDefaultListStyleStyle(): ListStyleStyleDeclaration;
+declare function getDefaultListStyleStyle(): NormalizedListStyleStyle;
 
-type TextInlineStyleDeclaration = HighlightStyleDeclaration & {
-    color: ColorDeclaration;
+type NormalizedTextInlineStyle = NormalizedHighlightStyle & {
+    color: NormalizedColor;
     verticalAlign: VerticalAlign;
     letterSpacing: number;
     wordSpacing: number;
@@ -448,103 +612,105 @@ type TextInlineStyleDeclaration = HighlightStyleDeclaration & {
     textOrientation: TextOrientation;
     textDecoration: TextDecoration;
 };
-declare function getDefaultTextInlineStyle(): Required<TextInlineStyleDeclaration>;
+declare function getDefaultTextInlineStyle(): Required<NormalizedTextInlineStyle>;
 
-type TextLineStyleDeclaration = ListStyleStyleDeclaration & {
+type NormalizedTextLineStyle = NormalizedListStyleStyle & {
     writingMode: WritingMode;
     textWrap: TextWrap;
     textAlign: TextAlign;
     textIndent: number;
     lineHeight: number;
 };
-declare function getDefaultTextLineStyle(): TextLineStyleDeclaration;
+declare function getDefaultTextLineStyle(): NormalizedTextLineStyle;
 
-interface TextDrawStyleDeclaration {
+interface NormalizedTextDrawStyle {
     textStrokeWidth: number;
-    textStrokeColor: ColorDeclaration;
+    textStrokeColor: NormalizedColor;
 }
-type TextStyleDeclaration = TextLineStyleDeclaration & TextInlineStyleDeclaration & TextDrawStyleDeclaration;
-declare function getDefaultTextStyle(): Required<TextStyleDeclaration>;
+type NormalizedTextStyle = NormalizedTextLineStyle & NormalizedTextInlineStyle & NormalizedTextDrawStyle;
+declare function getDefaultTextStyle(): Required<NormalizedTextStyle>;
 
-interface StyleDeclaration extends TextStyleDeclaration, ElementStyleDeclaration {
+interface NormalizedStyle extends NormalizedTextStyle, NormalizedElementStyle {
 }
-type StylePropertyObject = Partial<StyleDeclaration> & {
-    color?: Color;
-    backgroundColor?: Color;
-    borderColor?: Color;
-    outlineColor?: Color;
-    shadowColor?: Color;
+type StyleObject = Partial<NormalizedStyle> & {
+    color?: WithNone<Color>;
+    backgroundColor?: WithNone<Color>;
+    borderColor?: WithNone<Color>;
+    outlineColor?: WithNone<Color>;
+    shadowColor?: WithNone<Color>;
 };
-type StyleProperty = None | StylePropertyObject;
-declare function normalizeStyle(style?: StyleProperty): Partial<StyleDeclaration> | undefined;
-declare function getDefaultStyle(): StyleDeclaration;
+type Style = StyleObject;
+declare function normalizeStyle(style: Style): Partial<NormalizedStyle>;
+declare function getDefaultStyle(): NormalizedStyle;
 
-interface FragmentContent extends StylePropertyObject {
+interface FragmentContent extends StyleObject {
     content: string;
 }
-interface ParagraphContent extends StylePropertyObject {
+interface ParagraphContent extends StyleObject {
     fragments: FragmentContent[];
 }
 type TextContentFlat = string | FragmentContent | ParagraphContent | (string | FragmentContent)[];
 type TextContent = string | FragmentContent | ParagraphContent | TextContentFlat[];
-type TextContentDeclaration = (ParagraphContent & StylePropertyObject)[];
-interface TextDeclaration {
-    content: TextContentDeclaration;
-    effects?: StylePropertyObject[];
+type NormalizedTextContent = (ParagraphContent & StyleObject)[];
+interface NormalizedText {
+    content: NormalizedTextContent;
+    effects?: StyleObject[];
     measureDom?: any;
     fonts?: any;
 }
-type TextProperty = string | TextContent | (TextDeclaration & {
+type Text = string | TextContent | (NormalizedText & {
     content: TextContent;
-}) | TextDeclaration;
-declare function normalizeTextContent(content?: TextContent): TextContentDeclaration;
-declare function normalizeText(text?: TextProperty): TextDeclaration | undefined;
+}) | NormalizedText;
+declare function normalizeTextContent(content?: TextContent): NormalizedTextContent;
+declare function normalizeText(text: Text): NormalizedText;
 
-interface VideoDeclaration {
+interface NormalizedVideo {
     src: string;
 }
-type VideoProperty = None | string | VideoDeclaration;
-declare function normalizeVideo(video?: VideoProperty): VideoDeclaration | undefined;
-
-interface Element<T = MetaProperty> extends Node<T> {
-    style?: StyleProperty;
-    text?: TextProperty;
-    background?: BackgroundProperty;
-    geometry?: GeometryProperty;
-    fill?: FillProperty;
-    outline?: OutlineProperty;
-    foreground?: ForegroundProperty;
-    shadow?: ShadowProperty;
-    video?: VideoProperty;
-    audio?: AudioProperty;
-    effect?: EffectProperty;
+type Video = string | NormalizedVideo;
+declare function normalizeVideo(video: Video): NormalizedVideo | undefined;
+
+interface Element<T = Meta> extends Node<T> {
+    style?: WithNone<Style>;
+    text?: WithNone<Text>;
+    background?: WithNone<Background>;
+    shape?: WithNone<Shape>;
+    fill?: WithNone<Fill>;
+    outline?: WithNone<Outline>;
+    foreground?: WithNone<Foreground>;
+    shadow?: WithNone<Shadow>;
+    video?: WithNone<Video>;
+    audio?: WithNone<Audio>;
+    effect?: WithNone<Effect>;
     children?: Element[];
 }
-interface ElementDeclaration<T = MetaProperty> extends Element<T> {
-    style?: Partial<StyleDeclaration>;
-    text?: TextDeclaration;
-    background?: BackgroundDeclaration;
-    geometry?: GeometryDeclaration;
-    fill?: FillDeclaration;
-    outline?: OutlineDeclaration;
-    foreground?: ForegroundDeclaration;
-    shadow?: ShadowDeclaration;
-    video?: VideoDeclaration;
-    audio?: AudioDeclaration;
-    effect?: EffectDeclaration;
-    children?: ElementDeclaration[];
-}
-declare function normalizeElement<T = MetaProperty>(element: Element<T>): ElementDeclaration<T>;
+type NormalizedElement<T = Meta> = Node<T> & {
+    style?: Partial<NormalizedStyle>;
+    text?: NormalizedText;
+    background?: NormalizedBackground;
+    shape?: NormalizedShape;
+    fill?: NormalizedFill;
+    outline?: NormalizedOutline;
+    foreground?: NormalizedForeground;
+    shadow?: NormalizedShadow;
+    video?: NormalizedVideo;
+    audio?: NormalizedAudio;
+    effect?: NormalizedEffect;
+    children?: NormalizedElement[];
+};
+declare function normalizeElement<T = Meta>(element: Element<T>): NormalizedElement<T>;
 
 interface Document extends Element {
     fonts?: any;
 }
-interface DocumentDeclaration extends ElementDeclaration {
+interface NormalizedDocument extends NormalizedElement {
     fonts?: any;
 }
-declare function normalizeDocument(doc: Document): DocumentDeclaration;
+declare function normalizeDocument(doc: Document): NormalizedDocument;
 
+declare function isNone<T>(value: T): value is Extract<T, null | undefined | 'none'>;
+declare function round(number: number, digits?: number, base?: number): number;
 declare function clearUndef<T>(obj: T, deep?: boolean): T;
 
-export { clearUndef, getDefaultElementStyle, getDefaultHighlightStyle, getDefaultInnerShadow, getDefaultLayoutStyle, getDefaultListStyleStyle, getDefaultOuterShadow, getDefaultShadowStyle, getDefaultStyle, getDefaultTextInlineStyle, getDefaultTextLineStyle, getDefaultTextStyle, getDefaultTransformStyle, normalizeAudio, normalizeBackground, normalizeColor, normalizeDocument, normalizeEffect, normalizeElement, normalizeFill, normalizeForeground, normalizeGeometry, normalizeInnerShadow, normalizeOuterShadow, normalizeOutline, normalizeShadow, normalizeSoftEdge, normalizeStyle, normalizeText, normalizeTextContent, normalizeVideo, parseColor };
-export type { Align, AudioDeclaration, AudioProperty, BackgroundDeclaration, BackgroundProperty, BackgroundPropertyObject, BackgroundSize, BaseBackgroundDeclaration, BaseForegroundDeclaration, BaseOuterShadowDeclaration, BorderStyle, BoxShadow, BoxSizing, CmykColor, CmykaColor, Color, ColorDeclaration, Direction, Display, Document, DocumentDeclaration, EffectDeclaration, EffectProperty, EffectPropertyObject, Element, ElementDeclaration, ElementStyleDeclaration, FillDeclaration, FillProperty, FillPropertyObject, FillRule, FlexDirection, FlexWrap, FontKerning, FontStyle, FontWeight, ForegroundDeclaration, ForegroundProperty, ForegroundPropertyObject, FragmentContent, GeometryDeclaration, GeometryPathDeclaration, GeometryPathStyle, GeometryProperty, GradientFillDeclaration, HeadEnd, Hex8Color, HighlightColormap, HighlightDeclaration, HighlightImage, HighlightLine, HighlightReferImage, HighlightSize, HighlightStyleDeclaration, HighlightThickness, HslColor, HslaColor, HsvColor, HsvaColor, HwbColor, HwbaColor, InnerShadowDeclaration, InnerShadowProperty, InnerShadowPropertyObject, Justify, LabColor, LabaColor, LayoutStyleDeclaration, LchColor, LchaColor, LineEndSize, LineEndType, ListStyleColormap, ListStyleDeclaration, ListStyleImage, ListStylePosition, ListStyleSize, ListStyleStyleDeclaration, ListStyleType, MetaProperty, Node, None, ObjectColor, OuterShadowDeclaration, OuterShadowProperty, OuterShadowPropertyObject, OutlineDeclaration, OutlineFillDeclaration, OutlineProperty, OutlinePropertyObject, OutlineStyle, Overflow, ParagraphContent, PointerEvents, Position, RgbColor, RgbaColor, SVGPathData, ShadowDeclaration, ShadowProperty, ShadowPropertyObject, ShadowStyleDeclaration, SoftEdgeDeclaration, SoftEdgeProperty, SolidFillDeclaration, StrokeLinecap, StrokeLinejoin, StyleDeclaration, StyleProperty, StylePropertyObject, StyleUnit, TailEnd, TextAlign, TextContent, TextContentDeclaration, TextContentFlat, TextDeclaration, TextDecoration, TextDrawStyleDeclaration, TextInlineStyleDeclaration, TextLineStyleDeclaration, TextOrientation, TextProperty, TextStyleDeclaration, TextTransform, TextWrap, TextureFillDeclaration, TextureFillSourceRect, TextureFillSourceURL, TextureFillStretch, TextureFillStretchRect, TextureFillTile, TransformStyleDeclaration, Uint32Color, VerticalAlign, VideoDeclaration, VideoProperty, Visibility, WritingMode, XyzColor, XyzaColor };
+export { clearUndef, defaultColor, getDefaultElementStyle, getDefaultHighlightStyle, getDefaultInnerShadow, getDefaultLayoutStyle, getDefaultListStyleStyle, getDefaultOuterShadow, getDefaultShadowStyle, getDefaultStyle, getDefaultTextInlineStyle, getDefaultTextLineStyle, getDefaultTextStyle, getDefaultTransformStyle, isColor, isGradient, isNone, normalizeAudio, normalizeBackground, normalizeColor, normalizeColorFill, normalizeDocument, normalizeEffect, normalizeElement, normalizeFill, normalizeForeground, normalizeGradient, normalizeGradientFill, normalizeImageFill, normalizeInnerShadow, normalizeOuterShadow, normalizeOutline, normalizePresetFill, normalizeShadow, normalizeShape, normalizeSoftEdge, normalizeStyle, normalizeText, normalizeTextContent, normalizeVideo, parseColor, parseGradient, round, stringifyGradient };
+export type { Align, AngularNode, Audio, Background, BackgroundObject, BackgroundSize, BorderStyle, BoxShadow, BoxSizing, CmykColor, CmykaColor, Color, ColorFill, ColorFillObject, ColorStop, ColorStopNode, DefaultRadialNode, Direction, DirectionalNode, Display, Document, Effect, EffectObject, Element, EmNode, ExtentKeywordNode, Fill, FillObject, FillRule, FlexDirection, FlexWrap, FontKerning, FontStyle, FontWeight, Foreground, ForegroundObject, FragmentContent, GradientFill, GradientFillObject, GradientNode, HeadEnd, Hex8Color, HexNode, HighlightColormap, HighlightImage, HighlightLine, HighlightReferImage, HighlightSize, HighlightThickness, HslColor, HslaColor, HsvColor, HsvaColor, HwbColor, HwbaColor, ImageFillCropRect, ImageFillObject, ImageFillStretchRect, ImageFillTile, InnerShadow, InnerShadowObject, Justify, LabColor, LabaColor, LchColor, LchaColor, LineEndSize, LineEndType, LinearGradient, LinearGradientNode, ListStyleColormap, ListStyleImage, ListStylePosition, ListStyleSize, ListStyleType, LiteralNode, Meta, Node, None, NormalizedAudio, NormalizedBackground, NormalizedBaseBackground, NormalizedBaseForeground, NormalizedBaseOuterShadow, NormalizedColor, NormalizedColorFill, NormalizedDocument, NormalizedEffect, NormalizedElement, NormalizedElementStyle, NormalizedFill, NormalizedForeground, NormalizedGradientFill, NormalizedHighlight, NormalizedHighlightStyle, NormalizedImageFill, NormalizedInnerShadow, NormalizedLayoutStyle, NormalizedListStyle, NormalizedListStyleStyle, NormalizedOuterShadow, NormalizedOutline, NormalizedOutlineFill, NormalizedPresetFill, NormalizedShadow, NormalizedShadowStyle, NormalizedShape, NormalizedSoftEdge, NormalizedStyle, NormalizedText, NormalizedTextContent, NormalizedTextDrawStyle, NormalizedTextInlineStyle, NormalizedTextLineStyle, NormalizedTextStyle, NormalizedTransformStyle, NormalizedVideo, ObjectColor, OuterShadow, OuterShadowObject, Outline, OutlineObject, OutlineStyle, Overflow, ParagraphContent, PercentNode, PointerEvents, Position, PositionKeywordNode, PositionNode, PresetFill, PresetFillObject, PxNode, RadialGradient, RadialGradientNode, RepeatingLinearGradientNode, RepeatingRadialGradientNode, RgbColor, RgbNode, RgbaColor, RgbaNode, SVGPathData, Shadow, ShadowObject, Shape, ShapeNode, ShapePath, ShapePathStyle, SoftEdge, StrokeLinecap, StrokeLinejoin, Style, StyleObject, StyleUnit, TailEnd, Text, TextAlign, TextContent, TextContentFlat, TextDecoration, TextOrientation, TextTransform, TextWrap, Uint32Color, VerticalAlign, Video, Visibility, WithNone, WritingMode, XyzColor, XyzaColor };