html2canvas-pro 2.0.4 → 2.1.0

package/src/css/property-descriptors/object-fit.ts

@@ -0,0 +1,39 @@
+import { IPropertyListDescriptor, PropertyDescriptorParsingType } from '../property-descriptor';
+import { CSSValue, isIdentToken } from '../syntax/parser';
+import { Context } from '../../core/context';
+export const enum OBJECT_FIT {
+    FILL = 0,
+    CONTAIN = 1 << 1,
+    COVER = 1 << 2,
+    NONE = 1 << 3,
+    SCALE_DOWN = 1 << 4
+}
+
+export type ObjectFit = number;
+
+export const objectFit: IPropertyListDescriptor<ObjectFit> = {
+    name: 'objectFit',
+    initialValue: 'fill',
+    prefix: false,
+    type: PropertyDescriptorParsingType.LIST,
+    parse: (_context: Context, tokens: CSSValue[]): ObjectFit => {
+        return tokens.filter(isIdentToken).reduce((bit, token) => {
+            return bit | parseDisplayValue(token.value);
+        }, OBJECT_FIT.FILL);
+    }
+};
+
+const parseDisplayValue = (display: string): ObjectFit => {
+    switch (display) {
+        case 'contain':
+            return OBJECT_FIT.CONTAIN;
+        case 'cover':
+            return OBJECT_FIT.COVER;
+        case 'none':
+            return OBJECT_FIT.NONE;
+        case 'scale-down':
+            return OBJECT_FIT.SCALE_DOWN;
+    }
+
+    return OBJECT_FIT.FILL;
+};

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

@@ -0,0 +1,15 @@
+import { IPropertyValueDescriptor, PropertyDescriptorParsingType } from '../property-descriptor';
+import { CSSValue, isNumberToken } from '../syntax/parser';
+import { Context } from '../../core/context';
+export const opacity: IPropertyValueDescriptor<number> = {
+    name: 'opacity',
+    initialValue: '1',
+    type: PropertyDescriptorParsingType.VALUE,
+    prefix: false,
+    parse: (_context: Context, token: CSSValue): number => {
+        if (isNumberToken(token)) {
+            return token.number;
+        }
+        return 1;
+    }
+};

package/src/css/property-descriptors/overflow-wrap.ts

@@ -0,0 +1,22 @@
+import { IPropertyIdentValueDescriptor, PropertyDescriptorParsingType } from '../property-descriptor';
+import { Context } from '../../core/context';
+export const enum OVERFLOW_WRAP {
+    NORMAL = 'normal',
+    BREAK_WORD = 'break-word'
+}
+
+export const overflowWrap: IPropertyIdentValueDescriptor<OVERFLOW_WRAP> = {
+    name: 'overflow-wrap',
+    initialValue: 'normal',
+    prefix: false,
+    type: PropertyDescriptorParsingType.IDENT_VALUE,
+    parse: (_context: Context, overflow: string) => {
+        switch (overflow) {
+            case 'break-word':
+                return OVERFLOW_WRAP.BREAK_WORD;
+            case 'normal':
+            default:
+                return OVERFLOW_WRAP.NORMAL;
+        }
+    }
+};

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

@@ -0,0 +1,34 @@
+import { IPropertyListDescriptor, PropertyDescriptorParsingType } from '../property-descriptor';
+import { CSSValue, isIdentToken } from '../syntax/parser';
+import { Context } from '../../core/context';
+export const enum OVERFLOW {
+    VISIBLE = 0,
+    HIDDEN = 1,
+    SCROLL = 2,
+    CLIP = 3,
+    AUTO = 4
+}
+
+export const overflow: IPropertyListDescriptor<OVERFLOW[]> = {
+    name: 'overflow',
+    initialValue: 'visible',
+    prefix: false,
+    type: PropertyDescriptorParsingType.LIST,
+    parse: (_context: Context, tokens: CSSValue[]): OVERFLOW[] => {
+        return tokens.filter(isIdentToken).map((overflow) => {
+            switch (overflow.value) {
+                case 'hidden':
+                    return OVERFLOW.HIDDEN;
+                case 'scroll':
+                    return OVERFLOW.SCROLL;
+                case 'clip':
+                    return OVERFLOW.CLIP;
+                case 'auto':
+                    return OVERFLOW.AUTO;
+                case 'visible':
+                default:
+                    return OVERFLOW.VISIBLE;
+            }
+        });
+    }
+};

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

