html2canvas-pro 2.1.0 → 2.2.0

package/src/css/property-descriptors/border-radius.ts

@@ -1,19 +0,0 @@
-import { IPropertyListDescriptor, PropertyDescriptorParsingType } from '../property-descriptor';
-import { CSSValue } from '../syntax/parser';
-import { isLengthPercentage, LengthPercentageTuple, parseLengthPercentageTuple } from '../types/length-percentage';
-import { Context } from '../../core/context';
-export type BorderRadius = LengthPercentageTuple;
-
-const borderRadiusForSide = (side: string): IPropertyListDescriptor<BorderRadius> => ({
-    name: `border-radius-${side}`,
-    initialValue: '0 0',
-    prefix: false,
-    type: PropertyDescriptorParsingType.LIST,
-    parse: (_context: Context, tokens: CSSValue[]): BorderRadius =>
-        parseLengthPercentageTuple(tokens.filter(isLengthPercentage))
-});
-
-export const borderTopLeftRadius: IPropertyListDescriptor<BorderRadius> = borderRadiusForSide('top-left');
-export const borderTopRightRadius: IPropertyListDescriptor<BorderRadius> = borderRadiusForSide('top-right');
-export const borderBottomRightRadius: IPropertyListDescriptor<BorderRadius> = borderRadiusForSide('bottom-right');
-export const borderBottomLeftRadius: IPropertyListDescriptor<BorderRadius> = borderRadiusForSide('bottom-left');

package/src/css/property-descriptors/border-style.ts

@@ -1,34 +0,0 @@
-import { IPropertyIdentValueDescriptor, PropertyDescriptorParsingType } from '../property-descriptor';
-import { Context } from '../../core/context';
-export const enum BORDER_STYLE {
-    NONE = 0,
-    SOLID = 1,
-    DASHED = 2,
-    DOTTED = 3,
-    DOUBLE = 4
-}
-
-const borderStyleForSide = (side: string): IPropertyIdentValueDescriptor<BORDER_STYLE> => ({
-    name: `border-${side}-style`,
-    initialValue: 'solid',
-    prefix: false,
-    type: PropertyDescriptorParsingType.IDENT_VALUE,
-    parse: (_context: Context, style: string): BORDER_STYLE => {
-        switch (style) {
-            case 'none':
-                return BORDER_STYLE.NONE;
-            case 'dashed':
-                return BORDER_STYLE.DASHED;
-            case 'dotted':
-                return BORDER_STYLE.DOTTED;
-            case 'double':
-                return BORDER_STYLE.DOUBLE;
-        }
-        return BORDER_STYLE.SOLID;
-    }
-});
-
-export const borderTopStyle: IPropertyIdentValueDescriptor<BORDER_STYLE> = borderStyleForSide('top');
-export const borderRightStyle: IPropertyIdentValueDescriptor<BORDER_STYLE> = borderStyleForSide('right');
-export const borderBottomStyle: IPropertyIdentValueDescriptor<BORDER_STYLE> = borderStyleForSide('bottom');
-export const borderLeftStyle: IPropertyIdentValueDescriptor<BORDER_STYLE> = borderStyleForSide('left');

package/src/css/property-descriptors/border-width.ts

@@ -1,20 +0,0 @@
-import { IPropertyValueDescriptor, PropertyDescriptorParsingType } from '../property-descriptor';
-import { CSSValue, isDimensionToken } from '../syntax/parser';
-import { Context } from '../../core/context';
-const borderWidthForSide = (side: string): IPropertyValueDescriptor<number> => ({
-    name: `border-${side}-width`,
-    initialValue: '0',
-    type: PropertyDescriptorParsingType.VALUE,
-    prefix: false,
-    parse: (_context: Context, token: CSSValue): number => {
-        if (isDimensionToken(token)) {
-            return token.number;
-        }
-        return 0;
-    }
-});
-
-export const borderTopWidth: IPropertyValueDescriptor<number> = borderWidthForSide('top');
-export const borderRightWidth: IPropertyValueDescriptor<number> = borderWidthForSide('right');
-export const borderBottomWidth: IPropertyValueDescriptor<number> = borderWidthForSide('bottom');
-export const borderLeftWidth: IPropertyValueDescriptor<number> = borderWidthForSide('left');

