modern-idoc 0.6.0 → 0.6.2

package/dist/index.d.mts

@@ -1,10 +1,10 @@
 import { Colord } from 'colord';
 
-interface AudioDeclaration {
+interface NormalizedAudio {
     src: string;
 }
-type AudioProperty = 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,14 +64,15 @@ type ObjectColor = RgbColor | RgbaColor | HslColor | HslaColor | HsvColor | Hsva
 type Uint32Color = number;
 type Color = Uint32Color | ObjectColor | string;
 type Hex8Color = string;
-type ColorDeclaration = Hex8Color;
+type NormalizedColor = Hex8Color;
 declare function parseColor(color: Color): Colord;
-declare const defaultColor: ColorDeclaration;
-declare function normalizeColor(color: Color, orFail?: boolean): ColorDeclaration;
+declare const defaultColor: NormalizedColor;
+declare function isColor(value: string): boolean;
+declare function normalizeColor(color: Color, orFail?: boolean): NormalizedColor;
 
 interface ColorStop {
     offset: number;
-    color: ColorDeclaration;
+    color: NormalizedColor;
 }
 interface LinearGradient {
     type: 'linear-gradient';
@@ -84,6 +85,7 @@ interface RadialGradient {
     stops: ColorStop[];
     repeat?: boolean;
 }
+declare function isGradient(cssText: string): boolean;
 declare function normalizeGradient(cssText: string): (LinearGradient | RadialGradient)[];
 
 interface LinearGradientNode {
@@ -208,22 +210,32 @@ type GradientNode = LinearGradientNode | RepeatingLinearGradientNode | RadialGra
 declare function parseGradient(cssText: string): GradientNode[]
 declare function stringifyGradient(ast: GradientNode[]): string
 
-type None = undefined | null | 'none';
-type WithNone<T> = T | None;
-
-interface GradientFillDeclaration {
+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;
@@ -234,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;
@@ -251,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: WithNone<Color>;
-};
-type FillProperty = 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 = string | BackgroundPropertyObject;
-declare function normalizeBackground(background: BackgroundProperty): BackgroundDeclaration;
+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> & {
+type InnerShadowObject = Partial<NormalizedInnerShadow> & {
     color: WithNone<Color>;
 };
-type InnerShadowProperty = InnerShadowPropertyObject;
-declare function getDefaultInnerShadow(): InnerShadowDeclaration;
-declare function normalizeInnerShadow(shadow: InnerShadowProperty): InnerShadowDeclaration;
+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 = OuterShadowPropertyObject;
-declare function getDefaultOuterShadow(): OuterShadowDeclaration;
-declare function normalizeOuterShadow(shadow: OuterShadowProperty): OuterShadowDeclaration;
+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 = SoftEdgeDeclaration;
-declare function normalizeSoftEdge(softEdge: SoftEdgeProperty): SoftEdgeDeclaration;
+type SoftEdge = NormalizedSoftEdge;
+declare function normalizeSoftEdge(softEdge: SoftEdge): NormalizedSoftEdge;
 
-interface EffectDeclaration {
-    innerShadow?: InnerShadowDeclaration;
-    outerShadow?: OuterShadowDeclaration;
-    softEdge?: SoftEdgeDeclaration;
-}
-interface EffectPropertyObject {
-    innerShadow: WithNone<InnerShadowProperty>;
-    outerShadow: WithNone<OuterShadowProperty>;
-    softEdge: WithNone<SoftEdgeProperty>;
+interface NormalizedEffect {
+    innerShadow?: NormalizedInnerShadow;
+    outerShadow?: NormalizedOuterShadow;
+    softEdge?: NormalizedSoftEdge;
 }
-type EffectProperty = EffectPropertyObject;
-declare function normalizeEffect(effect: EffectProperty): EffectDeclaration;
-
-interface BaseForegroundDeclaration {
-    withGeometry?: boolean;
+interface EffectObject {
+    innerShadow: WithNone<InnerShadow>;
+    outerShadow: WithNone<OuterShadow>;
+    softEdge: WithNone<SoftEdge>;
 }
-type ForegroundDeclaration = BaseForegroundDeclaration & FillDeclaration;
-type ForegroundPropertyObject = BaseForegroundDeclaration & FillPropertyObject;
-type ForegroundProperty = string | ForegroundPropertyObject;
-declare function normalizeForeground(foreground: ForegroundProperty): ForegroundDeclaration | undefined;
+type Effect = EffectObject;
+declare function normalizeEffect(effect: Effect): NormalizedEffect;
 
-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[];
+interface NormalizedBaseForeground {
+    fillWithShape: boolean;
 }
-type GeometryProperty = SVGPathData | SVGPathData[] | GeometryPathDeclaration[] | GeometryDeclaration;
-declare function normalizeGeometry(geometry: GeometryProperty): GeometryDeclaration;
+type NormalizedForeground = NormalizedBaseForeground & NormalizedFill;
+type ForegroundObject = Partial<NormalizedBaseForeground> & FillObject;
+type Foreground = string | ForegroundObject;
+declare function normalizeForeground(foreground: Foreground): NormalizedForeground | undefined;
 
-interface MetaProperty {
+interface Meta {
     [key: string]: any;
 }
 
-interface Node<T = MetaProperty> {
+interface Node<T = Meta> {
     name?: string;
     children?: Node[];
     meta?: T;
@@ -388,41 +376,76 @@ interface TailEnd {
     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> & {
+type OutlineObject = Partial<NormalizedOutline> & {
     color: WithNone<Color>;
 };
-type OutlineProperty = string | OutlinePropertyObject;
-declare function normalizeOutline(outline: OutlineProperty): OutlineDeclaration;
+type Outline = string | OutlineObject;
+declare function normalizeOutline(outline: Outline): NormalizedOutline;
 
 type BoxShadow = string;
-interface ShadowDeclaration {
-    color: ColorDeclaration;
+interface NormalizedShadow {
+    color: NormalizedColor;
     offsetX?: number;
     offsetY?: number;
     blur?: number;
 }
-type ShadowPropertyObject = Partial<ShadowDeclaration> & {
+type ShadowObject = Partial<NormalizedShadow> & {
     color: WithNone<Color>;
 };
-type ShadowProperty = BoxShadow | ShadowPropertyObject;
-declare function normalizeShadow(shadow: ShadowProperty): ShadowDeclaration;
-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';
@@ -459,7 +482,7 @@ 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;
@@ -503,9 +526,9 @@ interface LayoutStyleDeclaration {
     paddingBottom: StyleUnit;
     padding: StyleUnit;
 }
-declare function getDefaultLayoutStyle(): Partial<LayoutStyleDeclaration>;
+declare function getDefaultLayoutStyle(): Partial<NormalizedLayoutStyle>;
 
-interface TransformStyleDeclaration {
+interface NormalizedTransformStyle {
     rotate: number;
     scaleX: number;
     scaleY: number;
@@ -516,20 +539,20 @@ interface TransformStyleDeclaration {
     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 & {
+type NormalizedElementStyle = Partial<NormalizedLayoutStyle> & NormalizedTransformStyle & NormalizedShadowStyle & {
     backgroundImage: WithNone<string>;
     backgroundSize: BackgroundSize;
-    backgroundColor: WithNone<ColorDeclaration>;
+    backgroundColor: WithNone<NormalizedColor>;
     backgroundColormap: WithNone<Record<string, string>>;
     borderRadius: number;
-    borderColor: WithNone<ColorDeclaration>;
+    borderColor: WithNone<NormalizedColor>;
     borderStyle: BorderStyle;
     outlineWidth: number;
     outlineOffset: number;
-    outlineColor: WithNone<ColorDeclaration>;
+    outlineColor: WithNone<NormalizedColor>;
     outlineStyle: string;
     visibility: Visibility;
     filter: string;
@@ -537,9 +560,9 @@ type ElementStyleDeclaration = Partial<LayoutStyleDeclaration> & TransformStyleD
     pointerEvents: PointerEvents;
     maskImage: WithNone<string>;
 };
-declare function getDefaultElementStyle(): ElementStyleDeclaration;
+declare function getDefaultElementStyle(): NormalizedElementStyle;
 
-interface HighlightDeclaration {
+interface NormalizedHighlight {
     image: HighlightImage;
     referImage: HighlightReferImage;
     colormap: HighlightColormap;
@@ -547,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;
@@ -556,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;
@@ -589,104 +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> & {
+type StyleObject = Partial<NormalizedStyle> & {
     color?: WithNone<Color>;
     backgroundColor?: WithNone<Color>;
     borderColor?: WithNone<Color>;
     outlineColor?: WithNone<Color>;
     shadowColor?: WithNone<Color>;
 };
-type StyleProperty = StylePropertyObject;
-declare function normalizeStyle(style: StyleProperty): Partial<StyleDeclaration>;
-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;
+}) | NormalizedText;
+declare function normalizeTextContent(content?: TextContent): NormalizedTextContent;
+declare function normalizeText(text: Text): NormalizedText;
 
-interface VideoDeclaration {
+interface NormalizedVideo {
     src: string;
 }
-type VideoProperty = string | VideoDeclaration;
-declare function normalizeVideo(video: VideoProperty): VideoDeclaration | undefined;
-
-interface Element<T = MetaProperty> extends Node<T> {
-    style?: WithNone<StyleProperty>;
-    text?: WithNone<TextProperty>;
-    background?: WithNone<BackgroundProperty>;
-    geometry?: WithNone<GeometryProperty>;
-    fill?: WithNone<FillProperty>;
-    outline?: WithNone<OutlineProperty>;
-    foreground?: WithNone<ForegroundProperty>;
-    shadow?: WithNone<ShadowProperty>;
-    video?: WithNone<VideoProperty>;
-    audio?: WithNone<AudioProperty>;
-    effect?: WithNone<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[];
 }
-type ElementDeclaration<T = MetaProperty> = Node<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[];
+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 = MetaProperty>(element: Element<T>): ElementDeclaration<T>;
+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, defaultColor, getDefaultElementStyle, getDefaultHighlightStyle, getDefaultInnerShadow, getDefaultLayoutStyle, getDefaultListStyleStyle, getDefaultOuterShadow, getDefaultShadowStyle, getDefaultStyle, getDefaultTextInlineStyle, getDefaultTextLineStyle, getDefaultTextStyle, getDefaultTransformStyle, isNone, normalizeAudio, normalizeBackground, normalizeColor, normalizeDocument, normalizeEffect, normalizeElement, normalizeFill, normalizeForeground, normalizeGeometry, normalizeGradient, normalizeInnerShadow, normalizeOuterShadow, normalizeOutline, normalizeShadow, normalizeSoftEdge, normalizeStyle, normalizeText, normalizeTextContent, normalizeVideo, parseColor, parseGradient, stringifyGradient };
-export type { Align, AngularNode, AudioDeclaration, AudioProperty, BackgroundDeclaration, BackgroundProperty, BackgroundPropertyObject, BackgroundSize, BaseBackgroundDeclaration, BaseForegroundDeclaration, BaseOuterShadowDeclaration, BorderStyle, BoxShadow, BoxSizing, CmykColor, CmykaColor, Color, ColorDeclaration, ColorStop, ColorStopNode, DefaultRadialNode, Direction, DirectionalNode, Display, Document, DocumentDeclaration, EffectDeclaration, EffectProperty, EffectPropertyObject, Element, ElementDeclaration, ElementStyleDeclaration, EmNode, ExtentKeywordNode, FillDeclaration, FillProperty, FillPropertyObject, FillRule, FlexDirection, FlexWrap, FontKerning, FontStyle, FontWeight, ForegroundDeclaration, ForegroundProperty, ForegroundPropertyObject, FragmentContent, GeometryDeclaration, GeometryPathDeclaration, GeometryPathStyle, GeometryProperty, GradientFillDeclaration, GradientNode, HeadEnd, Hex8Color, HexNode, 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, LinearGradient, LinearGradientNode, ListStyleColormap, ListStyleDeclaration, ListStyleImage, ListStylePosition, ListStyleSize, ListStyleStyleDeclaration, ListStyleType, LiteralNode, MetaProperty, Node, None, ObjectColor, OuterShadowDeclaration, OuterShadowProperty, OuterShadowPropertyObject, OutlineDeclaration, OutlineFillDeclaration, OutlineProperty, OutlinePropertyObject, OutlineStyle, Overflow, ParagraphContent, PercentNode, PointerEvents, Position, PositionKeywordNode, PositionNode, PxNode, RadialGradient, RadialGradientNode, RepeatingLinearGradientNode, RepeatingRadialGradientNode, RgbColor, RgbNode, RgbaColor, RgbaNode, SVGPathData, ShadowDeclaration, ShadowProperty, ShadowPropertyObject, ShadowStyleDeclaration, ShapeNode, 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, WithNone, 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 };