@@ -0,0 +1,14 @@
+import { IPropertyTypeValueDescriptor, PropertyDescriptorParsingType } from '../property-descriptor';
+
+const paddingForSide = (side: string): IPropertyTypeValueDescriptor => ({
+    name: `padding-${side}`,
+    initialValue: '0',
+    prefix: false,
+    type: PropertyDescriptorParsingType.TYPE_VALUE,
+    format: 'length-percentage'
+});
+
+export const paddingTop: IPropertyTypeValueDescriptor = paddingForSide('top');
+export const paddingRight: IPropertyTypeValueDescriptor = paddingForSide('right');
+export const paddingBottom: IPropertyTypeValueDescriptor = paddingForSide('bottom');
+export const paddingLeft: IPropertyTypeValueDescriptor = paddingForSide('left');

package/src/css/property-descriptors/paint-order.ts

@@ -0,0 +1,42 @@
+import { IPropertyListDescriptor, PropertyDescriptorParsingType } from '../property-descriptor';
+import { CSSValue, isIdentToken } from '../syntax/parser';
+import { Context } from '../../core/context';
+export const enum PAINT_ORDER_LAYER {
+    FILL,
+    STROKE,
+    MARKERS
+}
+
+export type PaintOrder = PAINT_ORDER_LAYER[];
+
+export const paintOrder: IPropertyListDescriptor<PaintOrder> = {
+    name: 'paint-order',
+    initialValue: 'normal',
+    prefix: false,
+    type: PropertyDescriptorParsingType.LIST,
+    parse: (_context: Context, tokens: CSSValue[]): PaintOrder => {
+        const DEFAULT_VALUE = [PAINT_ORDER_LAYER.FILL, PAINT_ORDER_LAYER.STROKE, PAINT_ORDER_LAYER.MARKERS];
+        const layers: PaintOrder = [];
+
+        tokens.filter(isIdentToken).forEach((token) => {
+            switch (token.value) {
+                case 'stroke':
+                    layers.push(PAINT_ORDER_LAYER.STROKE);
+                    break;
+                case 'fill':
+                    layers.push(PAINT_ORDER_LAYER.FILL);
+                    break;
+                case 'markers':
+                    layers.push(PAINT_ORDER_LAYER.MARKERS);
+                    break;
+            }
+        });
+        DEFAULT_VALUE.forEach((value) => {
+            if (layers.indexOf(value) === -1) {
+                layers.push(value);
+            }
+        });
+
+        return layers;
+    }
+};

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

@@ -0,0 +1,30 @@
+import { IPropertyIdentValueDescriptor, PropertyDescriptorParsingType } from '../property-descriptor';
+import { Context } from '../../core/context';
+export const enum POSITION {
+    STATIC = 0,
+    RELATIVE = 1,
+    ABSOLUTE = 2,
+    FIXED = 3,
+    STICKY = 4
+}
+
+export const position: IPropertyIdentValueDescriptor<POSITION> = {
+    name: 'position',
+    initialValue: 'static',
+    prefix: false,
+    type: PropertyDescriptorParsingType.IDENT_VALUE,
+    parse: (_context: Context, position: string) => {
+        switch (position) {
+            case 'relative':
+                return POSITION.RELATIVE;
+            case 'absolute':
+                return POSITION.ABSOLUTE;
+            case 'fixed':
+                return POSITION.FIXED;
+            case 'sticky':
+                return POSITION.STICKY;
+        }
+
+        return POSITION.STATIC;
+    }
+};

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