package/src/css/property-descriptors/box-shadow.ts

@@ -1,60 +0,0 @@
-import { PropertyDescriptorParsingType, IPropertyListDescriptor } from '../property-descriptor';
-import { CSSValue, isIdentWithValue, parseFunctionArgs } from '../syntax/parser';
-import { ZERO_LENGTH } from '../types/length-percentage';
-import { color, Color } from '../types/color';
-import { isLength, Length } from '../types/length';
-import { Context } from '../../core/context';
-
-export type BoxShadow = BoxShadowItem[];
-interface BoxShadowItem {
-    inset: boolean;
-    color: Color;
-    offsetX: Length;
-    offsetY: Length;
-    blur: Length;
-    spread: Length;
-}
-
-export const boxShadow: IPropertyListDescriptor<BoxShadow> = {
-    name: 'box-shadow',
-    initialValue: 'none',
-    type: PropertyDescriptorParsingType.LIST,
-    prefix: false,
-    parse: (context: Context, tokens: CSSValue[]): BoxShadow => {
-        if (tokens.length === 1 && isIdentWithValue(tokens[0], 'none')) {
-            return [];
-        }
-
-        return parseFunctionArgs(tokens).map((values: CSSValue[]) => {
-            const shadow: BoxShadowItem = {
-                color: 0x000000ff,
-                offsetX: ZERO_LENGTH,
-                offsetY: ZERO_LENGTH,
-                blur: ZERO_LENGTH,
-                spread: ZERO_LENGTH,
-                inset: false
-            };
-            let c = 0;
-            for (let i = 0; i < values.length; i++) {
-                const token = values[i];
-                if (isIdentWithValue(token, 'inset')) {
-                    shadow.inset = true;
-                } else if (isLength(token)) {
-                    if (c === 0) {
-                        shadow.offsetX = token;
-                    } else if (c === 1) {
-                        shadow.offsetY = token;
-                    } else if (c === 2) {
-                        shadow.blur = token;
-                    } else {
-                        shadow.spread = token;
-                    }
-                    c++;
-                } else {
-                    shadow.color = color.parse(context, token);
-                }
-            }
-            return shadow;
-        });
-    }
-};

package/src/css/property-descriptors/clip-path.ts

