@nativescript/canvas 0.9.22-v6 → 1.0.0-alpha.10

package/Canvas2D/CanvasRenderingContext2D/index.android.js

@@ -1,653 +1,641 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var common_1 = require("./common");
-var CanvasGradient_1 = require("../CanvasGradient");
-var Path2D_1 = require("../Path2D");
-var ImageData_1 = require("../ImageData");
-var TextMetrics_1 = require("../TextMetrics");
-var core_1 = require("@nativescript/core");
-var ImageAsset_1 = require("../../ImageAsset");
-var CanvasPattern_1 = require("../CanvasPattern");
-var Canvas_1 = require("../../Canvas");
-var CanvasRenderingContext2D = /** @class */ (function (_super) {
-    __extends(CanvasRenderingContext2D, _super);
-    function CanvasRenderingContext2D(context) {
-        var _this = _super.call(this) || this;
-        _this._shadowColor = 'transparent';
-        _this.context = context;
-        return _this;
-    }
-    CanvasRenderingContext2D.prototype._fillRuleFromString = function (string) {
+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';
+import lazy from '@nativescript/canvas/utils';
+const FillRule = {
+    EvenOdd: lazy(() => org.nativescript.canvas.TNSFillRule.EvenOdd),
+    NonZero: lazy(() => org.nativescript.canvas.TNSFillRule.NonZero),
+};
+const TextDirection = {
+    Ltr: lazy(() => org.nativescript.canvas.TNSTextDirection.Ltr),
+    Rtl: lazy(() => org.nativescript.canvas.TNSTextDirection.Rtl),
+};
+const ImageSmoothingQuality = {
+    Low: lazy(() => org.nativescript.canvas.TNSImageSmoothingQuality.Low),
+    Medium: lazy(() => org.nativescript.canvas.TNSImageSmoothingQuality.Medium),
+    High: lazy(() => org.nativescript.canvas.TNSImageSmoothingQuality.High),
+};
+const LineJoin = {
+    Bevel: lazy(() => org.nativescript.canvas.TNSLineJoin.Bevel),
+    Miter: lazy(() => org.nativescript.canvas.TNSLineJoin.Miter),
+    Round: lazy(() => org.nativescript.canvas.TNSLineJoin.Round),
+};
+const LineCap = {
+    Round: lazy(() => org.nativescript.canvas.TNSLineCap.Round),
+    Butt: lazy(() => org.nativescript.canvas.TNSLineCap.Butt),
+    Square: lazy(() => org.nativescript.canvas.TNSLineCap.Square),
+};
+const TextAlignment = {
+    Start: lazy(() => org.nativescript.canvas.TNSTextAlignment.Start),
+    Left: lazy(() => org.nativescript.canvas.TNSTextAlignment.Left),
+    Center: lazy(() => org.nativescript.canvas.TNSTextAlignment.Center),
+    Right: lazy(() => org.nativescript.canvas.TNSTextAlignment.Right),
+    End: lazy(() => org.nativescript.canvas.TNSTextAlignment.End),
+};
+const CompositeOperationType = {
+    SourceOver: lazy(() => org.nativescript.canvas.TNSCompositeOperationType.SourceOver),
+    SourceIn: lazy(() => org.nativescript.canvas.TNSCompositeOperationType.SourceIn),
+    SourceOut: lazy(() => org.nativescript.canvas.TNSCompositeOperationType.SourceOut),
+    SourceAtop: lazy(() => org.nativescript.canvas.TNSCompositeOperationType.SourceAtop),
+    DestinationOver: lazy(() => org.nativescript.canvas.TNSCompositeOperationType.DestinationOver),
+    DestinationIn: lazy(() => org.nativescript.canvas.TNSCompositeOperationType.DestinationIn),
+    DestinationOut: lazy(() => org.nativescript.canvas.TNSCompositeOperationType.DestinationOut),
+    DestinationAtop: lazy(() => org.nativescript.canvas.TNSCompositeOperationType.DestinationAtop),
+    Lighter: lazy(() => org.nativescript.canvas.TNSCompositeOperationType.Lighter),
+    Copy: lazy(() => org.nativescript.canvas.TNSCompositeOperationType.Copy),
+    Xor: lazy(() => org.nativescript.canvas.TNSCompositeOperationType.Xor),
+    Multiply: lazy(() => org.nativescript.canvas.TNSCompositeOperationType.Multiply),
+    Screen: lazy(() => org.nativescript.canvas.TNSCompositeOperationType.Screen),
+    Overlay: lazy(() => org.nativescript.canvas.TNSCompositeOperationType.Overlay),
+    Darken: lazy(() => org.nativescript.canvas.TNSCompositeOperationType.Darken),
+    Lighten: lazy(() => org.nativescript.canvas.TNSCompositeOperationType.Lighten),
+    ColorDodge: lazy(() => org.nativescript.canvas.TNSCompositeOperationType.ColorDodge),
+    ColorBurn: lazy(() => org.nativescript.canvas.TNSCompositeOperationType.ColorBurn),
+    HardLight: lazy(() => org.nativescript.canvas.TNSCompositeOperationType.HardLight),
+    SoftLight: lazy(() => org.nativescript.canvas.TNSCompositeOperationType.SoftLight),
+    Difference: lazy(() => org.nativescript.canvas.TNSCompositeOperationType.Difference),
+    Exclusion: lazy(() => org.nativescript.canvas.TNSCompositeOperationType.Exclusion),
+    Hue: lazy(() => org.nativescript.canvas.TNSCompositeOperationType.Hue),
+    Saturation: lazy(() => org.nativescript.canvas.TNSCompositeOperationType.Saturation),
+    Color: lazy(() => org.nativescript.canvas.TNSCompositeOperationType.Color),
+    Luminosity: lazy(() => org.nativescript.canvas.TNSCompositeOperationType.Luminosity),
+};
+const PatternRepetition = {
+    NoRepeat: lazy(() => org.nativescript.canvas.TNSPatternRepetition.NoRepeat),
+    Repeat: lazy(() => org.nativescript.canvas.TNSPatternRepetition.Repeat),
+    RepeatX: lazy(() => org.nativescript.canvas.TNSPatternRepetition.RepeatX),
+    RepeatY: lazy(() => org.nativescript.canvas.TNSPatternRepetition.RepeatY)
+};
+export class CanvasRenderingContext2D extends CanvasRenderingContext2DBase {
+    constructor(context) {
+        super();
+        this.context = context;
+    }
+    _fillRuleFromString(string) {
         if (string === 'evenodd') {
-            return org.nativescript.canvas.TNSFillRule.EvenOdd;
+            return FillRule.EvenOdd();
         }
         else if (string === 'nonzero') {
-            return org.nativescript.canvas.TNSFillRule.NonZero;
+            return FillRule.NonZero();
         }
         return null;
-    };
-    Object.defineProperty(CanvasRenderingContext2D.prototype, "native", {
-        get: function () {
-            return this.context;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(CanvasRenderingContext2D.prototype, "canvas", {
-        get: function () {
-            return this._canvas;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(CanvasRenderingContext2D.prototype, "shadowColor", {
-        get: function () {
-            this.log('shadowColor');
-            return this.context.getShadowColor();
-        },
-        set: function (color) {
-            this.log('shadowColor value:', color);
-            this._ensureLayoutBeforeDraw();
-            if (this.context) {
-                this.context.setShadowColor(color);
-            }
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(CanvasRenderingContext2D.prototype, "font", {
-        get: function () {
-            this.log('get font');
-            return this.context.getFont();
-        },
-        set: function (value) {
-            this.log('set font value:', value);
-            if (this.context) {
-                this.context.setFont(value);
-            }
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(CanvasRenderingContext2D.prototype, "direction", {
-        get: function () {
-            this.log('direction');
-            return this.context.getDirection() === org.nativescript.canvas.TNSTextDirection.Ltr ? "ltr" : "rtl";
-        },
-        set: function (value) {
-            this.log('direction value:', value);
-            this._ensureLayoutBeforeDraw();
-            if (this.context) {
-                this.context.setDirection(value === "rtl" ? org.nativescript.canvas.TNSTextDirection.Rtl : org.nativescript.canvas.TNSTextDirection.Ltr);
-            }
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(CanvasRenderingContext2D.prototype, "globalAlpha", {
-        get: function () {
-            this.log('globalAlpha');
-            return this.context.getGlobalAlpha();
-        },
-        set: function (alpha) {
-            this.log('globalAlpha value:', alpha);
-            this._ensureLayoutBeforeDraw();
-            if (this.context) {
-                this.context.setGlobalAlpha(alpha);
-            }
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(CanvasRenderingContext2D.prototype, "imageSmoothingEnabled", {
-        get: function () {
-            this.log('imageSmoothingEnabled');
-            return this.context.getImageSmoothingEnabled();
-        },
-        set: function (enabled) {
-            this.log('imageSmoothingEnabled value:', enabled);
-            this._ensureLayoutBeforeDraw();
-            if (this.context) {
-                this.context.setImageSmoothingEnabled(enabled);
-            }
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(CanvasRenderingContext2D.prototype, "imageSmoothingQuality", {
-        get: function () {
-            this.log('imageSmoothingQuality');
-            return this.context.getImageSmoothingQuality().toString();
-        },
-        set: function (quality) {
-            this.log('imageSmoothingQuality value:', quality);
-            this._ensureLayoutBeforeDraw();
-            if (this.context) {
-                switch (quality) {
-                    case 'high':
-                        this.context.setImageSmoothingQuality(org.nativescript.canvas.TNSImageSmoothingQuality.High);
-                        break;
-                    case 'medium':
-                        this.context.setImageSmoothingQuality(org.nativescript.canvas.TNSImageSmoothingQuality.Medium);
-                        break;
-                    default:
-                        this.context.setImageSmoothingQuality(org.nativescript.canvas.TNSImageSmoothingQuality.Low);
-                        break;
-                }
-            }
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(CanvasRenderingContext2D.prototype, "lineDashOffset", {
-        get: function () {
-            this.log('lineDashOffset');
-            return this.context.getLineDashOffset();
-        },
-        set: function (offset) {
-            this.log('lineDashOffset value:', offset);
-            this._ensureLayoutBeforeDraw();
-            if (this.context) {
-                this.context.setLineDashOffset(offset);
-            }
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(CanvasRenderingContext2D.prototype, "lineJoin", {
-        get: function () {
-            this.log('lineJoin');
-            return this.context.getLineJoin().toString();
-        },
-        set: function (join) {
-            this.log('lineJoin value:', join);
-            this._ensureLayoutBeforeDraw();
-            if (this.context) {
-                switch (join) {
-                    case 'bevel':
-                        this.context.setLineJoin(org.nativescript.canvas.TNSLineJoin.Bevel);
-                        break;
-                    case 'round':
-                        this.context.setLineJoin(org.nativescript.canvas.TNSLineJoin.Round);
-                        break;
-                    default:
-                        this.context.setLineJoin(org.nativescript.canvas.TNSLineJoin.Miter);
-                        break;
-                }
-            }
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(CanvasRenderingContext2D.prototype, "lineCap", {
-        get: function () {
-            this.log('lineCap');
-            return this.context.getLineCap().toString();
-        },
-        set: function (cap) {
-            this.log('lineCap value:', cap);
-            this._ensureLayoutBeforeDraw();
-            if (this.context) {
-                switch (cap) {
-                    case 'round':
-                        this.context.setLineCap(org.nativescript.canvas.TNSLineCap.Round);
-                        break;
-                    case 'square':
-                        this.context.setLineCap(org.nativescript.canvas.TNSLineCap.Square);
-                        break;
-                    default:
-                        this.context.setLineCap(org.nativescript.canvas.TNSLineCap.Butt);
-                }
-            }
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(CanvasRenderingContext2D.prototype, "miterLimit", {
-        get: function () {
-            this.log('miterLimit value:');
-            return this.context.getMiterLimit();
-        },
-        set: function (limit) {
-            this.log('miterLimit value:', limit);
-            this._ensureLayoutBeforeDraw();
-            if (this.context) {
-                this.context.setMiterLimit(limit);
-            }
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(CanvasRenderingContext2D.prototype, "shadowBlur", {
-        get: function () {
-            this.log('shadowBlur');
-            return this.context.getShadowBlur();
-        },
-        set: function (blur) {
-            this.log('shadowBlur value:', blur);
-            this._ensureLayoutBeforeDraw();
-            if (this.context) {
-                this.context.setShadowBlur(blur);
-            }
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(CanvasRenderingContext2D.prototype, "shadowOffsetX", {
-        get: function () {
-            this.log('shadowOffsetX');
-            return this.context.getShadowOffsetX();
-        },
-        set: function (x) {
-            this.log('shadowOffsetX value:', x);
-            this._ensureLayoutBeforeDraw();
-            if (this.context) {
-                this.context.setShadowOffsetX(x);
+    }
+    get native() {
+        return this.context;
+    }
+    get canvas() {
+        return this._canvas;
+    }
+    get shadowColor() {
+        this.log('shadowColor');
+        return this.context.getShadowColor();
+    }
+    set shadowColor(color) {
+        this.log('shadowColor value:', color);
+        this._ensureLayoutBeforeDraw();
+        if (this.context) {
+            this.context.setShadowColor(color);
+        }
+    }
+    get font() {
+        this.log('get font');
+        return this.context.getFont();
+    }
+    set font(value) {
+        this.log('set font value:', value);
+        if (this.context) {
+            this.context.setFont(value);
+        }
+    }
+    get direction() {
+        this.log('direction');
+        return this.context.getDirection() === TextDirection.Ltr() ? "ltr" : "rtl";
+    }
+    set direction(value) {
+        this.log('direction value:', value);
+        this._ensureLayoutBeforeDraw();
+        if (this.context) {
+            this.context.setDirection(value === "rtl" ? TextDirection.Rtl() : TextDirection.Ltr());
+        }
+    }
+    get globalAlpha() {
+        this.log('globalAlpha');
+        return this.context.getGlobalAlpha();
+    }
+    set globalAlpha(alpha) {
+        this.log('globalAlpha value:', alpha);
+        this._ensureLayoutBeforeDraw();
+        if (this.context) {
+            this.context.setGlobalAlpha(alpha);
+        }
+    }
+    get imageSmoothingEnabled() {
+        this.log('imageSmoothingEnabled');
+        return this.context.getImageSmoothingEnabled();
+    }
+    set imageSmoothingEnabled(enabled) {
+        this.log('imageSmoothingEnabled value:', enabled);
+        this._ensureLayoutBeforeDraw();
+        if (this.context) {
+            this.context.setImageSmoothingEnabled(enabled);
+        }
+    }
+    get imageSmoothingQuality() {
+        this.log('imageSmoothingQuality');
+        return this.context.getImageSmoothingQuality().toString();
+    }
+    set imageSmoothingQuality(quality) {
+        this.log('imageSmoothingQuality value:', quality);
+        this._ensureLayoutBeforeDraw();
+        if (this.context) {
+            switch (quality) {
+                case 'high':
+                    this.context.setImageSmoothingQuality(ImageSmoothingQuality.High());
+                    break;
+                case 'medium':
+                    this.context.setImageSmoothingQuality(ImageSmoothingQuality.Medium());
+                    break;
+                default:
+                    this.context.setImageSmoothingQuality(ImageSmoothingQuality.Low());
+                    break;
             }
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(CanvasRenderingContext2D.prototype, "shadowOffsetY", {
-        get: function () {
-            this.log('shadowOffsetY');
-            return this.context.getShadowOffsetY();
-        },
-        set: function (y) {
-            this.log('shadowOffsetY value:', y);
-            this._ensureLayoutBeforeDraw();
-            if (this.context) {
-                this.context.setShadowOffsetY(y);
+        }
+    }
+    get lineDashOffset() {
+        this.log('lineDashOffset');
+        return this.context.getLineDashOffset();
+    }
+    set lineDashOffset(offset) {
+        this.log('lineDashOffset value:', offset);
+        this._ensureLayoutBeforeDraw();
+        if (this.context) {
+            this.context.setLineDashOffset(offset);
+        }
+    }
+    get lineJoin() {
+        this.log('lineJoin');
+        return this.context.getLineJoin().toString();
+    }
+    set lineJoin(join) {
+        this.log('lineJoin value:', join);
+        this._ensureLayoutBeforeDraw();
+        if (this.context) {
+            switch (join) {
+                case 'bevel':
+                    this.context.setLineJoin(LineJoin.Bevel());
+                    break;
+                case 'round':
+                    this.context.setLineJoin(LineJoin.Round());
+                    break;
+                default:
+                    this.context.setLineJoin(LineJoin.Miter());
+                    break;
             }
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(CanvasRenderingContext2D.prototype, "textAlign", {
-        get: function () {
-            this.log('textAlign');
-            return this.context.getTextAlign().toString();
-        },
-        set: function (alignment) {
-            this.log('textAlign value:', alignment);
-            this._ensureLayoutBeforeDraw();
-            if (this.context) {
-                switch (alignment) {
-                    case 'start':
-                        this.context.setTextAlign(org.nativescript.canvas.TNSTextAlignment.Start);
-                        break;
-                    case 'center':
-                        this.context.setTextAlign(org.nativescript.canvas.TNSTextAlignment.Center);
-                        break;
-                    case 'end':
-                        this.context.setTextAlign(org.nativescript.canvas.TNSTextAlignment.End);
-                        break;
-                    case 'right':
-                        this.context.setTextAlign(org.nativescript.canvas.TNSTextAlignment.Right);
-                        break;
-                    default:
-                        this.context.setTextAlign(org.nativescript.canvas.TNSTextAlignment.Left);
-                        break;
-                }
+        }
+    }
+    get lineCap() {
+        this.log('lineCap');
+        return this.context.getLineCap().toString();
+    }
+    set lineCap(cap) {
+        this.log('lineCap value:', cap);
+        this._ensureLayoutBeforeDraw();
+        if (this.context) {
+            switch (cap) {
+                case 'round':
+                    this.context.setLineCap(LineCap.Round());
+                    break;
+                case 'square':
+                    this.context.setLineCap(LineCap.Square());
+                    break;
+                default:
+                    this.context.setLineCap(LineCap.Butt());
             }
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(CanvasRenderingContext2D.prototype, "globalCompositeOperation", {
-        get: function () {
-            this.log('globalCompositeOperation');
-            return this.context.getGlobalCompositeOperation().toString();
-        },
-        set: function (composite) {
-            this.log('globalCompositeOperation value:', composite);
-            this._ensureLayoutBeforeDraw();
-            if (this.context) {
-                var operation = void 0;
-                switch (composite.toLowerCase()) {
-                    case 'source-over':
-                        operation = org.nativescript.canvas.TNSCompositeOperationType.SourceOver;
-                        break;
-                    case 'source-in':
-                        operation = org.nativescript.canvas.TNSCompositeOperationType.SourceIn;
-                        break;
-                    case 'source-out':
-                        operation = org.nativescript.canvas.TNSCompositeOperationType.SourceOut;
-                        break;
-                    case 'source-atop':
-                        operation = org.nativescript.canvas.TNSCompositeOperationType.SourceAtop;
-                        break;
-                    case 'destination-over':
-                        operation = org.nativescript.canvas.TNSCompositeOperationType.DestinationOver;
-                        break;
-                    case 'destination-in':
-                        operation = org.nativescript.canvas.TNSCompositeOperationType.DestinationIn;
-                        break;
-                    case 'destination-out':
-                        operation = org.nativescript.canvas.TNSCompositeOperationType.DestinationOut;
-                        break;
-                    case 'destination-atop':
-                        operation = org.nativescript.canvas.TNSCompositeOperationType.DestinationAtop;
-                        break;
-                    case 'lighter':
-                        operation = org.nativescript.canvas.TNSCompositeOperationType.Lighter;
-                        break;
-                    case 'copy':
-                        operation = org.nativescript.canvas.TNSCompositeOperationType.Copy;
-                        break;
-                    case 'xor':
-                        operation = org.nativescript.canvas.TNSCompositeOperationType.Xor;
-                        break;
-                    case 'multiply':
-                        operation = org.nativescript.canvas.TNSCompositeOperationType.Multiply;
-                        break;
-                    case 'screen':
-                        operation = org.nativescript.canvas.TNSCompositeOperationType.Screen;
-                        break;
-                    case 'overlay':
-                        operation = org.nativescript.canvas.TNSCompositeOperationType.Overlay;
-                        break;
-                    case 'darken':
-                        operation = org.nativescript.canvas.TNSCompositeOperationType.Darken;
-                        break;
-                    case 'lighten':
-                        operation = org.nativescript.canvas.TNSCompositeOperationType.Lighten;
-                        break;
-                    case 'color-dodge':
-                        operation = org.nativescript.canvas.TNSCompositeOperationType.ColorDodge;
-                        break;
-                    case 'color-burn':
-                        operation = org.nativescript.canvas.TNSCompositeOperationType.ColorBurn;
-                        break;
-                    case 'hard-light':
-                        operation = org.nativescript.canvas.TNSCompositeOperationType.HardLight;
-                        break;
-                    case 'soft-light':
-                        operation = org.nativescript.canvas.TNSCompositeOperationType.SoftLight;
-                        break;
-                    case 'difference':
-                        operation = org.nativescript.canvas.TNSCompositeOperationType.Difference;
-                        break;
-                    case 'exclusion':
-                        operation = org.nativescript.canvas.TNSCompositeOperationType.Exclusion;
-                        break;
-                    case 'hue':
-                        operation = org.nativescript.canvas.TNSCompositeOperationType.Hue;
-                        break;
-                    case 'saturation':
-                        operation = org.nativescript.canvas.TNSCompositeOperationType.Saturation;
-                        break;
-                    case 'color':
-                        operation = org.nativescript.canvas.TNSCompositeOperationType.Color;
-                        break;
-                    case 'luminosity':
-                        operation = org.nativescript.canvas.TNSCompositeOperationType.Luminosity;
-                        break;
-                }
-                this.context.setGlobalCompositeOperation(operation);
+        }
+    }
+    get miterLimit() {
+        this.log('miterLimit value:');
+        return this.context.getMiterLimit();
+    }
+    set miterLimit(limit) {
+        this.log('miterLimit value:', limit);
+        this._ensureLayoutBeforeDraw();
+        if (this.context) {
+            this.context.setMiterLimit(limit);
+        }
+    }
+    get shadowBlur() {
+        this.log('shadowBlur');
+        return this.context.getShadowBlur();
+    }
+    set shadowBlur(blur) {
+        this.log('shadowBlur value:', blur);
+        this._ensureLayoutBeforeDraw();
+        if (this.context) {
+            this.context.setShadowBlur(blur);
+        }
+    }
+    get shadowOffsetX() {
+        this.log('shadowOffsetX');
+        return this.context.getShadowOffsetX();
+    }
+    set shadowOffsetX(x) {
+        this.log('shadowOffsetX value:', x);
+        this._ensureLayoutBeforeDraw();
+        if (this.context) {
+            this.context.setShadowOffsetX(x);
+        }
+    }
+    get shadowOffsetY() {
+        this.log('shadowOffsetY');
+        return this.context.getShadowOffsetY();
+    }
+    set shadowOffsetY(y) {
+        this.log('shadowOffsetY value:', y);
+        this._ensureLayoutBeforeDraw();
+        if (this.context) {
+            this.context.setShadowOffsetY(y);
+        }
+    }
+    get textAlign() {
+        this.log('textAlign');
+        return this.context.getTextAlign().toString();
+    }
+    set textAlign(alignment) {
+        this.log('textAlign value:', alignment);
+        this._ensureLayoutBeforeDraw();
+        if (this.context) {
+            switch (alignment) {
+                case 'start':
+                    this.context.setTextAlign(TextAlignment.Start());
+                    break;
+                case 'center':
+                    this.context.setTextAlign(TextAlignment.Center());
+                    break;
+                case 'end':
+                    this.context.setTextAlign(TextAlignment.End());
+                    break;
+                case 'right':
+                    this.context.setTextAlign(TextAlignment.Right());
+                    break;
+                default:
+                    this.context.setTextAlign(TextAlignment.Left());
+                    break;
             }
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(CanvasRenderingContext2D.prototype, "fillStyle", {
-        get: function () {
-            this.log('fillStyle');
+        }
+    }
+    get globalCompositeOperation() {
+        this.log('globalCompositeOperation');
+        return this.context.getGlobalCompositeOperation().toString();
+    }
+    set globalCompositeOperation(composite) {
+        this.log('globalCompositeOperation value:', composite);
+        this._ensureLayoutBeforeDraw();
+        if (this.context) {
+            let operation;
+            switch (composite.toLowerCase()) {
+                case 'source-over':
+                    operation = CompositeOperationType.SourceOver();
+                    break;
+                case 'source-in':
+                    operation = CompositeOperationType.SourceIn();
+                    break;
+                case 'source-out':
+                    operation = CompositeOperationType.SourceOut();
+                    break;
+                case 'source-atop':
+                    operation = CompositeOperationType.SourceAtop();
+                    break;
+                case 'destination-over':
+                    operation = CompositeOperationType.DestinationOver();
+                    break;
+                case 'destination-in':
+                    operation = CompositeOperationType.DestinationIn();
+                    break;
+                case 'destination-out':
+                    operation = CompositeOperationType.DestinationOut();
+                    break;
+                case 'destination-atop':
+                    operation = CompositeOperationType.DestinationAtop();
+                    break;
+                case 'lighter':
+                    operation = CompositeOperationType.Lighter();
+                    break;
+                case 'copy':
+                    operation = CompositeOperationType.Copy();
+                    break;
+                case 'xor':
+                    operation = CompositeOperationType.Xor();
+                    break;
+                case 'multiply':
+                    operation = CompositeOperationType.Multiply();
+                    break;
+                case 'screen':
+                    operation = CompositeOperationType.Screen();
+                    break;
+                case 'overlay':
+                    operation = CompositeOperationType.Overlay();
+                    break;
+                case 'darken':
+                    operation = CompositeOperationType.Darken();
+                    break;
+                case 'lighten':
+                    operation = CompositeOperationType.Lighten();
+                    break;
+                case 'color-dodge':
+                    operation = CompositeOperationType.ColorDodge();
+                    break;
+                case 'color-burn':
+                    operation = CompositeOperationType.ColorBurn();
+                    break;
+                case 'hard-light':
+                    operation = CompositeOperationType.HardLight();
+                    break;
+                case 'soft-light':
+                    operation = CompositeOperationType.SoftLight();
+                    break;
+                case 'difference':
+                    operation = CompositeOperationType.Difference();
+                    break;
+                case 'exclusion':
+                    operation = CompositeOperationType.Exclusion();
+                    break;
+                case 'hue':
+                    operation = CompositeOperationType.Hue();
+                    break;
+                case 'saturation':
+                    operation = CompositeOperationType.Saturation();
+                    break;
+                case 'color':
+                    operation = CompositeOperationType.Color();
+                    break;
+                case 'luminosity':
+                    operation = CompositeOperationType.Luminosity();
+                    break;
+            }
+            this.context.setGlobalCompositeOperation(operation);
+        }
+    }
+    get fillStyle() {
+        this.log('fillStyle');
+        if (this.context) {
             switch (this.context.getFillStyle().getStyleType()) {
-                case 0 /* Color */:
-                    var color = this.context.getFillStyle();
-                    return color.getColor();
-                case 1 /* Gradient */:
-                    return CanvasGradient_1.CanvasGradient.fromNative(this.context.getFillStyle());
-                case 2 /* Pattern */:
-                    return new CanvasPattern_1.CanvasPattern(this.context.getFillStyle());
-            }
-        },
-        set: function (color) {
-            this.log('fillStyle:', color);
-            if (color === undefined || color === null) {
-                return;
-            }
-            this._ensureLayoutBeforeDraw();
-            if (typeof color === 'string') {
-                this.context.setFillStyle(new org.nativescript.canvas.TNSColor(color));
-            }
-            else if (color instanceof CanvasGradient_1.CanvasGradient) {
-                this.context.setFillStyle(color.native);
-            }
-            else if (color instanceof CanvasPattern_1.CanvasPattern) {
-                this.context.setFillStyle(color.native);
-            }
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(CanvasRenderingContext2D.prototype, "strokeStyle", {
-        get: function () {
-            this.log('strokeStyle');
-            switch (this.context.getStrokeStyle().getStyleType()) {
-                case 0 /* Color */:
-                    var color = this.context.getStrokeStyle();
+                case org.nativescript.canvas.TNSColorStyleType.Color:
+                    const color = this.context.getFillStyle();
                     return color.getColor();
-                case 1 /* Gradient */:
-                    return CanvasGradient_1.CanvasGradient.fromNative(this.context.getStrokeStyle());
-                case 2 /* Pattern */:
-                    return new CanvasPattern_1.CanvasPattern(this.context.getStrokeStyle());
-            }
-        },
-        set: function (color) {
-            this.log('strokeStyle:', color);
-            if (color === undefined || color === null) {
-                return;
+                case org.nativescript.canvas.TNSColorStyleType.Gradient:
+                    return CanvasGradient.fromNative(this.context.getFillStyle());
+                case org.nativescript.canvas.TNSColorStyleType.Pattern:
+                    return new CanvasPattern(this.context.getFillStyle());
             }
-            this._ensureLayoutBeforeDraw();
-            if (typeof color === 'string') {
-                this.context.setStrokeStyle(new org.nativescript.canvas.TNSColor(color));
-            }
-            else if (color instanceof CanvasGradient_1.CanvasGradient) {
-                this.context.setStrokeStyle(color.native);
-            }
-            else if (color instanceof CanvasPattern_1.CanvasPattern) {
-                this.context.setStrokeStyle(color.native);
-            }
-        },
-        enumerable: true,
-        configurable: true
-    });
-    Object.defineProperty(CanvasRenderingContext2D.prototype, "lineWidth", {
-        get: function () {
-            this.log('lineWidth');
-            return this.context.getLineWidth();
-        },
-        set: function (width) {
-            this.log('lineWidth value:', width);
-            this._ensureLayoutBeforeDraw();
-            if (this.context) {
-                this.context.setLineWidth(width);
-            }
-        },
-        enumerable: true,
-        configurable: true
-    });
-    CanvasRenderingContext2D.prototype.addHitRegion = function (region) {
-    };
-    CanvasRenderingContext2D.prototype.arc = function (x, y, radius, startAngle, endAngle, anticlockwise) {
-        if (anticlockwise === void 0) { anticlockwise = false; }
+        }
+        return 'black';
+    }
+    set fillStyle(color) {
+        this.log('fillStyle:', color);
+        if (color === undefined || color === null) {
+            return;
+        }
+        this._ensureLayoutBeforeDraw();
+        if (typeof color === 'string') {
+            this.context.setFillStyle(new org.nativescript.canvas.TNSColor(color));
+        }
+        else if (color instanceof CanvasGradient) {
+            this.context.setFillStyle(color.native);
+        }
+        else if (color instanceof CanvasPattern) {
+            this.context.setFillStyle(color.native);
+        }
+    }
+    get filter() {
+        this.log('get filter');
+        return this.context.getFilter();
+    }
+    set filter(value) {
+        this.log('set filter', value);
+        if (this.context) {
+            this.context.setFilter(value);
+        }
+    }
+    get strokeStyle() {
+        this.log('strokeStyle');
+        switch (this.context.getStrokeStyle().getStyleType()) {
+            case 0 /* Color */:
+                const color = this.context.getStrokeStyle();
+                return color.getColor();
+            case 1 /* Gradient */:
+                return CanvasGradient.fromNative(this.context.getStrokeStyle());
+            case 2 /* Pattern */:
+                return new CanvasPattern(this.context.getStrokeStyle());
+        }
+    }
+    set strokeStyle(color) {
+        this.log('strokeStyle:', color);
+        if (color === undefined || color === null) {
+            return;
+        }
+        this._ensureLayoutBeforeDraw();
+        if (typeof color === 'string') {
+            this.context.setStrokeStyle(new org.nativescript.canvas.TNSColor(color));
+        }
+        else if (color instanceof CanvasGradient) {
+            this.context.setStrokeStyle(color.native);
+        }
+        else if (color instanceof CanvasPattern) {
+            this.context.setStrokeStyle(color.native);
+        }
+    }
+    get lineWidth() {
+        this.log('lineWidth');
+        return this.context.getLineWidth();
+    }
+    set lineWidth(width) {
+        this.log('lineWidth value:', width);
+        this._ensureLayoutBeforeDraw();
+        if (this.context) {
+            this.context.setLineWidth(width);
+        }
+    }
+    addHitRegion(region) {
+    }
+    arc(x, y, radius, startAngle, endAngle, anticlockwise = false) {
         this.log('arc value:', x, y, radius, startAngle, endAngle, anticlockwise);
         this._ensureLayoutBeforeDraw();
         this.context.arc(x, y, radius, startAngle, endAngle, anticlockwise);
-    };
-    CanvasRenderingContext2D.prototype.arcTo = function (x1, y1, x2, y2, radius) {
+    }
+    arcTo(x1, y1, x2, y2, radius) {
         this.log('arcTo value:', x1, y1, x2, y2, radius);
         this._ensureLayoutBeforeDraw();
         this.context.arcTo(x1, y1, x2, y2, radius);
-    };
-    CanvasRenderingContext2D.prototype.beginPath = function () {
+    }
+    beginPath() {
         this.log('beginPath');
         this._ensureLayoutBeforeDraw();
         this.context.beginPath();
-    };
-    CanvasRenderingContext2D.prototype.bezierCurveTo = function (cp1x, cp1y, cp2x, cp2y, x, y) {
+    }
+    bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y) {
         this.log('bezierCurveTo value:', cp1x, cp1y, cp2x, cp2y, x, y);
         this._ensureLayoutBeforeDraw();
         this.context.bezierCurveTo(cp1x, cp1y, cp2x, cp2y, x, y);
-    };
-    CanvasRenderingContext2D.prototype.clearHitRegions = function () {
-    };
-    CanvasRenderingContext2D.prototype.clearRect = function (x, y, width, height) {
+    }
+    clearHitRegions() {
+    }
+    clearRect(x, y, width, height) {
         this.log('clearRect value:', x, y, width, height);
         this._ensureLayoutBeforeDraw();
         this.context.clearRect(x, y, width, height);
-    };
-    CanvasRenderingContext2D.prototype.clip = function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        this.log.apply(this, ['clip value:'].concat(args));
+    }
+    clip(...args) {
+        this.log('clip value:', ...args);
         this._ensureLayoutBeforeDraw();
         if (typeof args[0] === 'string') {
-            this.context.clip(args[0]);
+            const rule = this._fillRuleFromString(args[0]);
+            this.context.clip(rule);
         }
-        else if (args[0] instanceof Path2D_1.Path2D && typeof args[1] === 'string') {
-            this.context.clip(args[0].native, args[1]);
+        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_1.Path2D) {
+        else if (args[0] instanceof Path2D) {
             this.context.clip(args[0].native);
         }
         else {
             this.context.clip();
         }
-    };
-    CanvasRenderingContext2D.prototype.closePath = function () {
+    }
+    closePath() {
         this.log('closePath');
         this._ensureLayoutBeforeDraw();
         this.context.closePath();
-    };
-    CanvasRenderingContext2D.prototype.createImageData = function (width, height) {
+    }
+    createImageData(width, height) {
         this.log('createImageData value:', arguments);
-        if (width instanceof ImageData_1.ImageData) {
-            return ImageData_1.ImageData.from(width);
+        if (width instanceof ImageData) {
+            return ImageData.from(width);
         }
         else {
-            return ImageData_1.ImageData.fromNative(this.context.createImageData(width, height));
+            return ImageData.fromNative(this.context.createImageData(width, height));
         }
-    };
-    CanvasRenderingContext2D.prototype.createLinearGradient = function (x0, y0, x1, y1) {
+    }
+    createLinearGradient(x0, y0, x1, y1) {
         this.log('createLinearGradient value:', x0, y0, x1, y1);
         this._ensureLayoutBeforeDraw();
-        return CanvasGradient_1.CanvasGradient.fromNative(this.context.createLinearGradient(x0, y0, x1, y1));
-    };
-    CanvasRenderingContext2D.prototype.createPattern = function (image, repetition) {
+        return CanvasGradient.fromNative(this.context.createLinearGradient(x0, y0, x1, y1));
+    }
+    createPattern(image, repetition) {
         this.log('createPattern value:', image, repetition);
         this._ensureLayoutBeforeDraw();
         if (repetition === undefined || typeof repetition !== 'string') {
-            var e = new Error('The string did not match the expected pattern.');
+            const e = new Error('The string did not match the expected pattern.');
             e.name = 'SyntaxError';
             throw e;
         }
-        var img;
-        if (image instanceof core_1.ImageSource) {
+        let img;
+        if (image instanceof ImageSource) {
             img = image.android;
         }
         else if (image instanceof android.graphics.Bitmap) {
             img = image;
         }
-        else if (image instanceof ImageAsset_1.ImageAsset) {
+        else if (image instanceof ImageAsset) {
             img = image.native;
         }
-        else if (image instanceof Canvas_1.Canvas) {
+        else if (image instanceof Canvas) {
             img = image.android;
         }
         else if (image && typeof image.tagName === 'string' && (image.tagName === 'IMG' || image.tagName === 'IMAGE')) {
-            if (image._imageSource instanceof core_1.ImageSource) {
+            if (image._imageSource instanceof ImageSource) {
                 img = image._imageSource.android;
             }
             else if (image._image instanceof android.graphics.Bitmap) {
                 img = image._image;
             }
-            else if (image._asset instanceof ImageAsset_1.ImageAsset) {
+            else if (image._asset instanceof ImageAsset) {
                 img = image._asset.native;
             }
             else if (typeof image.src === 'string') {
-                img = core_1.ImageSource.fromFileSync(image.src).android;
+                img = ImageSource.fromFileSync(image.src).android;
             }
         }
         else if (image &&
             typeof image.tagName === 'string' &&
-            image.tagName === 'CANVAS' && image._canvas instanceof Canvas_1.Canvas) {
+            image.tagName === 'CANVAS' && image._canvas instanceof Canvas) {
             img = image._canvas.android;
         }
+        else if (image instanceof ImageBitmap || (image === null || image === void 0 ? void 0 : image.nativeInstance) instanceof org.nativescript.canvas.TNSImageBitmap) {
+            img = image.native;
+        }
         if (!img) {
             return null;
         }
-        var rep;
+        let rep;
         switch (repetition) {
             case 'no-repeat':
-                rep = org.nativescript.canvas.TNSPatternRepetition.NoRepeat;
+                rep = PatternRepetition.NoRepeat();
                 break;
             case 'repeat-x':
-                rep = org.nativescript.canvas.TNSPatternRepetition.RepeatX;
+                rep = PatternRepetition.RepeatX();
                 break;
             case 'repeat-y':
-                rep = org.nativescript.canvas.TNSPatternRepetition.RepeatY;
+                rep = PatternRepetition.RepeatY();
                 break;
             default:
-                rep = org.nativescript.canvas.TNSPatternRepetition.Repeat;
+                rep = PatternRepetition.Repeat();
                 break;
         }
-        return new CanvasPattern_1.CanvasPattern(this.context.createPattern(img, rep));
-    };
-    CanvasRenderingContext2D.prototype.createRadialGradient = function (x0, y0, r0, x1, y1, r1) {
+        return new CanvasPattern(this.context.createPattern(img, rep));
+    }
+    createRadialGradient(x0, y0, r0, x1, y1, r1) {
         this.log('createRadialGradient value:', x0, y0, r0, x1, y1, r1);
         this._ensureLayoutBeforeDraw();
-        return CanvasGradient_1.CanvasGradient.fromNative(this.context.createRadialGradient(x0, y0, r0, x1, y1, r1));
-    };
-    CanvasRenderingContext2D.prototype.drawFocusIfNeeded = function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-    };
-    CanvasRenderingContext2D.prototype.drawImage = function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        this.log.apply(this, ['drawImage value:'].concat(args));
+        return CanvasGradient.fromNative(this.context.createRadialGradient(x0, y0, r0, x1, y1, r1));
+    }
+    drawFocusIfNeeded(...args) {
+    }
+    drawImage(...args) {
+        this.log('drawImage value:', ...args);
         this._ensureLayoutBeforeDraw();
-        var image = args[0];
-        if (image instanceof ImageAsset_1.ImageAsset) {
+        let image = args[0];
+        if (image instanceof ImageAsset) {
             image = image.native;
         }
-        else if (image instanceof core_1.ImageSource) {
+        else if (image instanceof ImageSource) {
             image = image.android;
         }
         else if (image instanceof android.graphics.Bitmap) {
             image = image;
         }
-        else if (image instanceof Canvas_1.Canvas) {
+        else if (image instanceof Canvas) {
             image = image.android;
         }
         else if (image && typeof image.tagName === 'string' && (image.tagName === 'IMG' || image.tagName === 'IMAGE')) {
-            if (image._imageSource instanceof core_1.ImageSource) {
+            if (image._imageSource instanceof ImageSource) {
                 image = image._imageSource.android;
             }
             else if (image._image instanceof android.graphics.Bitmap) {
                 image = image._image;
             }
-            else if (image._asset instanceof ImageAsset_1.ImageAsset) {
+            else if (image._asset instanceof ImageAsset) {
                 image = image._asset.native;
             }
             else if (typeof image.src === 'string') {
-                image = core_1.ImageSource.fromFileSync(image.src).android;
+                image = ImageSource.fromFileSync(image.src).android;
             }
         }
         else if (image &&
             typeof image.tagName === 'string' &&
-            image.tagName === 'CANVAS' && image._canvas instanceof Canvas_1.Canvas) {
+            image.tagName === 'CANVAS' && image._canvas instanceof Canvas) {
             image = image._canvas.android;
         }
+        else if (image instanceof ImageBitmap || (image === null || image === void 0 ? void 0 : image.nativeInstance) instanceof org.nativescript.canvas.TNSImageBitmap) {
+            image = image.native;
+        }
         if (args.length === 3) {
             this.context.drawImage(image, args[1], args[2]);
         }
@@ -657,39 +645,36 @@ var CanvasRenderingContext2D = /** @class */ (function (_super) {
         else if (args.length === 9) {
             this.context.drawImage(image, args[1], args[2], args[3], args[4], args[5], args[6], args[7], args[8]);
         }
-    };
-    CanvasRenderingContext2D.prototype.ellipse = function (x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise) {
-        if (anticlockwise === void 0) { anticlockwise = false; }
+    }
+    ellipse(x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise = false) {
         this.log('ellipse value:', x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise);
         this._ensureLayoutBeforeDraw();
         this.context.ellipse(x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise);
-    };
-    CanvasRenderingContext2D.prototype.fill = function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        this.log.apply(this, ['fill value:'].concat(args));
+    }
+    fill(...args) {
+        this.log('fill value:', ...args);
         this._ensureLayoutBeforeDraw();
         if (typeof args[0] === 'string') {
-            this.context.fill(args[0]);
+            const rule = this._fillRuleFromString(args[0]);
+            this.context.fill(rule);
         }
-        else if (args[0] instanceof Path2D_1.Path2D && typeof args[1] === 'string') {
-            this.context.fill(args[0].native, args[1]);
+        else if (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_1.Path2D) {
+        else if (args[0] instanceof Path2D) {
             this.context.fill(args[0].native);
         }
         else {
             this.context.fill();
         }
-    };
-    CanvasRenderingContext2D.prototype.fillRect = function (x, y, width, height) {
+    }
+    fillRect(x, y, width, height) {
         this.log('fillRect value:', x, y, width, height);
         this._ensureLayoutBeforeDraw();
         this.context.fillRect(x, y, width, height);
-    };
-    CanvasRenderingContext2D.prototype.fillText = function (text, x, y, maxWidth) {
+    }
+    fillText(text, x, y, maxWidth) {
         this.log('fillText value:', text, x, y, maxWidth);
         this._ensureLayoutBeforeDraw();
         if (typeof maxWidth === 'number') {
@@ -698,23 +683,19 @@ var CanvasRenderingContext2D = /** @class */ (function (_super) {
         else {
             this.context.fillText(text, x, y);
         }
-    };
-    CanvasRenderingContext2D.prototype.getImageData = function (sx, sy, sw, sh) {
+    }
+    getImageData(sx, sy, sw, sh) {
         this.log('getImageData value:', sx, sy, sw, sh);
         this._ensureLayoutBeforeDraw();
-        return ImageData_1.ImageData.fromNative(this.context.getImageData(sx, sy, sw, sh));
-    };
-    CanvasRenderingContext2D.prototype.getLineDash = function () {
+        return ImageData.fromNative(this.context.getImageData(sx, sy, sw, sh));
+    }
+    getLineDash() {
         this.log('getLineDash');
         this._ensureLayoutBeforeDraw();
         return this.context.getLineDash();
-    };
-    CanvasRenderingContext2D.prototype.isPointInPath = function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        this.log.apply(this, ['isPointInPath value:'].concat(args));
+    }
+    isPointInPath(...args) {
+        this.log('isPointInPath value:', ...args);
         this._ensureLayoutBeforeDraw();
         if (args.length === 2) {
             return this.context.isPointInPath(args[0], args[1]);
@@ -722,112 +703,101 @@ var CanvasRenderingContext2D = /** @class */ (function (_super) {
         else if (args.length === 3) {
             return this.context.isPointInPath(args[0], args[1], args[2]);
         }
-        else if (args.length === 4 && args[0] instanceof Path2D_1.Path2D) {
+        else if (args.length === 4 && args[0] instanceof Path2D) {
             return this.context.isPointInPath(args[0].native, args[1], args[2], args[3]);
         }
         return false;
-    };
-    CanvasRenderingContext2D.prototype.isPointInStroke = function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        this.log.apply(this, ['isPointInStroke value:'].concat(args));
+    }
+    isPointInStroke(...args) {
+        this.log('isPointInStroke value:', ...args);
         this._ensureLayoutBeforeDraw();
         if (args.length === 2) {
             return this.context.isPointInStroke(args[0], args[1]);
         }
-        else if (args.length === 3 && args[0] instanceof Path2D_1.Path2D) {
+        else if (args.length === 3 && args[0] instanceof Path2D) {
             return this.context.isPointInStroke(args[0].native, args[1], args[2]);
         }
         return false;
-    };
-    CanvasRenderingContext2D.prototype.lineTo = function (x, y) {
+    }
+    lineTo(x, y) {
         this.log('lineTo value:', x, y);
         this._ensureLayoutBeforeDraw();
         this.context.lineTo(x, y);
-    };
-    CanvasRenderingContext2D.prototype.measureText = function (text) {
+    }
+    measureText(text) {
         this.log('measureText value:', text);
         this._ensureLayoutBeforeDraw();
-        return new TextMetrics_1.TextMetrics(this.context.measureText(text));
-    };
-    CanvasRenderingContext2D.prototype.moveTo = function (x, y) {
+        return new TextMetrics(this.context.measureText(text));
+    }
+    moveTo(x, y) {
         this.log('moveTo value:', x, y);
         this._ensureLayoutBeforeDraw();
         this.context.moveTo(x, y);
-    };
-    CanvasRenderingContext2D.prototype.putImageData = function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        this.log.apply(this, ['putImageData value:'].concat(args));
+    }
+    putImageData(...args) {
+        this.log('putImageData value:', ...args);
         this._ensureLayoutBeforeDraw();
         if (!args) {
             return;
         }
-        var data = args[0];
-        // Would be nice not to update the native backing array each time ... but since buffers don't use pointers ... we are here 😅
+        let data = args[0];
         if (args.length === 3) {
-            //data.native.updateData(Array.from(data.data));
             this.context.putImageData(data.native, args[1], args[2]);
         }
         else if (args.length === 7) {
-            // data.native.updateData(Array.from(data.data));
             this.context.putImageData(data.native, args[1], args[2], args[3], args[4], args[5], args[6]);
         }
-    };
-    CanvasRenderingContext2D.prototype.quadraticCurveTo = function (cpx, cpy, x, y) {
+    }
+    quadraticCurveTo(cpx, cpy, x, y) {
         this.log('quadraticCurveTo value:', cpx, cpy, x, y);
         this._ensureLayoutBeforeDraw();
         this.context.quadraticCurveTo(cpx, cpy, x, y);
-    };
-    CanvasRenderingContext2D.prototype.rect = function (x, y, width, height) {
+    }
+    rect(x, y, width, height) {
         this.log('rect value:', x, y, width, height);
         this._ensureLayoutBeforeDraw();
         this.context.rect(x, y, width, height);
-    };
-    CanvasRenderingContext2D.prototype.removeHitRegion = function (id) {
-    };
-    CanvasRenderingContext2D.prototype.resetTransform = function () {
+    }
+    removeHitRegion(id) {
+    }
+    resetTransform() {
         this.log('resetTransform value:');
         this._ensureLayoutBeforeDraw();
         this.context.resetTransform();
-    };
-    CanvasRenderingContext2D.prototype.restore = function () {
+    }
+    restore() {
         this.log('restore');
         this._ensureLayoutBeforeDraw();
         this.context.restore();
-    };
-    CanvasRenderingContext2D.prototype.rotate = function (angle) {
+    }
+    rotate(angle) {
         this.log('rotate value:', angle);
         this._ensureLayoutBeforeDraw();
         this.context.rotate(angle);
-    };
-    CanvasRenderingContext2D.prototype.save = function () {
+    }
+    save() {
         this.log('save');
         this._ensureLayoutBeforeDraw();
         this.context.save();
-    };
-    CanvasRenderingContext2D.prototype.scale = function (x, y) {
+    }
+    scale(x, y) {
         this.log('scale value:', x, y);
         this._ensureLayoutBeforeDraw();
         this.context.scale(x, y);
-    };
-    CanvasRenderingContext2D.prototype.scrollPathIntoView = function (path) {
-    };
-    CanvasRenderingContext2D.prototype.setLineDash = function (segments) {
+    }
+    scrollPathIntoView(path) {
+    }
+    setLineDash(segments) {
         this.log('setLineDash value:', segments);
         this._ensureLayoutBeforeDraw();
         this.context.setLineDash(segments);
-    };
-    CanvasRenderingContext2D.prototype.setTransform = function (a, b, c, d, e, f) {
+    }
+    setTransform(a, b, c, d, e, f) {
         this.log('setTransform value:', a, b, c, d, e, f);
         this._ensureLayoutBeforeDraw();
         this.context.setTransform(a, b, c, d, e, f);
-    };
-    CanvasRenderingContext2D.prototype.stroke = function (path) {
+    }
+    stroke(path) {
         this.log('stroke value:', path);
         this._ensureLayoutBeforeDraw();
         if (path) {
@@ -836,13 +806,13 @@ var CanvasRenderingContext2D = /** @class */ (function (_super) {
         else {
             this.context.stroke();
         }
-    };
-    CanvasRenderingContext2D.prototype.strokeRect = function (x, y, width, height) {
+    }
+    strokeRect(x, y, width, height) {
         this.log('strokeRect value:', x, y, width, height);
         this._ensureLayoutBeforeDraw();
         this.context.strokeRect(x, y, width, height);
-    };
-    CanvasRenderingContext2D.prototype.strokeText = function (text, x, y, maxWidth) {
+    }
+    strokeText(text, x, y, maxWidth) {
         this.log('strokeText value:', text, x, y, maxWidth);
         this._ensureLayoutBeforeDraw();
         if (typeof maxWidth === 'number') {
@@ -851,35 +821,29 @@ var CanvasRenderingContext2D = /** @class */ (function (_super) {
         else {
             this.context.strokeText(text, x, y);
         }
-    };
-    CanvasRenderingContext2D.prototype.transform = function (a, b, c, d, e, f) {
+    }
+    transform(a, b, c, d, e, f) {
         this.log('transform value:', a, b, c, d, e, f);
         this._ensureLayoutBeforeDraw();
         this.context.transform(a, b, c, d, e, f);
-    };
-    CanvasRenderingContext2D.prototype.translate = function (x, y) {
+    }
+    translate(x, y) {
         this.log('translate value:', x, y);
         this._ensureLayoutBeforeDraw();
         this.context.translate(x, y);
-    };
-    CanvasRenderingContext2D.prototype._ensureLayoutBeforeDraw = function () {
+    }
+    _ensureLayoutBeforeDraw() {
         if (this.canvas) {
             this.canvas._layoutNative();
         }
-    };
-    CanvasRenderingContext2D.prototype.log = function (message) {
-        var args = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            args[_i - 1] = arguments[_i];
-        }
+    }
+    log(message, ...args) {
         if (!CanvasRenderingContext2D.isDebug) {
             return;
         }
         console.log(message, args);
-    };
-    CanvasRenderingContext2D.isDebug = false;
-    CanvasRenderingContext2D.colorCache = {};
-    return CanvasRenderingContext2D;
-}(common_1.CanvasRenderingContext2DBase));
-exports.CanvasRenderingContext2D = CanvasRenderingContext2D;
+    }
+}
+CanvasRenderingContext2D.isDebug = false;
+CanvasRenderingContext2D.colorCache = {};
 //# sourceMappingURL=index.android.js.map