@@ -0,0 +1,57 @@
+import { IPropertyListDescriptor, PropertyDescriptorParsingType } from '../property-descriptor';
+import { CSSValue, isStringToken } from '../syntax/parser';
+import { TokenType } from '../syntax/tokenizer';
+import { Context } from '../../core/context';
+
+export interface QUOTE {
+    open: string;
+    close: string;
+}
+
+export type Quotes = QUOTE[] | null;
+
+export const quotes: IPropertyListDescriptor<Quotes> = {
+    name: 'quotes',
+    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 quotes = [];
+        const filtered = tokens.filter(isStringToken);
+
+        if (filtered.length % 2 !== 0) {
+            return null;
+        }
+
+        for (let i = 0; i < filtered.length; i += 2) {
+            const open = filtered[i].value;
+            const close = filtered[i + 1].value;
+            quotes.push({ open, close });
+        }
+
+        return quotes;
+    }
+};
+
+export const getQuote = (quotes: Quotes, depth: number, open: boolean): string => {
+    if (!quotes) {
+        return '';
+    }
+
+    const quote = quotes[Math.min(depth, quotes.length - 1)];
+    if (!quote) {
+        return '';
+    }
+
+    return open ? quote.open : quote.close;
+};

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

@@ -0,0 +1,34 @@
+import { IPropertyValueDescriptor, PropertyDescriptorParsingType } from '../property-descriptor';
+import { CSSValue } from '../syntax/parser';
+import { TokenType } from '../syntax/tokenizer';
+import { Context } from '../../core/context';
+import { angle } from '../types/angle';
+
+export type Rotate = number | null;
+
+export const rotate: IPropertyValueDescriptor<Rotate> = {
+    name: 'rotate',
+    initialValue: 'none',
+    prefix: false,
+    type: PropertyDescriptorParsingType.VALUE,
+    parse: (_context: Context, token: CSSValue): Rotate => {
+        if (token.type === TokenType.IDENT_TOKEN && token.value === 'none') {
+            return null;
+        }
+
+        if (token.type === TokenType.NUMBER_TOKEN) {
+            if (token.number === 0) {
+                return 0;
+            }
+        }
+
+        if (token.type === TokenType.DIMENSION_TOKEN) {
+            // Parse angle and convert to degrees for storage
+            const radians = angle.parse(_context, token);
+            // Store as degrees for consistency
+            return (radians * 180) / Math.PI;
+        }
+
+        return null;
+    }
+};

package/src/css/property-descriptors/text-align.ts

@@ -0,0 +1,26 @@
+import { IPropertyIdentValueDescriptor, PropertyDescriptorParsingType } from '../property-descriptor';
+import { Context } from '../../core/context';
+export const enum TEXT_ALIGN {
+    LEFT = 0,
+    CENTER = 1,
+    RIGHT = 2
+}
+
+export const textAlign: IPropertyIdentValueDescriptor<TEXT_ALIGN> = {
+    name: 'text-align',
+    initialValue: 'left',
+    prefix: false,
+    type: PropertyDescriptorParsingType.IDENT_VALUE,
+    parse: (_context: Context, textAlign: string) => {
+        switch (textAlign) {
+            case 'right':
+                return TEXT_ALIGN.RIGHT;
+            case 'center':
+            case 'justify':
+                return TEXT_ALIGN.CENTER;
+            case 'left':
+            default:
+                return TEXT_ALIGN.LEFT;
+        }
+    }
+};

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

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

package/src/css/property-descriptors/text-decoration-line.ts

@@ -0,0 +1,38 @@
+import { IPropertyListDescriptor, PropertyDescriptorParsingType } from '../property-descriptor';
+import { CSSValue, isIdentToken } from '../syntax/parser';
+import { Context } from '../../core/context';
+
+export const enum TEXT_DECORATION_LINE {
+    NONE = 0,
+    UNDERLINE = 1,
+    OVERLINE = 2,
+    LINE_THROUGH = 3,
+    BLINK = 4
+}
+
+export type TextDecorationLine = TEXT_DECORATION_LINE[];
+
+export const textDecorationLine: IPropertyListDescriptor<TextDecorationLine> = {
+    name: 'text-decoration-line',
+    initialValue: 'none',
+    prefix: false,
+    type: PropertyDescriptorParsingType.LIST,
+    parse: (_context: Context, tokens: CSSValue[]): TextDecorationLine => {
+        return tokens
+            .filter(isIdentToken)
+            .map((token) => {
+                switch (token.value) {
+                    case 'underline':
+                        return TEXT_DECORATION_LINE.UNDERLINE;
+                    case 'overline':
+                        return TEXT_DECORATION_LINE.OVERLINE;
+                    case 'line-through':
+                        return TEXT_DECORATION_LINE.LINE_THROUGH;
+                    case 'none':
+                        return TEXT_DECORATION_LINE.BLINK;
+                }
+                return TEXT_DECORATION_LINE.NONE;
+            })
+            .filter((line) => line !== TEXT_DECORATION_LINE.NONE);
+    }
+};