@@ -1,271 +0,0 @@
-import { IPropertyValueDescriptor, PropertyDescriptorParsingType } from '../property-descriptor';
-import { CSSValue, isIdentToken, isIdentWithValue, nonWhiteSpace, parseFunctionArgs } from '../syntax/parser';
-import { StringValueToken, TokenType } from '../syntax/tokenizer';
-import {
-    LengthPercentage,
-    FIFTY_PERCENT,
-    HUNDRED_PERCENT,
-    ZERO_LENGTH,
-    isLengthPercentage
-} from '../types/length-percentage';
-import { Context } from '../../core/context';
-
-export const enum CLIP_PATH_TYPE {
-    NONE = 0,
-    INSET = 1,
-    CIRCLE = 2,
-    ELLIPSE = 3,
-    POLYGON = 4,
-    PATH = 5
-}
-
-/** Radius keyword or length-percentage for circle/ellipse. */
-export type ShapeRadius = LengthPercentage | 'closest-side' | 'farthest-side';
-
-export interface NoneClipPath {
-    type: CLIP_PATH_TYPE.NONE;
-}
-
-/**
- * inset(top right bottom left [ round <border-radius> ]?)
- * Amounts to cut from each side of the reference box.
- */
-export interface InsetClipPath {
-    type: CLIP_PATH_TYPE.INSET;
-    top: LengthPercentage;
-    right: LengthPercentage;
-    bottom: LengthPercentage;
-    left: LengthPercentage;
-}
-
-/**
- * circle( [ <shape-radius> ]? [ at <position> ]? )
- */
-export interface CircleClipPath {
-    type: CLIP_PATH_TYPE.CIRCLE;
-    radius: ShapeRadius;
-    cx: LengthPercentage;
-    cy: LengthPercentage;
-}
-
-/**
- * ellipse( [ <shape-radius>{2} ]? [ at <position> ]? )
- */
-export interface EllipseClipPath {
-    type: CLIP_PATH_TYPE.ELLIPSE;
-    rx: ShapeRadius;
-    ry: ShapeRadius;
-    cx: LengthPercentage;
-    cy: LengthPercentage;
-}
-
-/**
- * polygon( [ <fill-rule>, ]? [ <length-percentage> <length-percentage> ]# )
- */
-export interface PolygonClipPath {
-    type: CLIP_PATH_TYPE.POLYGON;
-    points: [LengthPercentage, LengthPercentage][];
-}
-
-/**
- * path( [ <fill-rule>, ]? <string> )
- * The string contains SVG path data in the element's local coordinate space.
- */
-export interface PathClipPath {
-    type: CLIP_PATH_TYPE.PATH;
-    d: string;
-}
-
-export type ClipPathValue =
-    | NoneClipPath
-    | InsetClipPath
-    | CircleClipPath
-    | EllipseClipPath
-    | PolygonClipPath
-    | PathClipPath;
-
-const NONE: NoneClipPath = { type: CLIP_PATH_TYPE.NONE };
-
-/**
- * Parse a shape-radius token: <length-percentage> | closest-side | farthest-side.
- * Defaults to 'closest-side' when no tokens are provided.
- */
-const parseShapeRadius = (tokens: CSSValue[]): ShapeRadius => {
-    const [first] = tokens;
-    if (!first) return 'closest-side';
-    if (isIdentToken(first)) {
-        // Any unrecognised keyword (e.g. 'closest-corner') intentionally falls back to
-        // 'closest-side' as the CSS spec requires unknown values to be treated as invalid
-        // and the initial value of <shape-radius> is 'closest-side'.
-        return first.value === 'farthest-side' ? 'farthest-side' : 'closest-side';
-    }
-    return isLengthPercentage(first) ? first : 'closest-side';
-};
-
-/**
- * Parse a CSS <position> as (cx, cy), each as a LengthPercentage.
- *
- * Supports the **1–2 value** subset of the CSS `<position>` syntax.
- * The 4-value form (`at left 10px top 20px`) is not supported and will be
- * parsed on a best-effort basis.
- *
- * Axis assignment rules:
- *   - `left` / `right`  → x-axis (cx)
- *   - `top`  / `bottom` → y-axis (cy)
- *   - `center` or a <length-percentage> → fills the first unset axis, in order
- *
- * Examples:
- *   "at left"        → cx=0,    cy=50%   (left is x; y defaults to center)
- *   "at top"         → cx=50%,  cy=0     (top is y; x defaults to center)
- *   "at center 30%"  → cx=50%,  cy=30%
- *   "at 30% center"  → cx=30%,  cy=50%
- *   "at left top"    → cx=0,    cy=0
- *   "at top left"    → cx=0,    cy=0     (keyword order is irrelevant)
- *
- * Unset axes fall back to 50%.
- */
-const parsePosition = (tokens: CSSValue[]): { cx: LengthPercentage; cy: LengthPercentage } => {
-    let cx: LengthPercentage | null = null;
-    let cy: LengthPercentage | null = null;
-
-    for (const token of tokens) {
-        if (isIdentToken(token)) {
-            switch (token.value) {
-                case 'left':
-                    cx = ZERO_LENGTH;
-                    break;
-                case 'right':
-                    cx = HUNDRED_PERCENT;
-                    break;
-                case 'top':
-                    cy = ZERO_LENGTH;
-                    break;
-                case 'bottom':
-                    cy = HUNDRED_PERCENT;
-                    break;
-                case 'center':
-                    // `center` fills whichever axis has not yet been claimed.
-                    if (cx === null) cx = FIFTY_PERCENT;
-                    else if (cy === null) cy = FIFTY_PERCENT;
-                    break;
-            }
-        } else if (isLengthPercentage(token)) {
-            // Length-percentages are assigned in source order.
-            if (cx === null) cx = token;
-            else if (cy === null) cy = token;
-        }
-    }
-
-    return { cx: cx ?? FIFTY_PERCENT, cy: cy ?? FIFTY_PERCENT };
-};
-
-/**
- * inset( <length-percentage>{1,4} [ round <'border-radius'> ]? )
- * The 1-4 shorthand follows the same expansion as margin/padding:
- *   1 value  → all four sides
- *   2 values → top/bottom | left/right
- *   3 values → top | left/right | bottom
- *   4 values → top | right | bottom | left
- * The optional `round` clause (border-radius) is parsed but ignored.
- */
-const parseInset = (values: CSSValue[]): InsetClipPath => {
-    const lengths: LengthPercentage[] = [];
-    for (const token of values) {
-        if (token.type === TokenType.WHITESPACE_TOKEN) continue;
-        if (isIdentToken(token) && token.value === 'round') break;
-        if (isLengthPercentage(token)) lengths.push(token);
-    }
-    const v0 = lengths[0] ?? ZERO_LENGTH;
-    const v1 = lengths[1] ?? v0;
-    const v2 = lengths[2] ?? v0;
-    const v3 = lengths[3] ?? v1;
-    return { type: CLIP_PATH_TYPE.INSET, top: v0, right: v1, bottom: v2, left: v3 };
-};
-
-/**
- * circle( [ <shape-radius> ]? [ at <position> ]? )
- */
-const parseCircle = (values: CSSValue[]): CircleClipPath => {
-    const nonWs = values.filter(nonWhiteSpace);
-    const atIdx = nonWs.findIndex((t) => isIdentWithValue(t, 'at'));
-    const radiusTokens = atIdx === -1 ? nonWs : nonWs.slice(0, atIdx);
-    const posTokens = atIdx === -1 ? [] : nonWs.slice(atIdx + 1);
-    return {
-        type: CLIP_PATH_TYPE.CIRCLE,
-        radius: parseShapeRadius(radiusTokens),
-        ...parsePosition(posTokens)
-    };
-};
-
-/**
- * ellipse( [ <shape-radius>{2} ]? [ at <position> ]? )
- */
-const parseEllipse = (values: CSSValue[]): EllipseClipPath => {
-    const nonWs = values.filter(nonWhiteSpace);
-    const atIdx = nonWs.findIndex((t) => isIdentWithValue(t, 'at'));
-    const radiusTokens = atIdx === -1 ? nonWs : nonWs.slice(0, atIdx);
-    const posTokens = atIdx === -1 ? [] : nonWs.slice(atIdx + 1);
-    return {
-        type: CLIP_PATH_TYPE.ELLIPSE,
-        rx: parseShapeRadius(radiusTokens.slice(0, 1)),
-        ry: parseShapeRadius(radiusTokens.slice(1, 2)),
-        ...parsePosition(posTokens)
-    };
-};
-
-/**
- * polygon( [ <fill-rule>, ]? [ <length-percentage> <length-percentage> ]# )
- * Each comma-separated group defines one vertex (x y).
- * A leading fill-rule keyword (nonzero/evenodd) is skipped.
- */
-const parsePolygon = (values: CSSValue[]): PolygonClipPath => {
-    const args = parseFunctionArgs(values);
-    const points: [LengthPercentage, LengthPercentage][] = [];
-    for (const arg of args) {
-        if (arg.length === 1 && isIdentToken(arg[0])) continue; // skip fill-rule
-        const lengths = arg.filter(isLengthPercentage);
-        if (lengths.length >= 2) {
-            points.push([lengths[0], lengths[1]]);
-        }
-    }
-    return { type: CLIP_PATH_TYPE.POLYGON, points };
-};
-
-/**
- * path( [ <fill-rule>, ]? <string> )
- * The string value is the SVG path data (coordinates in the element's local space).
- */
-const parsePath = (values: CSSValue[]): PathClipPath | NoneClipPath => {
-    const stringToken = values.find((t) => t.type === TokenType.STRING_TOKEN) as StringValueToken | undefined;
-    if (!stringToken) return NONE;
-    return { type: CLIP_PATH_TYPE.PATH, d: stringToken.value };
-};
-
-export const clipPath: IPropertyValueDescriptor<ClipPathValue> = {
-    name: 'clip-path',
-    initialValue: 'none',
-    prefix: false,
-    type: PropertyDescriptorParsingType.VALUE,
-    parse: (_context: Context, token: CSSValue): ClipPathValue => {
-        if (isIdentToken(token) && token.value === 'none') {
-            return NONE;
-        }
-
-        if (token.type === TokenType.FUNCTION) {
-            switch (token.name) {
-                case 'inset':
-                    return parseInset(token.values);
-                case 'circle':
-                    return parseCircle(token.values);
-                case 'ellipse':
-                    return parseEllipse(token.values);
-                case 'polygon':
-                    return parsePolygon(token.values);
-                case 'path':
-                    return parsePath(token.values);
-            }
-        }
-
-        return NONE;
-    }
-};

