@nativescript/canvas 2.0.0-alpha.1 → 2.0.0-alpha.3

package/Canvas2D/CanvasRenderingContext2D/index.ios.js

@@ -1,897 +0,0 @@
-import { CanvasRenderingContext2DBase } from './common';
-import { CanvasGradient } from '../CanvasGradient';
-import { Path2D } from '../Path2D';
-import { ImageData } from '../ImageData';
-import { TextMetrics } from '../TextMetrics';
-import { ImageSource } from '@nativescript/core';
-import { ImageAsset } from '../../ImageAsset';
-import { CanvasPattern } from '../CanvasPattern';
-import { Canvas } from '../../Canvas';
-export class CanvasRenderingContext2D extends CanvasRenderingContext2DBase {
-    constructor(context) {
-        super();
-        this.context = context;
-    }
-    _fillRuleFromString(string) {
-        if (string === 'evenodd') {
-            return 1 /* EvenOdd */;
-        }
-        else if (string === 'nonzero') {
-            return 0 /* NonZero */;
-        }
-        return null;
-    }
-    get native() {
-        return this.context;
-    }
-    get canvas() {
-        return this._canvas;
-    }
-    get direction() {
-        this.log('direction');
-        return this.context.getDirection() === 0 /* Ltr */ ? 'ltr' : 'rtl';
-    }
-    set direction(value) {
-        this.log('direction value:', value);
-        this._ensureLayoutBeforeDraw();
-        if (this.context) {
-            this.context.setDirection(value === 'rtl' ? 1 /* Rtl */ : 0 /* Ltr */);
-        }
-    }
-    get font() {
-        this.log('get font');
-        return this.context.font;
-    }
-    set font(value) {
-        this.log('set font value:', value);
-        if (this.context) {
-            this.context.font = value;
-        }
-    }
-    get shadowColor() {
-        this.log('get shadowColor');
-        return this.context.shadowColor;
-    }
-    set shadowColor(color) {
-        this.log('set shadowColor', color);
-        this._ensureLayoutBeforeDraw();
-        if (this.context && typeof color === 'string') {
-            this.context.shadowColor = color;
-        }
-    }
-    get globalAlpha() {
-        this.log('get globalAlpha');
-        return this.context.globalAlpha;
-    }
-    set globalAlpha(alpha) {
-        this.log('set globalAlpha', alpha);
-        this._ensureLayoutBeforeDraw();
-        if (this.context) {
-            this.context.globalAlpha = alpha;
-        }
-    }
-    get imageSmoothingEnabled() {
-        this.log('get imageSmoothingEnabled');
-        return this.context.imageSmoothingEnabled;
-    }
-    set imageSmoothingEnabled(enabled) {
-        this.log('set imageSmoothingEnabled', enabled);
-        this._ensureLayoutBeforeDraw();
-        if (this.context) {
-            this.context.imageSmoothingEnabled = enabled;
-        }
-    }
-    get imageSmoothingQuality() {
-        this.log('get imageSmoothingQuality');
-        switch (this.context.imageSmoothingQuality) {
-            case 2 /* High */:
-                return 'high';
-            case 1 /* Medium */:
-                return 'medium';
-            default:
-                return 'low';
-        }
-    }
-    set imageSmoothingQuality(quality) {
-        this.log('set imageSmoothingQuality', quality);
-        this._ensureLayoutBeforeDraw();
-        if (this.context) {
-            switch (quality) {
-                case 'high':
-                    this.context.imageSmoothingQuality = 2 /* High */;
-                    break;
-                case 'medium':
-                    this.context.imageSmoothingQuality = 1 /* Medium */;
-                    break;
-                case 'low':
-                    this.context.imageSmoothingQuality = 0 /* Low */;
-                    break;
-            }
-        }
-    }
-    get lineDashOffset() {
-        this.log('get lineDashOffset');
-        return this.context.lineDashOffset;
-    }
-    set lineDashOffset(offset) {
-        this.log('set lineDashOffset', offset);
-        this._ensureLayoutBeforeDraw();
-        if (this.context) {
-            this.context.lineDashOffset = offset;
-        }
-    }
-    get lineJoin() {
-        this.log('get lineJoin');
-        switch (this.context.lineJoin) {
-            case 1 /* Bevel */:
-                return 'bevel';
-            case 0 /* Round */:
-                return 'round';
-            default:
-                return 'miter';
-        }
-    }
-    set lineJoin(join) {
-        this.log('set lineJoin', join);
-        this._ensureLayoutBeforeDraw();
-        if (this.context) {
-            switch (join) {
-                case 'bevel':
-                    this.context.lineJoin = 1 /* Bevel */;
-                    break;
-                case 'round':
-                    this.context.lineJoin = 0 /* Round */;
-                    break;
-                case 'miter':
-                    this.context.lineJoin = 2 /* Miter */;
-                    break;
-            }
-        }
-    }
-    get lineCap() {
-        this.log('get lineCap');
-        switch (this.context.lineCap) {
-            case 1 /* Round */:
-                return 'round';
-            case 2 /* Square */:
-                return 'square';
-            default:
-                return 'butt';
-        }
-    }
-    set lineCap(cap) {
-        this.log('set lineCap', cap);
-        this._ensureLayoutBeforeDraw();
-        if (this.context) {
-            switch (cap) {
-                case 'round':
-                    this.context.lineCap = 1 /* Round */;
-                    break;
-                case 'square':
-                    this.context.lineCap = 2 /* Square */;
-                    break;
-                case 'butt':
-                    this.context.lineCap = 0 /* Butt */;
-            }
-        }
-    }
-    get miterLimit() {
-        this.log('get miterLimit');
-        return this.context.miterLimit;
-    }
-    set miterLimit(limit) {
-        this.log('set miterLimit', limit);
-        this._ensureLayoutBeforeDraw();
-        if (this.context) {
-            this.context.miterLimit = limit;
-        }
-    }
-    get shadowBlur() {
-        this.log('get shadowBlur');
-        return this.context.shadowBlur;
-    }
-    set shadowBlur(blur) {
-        this.log('set shadowBlur', blur);
-        this._ensureLayoutBeforeDraw();
-        if (this.context) {
-            this.context.shadowBlur = blur;
-        }
-    }
-    get shadowOffsetX() {
-        this.log('get shadowOffsetX');
-        return this.context.shadowOffsetX;
-    }
-    set shadowOffsetX(x) {
-        this.log('set shadowOffsetX', x);
-        this._ensureLayoutBeforeDraw();
-        if (this.context) {
-            this.context.shadowOffsetX = x;
-        }
-    }
-    get shadowOffsetY() {
-        this.log('get shadowOffsetY');
-        return this.context.shadowOffsetY;
-    }
-    set shadowOffsetY(y) {
-        this.log('set shadowOffsetY', y);
-        this._ensureLayoutBeforeDraw();
-        if (this.context) {
-            this.context.shadowOffsetY = y;
-        }
-    }
-    get textAlign() {
-        this.log('get textAlign');
-        switch (this.context.textAlign) {
-            case 0 /* Start */:
-                return 'start';
-            case 2 /* Center */:
-                return 'center';
-            case 4 /* End */:
-                return 'end';
-            case 3 /* Right */:
-                return 'right';
-            default:
-                return 'left';
-        }
-    }
-    set textAlign(alignment) {
-        this.log('set textAlign', alignment);
-        this._ensureLayoutBeforeDraw();
-        if (this.context) {
-            switch (alignment) {
-                case 'start':
-                    this.context.textAlign = 0 /* Start */;
-                    break;
-                case 'center':
-                    this.context.textAlign = 2 /* Center */;
-                    break;
-                case 'end':
-                    this.context.textAlign = 4 /* End */;
-                    break;
-                case 'right':
-                    this.context.textAlign = 3 /* Right */;
-                    break;
-                case 'left':
-                    this.context.textAlign = 1 /* Left */;
-                    break;
-            }
-        }
-    }
-    get globalCompositeOperation() {
-        this.log('get globalCompositeOperation');
-        switch (this.context.globalCompositeOperation) {
-            case 0 /* SourceOver */:
-                return 'source-over';
-            case 1 /* SourceIn */:
-                return 'source-in';
-            case 2 /* SourceOut */:
-                return 'source-out';
-            case 3 /* SourceAtop */:
-                return 'source-atop';
-            case 4 /* DestinationOver */:
-                return 'destination-over';
-            case 5 /* DestinationIn */:
-                return 'destination-in';
-            case 6 /* DestinationOut */:
-                return 'destination-out';
-            case 7 /* DestinationAtop */:
-                return 'destination-atop';
-            case 8 /* Lighter */:
-                return 'lighter';
-            case 9 /* Copy */:
-                return 'copy';
-            case 10 /* Xor */:
-                return 'xor';
-            case 11 /* Multiply */:
-                return 'multiply';
-            case 12 /* Screen */:
-                return 'screen';
-            case 13 /* Overlay */:
-                return 'overlay';
-            case 14 /* Darken */:
-                return 'darken';
-            case 15 /* Lighten */:
-                return 'lighten';
-            case 16 /* ColorDodge */:
-                return 'color-dodge';
-            case 17 /* ColorBurn */:
-                return 'color-burn';
-            case 18 /* HardLight */:
-                return 'hard-light';
-            case 19 /* SoftLight */:
-                return 'soft-light';
-            case 20 /* Difference */:
-                return 'difference';
-            case 21 /* Exclusion */:
-                return 'exclusion';
-            case 22 /* Hue */:
-                return 'hue';
-            case 23 /* Saturation */:
-                return 'saturation';
-            case 24 /* Color */:
-                return 'color';
-            case 25 /* Luminosity */:
-                return 'luminosity';
-        }
-    }
-    set globalCompositeOperation(composite) {
-        this.log('set globalCompositeOperation', composite);
-        this._ensureLayoutBeforeDraw();
-        if (this.context) {
-            switch (composite.toLowerCase()) {
-                case 'source-over':
-                    this.context.globalCompositeOperation = 0 /* SourceOver */;
-                    break;
-                case 'source-in':
-                    this.context.globalCompositeOperation = 1 /* SourceIn */;
-                    break;
-                case 'source-out':
-                    this.context.globalCompositeOperation = 2 /* SourceOut */;
-                    break;
-                case 'source-atop':
-                    this.context.globalCompositeOperation = 3 /* SourceAtop */;
-                    break;
-                case 'destination-over':
-                    this.context.globalCompositeOperation = 4 /* DestinationOver */;
-                    break;
-                case 'destination-in':
-                    this.context.globalCompositeOperation = 5 /* DestinationIn */;
-                    break;
-                case 'destination-out':
-                    this.context.globalCompositeOperation = 6 /* DestinationOut */;
-                    break;
-                case 'destination-atop':
-                    this.context.globalCompositeOperation = 7 /* DestinationAtop */;
-                    break;
-                case 'lighter':
-                    this.context.globalCompositeOperation = 8 /* Lighter */;
-                    break;
-                case 'copy':
-                    this.context.globalCompositeOperation = 9 /* Copy */;
-                    break;
-                case 'xor':
-                    this.context.globalCompositeOperation = 10 /* Xor */;
-                    break;
-                case 'multiply':
-                    this.context.globalCompositeOperation = 11 /* Multiply */;
-                    break;
-                case 'screen':
-                    this.context.globalCompositeOperation = 12 /* Screen */;
-                    break;
-                case 'overlay':
-                    this.context.globalCompositeOperation = 13 /* Overlay */;
-                    break;
-                case 'darken':
-                    this.context.globalCompositeOperation = 14 /* Darken */;
-                    break;
-                case 'lighten':
-                    this.context.globalCompositeOperation = 15 /* Lighten */;
-                    break;
-                case 'color-dodge':
-                    this.context.globalCompositeOperation = 16 /* ColorDodge */;
-                    break;
-                case 'color-burn':
-                    this.context.globalCompositeOperation = 17 /* ColorBurn */;
-                    break;
-                case 'hard-light':
-                    this.context.globalCompositeOperation = 18 /* HardLight */;
-                    break;
-                case 'soft-light':
-                    this.context.globalCompositeOperation = 19 /* SoftLight */;
-                    break;
-                case 'difference':
-                    this.context.globalCompositeOperation = 20 /* Difference */;
-                    break;
-                case 'exclusion':
-                    this.context.globalCompositeOperation = 21 /* Exclusion */;
-                    break;
-                case 'hue':
-                    this.context.globalCompositeOperation = 22 /* Hue */;
-                    break;
-                case 'saturation':
-                    this.context.globalCompositeOperation = 23 /* Saturation */;
-                    break;
-                case 'color':
-                    this.context.globalCompositeOperation = 24 /* Color */;
-                    break;
-                case 'luminosity':
-                    this.context.globalCompositeOperation = 25 /* Luminosity */;
-                    break;
-            }
-        }
-    }
-    get filter() {
-        this.log('get filter');
-        return this.context.filter;
-    }
-    set filter(value) {
-        this.log('set filter', value);
-        if (this.context) {
-            this.context.filter = value;
-        }
-    }
-    get fillStyle() {
-        this.log('get fillStyle');
-        switch (this.context.fillStyle.getStyleType()) {
-            case 0 /* Color */:
-                const color = this.context.fillStyle;
-                return color.color;
-            case 1 /* Gradient */:
-                return CanvasGradient.fromNative(this.context.fillStyle);
-            case 2 /* Pattern */:
-                return new CanvasPattern(this.context.fillStyle);
-        }
-    }
-    set fillStyle(color) {
-        this.log('set fillStyle', color);
-        if (color === undefined || color === null) {
-            return;
-        }
-        this._ensureLayoutBeforeDraw();
-        if (typeof color === 'string') {
-            this.context.setFillStyleWithString(color);
-        }
-        else if (color instanceof CanvasGradient) {
-            this.context.fillStyle = color.native;
-        }
-        else if (color instanceof CanvasPattern) {
-            this.context.fillStyle = color.native;
-        }
-    }
-    get strokeStyle() {
-        this.log('get strokeStyle');
-        switch (this.context.strokeStyle.getStyleType()) {
-            case 0 /* Color */:
-                const color = this.context.strokeStyle;
-                return color.color;
-            case 1 /* Gradient */:
-                return CanvasGradient.fromNative(this.context.strokeStyle);
-            case 2 /* Pattern */:
-                return new CanvasPattern(this.context.strokeStyle);
-        }
-    }
-    set strokeStyle(color) {
-        this.log('set strokeStyle', color);
-        if (color === undefined || color === null) {
-            return;
-        }
-        this._ensureLayoutBeforeDraw();
-        if (typeof color === 'string') {
-            this.context.setStrokeStyleWithString(color);
-        }
-        else if (color instanceof CanvasGradient) {
-            this.context.strokeStyle = color.native;
-        }
-        else if (color instanceof CanvasPattern) {
-            this.context.strokeStyle = color.native;
-        }
-    }
-    get lineWidth() {
-        this.log('get lineWidth');
-        return this.context.lineWidth;
-    }
-    set lineWidth(width) {
-        this.log('set lineWidth', width);
-        this._ensureLayoutBeforeDraw();
-        if (this.context) {
-            this.context.lineWidth = width;
-        }
-    }
-    addHitRegion(region) { }
-    arc(x, y, radius, startAngle, endAngle, anticlockwise = false) {
-        this.log('arc', x, y, radius, startAngle, anticlockwise);
-        this._ensureLayoutBeforeDraw();
-        this.context.arc(x, y, radius, startAngle, endAngle, anticlockwise);
-    }
-    arcTo(x1, y1, x2, y2, radius) {
-        this.log('arcTo', x1, y1, x2, y2, radius);
-        this._ensureLayoutBeforeDraw();
-        this.context.arcTo(x1, y1, x2, y2, radius);
-    }
-    beginPath() {
-        this.log('beginPath');
-        this._ensureLayoutBeforeDraw();
-        this.context.beginPath();
-    }
-    bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y) {
-        this.log('bezierCurveTo', cp1x, cp1y, cp2x, cp2y, x, y);
-        this._ensureLayoutBeforeDraw();
-        this.context.bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y);
-    }
-    clearHitRegions() { }
-    clearRect(x, y, width, height) {
-        this.log('clearRect', x, y, width, height);
-        this._ensureLayoutBeforeDraw();
-        this.context.clearRect(x, y, width, height);
-    }
-    clip(...args) {
-        this.log('clip', ...args);
-        this._ensureLayoutBeforeDraw();
-        if (typeof args[0] === 'string') {
-            // browser throws for invalid enum
-            const rule = this._fillRuleFromString(args[0]);
-            this.context.clip(rule);
-        }
-        else if (args[0] instanceof Path2D && typeof args[1] === 'string') {
-            const rule = this._fillRuleFromString(args[1]);
-            this.context.clip(args[0].native, rule);
-        }
-        else if (args[0] instanceof Path2D) {
-            this.context.clip(args[0].native);
-        }
-        else {
-            this.context.clip();
-        }
-    }
-    closePath() {
-        this.log('closePath');
-        this._ensureLayoutBeforeDraw();
-        this.context.closePath();
-    }
-    createImageData(width, height) {
-        this.log('createImageData', width, height);
-        if (width instanceof ImageData) {
-            return ImageData.fromNative(this.context.createImageData(width.native));
-        }
-        else {
-            return ImageData.fromNative(this.context.createImageData(width, height));
-        }
-    }
-    createLinearGradient(x0, y0, x1, y1) {
-        this.log('createLinearGradient', x0, y0, x1, y1);
-        this._ensureLayoutBeforeDraw();
-        return CanvasGradient.fromNative(this.context.createLinearGradient(x0, y0, x1, y1));
-    }
-    createPattern(image, repetition) {
-        this.log('createPattern', image, repetition);
-        this._ensureLayoutBeforeDraw();
-        if (repetition === undefined || typeof repetition !== 'string') {
-            const e = new Error('The string did not match the expected pattern.');
-            e.name = 'SyntaxError';
-            throw e;
-        }
-        let img;
-        if (image instanceof ImageSource) {
-            img = image.ios;
-        }
-        else if (image instanceof UIImage) {
-            img = image;
-        }
-        else if (image instanceof ImageAsset) {
-            img = image.native;
-        }
-        else if (image instanceof Canvas) {
-            img = image.ios;
-        }
-        else if (image && typeof image.tagName === 'string' && (image.tagName === 'IMG' || image.tagName === 'IMAGE')) {
-            if (image._imageSource instanceof ImageSource) {
-                img = image._imageSource.android;
-            }
-            else if (image._image instanceof UIImage) {
-                img = image._image;
-            }
-            else if (image._asset instanceof ImageAsset) {
-                img = image._asset.native;
-            }
-            else if (typeof image.src === 'string') {
-                img = ImageSource.fromFileSync(image.src).ios;
-            }
-        }
-        else if (image && typeof image.tagName === 'string' && image.tagName === 'CANVAS') {
-            if (image._canvas instanceof Canvas) {
-                img = image._canvas.ios;
-            }
-        }
-        else if (image instanceof ImageBitmap || (image === null || image === void 0 ? void 0 : image.native) instanceof TNSImageBitmap) {
-            img = image.native;
-        }
-        if (!img) {
-            return null;
-        }
-        let rep;
-        switch (repetition) {
-            case 'no-repeat':
-                rep = 3 /* NoRepeat */;
-                break;
-            case 'repeat-x':
-                rep = 1 /* RepeatX */;
-                break;
-            case 'repeat-y':
-                rep = 2 /* RepeatY */;
-                break;
-            default:
-                rep = 0 /* Repeat */;
-                break;
-        }
-        if (img instanceof TNSImageAsset) {
-            return new CanvasPattern(this.context.createPattern(img, rep));
-        }
-        else if (img instanceof TNSImageBitmap) {
-            return new CanvasPattern(this.context.createPattern(img, rep));
-        }
-        else if (img instanceof UIImage) {
-            return new CanvasPattern(this.context.createPattern(img, rep));
-        }
-        else if (img instanceof TNSCanvas) {
-            return new CanvasPattern(this.context.createPattern(img, rep));
-        }
-        return null;
-    }
-    createRadialGradient(x0, y0, r0, x1, y1, r1) {
-        this.log('createRadialGradient', x0, y0, r0, x1, y1, r1);
-        this._ensureLayoutBeforeDraw();
-        return CanvasGradient.fromNative(this.context.createRadialGradient(x0, y0, r0, x1, y1, r1));
-    }
-    drawFocusIfNeeded(...args) { }
-    drawImage(...args) {
-        this.log('drawImage', ...args);
-        this._ensureLayoutBeforeDraw();
-        if (!args) {
-            return;
-        }
-        let image = args[0];
-        let asset = null;
-        let width = 0;
-        let height = 0;
-        if (image instanceof ImageSource) {
-            image = image.ios;
-        }
-        else if (image instanceof ImageAsset || image instanceof UIImage) {
-            // NOOP
-        }
-        else if (image && typeof image.tagName === 'string' && (image.tagName === 'IMG' || image.tagName === 'IMAGE')) {
-            width = image.width;
-            height = image.height;
-            if (image._imageSource instanceof ImageSource) {
-                image = image._imageSource.ios;
-            }
-            else if (image._image instanceof UIImage) {
-                image = image._image;
-            }
-            else if (image._asset instanceof ImageAsset) {
-                image = image._asset;
-            }
-            else if (typeof image.src === 'string') {
-                image = ImageSource.fromFileSync(image.src).ios;
-            }
-        }
-        else if (image && typeof image.tagName === 'string' && image.tagName === 'CANVAS' && image._canvas instanceof Canvas) {
-            image = image._canvas;
-        }
-        else if (image instanceof ImageBitmap || (image === null || image === void 0 ? void 0 : image.native) instanceof TNSImageBitmap) {
-            image = image.native;
-        }
-        if (args.length === 3) {
-            if (image instanceof ImageAsset) {
-                this.context.drawImage(image.native, args[1], args[2]);
-            }
-            else if (image instanceof Canvas) {
-                this.context.drawImage(image.ios, args[1], args[2]);
-            }
-            else {
-                this.context.drawImage(image, args[1], args[2]);
-            }
-        }
-        else if (args.length === 5) {
-            if (image instanceof ImageAsset) {
-                this.context.drawImage(image.native, args[1], args[2], args[3], args[4]);
-            }
-            else if (image instanceof Canvas) {
-                this.context.drawImage(image.ios, args[1], args[2], args[3], args[4]);
-            }
-            else {
-                this.context.drawImage(image, args[1], args[2], args[3], args[4]);
-            }
-        }
-        else if (args.length === 9) {
-            if (image instanceof ImageAsset) {
-                this.context.drawImage(image.native, args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8]);
-            }
-            else if (image instanceof Canvas) {
-                this.context.drawImage(image.ios, args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8]);
-            }
-            else {
-                this.context.drawImage(image, args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8]);
-            }
-        }
-    }
-    ellipse(x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise = false) {
-        this.log('ellipse', x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise);
-        this._ensureLayoutBeforeDraw();
-        this.context.ellipse(x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise);
-    }
-    fill(...args) {
-        this.log('fill', ...args);
-        this._ensureLayoutBeforeDraw();
-        if (typeof args[0] === 'string') {
-            const rule = this._fillRuleFromString(args[0]);
-            this.context.fillWithValue(rule);
-        }
-        else if (args.length === 2 && args[0] instanceof Path2D && typeof args[1] === 'string') {
-            const rule = this._fillRuleFromString(args[1]);
-            this.context.fill(args[0].native, rule);
-        }
-        else if (args[0] instanceof Path2D) {
-            this.context.fillWithValue(args[0].native);
-        }
-        else {
-            this.context.fill();
-        }
-    }
-    fillRect(x, y, width, height) {
-        this.log('fillRect', x, y, width, height);
-        this._ensureLayoutBeforeDraw();
-        this.context.fillRect(x, y, width, height);
-    }
-    fillText(text, x, y, maxWidth) {
-        this.log('fillText', text, x, y, maxWidth);
-        this._ensureLayoutBeforeDraw();
-        if (typeof maxWidth === 'number') {
-            this.context.fillText(text + '', x, y, maxWidth);
-        }
-        else {
-            this.context.fillText(text + '', x, y);
-        }
-    }
-    getImageData(sx, sy, sw, sh) {
-        this.log('getImageData', sx, sy, sw, sh);
-        this._ensureLayoutBeforeDraw();
-        return ImageData.fromNative(this.context.getImageData(sx, sy, sw, sh));
-    }
-    getLineDash() {
-        this.log('getLineDash');
-        this._ensureLayoutBeforeDraw();
-        return this.context.getLineDash();
-    }
-    isPointInPath(...args) {
-        this.log('isPointInPath', ...args);
-        this._ensureLayoutBeforeDraw();
-        if (args.length === 2) {
-            return this.context.isPointInPath(args[0], args[1]);
-        }
-        else if (args.length === 3) {
-            return this.context.isPointInPath(args[0], args[1], args[2]);
-        }
-        else if (args.length === 4 && args[0] instanceof Path2D) {
-            return this.context.isPointInPath(args[0].native, args[1], args[2], args[3]);
-        }
-        return false;
-    }
-    isPointInStroke(...args) {
-        this.log('isPointInStroke', ...args);
-        this._ensureLayoutBeforeDraw();
-        if (args.length === 2) {
-            return this.context.isPointInStroke(args[0], args[1]);
-        }
-        else if (args.length === 3 && args[0] instanceof Path2D) {
-            return this.context.isPointInStroke(args[0].native, args[1], args[2]);
-        }
-        return false;
-    }
-    lineTo(x, y) {
-        this.log('lineTo', x, y);
-        this._ensureLayoutBeforeDraw();
-        this.context.lineTo(x, y);
-    }
-    measureText(text) {
-        this.log('measureText', text);
-        this._ensureLayoutBeforeDraw();
-        return new TextMetrics(this.context.measureText(text));
-    }
-    moveTo(x, y) {
-        this.log('moveTo', x, y);
-        this._ensureLayoutBeforeDraw();
-        this.context.moveTo(x, y);
-    }
-    putImageData(...args) {
-        this.log('putImageData', ...args);
-        this._ensureLayoutBeforeDraw();
-        if (!args) {
-            return;
-        }
-        let data = args[0];
-        if (args.length === 3) {
-            this.context.putImageData(data.native, args[1], args[2]);
-        }
-        else if (args.length === 7) {
-            this.context.putImageData(data.native, args[1], args[2], args[3], args[4], args[5], args[6]);
-        }
-    }
-    quadraticCurveTo(cpx, cpy, x, y) {
-        this.log('quadraticCurveTo', cpx, cpy, x, y);
-        this._ensureLayoutBeforeDraw();
-        this.context.quadraticCurveTo(cpx, cpy, x, y);
-    }
-    rect(x, y, width, height) {
-        this.log('rect', x, y, width, height);
-        this._ensureLayoutBeforeDraw();
-        this.context.rect(x, y, width, height);
-    }
-    removeHitRegion(id) { }
-    resetTransform() {
-        this.log('resetTransform');
-        this._ensureLayoutBeforeDraw();
-        this.context.resetTransform();
-    }
-    restore() {
-        this.log('restore');
-        this._ensureLayoutBeforeDraw();
-        this.context.restore();
-    }
-    rotate(angle) {
-        this.log('rotate', angle);
-        this._ensureLayoutBeforeDraw();
-        this.context.rotate(angle);
-    }
-    save() {
-        this.log('save');
-        this._ensureLayoutBeforeDraw();
-        this.context.save();
-    }
-    scale(x, y) {
-        this.log('scale', x, y);
-        this._ensureLayoutBeforeDraw();
-        if (typeof x === 'number' && typeof y === 'number') {
-            this.context.scale(x, y);
-        }
-    }
-    scrollPathIntoView(path) { }
-    setLineDash(segments) {
-        this.log('setLineDash', segments);
-        this._ensureLayoutBeforeDraw();
-        this.context.setLineDash(segments);
-    }
-    setTransform(a, b, c, d, e, f) {
-        this.log('setTransform', a, b, c, d, e, f);
-        this._ensureLayoutBeforeDraw();
-        this.context.setTransform(a, b, c, d, e, f);
-    }
-    stroke(path) {
-        this.log('stroke', path);
-        this._ensureLayoutBeforeDraw();
-        if (path) {
-            this.context.stroke(path.native);
-        }
-        else {
-            this.context.stroke();
-        }
-    }
-    strokeRect(x, y, width, height) {
-        this.log('strokeRect', x, y, width, height);
-        this._ensureLayoutBeforeDraw();
-        this.context.strokeRect(x, y, width, height);
-    }
-    strokeText(text, x, y, maxWidth) {
-        this.log('strokeText', text, x, y, maxWidth);
-        this._ensureLayoutBeforeDraw();
-        if (typeof maxWidth === 'number') {
-            this.context.strokeText(text + '', x, y, maxWidth);
-        }
-        else {
-            this.context.strokeText(text + '', x, y);
-        }
-    }
-    transform(a, b, c, d, e, f) {
-        this.log('transform', a, b, c, d, e, f);
-        this._ensureLayoutBeforeDraw();
-        this.context.transform(a, b, c, d, e, f);
-    }
-    translate(x, y) {
-        this.log('translate', x, y);
-        this._ensureLayoutBeforeDraw();
-        this.context.translate(x, y);
-    }
-    log(message, ...args) {
-        if (!CanvasRenderingContext2D.isDebug) {
-            return;
-        }
-        console.log(message, args);
-    }
-    _ensureLayoutBeforeDraw() {
-        if (this.canvas) {
-            this.canvas._layoutNative();
-        }
-    }
-}
-CanvasRenderingContext2D.isDebug = false;
-//# sourceMappingURL=index.ios.js.map