package/src/css/property-descriptors/text-decoration-style.ts

@@ -0,0 +1,32 @@
+import { IPropertyIdentValueDescriptor, PropertyDescriptorParsingType } from '../property-descriptor';
+import { Context } from '../../core/context';
+
+export const enum TEXT_DECORATION_STYLE {
+    SOLID = 0,
+    DOUBLE = 1,
+    DOTTED = 2,
+    DASHED = 3,
+    WAVY = 4
+}
+
+export const textDecorationStyle: IPropertyIdentValueDescriptor<TEXT_DECORATION_STYLE> = {
+    name: 'text-decoration-style',
+    initialValue: 'solid',
+    prefix: false,
+    type: PropertyDescriptorParsingType.IDENT_VALUE,
+    parse: (_context: Context, style: string): TEXT_DECORATION_STYLE => {
+        switch (style) {
+            case 'double':
+                return TEXT_DECORATION_STYLE.DOUBLE;
+            case 'dotted':
+                return TEXT_DECORATION_STYLE.DOTTED;
+            case 'dashed':
+                return TEXT_DECORATION_STYLE.DASHED;
+            case 'wavy':
+                return TEXT_DECORATION_STYLE.WAVY;
+            case 'solid':
+            default:
+                return TEXT_DECORATION_STYLE.SOLID;
+        }
+    }
+};

package/src/css/property-descriptors/text-decoration-thickness.ts

@@ -0,0 +1,30 @@
+import { IPropertyValueDescriptor, PropertyDescriptorParsingType } from '../property-descriptor';
+import { CSSValue, isIdentToken, isDimensionToken } from '../syntax/parser';
+import { Context } from '../../core/context';
+
+export type TextDecorationThickness = number | 'auto' | 'from-font';
+
+export const textDecorationThickness: IPropertyValueDescriptor<TextDecorationThickness> = {
+    name: 'text-decoration-thickness',
+    initialValue: 'auto',
+    prefix: false,
+    type: PropertyDescriptorParsingType.VALUE,
+    parse: (_context: Context, token: CSSValue): TextDecorationThickness => {
+        if (isIdentToken(token)) {
+            switch (token.value) {
+                case 'auto':
+                    return 'auto';
+                case 'from-font':
+                    return 'from-font';
+            }
+        }
+
+        if (isDimensionToken(token)) {
+            // Convert to pixels
+            return token.number;
+        }
+
+        // Default to auto
+        return 'auto';
+    }
+};

package/src/css/property-descriptors/text-overflow.ts

@@ -0,0 +1,23 @@
+import { IPropertyIdentValueDescriptor, PropertyDescriptorParsingType } from '../property-descriptor';
+import { Context } from '../../core/context';
+
+export const enum TEXT_OVERFLOW {
+    CLIP = 0,
+    ELLIPSIS = 1
+}
+
+export const textOverflow: IPropertyIdentValueDescriptor<TEXT_OVERFLOW> = {
+    name: 'text-overflow',
+    initialValue: 'clip',
+    prefix: false,
+    type: PropertyDescriptorParsingType.IDENT_VALUE,
+    parse: (_context: Context, textOverflow: string) => {
+        switch (textOverflow) {
+            case 'ellipsis':
+                return TEXT_OVERFLOW.ELLIPSIS;
+            case 'clip':
+            default:
+                return TEXT_OVERFLOW.CLIP;
+        }
+    }
+};

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