package/src/css/property-descriptors/color.ts

@@ -1,9 +0,0 @@
-import { IPropertyTypeValueDescriptor, PropertyDescriptorParsingType } from '../property-descriptor';
-
-export const color: IPropertyTypeValueDescriptor = {
-    name: `color`,
-    initialValue: 'transparent',
-    prefix: false,
-    type: PropertyDescriptorParsingType.TYPE_VALUE,
-    format: 'color'
-};

package/src/css/property-descriptors/content.ts

@@ -1,26 +0,0 @@
-import { TokenType } from '../syntax/tokenizer';
-import { IPropertyListDescriptor, PropertyDescriptorParsingType } from '../property-descriptor';
-import { CSSValue } from '../syntax/parser';
-import { Context } from '../../core/context';
-
-export type Content = CSSValue[];
-
-export const content: IPropertyListDescriptor<Content> = {
-    name: 'content',
-    initialValue: 'none',
-    type: PropertyDescriptorParsingType.LIST,
-    prefix: false,
-    parse: (_context: Context, tokens: CSSValue[]) => {
-        if (tokens.length === 0) {
-            return [];
-        }
-
-        const first = tokens[0];
-
-        if (first.type === TokenType.IDENT_TOKEN && first.value === 'none') {
-            return [];
-        }
-
-        return tokens;
-    }
-};

