@leafer-ui/core 1.0.0-rc.19 → 1.0.0-rc.20

package/lib/core.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-var draw$1 = require('@leafer-ui/draw');
+var draw = require('@leafer-ui/draw');
 var core = require('@leafer/core');
 
 /******************************************************************************
@@ -32,7 +32,7 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 };
 
-exports.App = class App extends draw$1.Leafer {
+exports.App = class App extends draw.Leafer {
     get __tag() { return 'App'; }
     get isApp() { return true; }
     constructor(userConfig, data) {
@@ -88,7 +88,7 @@ exports.App = class App extends draw$1.Leafer {
         this.children.forEach(leafer => leafer.forceRender(bounds));
     }
     addLeafer(merge) {
-        const leafer = new draw$1.Leafer(merge);
+        const leafer = new draw.Leafer(merge);
         this.add(leafer);
         return leafer;
     }
@@ -123,7 +123,8 @@ exports.App = class App extends draw$1.Leafer {
         if (this.viewReady)
             this.renderer.update();
     }
-    __render(canvas, _options) {
+    __render(canvas, options) {
+        canvas.setWorld(options.matrix || this.__world);
         this.children.forEach(leafer => canvas.copyWorld(leafer.canvas));
     }
     __onResize(event) {
@@ -156,11 +157,6 @@ exports.App = __decorate([
     core.registerUI()
 ], exports.App);
 
-function draw(leafer) {
-    const { config } = leafer;
-    config.move.dragOut = false;
-}
-
 const downKeyMap = {};
 const Keyboard = {
     isHoldSpaceKey() {
@@ -355,21 +351,16 @@ exports.KeyEvent = __decorate([
     core.registerUIEvent()
 ], exports.KeyEvent);
 
-function design(leafer) {
+function addInteractionWindow(leafer) {
     if (leafer.isApp)
         return;
     leafer.__eventIds.push(leafer.on_(exports.MoveEvent.BEFORE_MOVE, (e) => {
-        let { moveX, moveY } = e;
-        if (leafer.config.move.scroll) {
-            if (Math.abs(moveX) > Math.abs(moveY))
-                moveY = 0;
-            else
-                moveX = 0;
-        }
-        leafer.zoomLayer.move(moveX, moveY);
+        const { x, y } = leafer.getValidMove(e.moveX, e.moveY);
+        if (x || y)
+            leafer.zoomLayer.move(x, y);
     }), leafer.on_(exports.ZoomEvent.BEFORE_ZOOM, (e) => {
         const { zoomLayer } = leafer;
-        const changeScale = leafer.validScale(e.scale);
+        const changeScale = leafer.getValidScale(e.scale);
         if (changeScale !== 1) {
             core.PointHelper.scaleOf(zoomLayer, e, changeScale);
             zoomLayer.scale = zoomLayer.__.scaleX * changeScale;
@@ -377,6 +368,12 @@ function design(leafer) {
     }));
 }
 
+function document(leafer) {
+    addInteractionWindow(leafer);
+    leafer.config.move.scroll = 'limit';
+    leafer.config.zoom.min = 1;
+}
+
 const debug$1 = core.Debug.get('LeaferTypeCreator');
 const LeaferTypeCreator = {
     list: {},
@@ -399,12 +396,51 @@ const LeaferTypeCreator = {
     }
 };
 const { list, register } = LeaferTypeCreator;
-register('draw', draw);
-register('design', design);
+register('draw', () => { });
+register('design', addInteractionWindow);
+register('document', document);
 
-draw$1.Leafer.prototype.initType = function (type) {
+draw.Leafer.prototype.initType = function (type) {
     LeaferTypeCreator.run(type, this);
 };
+draw.Leafer.prototype.getValidMove = function (moveX, moveY) {
+    const { scroll, disabled } = this.app.config.move;
+    if (scroll) {
+        if (Math.abs(moveX) > Math.abs(moveY))
+            moveY = 0;
+        else
+            moveX = 0;
+        if (scroll === 'limit') {
+            const { x, y, width, height } = new core.Bounds(this.__world).addPoint(this.zoomLayer);
+            const right = x + width - this.width, bottom = y + height - this.height;
+            if (x >= 0 && right <= 0)
+                moveX = 0;
+            else if (moveX > 0) {
+                if (x + moveX > 0)
+                    moveX = -x;
+            }
+            else if (moveX < 0 && right + moveX < 0)
+                moveX = -right;
+            if (y >= 0 && bottom <= 0)
+                moveY = 0;
+            else if (moveY > 0) {
+                if (y + moveY > 0)
+                    moveY = -y;
+            }
+            else if (moveY < 0 && bottom + moveY < 0)
+                moveY = -bottom;
+        }
+    }
+    return { x: disabled ? 0 : moveX, y: disabled ? 0 : moveY };
+};
+draw.Leafer.prototype.getValidScale = function (changeScale) {
+    const { scaleX } = this.zoomLayer.__, { min, max, disabled } = this.app.config.zoom, absScale = Math.abs(scaleX * changeScale);
+    if (absScale < min)
+        changeScale = min / scaleX;
+    else if (absScale > max)
+        changeScale = max / scaleX;
+    return disabled ? 1 : changeScale;
+};
 
 class Transformer {
     constructor(interaction) {
@@ -576,7 +612,7 @@ class Dragger {
             return;
         }
         if (!this.moving && canDrag) {
-            if (this.moving = interaction.canMove(this.downData) || interaction.isHoldRightKey)
+            if (this.moving = interaction.canMove(this.downData) || interaction.isHoldRightKey || interaction.isMobileDragEmpty)
                 interaction.emit(exports.MoveEvent.START, this.dragData);
         }
         if (!this.moving) {
@@ -625,7 +661,7 @@ class Dragger {
         const list = this.getList();
         if (list.length && running) {
             const { moveX, moveY } = this.dragData;
-            list.forEach(leaf => leaf.moveWorld(moveX, moveY));
+            list.forEach(leaf => leaf.draggable && leaf.moveWorld(moveX, moveY));
         }
     }
     dragOverOrOut(data) {
@@ -652,7 +688,7 @@ class Dragger {
         this.dragEnterPath = path;
     }
     dragEnd(data, speed) {
-        if (!this.dragData)
+        if (!this.dragging && !this.moving)
             return;
         const { moveX, moveY } = this.dragData;
         if (this.interaction.config.move.dragAnimate && this.canAnimate && this.moving && (Math.abs(moveX) > 1 || Math.abs(moveY) > 1)) {
@@ -675,12 +711,16 @@ class Dragger {
         if (throughPath)
             endDragData.throughPath = throughPath;
         endDragData.path = path;
-        if (this.moving)
+        if (this.moving) {
+            this.moving = false;
             interaction.emit(exports.MoveEvent.END, endDragData);
+        }
         if (this.dragging) {
+            const dropList = this.getList();
+            this.dragging = false;
             interaction.emit(exports.DragEvent.END, endDragData);
-            this.swipe(data, endDragData);
-            this.drop(data);
+            this.swipe(data, downData, dragData, endDragData);
+            this.drop(data, dropList, this.dragEnterPath);
         }
         this.autoMoveCancel();
         this.dragReset();
@@ -692,22 +732,21 @@ class Dragger {
             this.interaction.target.nextRender(animateWait, null, off);
         this.animateWait = func;
     }
-    swipe(data, endDragData) {
-        const { interaction, downData } = this;
+    swipe(data, downData, dragData, endDragData) {
+        const { interaction } = this;
         if (core.PointHelper.getDistance(downData, data) > interaction.config.pointer.swipeDistance) {
-            const swipeData = getSwipeEventData(downData, this.dragData, endDragData);
+            const swipeData = getSwipeEventData(downData, dragData, endDragData);
             this.interaction.emit(swipeData.type, swipeData);
         }
     }
-    drop(data) {
-        const dropData = getDropEventData(data, this.getList(), exports.DragEvent.data);
-        dropData.path = this.dragEnterPath;
+    drop(data, dropList, dragEnterPath) {
+        const dropData = getDropEventData(data, dropList, exports.DragEvent.data);
+        dropData.path = dragEnterPath;
         this.interaction.emit(exports.DropEvent.DROP, dropData);
-        this.interaction.emit(exports.DragEvent.LEAVE, data, this.dragEnterPath);
+        this.interaction.emit(exports.DragEvent.LEAVE, data, dragEnterPath);
     }
     dragReset() {
         exports.DragEvent.list = exports.DragEvent.data = this.dragableList = this.dragData = this.downData = this.dragOverPath = this.dragEnterPath = null;
-        this.dragging = this.moving = false;
     }
     checkDragOut(data) {
         const { interaction } = this;
@@ -795,8 +834,8 @@ function emitEvent(leaf, type, data, capture, excludePath) {
     if (leaf.destroyed)
         return true;
     if (leaf.__.hitSelf && !exclude(leaf, excludePath)) {
-        if (draw$1.State.updateEventStyle)
-            draw$1.State.updateEventStyle(leaf, type);
+        if (draw.State.updateEventStyle)
+            draw.State.updateEventStyle(leaf, type);
         if (leaf.hasEvent(type, capture)) {
             data.phase = capture ? 1 : ((leaf === data.target) ? 2 : 3);
             const event = core.EventCreator.get(type, data);
@@ -839,6 +878,7 @@ const config = {
         tapTime: 120,
         longPressTime: 800,
         transformTime: 500,
+        hover: true,
         dragHover: true,
         dragDistance: 2,
         swipeDistance: 20,
@@ -850,9 +890,12 @@ const config = {
 const { pathHasEventType, getMoveEventData, getZoomEventData, getRotateEventData } = InteractionHelper;
 class InteractionBase {
     get dragging() { return this.dragger.dragging; }
+    get moveMode() { return this.config.move.drag || this.isHoldSpaceKey || this.isHoldMiddleKey || (this.isHoldRightKey && this.dragger.moving) || this.isDragEmpty; }
     get isDragEmpty() { return this.config.move.dragEmpty && this.isRootPath(this.hoverData) && (!this.downData || this.isRootPath(this.downData)); }
+    get isMobileDragEmpty() { return this.config.move.dragEmpty && !this.config.pointer.hover && this.downData && this.isTreePath(this.downData); }
+    get isHoldMiddleKey() { return this.config.move.holdMiddleKey && this.downData && PointerButton.middle(this.downData); }
     get isHoldRightKey() { return this.config.move.holdRightKey && this.downData && PointerButton.right(this.downData); }
-    get moveMode() { return this.config.move.drag || (this.config.move.holdSpaceKey && Keyboard.isHoldSpaceKey()) || (this.downData && ((this.config.move.holdMiddleKey && PointerButton.middle(this.downData)) || (this.isHoldRightKey && this.dragger.moving))) || this.isDragEmpty; }
+    get isHoldSpaceKey() { return this.config.move.holdSpaceKey && Keyboard.isHoldSpaceKey(); }
     get hitRadius() { return this.config.pointer.hitRadius; }
     constructor(target, canvas, selector, userConfig) {
         this.config = config;
@@ -894,7 +937,8 @@ class InteractionBase {
             this.waitMenuTap = true;
         }
         this.dragger.setDragData(data);
-        this.updateCursor(data);
+        if (!this.isHoldRightKey)
+            this.updateCursor(data);
     }
     pointerMove(data) {
         if (!data)
@@ -912,9 +956,10 @@ class InteractionBase {
         }
     }
     pointerMoveReal(data) {
+        const { dragHover, dragDistance } = this.config.pointer;
         this.emit(exports.PointerEvent.BEFORE_MOVE, data, this.defaultPath);
         if (this.downData) {
-            const canDrag = core.PointHelper.getDistance(this.downData, data) > this.config.pointer.dragDistance;
+            const canDrag = core.PointHelper.getDistance(this.downData, data) > dragDistance;
             if (canDrag) {
                 if (this.waitTap)
                     this.pointerWaitCancel();
@@ -926,7 +971,7 @@ class InteractionBase {
             this.updateHoverData(data);
             this.checkPath(data);
             this.emit(exports.PointerEvent.MOVE, data);
-            if (!(this.dragging && !this.config.pointer.dragHover))
+            if (!(this.dragging && !dragHover))
                 this.pointerHover(data);
             if (this.dragger.dragging) {
                 this.dragger.dragOverOrOut(data);
@@ -942,20 +987,25 @@ class InteractionBase {
         if (!downData)
             return;
         PointerButton.defaultLeft(data);
-        this.downData = null;
         this.findPath(data);
+        const upData = Object.assign(Object.assign({}, data), { path: data.path.clone() });
         data.path.addList(downData.path.list);
         this.checkPath(data);
+        this.downData = null;
         this.emit(exports.PointerEvent.BEFORE_UP, data);
         this.emit(exports.PointerEvent.UP, data);
         this.touchLeave(data);
-        this.tap(data);
-        this.menuTap(data);
+        if (!data.isCancel) {
+            this.tap(data);
+            this.menuTap(data);
+        }
         this.dragger.dragEnd(data);
-        this.updateCursor(data);
+        this.updateCursor(upData);
     }
     pointerCancel() {
-        this.pointerUp(this.dragger.dragData);
+        const data = Object.assign({}, this.dragger.dragData);
+        data.isCancel = true;
+        this.pointerUp(data);
     }
     multiTouch(data, list) {
         const { move, angle, scale, center } = MultiTouchHelper.getData(list);
@@ -1005,8 +1055,10 @@ class InteractionBase {
             this.updateCursor();
     }
     pointerHover(data) {
-        this.pointerOverOrOut(data);
-        this.pointerEnterOrLeave(data);
+        if (this.config.pointer.hover) {
+            this.pointerOverOrOut(data);
+            this.pointerEnterOrLeave(data);
+        }
     }
     pointerOverOrOut(data) {
         const { path } = data;
@@ -1087,6 +1139,12 @@ class InteractionBase {
     isRootPath(data) {
         return data && data.path.list[0].isLeafer;
     }
+    isTreePath(data) {
+        const app = this.target.app;
+        if (!app || !app.isApp)
+            return false;
+        return app.editor && (!data.path.has(app.editor) && data.path.has(app.tree));
+    }
     checkPath(data, useDefaultPath) {
         if (useDefaultPath || this.canMove(data))
             data.path = this.defaultPath;
@@ -1133,7 +1191,7 @@ class InteractionBase {
         this.hoverData = data;
     }
     updateCursor(data) {
-        if (this.config.cursor.stop)
+        if (this.config.cursor.stop || !this.config.pointer.hover)
             return;
         if (!data) {
             this.updateHoverData();
@@ -1243,22 +1301,25 @@ Cursor.custom = {};
 class HitCanvasManager extends core.CanvasManager {
     constructor() {
         super(...arguments);
-        this.pathTypeList = new core.LeafList();
-        this.imageTypeList = new core.LeafList();
+        this.maxTotal = 1000;
+        this.pathList = new core.LeafList();
+        this.pixelList = new core.LeafList();
     }
-    getImageType(leaf, size) {
-        this.imageTypeList.add(leaf);
-        return core.Creator.hitCanvas(size);
+    getPixelType(leaf, config) {
+        this.__autoClear();
+        this.pixelList.add(leaf);
+        return core.Creator.hitCanvas(config);
     }
     getPathType(leaf) {
-        this.pathTypeList.add(leaf);
+        this.__autoClear();
+        this.pathList.add(leaf);
         return core.Creator.hitCanvas();
     }
     clearImageType() {
-        this.__clearLeafList(this.imageTypeList);
+        this.__clearLeafList(this.pixelList);
     }
     clearPathType() {
-        this.__clearLeafList(this.pathTypeList);
+        this.__clearLeafList(this.pathList);
     }
     __clearLeafList(leafList) {
         if (leafList.length) {
@@ -1271,56 +1332,117 @@ class HitCanvasManager extends core.CanvasManager {
             leafList.reset();
         }
     }
+    __autoClear() {
+        if (this.pathList.length + this.pixelList.length > this.maxTotal)
+            this.clear();
+    }
     clear() {
         this.clearPathType();
         this.clearImageType();
     }
 }
 
+const canvas = core.LeaferCanvasBase.prototype;
+canvas.hitFill = function (point, fillRule) {
+    return fillRule ? this.context.isPointInPath(point.x, point.y, fillRule) : this.context.isPointInPath(point.x, point.y);
+};
+canvas.hitStroke = function (point, strokeWidth) {
+    this.strokeWidth = strokeWidth;
+    return this.context.isPointInStroke(point.x, point.y);
+};
+canvas.hitPixel = function (radiusPoint, offset, scale = 1) {
+    let { x, y, radiusX, radiusY } = radiusPoint;
+    if (offset)
+        x -= offset.x, y -= offset.y;
+    core.tempBounds.set(x - radiusX, y - radiusY, radiusX * 2, radiusY * 2).scale(scale).ceil();
+    const { data } = this.context.getImageData(core.tempBounds.x, core.tempBounds.y, core.tempBounds.width, core.tempBounds.height);
+    for (let i = 0, len = data.length; i < len; i += 4) {
+        if (data[i + 3] > 0)
+            return true;
+    }
+    return data[3] > 0;
+};
+
 const { toInnerRadiusPointOf, copy, setRadius } = core.PointHelper;
 const inner = {};
-core.Leaf.prototype.__hitWorld = function (point) {
-    if (this.__layout.hitCanvasChanged || !this.__hitCanvas) {
-        this.__updateHitCanvas();
-        if (!this.__layout.boundsChanged)
-            this.__layout.hitCanvasChanged = false;
-    }
+const leaf = core.Leaf.prototype;
+leaf.__hitWorld = function (point) {
     if (this.__.hitRadius) {
         copy(inner, point), point = inner;
         setRadius(point, this.__.hitRadius);
     }
     toInnerRadiusPointOf(point, this.__world, inner);
-    if (this.__.hitBox) {
+    const { width, height } = this.__world;
+    const isSmall = width < 10 && height < 10;
+    if (this.__.hitBox || isSmall) {
         if (core.BoundsHelper.hitRadiusPoint(this.__layout.boxBounds, inner))
             return true;
+        if (isSmall)
+            return false;
+    }
+    if (this.__layout.hitCanvasChanged || !this.__hitCanvas) {
+        this.__updateHitCanvas();
+        if (!this.__layout.boundsChanged)
+            this.__layout.hitCanvasChanged = false;
     }
     return this.__hit(inner);
 };
+leaf.__hitFill = function (inner) { var _a; return (_a = this.__hitCanvas) === null || _a === void 0 ? void 0 : _a.hitFill(inner, this.__.windingRule); };
+leaf.__hitStroke = function (inner, strokeWidth) { var _a; return (_a = this.__hitCanvas) === null || _a === void 0 ? void 0 : _a.hitStroke(inner, strokeWidth); };
+leaf.__hitPixel = function (inner) { var _a; return (_a = this.__hitCanvas) === null || _a === void 0 ? void 0 : _a.hitPixel(inner, this.__layout.renderBounds, this.__hitCanvas.hitScale); };
+leaf.__drawHitPath = function (canvas) { if (canvas)
+    this.__drawRenderPath(canvas); };
 
-draw$1.UI.prototype.__updateHitCanvas = function () {
+const matrix = new core.Matrix();
+const ui$1 = draw.UI.prototype;
+ui$1.__updateHitCanvas = function () {
+    const data = this.__, { hitCanvasManager } = this.leafer;
+    const isHitPixelFill = data.__pixelFill && data.hitFill === 'pixel';
+    const isHitPixelStroke = data.__pixelStroke && data.hitStroke === 'pixel';
+    const isHitPixel = isHitPixelFill || isHitPixelStroke;
     if (!this.__hitCanvas)
-        this.__hitCanvas = this.leafer.hitCanvasManager.getPathType(this);
+        this.__hitCanvas = isHitPixel ? hitCanvasManager.getPixelType(this, { contextSettings: { willReadFrequently: true } }) : hitCanvasManager.getPathType(this);
     const h = this.__hitCanvas;
+    if (isHitPixel) {
+        const { renderBounds } = this.__layout;
+        const size = core.Platform.image.hitCanvasSize;
+        const scale = h.hitScale = core.tempBounds.set(0, 0, size, size).getFitMatrix(renderBounds, 0.5).a;
+        const { x, y, width, height } = core.tempBounds.set(renderBounds).scale(scale);
+        h.resize({ width, height, pixelRatio: 1 });
+        h.clear();
+        draw.ImageManager.patternLocked = true;
+        this.__renderShape(h, { matrix: matrix.setWith(this.__world).scaleWith(1 / scale).invertWith().translate(-x, -y) }, !isHitPixelFill, !isHitPixelStroke);
+        draw.ImageManager.patternLocked = false;
+        h.resetTransform();
+        data.__isHitPixel = true;
+    }
+    else {
+        data.__isHitPixel && (data.__isHitPixel = false);
+    }
     this.__drawHitPath(h);
-    h.setStrokeOptions(this.__);
+    h.setStrokeOptions(data);
 };
-draw$1.UI.prototype.__hit = function (inner) {
+ui$1.__hit = function (inner) {
     if (core.Platform.name === 'miniapp')
         this.__drawHitPath(this.__hitCanvas);
-    const { fill, hitFill, windingRule } = this.__;
-    const needHitFill = (fill && hitFill === 'path') || hitFill === 'all';
-    const isHitFill = this.__hitFill(inner, windingRule);
-    if (needHitFill && isHitFill)
+    const data = this.__;
+    if (data.__isHitPixel && this.__hitPixel(inner))
         return true;
-    const { stroke, hitStroke, __strokeWidth, strokeAlign } = this.__;
-    const needHitStroke = (stroke && hitStroke === 'path') || hitStroke === 'all';
+    const { hitFill } = data;
+    const needHitFillPath = ((data.fill && hitFill == 'path') || hitFill === 'all');
+    if (needHitFillPath && this.__hitFill(inner))
+        return true;
+    const { hitStroke, __strokeWidth } = data;
+    const needHitStrokePath = ((data.stroke && hitStroke == 'path') || hitStroke === 'all');
+    if (!needHitFillPath && !needHitStrokePath)
+        return false;
     const radiusWidth = inner.radiusX * 2;
     let hitWidth = radiusWidth;
-    if (needHitStroke) {
-        switch (strokeAlign) {
+    if (needHitStrokePath) {
+        switch (data.strokeAlign) {
             case 'inside':
                 hitWidth += __strokeWidth * 2;
-                if (!needHitFill && (isHitFill && this.__hitStroke(inner, hitWidth)))
+                if (!needHitFillPath && this.__hitFill(inner) && this.__hitStroke(inner, hitWidth))
                     return true;
                 hitWidth = radiusWidth;
                 break;
@@ -1329,8 +1451,8 @@ draw$1.UI.prototype.__hit = function (inner) {
                 break;
             case 'outside':
                 hitWidth += __strokeWidth * 2;
-                if (!needHitFill) {
-                    if (!isHitFill && this.__hitStroke(inner, hitWidth))
+                if (!needHitFillPath) {
+                    if (!this.__hitFill(inner) && this.__hitStroke(inner, hitWidth))
                         return true;
                     hitWidth = radiusWidth;
                 }
@@ -1340,22 +1462,22 @@ draw$1.UI.prototype.__hit = function (inner) {
     return hitWidth ? this.__hitStroke(inner, hitWidth) : false;
 };
 
-const ui = new draw$1.UI();
-draw$1.Rect.prototype.__updateHitCanvas = function () {
+const ui = new draw.UI();
+draw.Rect.prototype.__updateHitCanvas = function () {
     if (this.stroke || this.cornerRadius)
         ui.__updateHitCanvas.call(this);
 };
-draw$1.Rect.prototype.__hitFill = function (inner, windingRule) {
-    return this.__hitCanvas ? ui.__hitFill.call(this, inner, windingRule) : core.BoundsHelper.hitRadiusPoint(this.__layout.boxBounds, inner);
+draw.Rect.prototype.__hitFill = function (inner) {
+    return this.__hitCanvas ? ui.__hitFill.call(this, inner) : core.BoundsHelper.hitRadiusPoint(this.__layout.boxBounds, inner);
 };
 
-draw$1.UI.prototype.find = function (condition, options) {
+draw.UI.prototype.find = function (condition, options) {
     return this.leafer ? this.leafer.selector.getBy(condition, this, false, options) : [];
 };
-draw$1.UI.prototype.findOne = function (condition, options) {
+draw.UI.prototype.findOne = function (condition, options) {
     return this.leafer ? this.leafer.selector.getBy(condition, this, true, options) : null;
 };
-draw$1.Group.prototype.pick = function (hitPoint, options) {
+draw.Group.prototype.pick = function (hitPoint, options) {
     this.__layout.update();
     if (!options)
         options = {};
@@ -1371,9 +1493,9 @@ exports.LeaferTypeCreator = LeaferTypeCreator;
 exports.MultiTouchHelper = MultiTouchHelper;
 exports.PointerButton = PointerButton;
 exports.UIEvent = UIEvent;
-Object.keys(draw$1).forEach(function (k) {
+Object.keys(draw).forEach(function (k) {
     if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
         enumerable: true,
-        get: function () { return draw$1[k]; }
+        get: function () { return draw[k]; }
     });
 });