@@ -0,0 +1,52 @@
+import { PropertyDescriptorParsingType, IPropertyListDescriptor } from '../property-descriptor';
+import { CSSValue, isIdentWithValue, parseFunctionArgs } from '../syntax/parser';
+import { ZERO_LENGTH } from '../types/length-percentage';
+import { color, Color, COLORS } from '../types/color';
+import { isLength, Length } from '../types/length';
+import { Context } from '../../core/context';
+
+export type TextShadow = TextShadowItem[];
+interface TextShadowItem {
+    color: Color;
+    offsetX: Length;
+    offsetY: Length;
+    blur: Length;
+}
+
+export const textShadow: IPropertyListDescriptor<TextShadow> = {
+    name: 'text-shadow',
+    initialValue: 'none',
+    type: PropertyDescriptorParsingType.LIST,
+    prefix: false,
+    parse: (context: Context, tokens: CSSValue[]): TextShadow => {
+        if (tokens.length === 1 && isIdentWithValue(tokens[0], 'none')) {
+            return [];
+        }
+
+        return parseFunctionArgs(tokens).map((values: CSSValue[]) => {
+            const shadow: TextShadowItem = {
+                color: COLORS.TRANSPARENT,
+                offsetX: ZERO_LENGTH,
+                offsetY: ZERO_LENGTH,
+                blur: ZERO_LENGTH
+            };
+            let c = 0;
+            for (let i = 0; i < values.length; i++) {
+                const token = values[i];
+                if (isLength(token)) {
+                    if (c === 0) {
+                        shadow.offsetX = token;
+                    } else if (c === 1) {
+                        shadow.offsetY = token;
+                    } else {
+                        shadow.blur = token;
+                    }
+                    c++;
+                } else {
+                    shadow.color = color.parse(context, token);
+                }
+            }
+            return shadow;
+        });
+    }
+};

package/src/css/property-descriptors/text-transform.ts

@@ -0,0 +1,27 @@
+import { IPropertyIdentValueDescriptor, PropertyDescriptorParsingType } from '../property-descriptor';
+import { Context } from '../../core/context';
+export const enum TEXT_TRANSFORM {
+    NONE = 0,
+    LOWERCASE = 1,
+    UPPERCASE = 2,
+    CAPITALIZE = 3
+}
+
+export const textTransform: IPropertyIdentValueDescriptor<TEXT_TRANSFORM> = {
+    name: 'text-transform',
+    initialValue: 'none',
+    prefix: false,
+    type: PropertyDescriptorParsingType.IDENT_VALUE,
+    parse: (_context: Context, textTransform: string) => {
+        switch (textTransform) {
+            case 'uppercase':
+                return TEXT_TRANSFORM.UPPERCASE;
+            case 'lowercase':
+                return TEXT_TRANSFORM.LOWERCASE;
+            case 'capitalize':
+                return TEXT_TRANSFORM.CAPITALIZE;
+        }
+
+        return TEXT_TRANSFORM.NONE;
+    }
+};

package/src/css/property-descriptors/text-underline-offset.ts

@@ -0,0 +1,27 @@
+import { IPropertyValueDescriptor, PropertyDescriptorParsingType } from '../property-descriptor';
+import { CSSValue, isIdentToken, isDimensionToken } from '../syntax/parser';
+import { Context } from '../../core/context';
+
+export type TextUnderlineOffset = number | 'auto';
+
+export const textUnderlineOffset: IPropertyValueDescriptor<TextUnderlineOffset> = {
+    name: 'text-underline-offset',
+    initialValue: 'auto',
+    prefix: false,
+    type: PropertyDescriptorParsingType.VALUE,
+    parse: (_context: Context, token: CSSValue): TextUnderlineOffset => {
+        if (isIdentToken(token)) {
+            if (token.value === 'auto') {
+                return 'auto';
+            }
+        }
+
+        if (isDimensionToken(token)) {
+            // Return pixel value
+            return token.number;
+        }
+
+        // Default to auto
+        return 'auto';
+    }
+};

package/src/css/property-descriptors/transform-origin.ts