package/src/css/property-descriptors/counter-increment.ts

@@ -1,43 +0,0 @@
-import { IPropertyListDescriptor, PropertyDescriptorParsingType } from '../property-descriptor';
-import { CSSValue, isNumberToken, nonWhiteSpace } from '../syntax/parser';
-import { TokenType } from '../syntax/tokenizer';
-import { Context } from '../../core/context';
-
-export interface COUNTER_INCREMENT {
-    counter: string;
-    increment: number;
-}
-
-export type CounterIncrement = COUNTER_INCREMENT[] | null;
-
-export const counterIncrement: IPropertyListDescriptor<CounterIncrement> = {
-    name: 'counter-increment',
-    initialValue: 'none',
-    prefix: true,
-    type: PropertyDescriptorParsingType.LIST,
-    parse: (_context: Context, tokens: CSSValue[]) => {
-        if (tokens.length === 0) {
-            return null;
-        }
-
-        const first = tokens[0];
-
-        if (first.type === TokenType.IDENT_TOKEN && first.value === 'none') {
-            return null;
-        }
-
-        const increments = [];
-        const filtered = tokens.filter(nonWhiteSpace);
-
-        for (let i = 0; i < filtered.length; i++) {
-            const counter = filtered[i];
-            const next = filtered[i + 1];
-            if (counter.type === TokenType.IDENT_TOKEN) {
-                const increment = next && isNumberToken(next) ? next.number : 1;
-                increments.push({ counter: counter.value, increment });
-            }
-        }
-
-        return increments;
-    }
-};