@@ -0,0 +1,29 @@
+import { IPropertyListDescriptor, PropertyDescriptorParsingType } from '../property-descriptor';
+import { CSSValue } from '../syntax/parser';
+import { isLengthPercentage, LengthPercentage } from '../types/length-percentage';
+import { FLAG_INTEGER, TokenType } from '../syntax/tokenizer';
+import { Context } from '../../core/context';
+export type TransformOrigin = [LengthPercentage, LengthPercentage];
+
+const DEFAULT_VALUE: LengthPercentage = {
+    type: TokenType.PERCENTAGE_TOKEN,
+    number: 50,
+    flags: FLAG_INTEGER
+};
+const DEFAULT: TransformOrigin = [DEFAULT_VALUE, DEFAULT_VALUE];
+
+export const transformOrigin: IPropertyListDescriptor<TransformOrigin> = {
+    name: 'transform-origin',
+    initialValue: '50% 50%',
+    prefix: true,
+    type: PropertyDescriptorParsingType.LIST,
+    parse: (_context: Context, tokens: CSSValue[]) => {
+        const origins: LengthPercentage[] = tokens.filter(isLengthPercentage);
+
+        if (origins.length !== 2) {
+            return DEFAULT;
+        }
+
+        return [origins[0], origins[1]];
+    }
+};

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

@@ -0,0 +1,74 @@
+import { IPropertyValueDescriptor, PropertyDescriptorParsingType } from '../property-descriptor';
+import { CSSValue } from '../syntax/parser';
+import { NumberValueToken, TokenType } from '../syntax/tokenizer';
+import { Context } from '../../core/context';
+import { angle } from '../types/angle';
+export type Matrix = [number, number, number, number, number, number];
+export type Transform = Matrix | null;
+
+export const transform: IPropertyValueDescriptor<Transform> = {
+    name: 'transform',
+    initialValue: 'none',
+    prefix: true,
+    type: PropertyDescriptorParsingType.VALUE,
+    parse: (_context: Context, token: CSSValue) => {
+        if (token.type === TokenType.IDENT_TOKEN && token.value === 'none') {
+            return null;
+        }
+
+        if (token.type === TokenType.FUNCTION) {
+            const transformFunction = SUPPORTED_TRANSFORM_FUNCTIONS[token.name];
+            if (typeof transformFunction === 'undefined') {
+                throw new Error(`Attempting to parse an unsupported transform function "${token.name}"`);
+            }
+            return transformFunction(_context, token.values);
+        }
+
+        return null;
+    }
+};
+
+const matrix = (_context: Context, args: CSSValue[]): Transform => {
+    const values = args.filter((arg) => arg.type === TokenType.NUMBER_TOKEN).map((arg: NumberValueToken) => arg.number);
+
+    return values.length === 6 ? (values as Matrix) : null;
+};
+
+// doesn't support 3D transforms at the moment
+const matrix3d = (_context: Context, args: CSSValue[]): Transform => {
+    const values = args.filter((arg) => arg.type === TokenType.NUMBER_TOKEN).map((arg: NumberValueToken) => arg.number);
+
+    const [a1, b1, {}, {}, a2, b2, {}, {}, {}, {}, {}, {}, a4, b4, {}, {}] = values;
+
+    return values.length === 16 ? [a1, b1, a2, b2, a4, b4] : null;
+};
+
+const rotate = (context: Context, args: CSSValue[]): Transform => {
+    if (args.length !== 1) {
+        return null;
+    }
+
+    const arg = args[0];
+    let radians = 0;
+
+    if (arg.type === TokenType.NUMBER_TOKEN && arg.number === 0) {
+        radians = 0;
+    } else if (arg.type === TokenType.DIMENSION_TOKEN) {
+        radians = angle.parse(context, arg);
+    } else {
+        return null;
+    }
+
+    const cos = Math.cos(radians);
+    const sin = Math.sin(radians);
+
+    return [cos, sin, -sin, cos, 0, 0];
+};
+
+const SUPPORTED_TRANSFORM_FUNCTIONS: {
+    [key: string]: (context: Context, args: CSSValue[]) => Transform;
+} = {
+    matrix: matrix,
+    matrix3d: matrix3d,
+    rotate: rotate
+};