package/src/css/property-descriptors/counter-reset.ts

@@ -1,36 +0,0 @@
-import { IPropertyListDescriptor, PropertyDescriptorParsingType } from '../property-descriptor';
-import { CSSValue, isIdentToken, isNumberToken, nonWhiteSpace } from '../syntax/parser';
-import { Context } from '../../core/context';
-
-export interface COUNTER_RESET {
-    counter: string;
-    reset: number;
-}
-
-export type CounterReset = COUNTER_RESET[];
-
-export const counterReset: IPropertyListDescriptor<CounterReset> = {
-    name: 'counter-reset',
-    initialValue: 'none',
-    prefix: true,
-    type: PropertyDescriptorParsingType.LIST,
-    parse: (_context: Context, tokens: CSSValue[]) => {
-        if (tokens.length === 0) {
-            return [];
-        }
-
-        const resets = [];
-        const filtered = tokens.filter(nonWhiteSpace);
-
-        for (let i = 0; i < filtered.length; i++) {
-            const counter = filtered[i];
-            const next = filtered[i + 1];
-            if (isIdentToken(counter) && counter.value !== 'none') {
-                const reset = next && isNumberToken(next) ? next.number : 0;
-                resets.push({ counter: counter.value, reset });
-            }
-        }
-
-        return resets;
-    }
-};

package/src/css/property-descriptors/direction.ts

@@ -1,23 +0,0 @@
-import { IPropertyIdentValueDescriptor, PropertyDescriptorParsingType } from '../property-descriptor';
-import { Context } from '../../core/context';
-
-export const enum DIRECTION {
-    LTR = 0,
-    RTL = 1
-}
-
-export const direction: IPropertyIdentValueDescriptor<DIRECTION> = {
-    name: 'direction',
-    initialValue: 'ltr',
-    prefix: false,
-    type: PropertyDescriptorParsingType.IDENT_VALUE,
-    parse: (_context: Context, direction: string) => {
-        switch (direction) {
-            case 'rtl':
-                return DIRECTION.RTL;
-            case 'ltr':
-            default:
-                return DIRECTION.LTR;
-        }
-    }
-};

package/src/css/property-descriptors/display.ts

@@ -1,117 +0,0 @@
-import { IPropertyListDescriptor, PropertyDescriptorParsingType } from '../property-descriptor';
-import { CSSValue, isIdentToken } from '../syntax/parser';
-import { Context } from '../../core/context';
-export const enum DISPLAY {
-    NONE = 0,
-    BLOCK = 1 << 1,
-    INLINE = 1 << 2,
-    RUN_IN = 1 << 3,
-    FLOW = 1 << 4,
-    FLOW_ROOT = 1 << 5,
-    TABLE = 1 << 6,
-    FLEX = 1 << 7,
-    GRID = 1 << 8,
-    RUBY = 1 << 9,
-    SUBGRID = 1 << 10,
-    LIST_ITEM = 1 << 11,
-    TABLE_ROW_GROUP = 1 << 12,
-    TABLE_HEADER_GROUP = 1 << 13,
-    TABLE_FOOTER_GROUP = 1 << 14,
-    TABLE_ROW = 1 << 15,
-    TABLE_CELL = 1 << 16,
-    TABLE_COLUMN_GROUP = 1 << 17,
-    TABLE_COLUMN = 1 << 18,
-    TABLE_CAPTION = 1 << 19,
-    RUBY_BASE = 1 << 20,
-    RUBY_TEXT = 1 << 21,
-    RUBY_BASE_CONTAINER = 1 << 22,
-    RUBY_TEXT_CONTAINER = 1 << 23,
-    CONTENTS = 1 << 24,
-    INLINE_BLOCK = 1 << 25,
-    INLINE_LIST_ITEM = 1 << 26,
-    INLINE_TABLE = 1 << 27,
-    INLINE_FLEX = 1 << 28,
-    INLINE_GRID = 1 << 29
-}
-
-export type Display = number;
-
-export const display: IPropertyListDescriptor<Display> = {
-    name: 'display',
-    initialValue: 'inline-block',
-    prefix: false,
-    type: PropertyDescriptorParsingType.LIST,
-    parse: (_context: Context, tokens: CSSValue[]): Display => {
-        return tokens.filter(isIdentToken).reduce((bit, token) => {
-            return bit | parseDisplayValue(token.value);
-        }, DISPLAY.NONE);
-    }
-};
-
-const parseDisplayValue = (display: string): Display => {
-    switch (display) {
-        case 'block':
-        case '-webkit-box':
-            return DISPLAY.BLOCK;
-        case 'inline':
-            return DISPLAY.INLINE;
-        case 'run-in':
-            return DISPLAY.RUN_IN;
-        case 'flow':
-            return DISPLAY.FLOW;
-        case 'flow-root':
-            return DISPLAY.FLOW_ROOT;
-        case 'table':
-            return DISPLAY.TABLE;
-        case 'flex':
-        case '-webkit-flex':
-            return DISPLAY.FLEX;
-        case 'grid':
-        case '-ms-grid':
-            return DISPLAY.GRID;
-        case 'ruby':
-            return DISPLAY.RUBY;
-        case 'subgrid':
-            return DISPLAY.SUBGRID;
-        case 'list-item':
-            return DISPLAY.LIST_ITEM;
-        case 'table-row-group':
-            return DISPLAY.TABLE_ROW_GROUP;
-        case 'table-header-group':
-            return DISPLAY.TABLE_HEADER_GROUP;
-        case 'table-footer-group':
-            return DISPLAY.TABLE_FOOTER_GROUP;
-        case 'table-row':
-            return DISPLAY.TABLE_ROW;
-        case 'table-cell':
-            return DISPLAY.TABLE_CELL;
-        case 'table-column-group':
-            return DISPLAY.TABLE_COLUMN_GROUP;
-        case 'table-column':
-            return DISPLAY.TABLE_COLUMN;
-        case 'table-caption':
-            return DISPLAY.TABLE_CAPTION;
-        case 'ruby-base':
-            return DISPLAY.RUBY_BASE;
-        case 'ruby-text':
-            return DISPLAY.RUBY_TEXT;
-        case 'ruby-base-container':
-            return DISPLAY.RUBY_BASE_CONTAINER;
-        case 'ruby-text-container':
-            return DISPLAY.RUBY_TEXT_CONTAINER;
-        case 'contents':
-            return DISPLAY.CONTENTS;
-        case 'inline-block':
-            return DISPLAY.INLINE_BLOCK;
-        case 'inline-list-item':
-            return DISPLAY.INLINE_LIST_ITEM;
-        case 'inline-table':
-            return DISPLAY.INLINE_TABLE;
-        case 'inline-flex':
-            return DISPLAY.INLINE_FLEX;
-        case 'inline-grid':
-            return DISPLAY.INLINE_GRID;
-    }
-
-    return DISPLAY.NONE;
-};

package/src/css/property-descriptors/duration.ts

@@ -1,14 +0,0 @@
-import { IPropertyListDescriptor, PropertyDescriptorParsingType } from '../property-descriptor';
-import { Context } from '../../core/context';
-import { CSSValue, isDimensionToken } from '../syntax/parser';
-import { time } from '../types/time';
-
-export const duration: IPropertyListDescriptor<number[]> = {
-    name: 'duration',
-    initialValue: '0s',
-    prefix: false,
-    type: PropertyDescriptorParsingType.LIST,
-    parse: (context: Context, tokens: CSSValue[]) => {
-        return tokens.filter(isDimensionToken).map((token) => time.parse(context, token));
-    }
-};