Skip to content

Instantly share code, notes, and snippets.

@jtenner

jtenner/index.js

Last active November 14, 2017 22:40
Show Gist options
  • Save jtenner/d7d0641580f74ec913bc190aad43aa9e to your computer and use it in GitHub Desktop.
Save jtenner/d7d0641580f74ec913bc190aad43aa9e to your computer and use it in GitHub Desktop.
Download ZIP
requirebin sketch
Raw
index.js
const rbush = require( "rbush" );
const ctx = document.createElement( "canvas" ).getContext( "2d" );
const width = ctx.canvas.width = 800;
const height = ctx.canvas.height = 600;
const e2d = require( "e2d" );
document.body.appendChild( ctx.canvas );
const tree = rbush();
const rects = [];
for ( let i = 0; i < 100; i++ ) {
const rectWidth = 10 + Math.random() * 90;
const rectHeight = 10 + Math.random() * 90;
const minX = 0 + Math.random() * ( width - rectWidth );
const minY = 0 + Math.random() * ( height - rectHeight );
const maxX = minX + rectWidth;
const maxY = minY + rectHeight;
const rect = {
rectWidth,
rectHeight,
minX,
minY,
maxX,
maxY,
fill: e2d.fillRect( minX, minY, rectWidth, rectHeight ),
};
rects.push( e2d.strokeRect( minX, minY, rectWidth, rectHeight ) );
tree.insert( rect );
}
e2d.initialize( ctx );
e2d.raf(frame => {
const { x, y } = e2d.mouseData( ctx );
const mouseRect = e2d.fillStyle( "red", e2d.strokeRect( x - 10, y - 10, 20, 20 ) );
e2d.render(
e2d.clearRect( width, height ),
tree.search({
minX: x - 10,
minY: y - 10,
maxX: x + 10,
maxY: y + 10
}).map(z => z.fill),
mouseRect,
rects,
ctx
);
});
Raw
minified.js
setTimeout(function(){
;require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
'use strict';
module.exports = partialSort;
// Floyd-Rivest selection algorithm:
// Rearrange items so that all items in the [left, k] range are smaller than all items in (k, right];
// The k-th element will have the (k - left + 1)th smallest value in [left, right]
function partialSort(arr, k, left, right, compare) {
left = left || 0;
right = right || (arr.length - 1);
compare = compare || defaultCompare;
while (right > left) {
if (right - left > 600) {
var n = right - left + 1;
var m = k - left + 1;
var z = Math.log(n);
var s = 0.5 * Math.exp(2 * z / 3);
var sd = 0.5 * Math.sqrt(z * s * (n - s) / n) * (m - n / 2 < 0 ? -1 : 1);
var newLeft = Math.max(left, Math.floor(k - m * s / n + sd));
var newRight = Math.min(right, Math.floor(k + (n - m) * s / n + sd));
partialSort(arr, k, newLeft, newRight, compare);
}
var t = arr[k];
var i = left;
var j = right;
swap(arr, left, k);
if (compare(arr[right], t) > 0) swap(arr, left, right);
while (i < j) {
swap(arr, i, j);
i++;
j--;
while (compare(arr[i], t) < 0) i++;
while (compare(arr[j], t) > 0) j--;
}
if (compare(arr[left], t) === 0) swap(arr, left, j);
else {
j++;
swap(arr, j, right);
}
if (j <= k) left = j + 1;
if (k <= j) right = j - 1;
}
}
function swap(arr, i, j) {
var tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
function defaultCompare(a, b) {
return a < b ? -1 : a > b ? 1 : 0;
}
},{}],"rbush":[function(require,module,exports){
'use strict';
module.exports = rbush;
var quickselect = require('quickselect');
function rbush(maxEntries, format) {
if (!(this instanceof rbush)) return new rbush(maxEntries, format);
// max entries in a node is 9 by default; min node fill is 40% for best performance
this._maxEntries = Math.max(4, maxEntries || 9);
this._minEntries = Math.max(2, Math.ceil(this._maxEntries * 0.4));
if (format) {
this._initFormat(format);
}
this.clear();
}
rbush.prototype = {
all: function () {
return this._all(this.data, []);
},
search: function (bbox) {
var node = this.data,
result = [],
toBBox = this.toBBox;
if (!intersects(bbox, node)) return result;
var nodesToSearch = [],
i, len, child, childBBox;
while (node) {
for (i = 0, len = node.children.length; i < len; i++) {
child = node.children[i];
childBBox = node.leaf ? toBBox(child) : child;
if (intersects(bbox, childBBox)) {
if (node.leaf) result.push(child);
else if (contains(bbox, childBBox)) this._all(child, result);
else nodesToSearch.push(child);
}
}
node = nodesToSearch.pop();
}
return result;
},
collides: function (bbox) {
var node = this.data,
toBBox = this.toBBox;
if (!intersects(bbox, node)) return false;
var nodesToSearch = [],
i, len, child, childBBox;
while (node) {
for (i = 0, len = node.children.length; i < len; i++) {
child = node.children[i];
childBBox = node.leaf ? toBBox(child) : child;
if (intersects(bbox, childBBox)) {
if (node.leaf || contains(bbox, childBBox)) return true;
nodesToSearch.push(child);
}
}
node = nodesToSearch.pop();
}
return false;
},
load: function (data) {
if (!(data && data.length)) return this;
if (data.length < this._minEntries) {
for (var i = 0, len = data.length; i < len; i++) {
this.insert(data[i]);
}
return this;
}
// recursively build the tree with the given data from stratch using OMT algorithm
var node = this._build(data.slice(), 0, data.length - 1, 0);
if (!this.data.children.length) {
// save as is if tree is empty
this.data = node;
} else if (this.data.height === node.height) {
// split root if trees have the same height
this._splitRoot(this.data, node);
} else {
if (this.data.height < node.height) {
// swap trees if inserted one is bigger
var tmpNode = this.data;
this.data = node;
node = tmpNode;
}
// insert the small tree into the large tree at appropriate level
this._insert(node, this.data.height - node.height - 1, true);
}
return this;
},
insert: function (item) {
if (item) this._insert(item, this.data.height - 1);
return this;
},
clear: function () {
this.data = createNode([]);
return this;
},
remove: function (item, equalsFn) {
if (!item) return this;
var node = this.data,
bbox = this.toBBox(item),
path = [],
indexes = [],
i, parent, index, goingUp;
// depth-first iterative tree traversal
while (node || path.length) {
if (!node) { // go up
node = path.pop();
parent = path[path.length - 1];
i = indexes.pop();
goingUp = true;
}
if (node.leaf) { // check current node
index = findItem(item, node.children, equalsFn);
if (index !== -1) {
// item found, remove the item and condense tree upwards
node.children.splice(index, 1);
path.push(node);
this._condense(path);
return this;
}
}
if (!goingUp && !node.leaf && contains(node, bbox)) { // go down
path.push(node);
indexes.push(i);
i = 0;
parent = node;
node = node.children[0];
} else if (parent) { // go right
i++;
node = parent.children[i];
goingUp = false;
} else node = null; // nothing found
}
return this;
},
toBBox: function (item) { return item; },
compareMinX: compareNodeMinX,
compareMinY: compareNodeMinY,
toJSON: function () { return this.data; },
fromJSON: function (data) {
this.data = data;
return this;
},
_all: function (node, result) {
var nodesToSearch = [];
while (node) {
if (node.leaf) result.push.apply(result, node.children);
else nodesToSearch.push.apply(nodesToSearch, node.children);
node = nodesToSearch.pop();
}
return result;
},
_build: function (items, left, right, height) {
var N = right - left + 1,
M = this._maxEntries,
node;
if (N <= M) {
// reached leaf level; return leaf
node = createNode(items.slice(left, right + 1));
calcBBox(node, this.toBBox);
return node;
}
if (!height) {
// target height of the bulk-loaded tree
height = Math.ceil(Math.log(N) / Math.log(M));
// target number of root entries to maximize storage utilization
M = Math.ceil(N / Math.pow(M, height - 1));
}
node = createNode([]);
node.leaf = false;
node.height = height;
// split the items into M mostly square tiles
var N2 = Math.ceil(N / M),
N1 = N2 * Math.ceil(Math.sqrt(M)),
i, j, right2, right3;
multiSelect(items, left, right, N1, this.compareMinX);
for (i = left; i <= right; i += N1) {
right2 = Math.min(i + N1 - 1, right);
multiSelect(items, i, right2, N2, this.compareMinY);
for (j = i; j <= right2; j += N2) {
right3 = Math.min(j + N2 - 1, right2);
// pack each entry recursively
node.children.push(this._build(items, j, right3, height - 1));
}
}
calcBBox(node, this.toBBox);
return node;
},
_chooseSubtree: function (bbox, node, level, path) {
var i, len, child, targetNode, area, enlargement, minArea, minEnlargement;
while (true) {
path.push(node);
if (node.leaf || path.length - 1 === level) break;
minArea = minEnlargement = Infinity;
for (i = 0, len = node.children.length; i < len; i++) {
child = node.children[i];
area = bboxArea(child);
enlargement = enlargedArea(bbox, child) - area;
// choose entry with the least area enlargement
if (enlargement < minEnlargement) {
minEnlargement = enlargement;
minArea = area < minArea ? area : minArea;
targetNode = child;
} else if (enlargement === minEnlargement) {
// otherwise choose one with the smallest area
if (area < minArea) {
minArea = area;
targetNode = child;
}
}
}
node = targetNode || node.children[0];
}
return node;
},
_insert: function (item, level, isNode) {
var toBBox = this.toBBox,
bbox = isNode ? item : toBBox(item),
insertPath = [];
// find the best node for accommodating the item, saving all nodes along the path too
var node = this._chooseSubtree(bbox, this.data, level, insertPath);
// put the item into the node
node.children.push(item);
extend(node, bbox);
// split on node overflow; propagate upwards if necessary
while (level >= 0) {
if (insertPath[level].children.length > this._maxEntries) {
this._split(insertPath, level);
level--;
} else break;
}
// adjust bboxes along the insertion path
this._adjustParentBBoxes(bbox, insertPath, level);
},
// split overflowed node into two
_split: function (insertPath, level) {
var node = insertPath[level],
M = node.children.length,
m = this._minEntries;
this._chooseSplitAxis(node, m, M);
var splitIndex = this._chooseSplitIndex(node, m, M);
var newNode = createNode(node.children.splice(splitIndex, node.children.length - splitIndex));
newNode.height = node.height;
newNode.leaf = node.leaf;
calcBBox(node, this.toBBox);
calcBBox(newNode, this.toBBox);
if (level) insertPath[level - 1].children.push(newNode);
else this._splitRoot(node, newNode);
},
_splitRoot: function (node, newNode) {
// split root node
this.data = createNode([node, newNode]);
this.data.height = node.height + 1;
this.data.leaf = false;
calcBBox(this.data, this.toBBox);
},
_chooseSplitIndex: function (node, m, M) {
var i, bbox1, bbox2, overlap, area, minOverlap, minArea, index;
minOverlap = minArea = Infinity;
for (i = m; i <= M - m; i++) {
bbox1 = distBBox(node, 0, i, this.toBBox);
bbox2 = distBBox(node, i, M, this.toBBox);
overlap = intersectionArea(bbox1, bbox2);
area = bboxArea(bbox1) + bboxArea(bbox2);
// choose distribution with minimum overlap
if (overlap < minOverlap) {
minOverlap = overlap;
index = i;
minArea = area < minArea ? area : minArea;
} else if (overlap === minOverlap) {
// otherwise choose distribution with minimum area
if (area < minArea) {
minArea = area;
index = i;
}
}
}
return index;
},
// sorts node children by the best axis for split
_chooseSplitAxis: function (node, m, M) {
var compareMinX = node.leaf ? this.compareMinX : compareNodeMinX,
compareMinY = node.leaf ? this.compareMinY : compareNodeMinY,
xMargin = this._allDistMargin(node, m, M, compareMinX),
yMargin = this._allDistMargin(node, m, M, compareMinY);
// if total distributions margin value is minimal for x, sort by minX,
// otherwise it's already sorted by minY
if (xMargin < yMargin) node.children.sort(compareMinX);
},
// total margin of all possible split distributions where each node is at least m full
_allDistMargin: function (node, m, M, compare) {
node.children.sort(compare);
var toBBox = this.toBBox,
leftBBox = distBBox(node, 0, m, toBBox),
rightBBox = distBBox(node, M - m, M, toBBox),
margin = bboxMargin(leftBBox) + bboxMargin(rightBBox),
i, child;
for (i = m; i < M - m; i++) {
child = node.children[i];
extend(leftBBox, node.leaf ? toBBox(child) : child);
margin += bboxMargin(leftBBox);
}
for (i = M - m - 1; i >= m; i--) {
child = node.children[i];
extend(rightBBox, node.leaf ? toBBox(child) : child);
margin += bboxMargin(rightBBox);
}
return margin;
},
_adjustParentBBoxes: function (bbox, path, level) {
// adjust bboxes along the given tree path
for (var i = level; i >= 0; i--) {
extend(path[i], bbox);
}
},
_condense: function (path) {
// go through the path, removing empty nodes and updating bboxes
for (var i = path.length - 1, siblings; i >= 0; i--) {
if (path[i].children.length === 0) {
if (i > 0) {
siblings = path[i - 1].children;
siblings.splice(siblings.indexOf(path[i]), 1);
} else this.clear();
} else calcBBox(path[i], this.toBBox);
}
},
_initFormat: function (format) {
// data format (minX, minY, maxX, maxY accessors)
// uses eval-type function compilation instead of just accepting a toBBox function
// because the algorithms are very sensitive to sorting functions performance,
// so they should be dead simple and without inner calls
var compareArr = ['return a', ' - b', ';'];
this.compareMinX = new Function('a', 'b', compareArr.join(format[0]));
this.compareMinY = new Function('a', 'b', compareArr.join(format[1]));
this.toBBox = new Function('a',
'return {minX: a' + format[0] +
', minY: a' + format[1] +
', maxX: a' + format[2] +
', maxY: a' + format[3] + '};');
}
};
function findItem(item, items, equalsFn) {
if (!equalsFn) return items.indexOf(item);
for (var i = 0; i < items.length; i++) {
if (equalsFn(item, items[i])) return i;
}
return -1;
}
// calculate node's bbox from bboxes of its children
function calcBBox(node, toBBox) {
distBBox(node, 0, node.children.length, toBBox, node);
}
// min bounding rectangle of node children from k to p-1
function distBBox(node, k, p, toBBox, destNode) {
if (!destNode) destNode = createNode(null);
destNode.minX = Infinity;
destNode.minY = Infinity;
destNode.maxX = -Infinity;
destNode.maxY = -Infinity;
for (var i = k, child; i < p; i++) {
child = node.children[i];
extend(destNode, node.leaf ? toBBox(child) : child);
}
return destNode;
}
function extend(a, b) {
a.minX = Math.min(a.minX, b.minX);
a.minY = Math.min(a.minY, b.minY);
a.maxX = Math.max(a.maxX, b.maxX);
a.maxY = Math.max(a.maxY, b.maxY);
return a;
}
function compareNodeMinX(a, b) { return a.minX - b.minX; }
function compareNodeMinY(a, b) { return a.minY - b.minY; }
function bboxArea(a) { return (a.maxX - a.minX) * (a.maxY - a.minY); }
function bboxMargin(a) { return (a.maxX - a.minX) + (a.maxY - a.minY); }
function enlargedArea(a, b) {
return (Math.max(b.maxX, a.maxX) - Math.min(b.minX, a.minX)) *
(Math.max(b.maxY, a.maxY) - Math.min(b.minY, a.minY));
}
function intersectionArea(a, b) {
var minX = Math.max(a.minX, b.minX),
minY = Math.max(a.minY, b.minY),
maxX = Math.min(a.maxX, b.maxX),
maxY = Math.min(a.maxY, b.maxY);
return Math.max(0, maxX - minX) *
Math.max(0, maxY - minY);
}
function contains(a, b) {
return a.minX <= b.minX &&
a.minY <= b.minY &&
b.maxX <= a.maxX &&
b.maxY <= a.maxY;
}
function intersects(a, b) {
return b.minX <= a.maxX &&
b.minY <= a.maxY &&
b.maxX >= a.minX &&
b.maxY >= a.minY;
}
function createNode(children) {
return {
children: children,
height: 1,
leaf: true,
minX: Infinity,
minY: Infinity,
maxX: -Infinity,
maxY: -Infinity
};
}
// sort an array so that items come in groups of n unsorted items, with groups sorted between each other;
// combines selection algorithm with binary divide & conquer approach
function multiSelect(arr, left, right, n, compare) {
var stack = [left, right],
mid;
while (stack.length) {
right = stack.pop();
left = stack.pop();
if (right - left <= n) continue;
mid = left + Math.ceil((right - left) / n / 2) * n;
quickselect(arr, mid, left, right, compare);
stack.push(left, mid, mid, right);
}
}
},{"quickselect":1}]},{},[])
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../home/admin/browserify-cdn/node_modules/browserify/node_modules/browser-pack/_prelude.js","node_modules/quickselect/index.js","rbush"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC5DA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","'use strict';\n\nmodule.exports = partialSort;\n\n// Floyd-Rivest selection algorithm:\n// Rearrange items so that all items in the [left, k] range are smaller than all items in (k, right];\n// The k-th element will have the (k - left + 1)th smallest value in [left, right]\n\nfunction partialSort(arr, k, left, right, compare) {\n    left = left || 0;\n    right = right || (arr.length - 1);\n    compare = compare || defaultCompare;\n\n    while (right > left) {\n        if (right - left > 600) {\n            var n = right - left + 1;\n            var m = k - left + 1;\n            var z = Math.log(n);\n            var s = 0.5 * Math.exp(2 * z / 3);\n            var sd = 0.5 * Math.sqrt(z * s * (n - s) / n) * (m - n / 2 < 0 ? -1 : 1);\n            var newLeft = Math.max(left, Math.floor(k - m * s / n + sd));\n            var newRight = Math.min(right, Math.floor(k + (n - m) * s / n + sd));\n            partialSort(arr, k, newLeft, newRight, compare);\n        }\n\n        var t = arr[k];\n        var i = left;\n        var j = right;\n\n        swap(arr, left, k);\n        if (compare(arr[right], t) > 0) swap(arr, left, right);\n\n        while (i < j) {\n            swap(arr, i, j);\n            i++;\n            j--;\n            while (compare(arr[i], t) < 0) i++;\n            while (compare(arr[j], t) > 0) j--;\n        }\n\n        if (compare(arr[left], t) === 0) swap(arr, left, j);\n        else {\n            j++;\n            swap(arr, j, right);\n        }\n\n        if (j <= k) left = j + 1;\n        if (k <= j) right = j - 1;\n    }\n}\n\nfunction swap(arr, i, j) {\n    var tmp = arr[i];\n    arr[i] = arr[j];\n    arr[j] = tmp;\n}\n\nfunction defaultCompare(a, b) {\n    return a < b ? -1 : a > b ? 1 : 0;\n}\n","'use strict';\n\nmodule.exports = rbush;\n\nvar quickselect = require('quickselect');\n\nfunction rbush(maxEntries, format) {\n    if (!(this instanceof rbush)) return new rbush(maxEntries, format);\n\n    // max entries in a node is 9 by default; min node fill is 40% for best performance\n    this._maxEntries = Math.max(4, maxEntries || 9);\n    this._minEntries = Math.max(2, Math.ceil(this._maxEntries * 0.4));\n\n    if (format) {\n        this._initFormat(format);\n    }\n\n    this.clear();\n}\n\nrbush.prototype = {\n\n    all: function () {\n        return this._all(this.data, []);\n    },\n\n    search: function (bbox) {\n\n        var node = this.data,\n            result = [],\n            toBBox = this.toBBox;\n\n        if (!intersects(bbox, node)) return result;\n\n        var nodesToSearch = [],\n            i, len, child, childBBox;\n\n        while (node) {\n            for (i = 0, len = node.children.length; i < len; i++) {\n\n                child = node.children[i];\n                childBBox = node.leaf ? toBBox(child) : child;\n\n                if (intersects(bbox, childBBox)) {\n                    if (node.leaf) result.push(child);\n                    else if (contains(bbox, childBBox)) this._all(child, result);\n                    else nodesToSearch.push(child);\n                }\n            }\n            node = nodesToSearch.pop();\n        }\n\n        return result;\n    },\n\n    collides: function (bbox) {\n\n        var node = this.data,\n            toBBox = this.toBBox;\n\n        if (!intersects(bbox, node)) return false;\n\n        var nodesToSearch = [],\n            i, len, child, childBBox;\n\n        while (node) {\n            for (i = 0, len = node.children.length; i < len; i++) {\n\n                child = node.children[i];\n                childBBox = node.leaf ? toBBox(child) : child;\n\n                if (intersects(bbox, childBBox)) {\n                    if (node.leaf || contains(bbox, childBBox)) return true;\n                    nodesToSearch.push(child);\n                }\n            }\n            node = nodesToSearch.pop();\n        }\n\n        return false;\n    },\n\n    load: function (data) {\n        if (!(data && data.length)) return this;\n\n        if (data.length < this._minEntries) {\n            for (var i = 0, len = data.length; i < len; i++) {\n                this.insert(data[i]);\n            }\n            return this;\n        }\n\n        // recursively build the tree with the given data from stratch using OMT algorithm\n        var node = this._build(data.slice(), 0, data.length - 1, 0);\n\n        if (!this.data.children.length) {\n            // save as is if tree is empty\n            this.data = node;\n\n        } else if (this.data.height === node.height) {\n            // split root if trees have the same height\n            this._splitRoot(this.data, node);\n\n        } else {\n            if (this.data.height < node.height) {\n                // swap trees if inserted one is bigger\n                var tmpNode = this.data;\n                this.data = node;\n                node = tmpNode;\n            }\n\n            // insert the small tree into the large tree at appropriate level\n            this._insert(node, this.data.height - node.height - 1, true);\n        }\n\n        return this;\n    },\n\n    insert: function (item) {\n        if (item) this._insert(item, this.data.height - 1);\n        return this;\n    },\n\n    clear: function () {\n        this.data = createNode([]);\n        return this;\n    },\n\n    remove: function (item, equalsFn) {\n        if (!item) return this;\n\n        var node = this.data,\n            bbox = this.toBBox(item),\n            path = [],\n            indexes = [],\n            i, parent, index, goingUp;\n\n        // depth-first iterative tree traversal\n        while (node || path.length) {\n\n            if (!node) { // go up\n                node = path.pop();\n                parent = path[path.length - 1];\n                i = indexes.pop();\n                goingUp = true;\n            }\n\n            if (node.leaf) { // check current node\n                index = findItem(item, node.children, equalsFn);\n\n                if (index !== -1) {\n                    // item found, remove the item and condense tree upwards\n                    node.children.splice(index, 1);\n                    path.push(node);\n                    this._condense(path);\n                    return this;\n                }\n            }\n\n            if (!goingUp && !node.leaf && contains(node, bbox)) { // go down\n                path.push(node);\n                indexes.push(i);\n                i = 0;\n                parent = node;\n                node = node.children[0];\n\n            } else if (parent) { // go right\n                i++;\n                node = parent.children[i];\n                goingUp = false;\n\n            } else node = null; // nothing found\n        }\n\n        return this;\n    },\n\n    toBBox: function (item) { return item; },\n\n    compareMinX: compareNodeMinX,\n    compareMinY: compareNodeMinY,\n\n    toJSON: function () { return this.data; },\n\n    fromJSON: function (data) {\n        this.data = data;\n        return this;\n    },\n\n    _all: function (node, result) {\n        var nodesToSearch = [];\n        while (node) {\n            if (node.leaf) result.push.apply(result, node.children);\n            else nodesToSearch.push.apply(nodesToSearch, node.children);\n\n            node = nodesToSearch.pop();\n        }\n        return result;\n    },\n\n    _build: function (items, left, right, height) {\n\n        var N = right - left + 1,\n            M = this._maxEntries,\n            node;\n\n        if (N <= M) {\n            // reached leaf level; return leaf\n            node = createNode(items.slice(left, right + 1));\n            calcBBox(node, this.toBBox);\n            return node;\n        }\n\n        if (!height) {\n            // target height of the bulk-loaded tree\n            height = Math.ceil(Math.log(N) / Math.log(M));\n\n            // target number of root entries to maximize storage utilization\n            M = Math.ceil(N / Math.pow(M, height - 1));\n        }\n\n        node = createNode([]);\n        node.leaf = false;\n        node.height = height;\n\n        // split the items into M mostly square tiles\n\n        var N2 = Math.ceil(N / M),\n            N1 = N2 * Math.ceil(Math.sqrt(M)),\n            i, j, right2, right3;\n\n        multiSelect(items, left, right, N1, this.compareMinX);\n\n        for (i = left; i <= right; i += N1) {\n\n            right2 = Math.min(i + N1 - 1, right);\n\n            multiSelect(items, i, right2, N2, this.compareMinY);\n\n            for (j = i; j <= right2; j += N2) {\n\n                right3 = Math.min(j + N2 - 1, right2);\n\n                // pack each entry recursively\n                node.children.push(this._build(items, j, right3, height - 1));\n            }\n        }\n\n        calcBBox(node, this.toBBox);\n\n        return node;\n    },\n\n    _chooseSubtree: function (bbox, node, level, path) {\n\n        var i, len, child, targetNode, area, enlargement, minArea, minEnlargement;\n\n        while (true) {\n            path.push(node);\n\n            if (node.leaf || path.length - 1 === level) break;\n\n            minArea = minEnlargement = Infinity;\n\n            for (i = 0, len = node.children.length; i < len; i++) {\n                child = node.children[i];\n                area = bboxArea(child);\n                enlargement = enlargedArea(bbox, child) - area;\n\n                // choose entry with the least area enlargement\n                if (enlargement < minEnlargement) {\n                    minEnlargement = enlargement;\n                    minArea = area < minArea ? area : minArea;\n                    targetNode = child;\n\n                } else if (enlargement === minEnlargement) {\n                    // otherwise choose one with the smallest area\n                    if (area < minArea) {\n                        minArea = area;\n                        targetNode = child;\n                    }\n                }\n            }\n\n            node = targetNode || node.children[0];\n        }\n\n        return node;\n    },\n\n    _insert: function (item, level, isNode) {\n\n        var toBBox = this.toBBox,\n            bbox = isNode ? item : toBBox(item),\n            insertPath = [];\n\n        // find the best node for accommodating the item, saving all nodes along the path too\n        var node = this._chooseSubtree(bbox, this.data, level, insertPath);\n\n        // put the item into the node\n        node.children.push(item);\n        extend(node, bbox);\n\n        // split on node overflow; propagate upwards if necessary\n        while (level >= 0) {\n            if (insertPath[level].children.length > this._maxEntries) {\n                this._split(insertPath, level);\n                level--;\n            } else break;\n        }\n\n        // adjust bboxes along the insertion path\n        this._adjustParentBBoxes(bbox, insertPath, level);\n    },\n\n    // split overflowed node into two\n    _split: function (insertPath, level) {\n\n        var node = insertPath[level],\n            M = node.children.length,\n            m = this._minEntries;\n\n        this._chooseSplitAxis(node, m, M);\n\n        var splitIndex = this._chooseSplitIndex(node, m, M);\n\n        var newNode = createNode(node.children.splice(splitIndex, node.children.length - splitIndex));\n        newNode.height = node.height;\n        newNode.leaf = node.leaf;\n\n        calcBBox(node, this.toBBox);\n        calcBBox(newNode, this.toBBox);\n\n        if (level) insertPath[level - 1].children.push(newNode);\n        else this._splitRoot(node, newNode);\n    },\n\n    _splitRoot: function (node, newNode) {\n        // split root node\n        this.data = createNode([node, newNode]);\n        this.data.height = node.height + 1;\n        this.data.leaf = false;\n        calcBBox(this.data, this.toBBox);\n    },\n\n    _chooseSplitIndex: function (node, m, M) {\n\n        var i, bbox1, bbox2, overlap, area, minOverlap, minArea, index;\n\n        minOverlap = minArea = Infinity;\n\n        for (i = m; i <= M - m; i++) {\n            bbox1 = distBBox(node, 0, i, this.toBBox);\n            bbox2 = distBBox(node, i, M, this.toBBox);\n\n            overlap = intersectionArea(bbox1, bbox2);\n            area = bboxArea(bbox1) + bboxArea(bbox2);\n\n            // choose distribution with minimum overlap\n            if (overlap < minOverlap) {\n                minOverlap = overlap;\n                index = i;\n\n                minArea = area < minArea ? area : minArea;\n\n            } else if (overlap === minOverlap) {\n                // otherwise choose distribution with minimum area\n                if (area < minArea) {\n                    minArea = area;\n                    index = i;\n                }\n            }\n        }\n\n        return index;\n    },\n\n    // sorts node children by the best axis for split\n    _chooseSplitAxis: function (node, m, M) {\n\n        var compareMinX = node.leaf ? this.compareMinX : compareNodeMinX,\n            compareMinY = node.leaf ? this.compareMinY : compareNodeMinY,\n            xMargin = this._allDistMargin(node, m, M, compareMinX),\n            yMargin = this._allDistMargin(node, m, M, compareMinY);\n\n        // if total distributions margin value is minimal for x, sort by minX,\n        // otherwise it's already sorted by minY\n        if (xMargin < yMargin) node.children.sort(compareMinX);\n    },\n\n    // total margin of all possible split distributions where each node is at least m full\n    _allDistMargin: function (node, m, M, compare) {\n\n        node.children.sort(compare);\n\n        var toBBox = this.toBBox,\n            leftBBox = distBBox(node, 0, m, toBBox),\n            rightBBox = distBBox(node, M - m, M, toBBox),\n            margin = bboxMargin(leftBBox) + bboxMargin(rightBBox),\n            i, child;\n\n        for (i = m; i < M - m; i++) {\n            child = node.children[i];\n            extend(leftBBox, node.leaf ? toBBox(child) : child);\n            margin += bboxMargin(leftBBox);\n        }\n\n        for (i = M - m - 1; i >= m; i--) {\n            child = node.children[i];\n            extend(rightBBox, node.leaf ? toBBox(child) : child);\n            margin += bboxMargin(rightBBox);\n        }\n\n        return margin;\n    },\n\n    _adjustParentBBoxes: function (bbox, path, level) {\n        // adjust bboxes along the given tree path\n        for (var i = level; i >= 0; i--) {\n            extend(path[i], bbox);\n        }\n    },\n\n    _condense: function (path) {\n        // go through the path, removing empty nodes and updating bboxes\n        for (var i = path.length - 1, siblings; i >= 0; i--) {\n            if (path[i].children.length === 0) {\n                if (i > 0) {\n                    siblings = path[i - 1].children;\n                    siblings.splice(siblings.indexOf(path[i]), 1);\n\n                } else this.clear();\n\n            } else calcBBox(path[i], this.toBBox);\n        }\n    },\n\n    _initFormat: function (format) {\n        // data format (minX, minY, maxX, maxY accessors)\n\n        // uses eval-type function compilation instead of just accepting a toBBox function\n        // because the algorithms are very sensitive to sorting functions performance,\n        // so they should be dead simple and without inner calls\n\n        var compareArr = ['return a', ' - b', ';'];\n\n        this.compareMinX = new Function('a', 'b', compareArr.join(format[0]));\n        this.compareMinY = new Function('a', 'b', compareArr.join(format[1]));\n\n        this.toBBox = new Function('a',\n            'return {minX: a' + format[0] +\n            ', minY: a' + format[1] +\n            ', maxX: a' + format[2] +\n            ', maxY: a' + format[3] + '};');\n    }\n};\n\nfunction findItem(item, items, equalsFn) {\n    if (!equalsFn) return items.indexOf(item);\n\n    for (var i = 0; i < items.length; i++) {\n        if (equalsFn(item, items[i])) return i;\n    }\n    return -1;\n}\n\n// calculate node's bbox from bboxes of its children\nfunction calcBBox(node, toBBox) {\n    distBBox(node, 0, node.children.length, toBBox, node);\n}\n\n// min bounding rectangle of node children from k to p-1\nfunction distBBox(node, k, p, toBBox, destNode) {\n    if (!destNode) destNode = createNode(null);\n    destNode.minX = Infinity;\n    destNode.minY = Infinity;\n    destNode.maxX = -Infinity;\n    destNode.maxY = -Infinity;\n\n    for (var i = k, child; i < p; i++) {\n        child = node.children[i];\n        extend(destNode, node.leaf ? toBBox(child) : child);\n    }\n\n    return destNode;\n}\n\nfunction extend(a, b) {\n    a.minX = Math.min(a.minX, b.minX);\n    a.minY = Math.min(a.minY, b.minY);\n    a.maxX = Math.max(a.maxX, b.maxX);\n    a.maxY = Math.max(a.maxY, b.maxY);\n    return a;\n}\n\nfunction compareNodeMinX(a, b) { return a.minX - b.minX; }\nfunction compareNodeMinY(a, b) { return a.minY - b.minY; }\n\nfunction bboxArea(a)   { return (a.maxX - a.minX) * (a.maxY - a.minY); }\nfunction bboxMargin(a) { return (a.maxX - a.minX) + (a.maxY - a.minY); }\n\nfunction enlargedArea(a, b) {\n    return (Math.max(b.maxX, a.maxX) - Math.min(b.minX, a.minX)) *\n           (Math.max(b.maxY, a.maxY) - Math.min(b.minY, a.minY));\n}\n\nfunction intersectionArea(a, b) {\n    var minX = Math.max(a.minX, b.minX),\n        minY = Math.max(a.minY, b.minY),\n        maxX = Math.min(a.maxX, b.maxX),\n        maxY = Math.min(a.maxY, b.maxY);\n\n    return Math.max(0, maxX - minX) *\n           Math.max(0, maxY - minY);\n}\n\nfunction contains(a, b) {\n    return a.minX <= b.minX &&\n           a.minY <= b.minY &&\n           b.maxX <= a.maxX &&\n           b.maxY <= a.maxY;\n}\n\nfunction intersects(a, b) {\n    return b.minX <= a.maxX &&\n           b.minY <= a.maxY &&\n           b.maxX >= a.minX &&\n           b.maxY >= a.minY;\n}\n\nfunction createNode(children) {\n    return {\n        children: children,\n        height: 1,\n        leaf: true,\n        minX: Infinity,\n        minY: Infinity,\n        maxX: -Infinity,\n        maxY: -Infinity\n    };\n}\n\n// sort an array so that items come in groups of n unsorted items, with groups sorted between each other;\n// combines selection algorithm with binary divide & conquer approach\n\nfunction multiSelect(arr, left, right, n, compare) {\n    var stack = [left, right],\n        mid;\n\n    while (stack.length) {\n        right = stack.pop();\n        left = stack.pop();\n\n        if (right - left <= n) continue;\n\n        mid = left + Math.ceil((right - left) / n / 2) * n;\n        quickselect(arr, mid, left, right, compare);\n\n        stack.push(left, mid, mid, right);\n    }\n}\n"]}
require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({"e2d":[function(require,module,exports){
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory();
else if(typeof define === 'function' && define.amd)
define([], factory);
else if(typeof exports === 'object')
exports["e2d"] = factory();
else
root["e2d"] = factory();
})(this, function() {
return /******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId])
/******/ return installedModules[moduleId].exports;
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ i: moduleId,
/******/ l: false,
/******/ exports: {}
/******/ };
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/ // Flag the module as loaded
/******/ module.l = true;
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/ // identity function for calling harmony imports with the correct context
/******/ __webpack_require__.i = function(value) { return value; };
/******/ // define getter function for harmony exports
/******/ __webpack_require__.d = function(exports, name, getter) {
/******/ if(!__webpack_require__.o(exports, name)) {
/******/ Object.defineProperty(exports, name, {
/******/ configurable: false,
/******/ enumerable: true,
/******/ get: getter
/******/ });
/******/ }
/******/ };
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = function(module) {
/******/ var getter = module && module.__esModule ?
/******/ function getDefault() { return module['default']; } :
/******/ function getModuleExports() { return module; };
/******/ __webpack_require__.d(getter, 'a', getter);
/******/ return getter;
/******/ };
/******/ // Object.prototype.hasOwnProperty.call
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/ // Load entry module and return exports
/******/ return __webpack_require__(__webpack_require__.s = 58);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports) {
class Instruction {
constructor(type, props) {
this.type = type;
this.props = props;
return Object.seal(this);
}
}
Object.seal(Instruction);
Object.seal(Instruction.prototype);
module.exports = Instruction;
/***/ },
/* 1 */
/***/ function(module, exports) {
let transformPoints = (points, matrix) => {
let result = [],
x, y;
for(let i = 0; i < points.length; i++) {
[x, y] = points[i];
result.push([
matrix[0] * x + matrix[2] * y + matrix[4],
matrix[1] * x + matrix[3] * y + matrix[5]
]);
}
return result;
};
module.exports = transformPoints;
/***/ },
/* 2 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0),
cache = new Instruction('beginPath');
let beginPath = () => cache;
module.exports = beginPath;
/***/ },
/* 3 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0);
let cache = new Instruction('closePath');
let closePath = () => cache;
module.exports = closePath;
/***/ },
/* 4 */
/***/ function(module, exports) {
let cycleMouseData = (ctx) => {
let mouseData = ctx.canvas[Symbol.for('mouseData')];
if (mouseData) {
mouseData.dx = mouseData.x - mouseData.previousX;
mouseData.dy = mouseData.y - mouseData.previousY;
mouseData.previousX = mouseData.x;
mouseData.previousY = mouseData.y;
mouseData.clicked = 0;
}
};
module.exports = cycleMouseData;
/***/ },
/* 5 */
/***/ function(module, exports) {
let det = 0;
let invertMatrix = ([a, b, c, d, e, f]) => (
det = 1 / (a * d - c * b),
[
d * det,
-c * det,
-b * det,
a * det,
(b * f - e * d) * det,
(e * b - a * f) * det
]
);
module.exports = invertMatrix;
/***/ },
/* 6 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0);
let lineTo = (x, y) => new Instruction('lineTo', { x, y });
module.exports = lineTo;
/***/ },
/* 7 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0);
let moveTo = (x, y) => new Instruction('moveTo', { x, y });
module.exports = moveTo;
/***/ },
/* 8 */
/***/ function(module, exports) {
let pointInRect = ([px, py], [[x, y], [width, height]]) => px > x && py > y && px < width && py < height;
module.exports = pointInRect;
/***/ },
/* 9 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0);
let end = new Instruction('restore');
let setTransform = (matrix, ...children) => [
new Instruction('setTransform', [
matrix[0],
matrix[1],
matrix[2],
matrix[3],
matrix[4],
matrix[5]
]),
children,
end
];
module.exports = setTransform;
/***/ },
/* 10 */
/***/ function(module, exports, __webpack_require__) {
let pointInPolygon = __webpack_require__(57);
let transformPoints = __webpack_require__(1);
let invertMatrix = __webpack_require__(5);
let pointInRect = __webpack_require__(8);
let matrix = new Float64Array(6);
module.exports = (ctx) => {
let regions = ctx.canvas[Symbol.for('regions')],
mousePoints = ctx.canvas[Symbol.for('mousePoints')],
mouseData = ctx.canvas[Symbol.for('mouseData')],
results = {};
//the mouse might have held still, add the current mouse position
if (mousePoints.length === 0) {
mousePoints.push([mouseData.x, mouseData.y, mouseData.state]);
}
for(let region of regions) {
//invert the region matrix and transform the mouse points
let transformedMousePoints = transformPoints(mousePoints, invertMatrix(region.matrix));
//the mouse points are now relative to the mouse region
if (!region.polygon) {
for (let mousePoint of transformedMousePoints) {
if (pointInRect(mousePoint, region.points)) {
region.hover = true;
region.clicked = !!mouseData.clicked;
results[region.id] = region;
break;
}
}
continue;
}
//loop over each point until one is matched
for(let mousePoint of transformedMousePoints) {
if (pointInPolygon(mousePoint, region.points)) {
region.hover = true;
region.clicked = !!mouseData.clicked;
results[region.id] = region;
break;
}
}
}
return results;
};
/***/ },
/* 11 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0),
pi2 = Math.PI * 2;
let arc = (...args) => {
let [x, y, r, startAngle, endAngle, counterclockwise] = args;
let props = { x: 0, y: 0, r: x, startAngle: 0, endAngle: pi2, counterclockwise: false };
if (args.length > 3) {
props.startAngle = startAngle;
props.endAngle = endAngle;
props.counterclockwise = !!counterclockwise;
}
if (args.length > 1){
props.x = x;
props.y = y;
props.r = r;
}
return new Instruction("arc", props);
};
module.exports = arc;
/***/ },
/* 12 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0);
let arcTo = (x1, y1, x2, y2, r) => new Instruction('arcTo', { x1, y1, x2, y2, r });
module.exports = arcTo;
/***/ },
/* 13 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0);
let bezierCurveTo = (cp1x, cp1y, cp2x, cp2y, x, y) => new Instruction('bezierCurveTo', {
cp1x,
cp1y,
cp2x,
cp2y,
x,
y
});
module.exports = bezierCurveTo;
/***/ },
/* 14 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0);
let clearRect = (...args) => new Instruction('clearRect',
args.length > 2 ?
{ x: args[0], y: args[1], width: args[2], height: args[3] } :
{ x: 0, y: 0, width: args[0], height: args[1] }
);
module.exports = clearRect;
/***/ },
/* 15 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0);
let begin = new Instruction('beginClip'),
performClip = new Instruction('clip'),
end = new Instruction('endClip');
let clip = (path, ...children) => [
begin,
path,
performClip,
children,
end
];
module.exports = clip;
/***/ },
/* 16 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0);
let cache = new Instruction('clipPath');
let clipPath = () => cache;
module.exports = clipPath;
/***/ },
/* 17 */
/***/ function(module, exports) {
let createRegularPolygon = (radius = 0, position = [0, 0], sides = 3) => {
let polygon = [];
for(let i = 0; i < sides; i++) {
polygon.push([
position[0] + radius * Math.cos(Math.PI * 2 * i / sides),
position[1] + radius * Math.sin(Math.PI * 2 * i / sides)
]);
}
return polygon;
};
module.exports = createRegularPolygon;
/***/ },
/* 18 */
/***/ function(module, exports) {
let concat = [].concat;
let createWrapper = (...args) => {
for(let i = 0; i < args.length; i++) {
//parse and flatten the arguments
while (args[i] && args[i].constructor === Array) {
args = concat.apply([], args).filter(Boolean);
}
if (!args[i]) {
continue;
}
let { type } = args[i];
if (type === 'placeholder') {
// i is set to the placeholder index now
//now grab all the elements to the left of the placeHolder
let left = args.splice(0, i);
//remove the placeHolder from the array
args.shift();
return (...children) => [left, children, args];
}
}
throw new Error('Could not find placeholder, did you forget the e2d.placeHolder() call?');
};
module.exports = concat;
/***/ },
/* 19 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0);
let drawImage = (...args) => {
let [img, sx, sy, sWidth, sHeight, dx, dy, dWidth, dHeight] = args;
if (args.length === 9) {
return new Instruction('drawImageSource', {
img,
sx,
sy,
sWidth,
sHeight,
dx,
dy,
dWidth,
dHeight
});
}
if (args.length >= 5) {
return new Instruction('drawImageSize', {
img,
dx: sx,
dy: sy,
dWidth: sWidth,
dHeight: sHeight
});
}
if (args.length >= 3) {
return new Instruction('drawImage', {
img,
dx: sx,
dy: sy
});
}
return new Instruction('drawImage', {
img,
dx: 0,
dy: 0
});
};
module.exports = drawImage;
/***/ },
/* 20 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0),
pi2 = Math.PI * 2;
let ellipse = (...args) => {
let [x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise] = args;
let props = { x: 0, y: 0, radiusX: x, radiusY: y, rotation: 0, startAngle: 0, endAngle: pi2, anticlockwise: false };
if (args.length > 5) {
props.startAngle = startAngle;
props.endAngle = endAngle;
props.anticlockwise = !!anticlockwise;
}
if (args.length > 4) {
props.rotation = rotation;
}
if (args.length > 2){
props.x = x;
props.y = y;
props.radiusX = radiusX;
props.radiusY = radiusY;
}
return new Instruction("ellipse", props);
};
module.exports = ellipse;
/***/ },
/* 21 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0);
let cache = new Instruction('fill');
let fill = () => cache;
module.exports = fill;
/***/ },
/* 22 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0),
pi2 = Math.PI * 2;
let fillArc = (...args) => {
let [x, y, r, startAngle, endAngle, counterclockwise] = args;
let props = { x: 0, y: 0, r: x, startAngle: 0, endAngle: pi2, counterclockwise: false };
if (args.length > 3) {
props.startAngle = startAngle;
props.endAngle = endAngle;
props.counterclockwise = !!counterclockwise;
}
if (args.length >= 2) {
props.x = x;
props.y = y;
props.r = r;
}
return new Instruction("fillArc", props);
};
module.exports = fillArc;
/***/ },
/* 23 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0);
let fillRect = (...args) => new Instruction('fillRect',
args.length > 2 ?
{ x: args[0], y: args[1], width: args[2], height: args[3] } :
{ x: 0, y: 0, width: args[0], height: args[1] }
);
module.exports = fillRect;
/***/ },
/* 24 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0);
let end = new Instruction('endFillStyle');
let fillStyle = (value, ...children) => [
new Instruction('fillStyle', { value }),
children,
end
];
module.exports = fillStyle;
/***/ },
/* 25 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0);
let fillText = (...args) => {
let [text, x, y, maxWidth] = args;
if (args.length < 4) {
maxWidth = null;
}
if (args.length < 3) {
x = 0;
y = 0;
}
return new Instruction('fillText', { text, x, y, maxWidth });
};
module.exports = fillText;
/***/ },
/* 26 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0);
let end = new Instruction('endGlobalAlpha');
let globalAlpha = (value, ...children) => [
new Instruction('globalAlpha', { value }),
children,
end
];
module.exports = globalAlpha;
/***/ },
/* 27 */
/***/ function(module, exports, __webpack_require__) {
var Instruction = __webpack_require__(0);
let end = new Instruction('endGlobalCompositeOperation');
let globalCompositeOperation = (value, ...children) => [
new Instruction('globalCompositeOperation', { value }),
children,
end
];
module.exports = globalCompositeOperation;
/***/ },
/* 28 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0);
let hitRect = (id, ...args) => {
let [x, y, width, height] = args;
if (args.length <= 3) {
width = x;
height = y;
x = 0;
y = 0;
}
return new Instruction('hitRect', {
id,
points: [
[x, y],
[x + width, y + height]
]
});
};
module.exports = hitRect;
/***/ },
/* 29 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0);
let hitRegion = (id, points) => new Instruction('hitRegion', { id, points });
module.exports = hitRegion;
/***/ },
/* 30 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0);
let end = new Instruction('endImageSmoothingEnabled');
let imageSmoothingEnabled = (value, ...children) => [
new Instruction('imageSmoothingEnabled', { value }),
children,
end
];
module.exports = imageSmoothingEnabled;
/***/ },
/* 31 */
/***/ function(module, exports, __webpack_require__) {
let keycode = __webpack_require__(56);
module.exports = (ctx) => {
let { canvas } = ctx;
//mouseData
canvas[Symbol.for('mouseData')] = {
x: 0,
y: 0,
dx: 0,
dy: 0,
previousX: 0,
previousY: 0,
state: false,
clicked: 0
};
let keys = canvas[Symbol.for('keyData')] = {};
for (let name in keycode.code) {
if (keycode.code.hasOwnProperty(name)) {
keys[name] = false;
}
}
//mouse regions
canvas[Symbol.for('regions')] = [];
canvas[Symbol.for('mousePoints')] = [];
//make the canvas receive touch and mouse events
canvas.tabIndex = 1;
let mouseMove = (evt) => {
let { clientX, clientY } = evt;
//get left and top coordinates
let { left, top } = canvas.getBoundingClientRect();
let mouseData = canvas[Symbol.for('mouseData')];
let point = [clientX - left, clientY - top, mouseData.state];
mouseData.x = point[0];
mouseData.y = point[1];
let points = canvas[Symbol.for('mousePoints')];
points.push(point);
//store the last 100 stored positions for hover detection
if (points.length > 100) {
points.splice(0, points.length - 100);
}
evt.preventDefault();
return false;
};
canvas.addEventListener('mousemove', (evt) => mouseMove(evt));
canvas.addEventListener('mousedown', (evt) => {
let { target } = evt;
if (target === canvas) {
let mouseData = canvas[Symbol.for('mouseData')];
if (!mouseData.state) {
mouseData.clicked += 1;
}
mouseData.state = true;
return mouseMove(evt);
}
});
canvas.addEventListener('mouseup', (evt) => {
let mouseData = canvas[Symbol.for('mouseData')];
mouseData.state = false;
return mouseMove(evt);
});
canvas.addEventListener('keydown', (evt) => {
canvas[Symbol.for('keyData')][keycode(evt.keyCode)] = true;
evt.preventDefault();
return false;
});
canvas.addEventListener('keyup', (evt) => {
canvas[Symbol.for('keyData')][keycode(evt.keyCode)] = false;
evt.preventDefault();
return false;
});
};
/***/ },
/* 32 */
/***/ function(module, exports) {
module.exports = (ctx) => ctx.canvas[Symbol.for('keyData')];
/***/ },
/* 33 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0);
let end = new Instruction('endLineStyle');
let lineStyle = (value, ...children) => {
value = value || {};
var result = {
lineWidth: null,
lineCap: null,
lineJoin: null,
miterLimit: null,
lineDash: null,
lineDashOffset: null
};
if (typeof value.lineWidth !== 'undefined') {
result.lineWidth = value.lineWidth;
}
if (typeof value.lineCap !== 'undefined') {
result.lineCap = value.lineCap;
}
if (typeof value.lineJoin !== 'undefined') {
result.lineJoin = value.lineJoin;
}
if (typeof value.miterLimit !== 'undefined') {
result.miterLimit = value.miterLimit;
}
if (typeof value.lineDash !== 'undefined') {
result.lineDash = value.lineDash || [];
}
if (typeof value.lineDashOffset !== 'undefined') {
result.lineDashOffset = value.lineDashOffset;
}
return [
new Instruction('lineStyle', result),
children,
end
];
};
module.exports = lineStyle;
/***/ },
/* 34 */
/***/ function(module, exports) {
module.exports = (ctx) => ctx.canvas[Symbol.for('mouseData')];
/***/ },
/* 35 */
/***/ function(module, exports, __webpack_require__) {
let moveTo = __webpack_require__(7), lineTo = __webpack_require__(6);
let moveToLineTo = (point, index) => index === 0 ?
moveTo(point[0], point[1]) :
lineTo(point[0], point[1]);
module.exports = moveToLineTo;
/***/ },
/* 36 */
/***/ function(module, exports, __webpack_require__) {
let beginPath = __webpack_require__(2)(),
closePath = __webpack_require__(3)();
let path = (...children) => [
beginPath,
children,
closePath
];
module.exports = path;
/***/ },
/* 37 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0);
let cache = new Instruction('placeholder');
let placeHolder = () => cache;
module.exports = placeHolder;
/***/ },
/* 38 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0);
let quadraticCurveTo = (cpx, cpy, x, y) => new Instruction('quadraticCurveTo', {
cpx,
cpy,
x,
y
});
module.exports = quadraticCurveTo;
/***/ },
/* 39 */
/***/ function(module, exports) {
let raf = (func) => {
requestAnimationFrame(() => raf(func));
return func();
};
module.exports = raf;
/***/ },
/* 40 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0);
let rect = (...args) => new Instruction('rect',
args.length > 2 ?
{ x: args[0], y: args[1], width: args[2], height: args[3] } :
{ x: 0, y: 0, width: args[0], height: args[1] }
);
module.exports = rect;
/***/ },
/* 41 */
/***/ function(module, exports, __webpack_require__) {
//initialize all the properties
let identity = [1, 0, 0, 1, 0, 0],
matrix = new Float64Array(identity),
fillStyleStack = [],
strokeStyleStack = [],
lineStyleStack = [],
textStyleStack = [],
shadowStyleStack = [],
globalCompositeOperationStack = [],
globalAlphaStack = [],
imageSmoothingEnabledStack = [],
transformStack = new Float64Array(501 * 6),
transformStackIndex = 6,
concat = [].concat,
supportsEllipse = false;
if (typeof CanvasRenderingContext2D !== 'undefined') {
supportsEllipse = CanvasRenderingContext2D.prototype.hasOwnProperty('ellipse');
}
//transform points function
const transformPoints = __webpack_require__(1);
const cycleMouseData = __webpack_require__(4);
const increaseTransformStackSize = () => {
let cache = transformStack;
transformStack = new Float64Array(transformStack.length + 600); //add 100 more
transformStack.set(cache);
return this;
};
transformStack.set(identity);
const PI2 = Math.PI * 2;
let empty = (target) => target && target.splice(0, target.length);
module.exports = (...args) => {
let children = args.slice(0, -1),
ctx = args[args.length - 1];
let regions = ctx.canvas[Symbol.for('regions')],
mousePoints = ctx.canvas[Symbol.for('mousePoints')],
extensions = ctx.canvas[Symbol.for('extensions')];
let cache;
cycleMouseData(ctx);
empty(regions);
empty(mousePoints);
let len = children.length;
//flatten children during the loop process to save cpu
for (let i = 0; i < len; i++) {
let child = children[i];
//flattening algorithm
if (child && child.constructor === Array) {
children = concat.apply([], children);
child = children[i];
//repeat as necessary
while (child && child.constructor === Array) {
children = concat.apply([], children);
child = children[i];
}
len = children.length;
}
//child must be truthy
if (!child) {
continue;
}
let { props, type } = child;
if (type === 'transform') {
//copy transformStack values to matrix
matrix[0] = transformStack[transformStackIndex - 6];
matrix[1] = transformStack[transformStackIndex - 5];
matrix[2] = transformStack[transformStackIndex - 4];
matrix[3] = transformStack[transformStackIndex - 3];
matrix[4] = transformStack[transformStackIndex - 2];
matrix[5] = transformStack[transformStackIndex - 1];
//increase the index
transformStackIndex += 6;
if (transformStackIndex > transformStack.length) {
increaseTransformStackSize();
}
//perform the transform math
transformStack[transformStackIndex - 6] = //d
matrix[0] * props[0] + matrix[2] * props[1];
transformStack[transformStackIndex - 5] = //b
matrix[1] * props[0] + matrix[3] * props[1];
transformStack[transformStackIndex - 4] = //c
matrix[0] * props[2] + matrix[2] * props[3];
transformStack[transformStackIndex - 3] = //d
matrix[1] * props[2] + matrix[3] * props[3];
transformStack[transformStackIndex - 2] = //e
matrix[0] * props[4] + matrix[2] * props[5] + matrix[4];
transformStack[transformStackIndex - 1] = //f
matrix[1] * props[4] + matrix[3] * props[5] + matrix[5];
//modify the ctx
ctx.setTransform(
transformStack[transformStackIndex - 6],
transformStack[transformStackIndex - 5],
transformStack[transformStackIndex - 4],
transformStack[transformStackIndex - 3],
transformStack[transformStackIndex - 2],
transformStack[transformStackIndex - 1]
);
continue;
}
if (type === 'setTransform') {
transformStackIndex += 6;
if (transformStackIndex > transformStack.length) {
increaseTransformStackSize();
}
transformStack[transformStackIndex - 6] = props[0];//a
transformStack[transformStackIndex - 5] = props[1];//b
transformStack[transformStackIndex - 4] = props[2];//c
transformStack[transformStackIndex - 3] = props[3];//d
transformStack[transformStackIndex - 2] = props[4];//e
transformStack[transformStackIndex - 1] = props[5];//f
ctx.setTransform(props[0], props[1], props[2], props[3], props[4], props[5]);
continue;
}
if (type === 'scale') {
matrix[0] = transformStack[transformStackIndex - 6];
matrix[1] = transformStack[transformStackIndex - 5];
matrix[2] = transformStack[transformStackIndex - 4];
matrix[3] = transformStack[transformStackIndex - 3];
matrix[4] = transformStack[transformStackIndex - 2];
matrix[5] = transformStack[transformStackIndex - 1];
transformStackIndex += 6;
if (transformStackIndex > transformStack.length) {
increaseTransformStackSize();
}
transformStack[transformStackIndex - 6] = matrix[0] * props.x; //a
transformStack[transformStackIndex - 5] = matrix[1] * props.x; //b
transformStack[transformStackIndex - 4] = matrix[2] * props.y; //c
transformStack[transformStackIndex - 3] = matrix[3] * props.y; //d
transformStack[transformStackIndex - 2] = matrix[4]; //e
transformStack[transformStackIndex - 1] = matrix[5]; //f
ctx.setTransform(
transformStack[transformStackIndex - 6],
transformStack[transformStackIndex - 5],
transformStack[transformStackIndex - 4],
transformStack[transformStackIndex - 3],
transformStack[transformStackIndex - 2],
transformStack[transformStackIndex - 1]
);
continue;
}
if (type === 'translate') {
matrix[0] = transformStack[transformStackIndex - 6];
matrix[1] = transformStack[transformStackIndex - 5];
matrix[2] = transformStack[transformStackIndex - 4];
matrix[3] = transformStack[transformStackIndex - 3];
matrix[4] = transformStack[transformStackIndex - 2];
matrix[5] = transformStack[transformStackIndex - 1];
transformStackIndex += 6;
if (transformStackIndex > transformStack.length) {
increaseTransformStackSize();
}
transformStack[transformStackIndex - 6] = matrix[0]; //a
transformStack[transformStackIndex - 5] = matrix[1]; //b
transformStack[transformStackIndex - 4] = matrix[2]; //c
transformStack[transformStackIndex - 3] = matrix[3]; //d
transformStack[transformStackIndex - 2] = matrix[4] + matrix[0] * props.x + matrix[2] * props.y; //e
transformStack[transformStackIndex - 1] = matrix[5] + matrix[1] * props.x + matrix[3] * props.y; //f
ctx.setTransform(
transformStack[transformStackIndex - 6],
transformStack[transformStackIndex - 5],
transformStack[transformStackIndex - 4],
transformStack[transformStackIndex - 3],
transformStack[transformStackIndex - 2],
transformStack[transformStackIndex - 1]
);
continue;
}
if (type === 'rotate') {
matrix[0] = transformStack[transformStackIndex - 6];
matrix[1] = transformStack[transformStackIndex - 5];
matrix[2] = transformStack[transformStackIndex - 4];
matrix[3] = transformStack[transformStackIndex - 3];
matrix[4] = transformStack[transformStackIndex - 2];
matrix[5] = transformStack[transformStackIndex - 1];
transformStackIndex += 6;
if (transformStackIndex > transformStack.length) {
increaseTransformStackSize();
}
transformStack[transformStackIndex - 6] =
matrix[0] * props.cos + matrix[2] * props.sin; //a
transformStack[transformStackIndex - 5] =
matrix[1] * props.cos + matrix[3] * props.sin; //b
transformStack[transformStackIndex - 4] =
matrix[0] * -props.sin + matrix[2] * props.cos; //c
transformStack[transformStackIndex - 3] =
matrix[1] * -props.sin + matrix[3] * props.cos; //d
transformStack[transformStackIndex - 2] = matrix[4]; //e
transformStack[transformStackIndex - 1] = matrix[5];//f
ctx.setTransform(
transformStack[transformStackIndex - 6],
transformStack[transformStackIndex - 5],
transformStack[transformStackIndex - 4],
transformStack[transformStackIndex - 3],
transformStack[transformStackIndex - 2],
transformStack[transformStackIndex - 1]
);
continue;
}
if (type === 'skewX') {
matrix[0] = transformStack[transformStackIndex - 6];
matrix[1] = transformStack[transformStackIndex - 5];
matrix[2] = transformStack[transformStackIndex - 4];
matrix[3] = transformStack[transformStackIndex - 3];
matrix[4] = transformStack[transformStackIndex - 2];
matrix[5] = transformStack[transformStackIndex - 1];
transformStackIndex += 6;
if (transformStackIndex > transformStack.length) {
increaseTransformStackSize();
}
transformStack[transformStackIndex - 6] = matrix[0]; //a
transformStack[transformStackIndex - 5] = matrix[1]; //b
transformStack[transformStackIndex - 4] = //c
matrix[0] * props.x + matrix[2];
transformStack[transformStackIndex - 3] = //d
matrix[1] * props.x + matrix[3];
transformStack[transformStackIndex - 2] = matrix[4]; //e
transformStack[transformStackIndex - 1] = matrix[5]; //f
ctx.setTransform(
transformStack[transformStackIndex - 6],
transformStack[transformStackIndex - 5],
transformStack[transformStackIndex - 4],
transformStack[transformStackIndex - 3],
transformStack[transformStackIndex - 2],
transformStack[transformStackIndex - 1]
);
continue;
}
if (type === 'skewY') {
matrix[0] = transformStack[transformStackIndex - 6];
matrix[1] = transformStack[transformStackIndex - 5];
matrix[2] = transformStack[transformStackIndex - 4];
matrix[3] = transformStack[transformStackIndex - 3];
matrix[4] = transformStack[transformStackIndex - 2];
matrix[5] = transformStack[transformStackIndex - 1];
transformStackIndex += 6;
if (transformStackIndex > transformStack.length) {
increaseTransformStackSize();
}
transformStack[transformStackIndex - 6] =
matrix[0] * 1 + matrix[2] * props.y; //a
transformStack[transformStackIndex - 5] =
matrix[1] * 1 + matrix[3] * props.y; //b
transformStack[transformStackIndex - 4] = matrix[2]; //c
transformStack[transformStackIndex - 3] = matrix[3]; //d
transformStack[transformStackIndex - 2] = matrix[4]; //e
transformStack[transformStackIndex - 1] = matrix[5]; //f
ctx.setTransform(
transformStack[transformStackIndex - 6],
transformStack[transformStackIndex - 5],
transformStack[transformStackIndex - 4],
transformStack[transformStackIndex - 3],
transformStack[transformStackIndex - 2],
transformStack[transformStackIndex - 1]
);
continue;
}
if (type === 'restore') {
transformStackIndex -= 6;
matrix[0] = transformStack[transformStackIndex - 6];
matrix[1] = transformStack[transformStackIndex - 5];
matrix[2] = transformStack[transformStackIndex - 4];
matrix[3] = transformStack[transformStackIndex - 3];
matrix[4] = transformStack[transformStackIndex - 2];
matrix[5] = transformStack[transformStackIndex - 1];
ctx.setTransform(matrix[0], matrix[1], matrix[2], matrix[3], matrix[4], matrix[5]);
continue;
}
if (type === 'fillRect') {
ctx.fillRect(props.x, props.y, props.width, props.height);
continue;
}
if (type === 'strokeRect') {
ctx.strokeRect(props.x, props.y, props.width, props.height);
continue;
}
if (type === 'clearRect') {
ctx.clearRect(props.x, props.y, props.width, props.height);
continue;
}
if (type === 'rect') {
ctx.rect(props.x, props.y, props.width, props.height);
continue;
}
if (type === 'fillStyle') {
fillStyleStack.push(ctx.fillStyle);
ctx.fillStyle = props.value;
continue;
}
if (type === 'strokeStyle') {
strokeStyleStack.push(ctx.strokeStyle);
ctx.strokeStyle = props.value;
continue;
}
if (type === 'endFillStyle') {
ctx.fillStyle = fillStyleStack.pop();
continue;
}
if (type === 'endStrokeStyle') {
ctx.strokeStyle = strokeStyleStack.pop();
continue;
}
if (type === 'lineStyle') {
lineStyleStack.push({
lineWidth: ctx.lineWidth,
lineCap: ctx.lineCap,
lineJoin: ctx.lineJoin,
miterLimit: ctx.miterLimit,
lineDash: ctx.getLineDash(),
lineDashOffset: ctx.lineDashOffset
});
if (props.lineWidth !== null) {
ctx.lineWidth = props.lineWidth;
}
if (props.lineCap !== null) {
ctx.lineCap = props.lineCap;
}
if (props.lineJoin !== null) {
ctx.lineJoin = props.lineJoin;
}
if (props.miterLimit !== null) {
ctx.miterLimit = props.miterLimit;
}
if (props.lineDash !== null) {
ctx.setLineDash(props.lineDash);
}
if (props.lineDashOffset !== null) {
ctx.lineDashOffset = props.lineDashOffset;
}
continue;
}
if (type === 'endLineStyle') {
cache = lineStyleStack.pop();
ctx.lineWidth = cache.lineWidth;
ctx.lineCap = cache.lineCap;
ctx.lineJoin = cache.lineJoin;
ctx.miterLimit = cache.miterLimit;
ctx.setLineDash(cache.lineDash);
ctx.lineDashOffset = cache.lineDashOffset;
continue;
}
if (type === 'textStyle') {
textStyleStack.push({
font: ctx.font,
textAlign: ctx.textAlign,
textBaseline: ctx.textBaseline,
direction: ctx.direction
});
if (props.font !== null) {
ctx.font = props.font;
}
if (props.textAlign !== null) {
ctx.textAlign = props.textAlign;
}
if (props.textBaseline !== null) {
ctx.textBaseline = props.textBaseline;
}
if (props.direction !== null) {
ctx.direction = props.direction;
}
continue;
}
if (type === 'endTextStyle') {
cache = textStyleStack.pop();
ctx.font = cache.font;
ctx.textAlign = cache.textAlign;
ctx.textBaseline = cache.textBaseline;
ctx.direction = cache.direction;
continue;
}
if (type === 'shadowStyle') {
shadowStyleStack.push({
shadowBlur: ctx.shadowBlur,
shadowColor: ctx.shadowColor,
shadowOffsetX: ctx.shadowOffsetX,
shadowOffsetY: ctx.shadowOffsetY
});
if (props.shadowBlur !== null) {
ctx.shadowBlur = props.shadowBlur;
}
if (props.shadowColor !== null) {
ctx.shadowColor = props.shadowColor;
}
if (props.shadowOffsetX !== null) {
ctx.shadowOffsetX = props.shadowOffsetX;
}
if (props.shadowOffsetY !== null) {
ctx.shadowOffsetY = props.shadowOffsetY;
}
continue;
}
if (type === 'endShadowStyle') {
cache = shadowStyleStack.pop();
ctx.shadowBlur = cache.shadowBlur;
ctx.shadowColor = cache.shadowColor;
ctx.shadowOffsetX = cache.shadowOffsetX;
ctx.shadowOffsetY = cache.shadowOffsetY;
continue;
}
if (type === 'strokeText') {
if (props.maxWidth) {
ctx.strokeText(props.text, props.x, props.y, props.maxWidth);
continue;
}
ctx.strokeText(props.text, props.x, props.y);
continue;
}
if (type === 'fillText') {
if (props.maxWidth) {
ctx.fillText(props.text, props.x, props.y, props.maxWidth);
continue;
}
ctx.fillText(props.text, props.x, props.y);
continue;
}
if (type === 'drawImage') {
ctx.drawImage(props.img, props.dx, props.dy);
continue;
}
if (type === 'drawImageSize') {
ctx.drawImage(props.img, props.dx, props.dy, props.dWidth, props.dHeight);
continue;
}
if (type === 'drawImageSource') {
ctx.drawImage(props.img, props.sx, props.sy, props.sWidth, props.sHeight, props.dx, props.dy, props.dWidth, props.dHeight);
continue;
}
if (type === 'strokeArc') {
ctx.beginPath();
ctx.arc(props.x, props.y, props.r, props.startAngle, props.endAngle, props.counterclockwise);
ctx.closePath();
ctx.stroke();
continue;
}
if (type === 'fillArc') {
ctx.beginPath();
ctx.arc(props.x, props.y, props.r, props.startAngle, props.endAngle, props.counterclockwise);
ctx.closePath();
ctx.fill();
continue;
}
if (type === 'moveTo') {
ctx.moveTo(props.x, props.y);
continue;
}
if (type === 'lineTo') {
ctx.lineTo(props.x, props.y);
continue;
}
if (type === 'bezierCurveTo') {
ctx.bezierCurveTo(props.cp1x, props.cp1y, props.cp2x, props.cp2y, props.x, props.y);
continue;
}
if (type === 'quadraticCurveTo') {
ctx.quadraticCurveTo(props.cpx, props.cpy, props.x, props.y);
continue;
}
if (type === 'arc') {
ctx.arc(props.x, props.y, props.r, props.startAngle, props.endAngle, props.counterclockwise);
continue;
}
if (type === 'arcTo') {
ctx.arcTo(props.x1, props.y1, props.x2, props.y2, props.r);
continue;
}
if (type === 'ellipse') {
//if the method is provided by the browser
if (supportsEllipse) {
ctx.ellipse(
props.x,
props.y,
props.radiusX,
props.radiusY,
props.rotation,
props.startAngle,
props.endAngle,
props.anticlockwise
);
continue;
}
ctx.save();
ctx.translate(props.x, props.y);
ctx.rotate(props.rotation);
ctx.scale(props.radiusX, props.radiusY);
ctx.arc(0, 0, 1, props.startAngle, props.endAngle, props.anticlockwise);
ctx.restore();
continue;
}
if (type === 'globalCompositeOperation') {
globalCompositeOperationStack.push(ctx.globalCompositeOperation);
ctx.globalCompositeOperation = props.value;
continue;
}
if (type === 'endGlobalCompositeOperation') {
ctx.globalCompositeOperation = globalCompositeOperationStack.pop();
continue;
}
if (type === 'fill') {
ctx.fill();
continue;
}
if (type === 'stroke') {
ctx.stroke();
continue;
}
if (type === 'beginClip') {
ctx.save();
ctx.beginPath();
continue;
}
if (type === 'clip') {
ctx.clip();
continue;
}
if (type === 'endClip') {
ctx.restore();
continue;
}
if (type === 'beginPath') {
ctx.beginPath();
continue;
}
if (type === 'closePath') {
ctx.closePath();
continue;
}
if (type === 'globalAlpha') {
globalAlphaStack.push(ctx.globalAlpha);
ctx.globalAlpha *= props.value;
continue;
}
if (type === 'endGlobalAlpha') {
ctx.globalAlpha = globalAlphaStack.pop();
continue;
}
if (type === 'hitRect' && regions) {
cache = [
transformStack[transformStackIndex - 6],
transformStack[transformStackIndex - 5],
transformStack[transformStackIndex - 4],
transformStack[transformStackIndex - 3],
transformStack[transformStackIndex - 2],
transformStack[transformStackIndex - 1]
];
regions.push({
id: props.id,
points: props.points,
matrix: cache,
//rectangle!
polygon: false,
hover: false,
touched: false,
clicked: false
});
}
if (type === 'hitRegion' && regions) {
cache = [
transformStack[transformStackIndex - 6],
transformStack[transformStackIndex - 5],
transformStack[transformStackIndex - 4],
transformStack[transformStackIndex - 3],
transformStack[transformStackIndex - 2],
transformStack[transformStackIndex - 1]
];
regions.push({
id: props.id,
points: props.points,
matrix: cache,
polygon: true,
hover: false,
touched: false,
clicked: false
});
continue;
}
if (type === 'imageSmoothingEnabled') {
imageSmoothingEnabledStack.push(ctx.imageSmoothingEnabled);
ctx.imageSmoothingEnabled = props.value;
continue;
}
if (type === 'endImageSmoothingEnabled') {
ctx.imageSmoothingEnabled = imageSmoothingEnabledStack.pop();
continue;
}
if (extensions && extensions[type]) {
extensions[type](props, ctx);
continue;
}
}
};
/***/ },
/* 42 */
/***/ function(module, exports, __webpack_require__) {
let setTransform = __webpack_require__(9);
let resetTransform = (...children) => setTransform([1, 0, 0, 1, 0, 0], children);
module.exports = resetTransform;
/***/ },
/* 43 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0);
let end = new Instruction('restore');
let rotate = (r, ...children) => [
new Instruction('rotate', { cos: Math.cos(r), sin: Math.sin(r) }),
children,
end
];
module.exports = rotate;
/***/ },
/* 44 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0);
let end = new Instruction('restore');
let scale = (x, y, ...children) => {
if (typeof y !== 'number') {
children = [y].concat(children);
y = x;
}
return [
new Instruction('scale', { x, y }),
children,
end
];
};
module.exports = scale;
/***/ },
/* 45 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0);
let end = new Instruction('endShadowStyle');
let shadowStyle = (value, ...children) => {
value = value || {};
var result = {
shadowBlur: null,
shadowColor: null,
shadowOffsetX: null,
shadowOffsetY: null
};
if (typeof value.shadowBlur !== 'undefined') {
result.shadowBlur = value.shadowBlur;
}
if (typeof value.shadowColor !== 'undefined') {
result.shadowColor = value.shadowColor;
}
if (typeof value.shadowOffsetX !== 'undefined') {
result.shadowOffsetX = value.shadowOffsetX;
}
if (typeof value.direction !== 'undefined') {
result.shadowOffsetY = value.shadowOffsetY;
}
return [
new Instruction('shadowStyle', value),
children,
end
];
};
module.exports = shadowStyle;
/***/ },
/* 46 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0);
let end = new Instruction('restore');
let skewX = (x, ...children) => [
new Instruction('skewX', { x: Math.tan(x) }),
children,
end
];
module.exports = skewX;
/***/ },
/* 47 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0);
let end = new Instruction('restore');
let skewY = (x, ...children) => [
new Instruction('skewY', { y: Math.tan(y) }),
children,
end
];
module.exports = skewY;
/***/ },
/* 48 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0);
let cache = new Instruction('stroke');
let stroke = () => cache;
module.exports = stroke;
/***/ },
/* 49 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0),
pi2 = Math.PI * 2;
let strokeArc = (...args) => {
let [x, y, r, startAngle, endAngle, counterclockwise] = args;
let props = { x: 0, y: 0, r: x, startAngle: 0, endAngle: pi2, counterclockwise: false };
if (args.length > 3) {
props.startAngle = startAngle;
props.endAngle = endAngle;
props.counterclockwise = !!counterclockwise;
}
if (args.length > 1){
props.x = x;
props.y = y;
props.r = r;
}
return new Instruction("strokeArc", props);
};
module.exports = strokeArc;
/***/ },
/* 50 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0);
let strokeRect = (...args) => new Instruction('strokeRect',
args.length > 2 ?
{ x: args[0], y: args[1], width: args[2], height: args[3] } :
{ x: 0, y: 0, width: args[0], height: args[1] }
);
module.exports = strokeRect;
/***/ },
/* 51 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0);
let end = new Instruction('endStrokeStyle');
let strokeStyle = (value, ...children) => [
new Instruction('strokeStyle', { value }),
children,
end
];
module.exports = strokeStyle;
/***/ },
/* 52 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0);
let strokeText = (...args) => {
let [text, x, y, maxWidth] = args;
if (args.length < 4) {
maxWidth = null;
}
if (args.length < 3) {
x = 0;
y = 0;
}
return new Instruction('strokeText', {
text,
x,
y,
maxWidth
});
};
module.exports = strokeText;
/***/ },
/* 53 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0);
let end = new Instruction('endTextStyle');
let textStyle = (value, ...children) => {
value = value || {};
var result = {
font: null,
textAlign: null,
textBaseline: null,
direction: null
};
if (typeof value.font !== 'undefined') {
result.font = value.font;
}
if (typeof value.textAlign !== 'undefined') {
result.textAlign = value.textAlign;
}
if (typeof value.textBaseline !== 'undefined') {
result.textBaseline = value.textBaseline;
}
if (typeof value.direction !== 'undefined') {
result.direction = value.direction;
}
return [
new Instruction('textStyle', result),
children,
end
];
};
module.exports = textStyle;
/***/ },
/* 54 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0);
let end = new Instruction('restore');
let transform = (values, ...children) => {
return [
new Instruction('transform',[
values[0],
values[1],
values[2],
values[3],
values[4],
values[5]
]),
children,
end
];
};
module.exports = transform;
/***/ },
/* 55 */
/***/ function(module, exports, __webpack_require__) {
let Instruction = __webpack_require__(0);
let end = new Instruction('restore');
let translate = (x, y, ...children) => [
new Instruction('translate', { x: x, y: y }),
children,
end
];
module.exports = translate;
/***/ },
/* 56 */
/***/ function(module, exports) {
// Source: http://jsfiddle.net/vWx8V/
// http://stackoverflow.com/questions/5603195/full-list-of-javascript-keycodes
/**
* Conenience method returns corresponding value for given keyName or keyCode.
*
* @param {Mixed} keyCode {Number} or keyName {String}
* @return {Mixed}
* @api public
*/
exports = module.exports = function(searchInput) {
// Keyboard Events
if (searchInput && 'object' === typeof searchInput) {
var hasKeyCode = searchInput.which || searchInput.keyCode || searchInput.charCode
if (hasKeyCode) searchInput = hasKeyCode
}
// Numbers
if ('number' === typeof searchInput) return names[searchInput]
// Everything else (cast to string)
var search = String(searchInput)
// check codes
var foundNamedKey = codes[search.toLowerCase()]
if (foundNamedKey) return foundNamedKey
// check aliases
var foundNamedKey = aliases[search.toLowerCase()]
if (foundNamedKey) return foundNamedKey
// weird character?
if (search.length === 1) return search.charCodeAt(0)
return undefined
}
/**
* Get by name
*
* exports.code['enter'] // => 13
*/
var codes = exports.code = exports.codes = {
'backspace': 8,
'tab': 9,
'enter': 13,
'shift': 16,
'ctrl': 17,
'alt': 18,
'pause/break': 19,
'caps lock': 20,
'esc': 27,
'space': 32,
'page up': 33,
'page down': 34,
'end': 35,
'home': 36,
'left': 37,
'up': 38,
'right': 39,
'down': 40,
'insert': 45,
'delete': 46,
'command': 91,
'left command': 91,
'right command': 93,
'numpad *': 106,
'numpad +': 107,
'numpad -': 109,
'numpad .': 110,
'numpad /': 111,
'num lock': 144,
'scroll lock': 145,
'my computer': 182,
'my calculator': 183,
';': 186,
'=': 187,
',': 188,
'-': 189,
'.': 190,
'/': 191,
'`': 192,
'[': 219,
'\\': 220,
']': 221,
"'": 222
}
// Helper aliases
var aliases = exports.aliases = {
'windows': 91,
'⇧': 16,
'⌥': 18,
'⌃': 17,
'⌘': 91,
'ctl': 17,
'control': 17,
'option': 18,
'pause': 19,
'break': 19,
'caps': 20,
'return': 13,
'escape': 27,
'spc': 32,
'pgup': 33,
'pgdn': 34,
'ins': 45,
'del': 46,
'cmd': 91
}
/*!
* Programatically add the following
*/
// lower case chars
for (i = 97; i < 123; i++) codes[String.fromCharCode(i)] = i - 32
// numbers
for (var i = 48; i < 58; i++) codes[i - 48] = i
// function keys
for (i = 1; i < 13; i++) codes['f'+i] = i + 111
// numpad keys
for (i = 0; i < 10; i++) codes['numpad '+i] = i + 96
/**
* Get by code
*
* exports.name[13] // => 'Enter'
*/
var names = exports.names = exports.title = {} // title for backward compat
// Create reverse mapping
for (i in codes) names[codes[i]] = i
// Add aliases
for (var alias in aliases) {
codes[alias] = aliases[alias]
}
/***/ },
/* 57 */
/***/ function(module, exports) {
module.exports = function (point, vs) {
// ray-casting algorithm based on
// http://www.ecse.rpi.edu/Homepages/wrf/Research/Short_Notes/pnpoly.html
var x = point[0], y = point[1];
var inside = false;
for (var i = 0, j = vs.length - 1; i < vs.length; j = i++) {
var xi = vs[i][0], yi = vs[i][1];
var xj = vs[j][0], yj = vs[j][1];
var intersect = ((yi > y) != (yj > y))
&& (x < (xj - xi) * (y - yi) / (yj - yi) + xi);
if (intersect) inside = !inside;
}
return inside;
};
/***/ },
/* 58 */
/***/ function(module, exports, __webpack_require__) {
module.exports = {
'activeRegions': __webpack_require__(10),
'arc': __webpack_require__(11),
'arcTo': __webpack_require__(12),
'beginPath': __webpack_require__(2),
'bezierCurveTo': __webpack_require__(13),
'clearRect': __webpack_require__(14),
'clip': __webpack_require__(15),
'clipPath': __webpack_require__(16),
'closePath': __webpack_require__(3),
'createRegularPolygon': __webpack_require__(17),
'createWrapper': __webpack_require__(18),
'cycleMouseData': __webpack_require__(4),
'drawImage': __webpack_require__(19),
'ellipse': __webpack_require__(20),
'fill': __webpack_require__(21),
'fillArc': __webpack_require__(22),
'fillRect': __webpack_require__(23),
'fillStyle': __webpack_require__(24),
'fillText': __webpack_require__(25),
'globalAlpha': __webpack_require__(26),
'globalCompositeOperation': __webpack_require__(27),
'hitRect': __webpack_require__(28),
'hitRegion': __webpack_require__(29),
'imageSmoothingEnabled': __webpack_require__(30),
'initialize': __webpack_require__(31),
'Instruction': __webpack_require__(0),
'invertMatrix': __webpack_require__(5),
'keyData': __webpack_require__(32),
'lineStyle': __webpack_require__(33),
'lineTo': __webpack_require__(6),
'mouseData': __webpack_require__(34),
'moveTo': __webpack_require__(7),
'moveToLineTo': __webpack_require__(35),
'path': __webpack_require__(36),
'placeHolder': __webpack_require__(37),
'pointInRect': __webpack_require__(8),
'quadraticCurveTo': __webpack_require__(38),
'raf': __webpack_require__(39),
'rect': __webpack_require__(40),
'render': __webpack_require__(41),
'resetTransform': __webpack_require__(42),
'rotate': __webpack_require__(43),
'scale': __webpack_require__(44),
'setTransform': __webpack_require__(9),
'shadowStyle': __webpack_require__(45),
'skewX': __webpack_require__(46),
'skewY': __webpack_require__(47),
'stroke': __webpack_require__(48),
'strokeArc': __webpack_require__(49),
'strokeRect': __webpack_require__(50),
'strokeStyle': __webpack_require__(51),
'strokeText': __webpack_require__(52),
'textStyle': __webpack_require__(53),
'transform': __webpack_require__(54),
'transformPoints': __webpack_require__(1),
'translate': __webpack_require__(55)
};
/***/ }
/******/ ]);
});
},{}]},{},[])
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../home/admin/browserify-cdn/node_modules/browserify/node_modules/browser-pack/_prelude.js","e2d"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"e2d\"] = factory();\n\telse\n\t\troot[\"e2d\"] = factory();\n})(this, function() {\nreturn /******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId])\n/******/ \t\t\treturn installedModules[moduleId].exports;\n\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\ti: moduleId,\n/******/ \t\t\tl: false,\n/******/ \t\t\texports: {}\n/******/ \t\t};\n\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.l = true;\n\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n\n\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n\n/******/ \t// identity function for calling harmony imports with the correct context\n/******/ \t__webpack_require__.i = function(value) { return value; };\n\n/******/ \t// define getter function for harmony exports\n/******/ \t__webpack_require__.d = function(exports, name, getter) {\n/******/ \t\tif(!__webpack_require__.o(exports, name)) {\n/******/ \t\t\tObject.defineProperty(exports, name, {\n/******/ \t\t\t\tconfigurable: false,\n/******/ \t\t\t\tenumerable: true,\n/******/ \t\t\t\tget: getter\n/******/ \t\t\t});\n/******/ \t\t}\n/******/ \t};\n\n/******/ \t// getDefaultExport function for compatibility with non-harmony modules\n/******/ \t__webpack_require__.n = function(module) {\n/******/ \t\tvar getter = module && module.__esModule ?\n/******/ \t\t\tfunction getDefault() { return module['default']; } :\n/******/ \t\t\tfunction getModuleExports() { return module; };\n/******/ \t\t__webpack_require__.d(getter, 'a', getter);\n/******/ \t\treturn getter;\n/******/ \t};\n\n/******/ \t// Object.prototype.hasOwnProperty.call\n/******/ \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(__webpack_require__.s = 58);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ function(module, exports) {\n\nclass Instruction {\r\n  constructor(type, props) {\r\n    this.type = type;\r\n    this.props = props;\r\n    return Object.seal(this);\r\n  }\r\n}\r\n\r\nObject.seal(Instruction);\r\nObject.seal(Instruction.prototype);\r\n\r\nmodule.exports = Instruction;\r\n\n\n/***/ },\n/* 1 */\n/***/ function(module, exports) {\n\nlet transformPoints = (points, matrix) => {\r\n  let result = [],\r\n      x, y;\r\n\r\n  for(let i = 0; i < points.length; i++) {\r\n    [x, y] = points[i];\r\n    result.push([\r\n      matrix[0] * x + matrix[2] * y + matrix[4],\r\n      matrix[1] * x + matrix[3] * y + matrix[5]\r\n    ]);\r\n  }\r\n  return result;\r\n};\r\n\r\nmodule.exports = transformPoints;\r\n\n\n/***/ },\n/* 2 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0),\r\n  cache = new Instruction('beginPath');\r\n\r\nlet beginPath = () => cache;\r\n\r\nmodule.exports = beginPath;\n\n/***/ },\n/* 3 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0);\r\nlet cache = new Instruction('closePath');\r\n\r\nlet closePath = () => cache;\r\n\r\nmodule.exports = closePath;\r\n\n\n/***/ },\n/* 4 */\n/***/ function(module, exports) {\n\n\r\nlet cycleMouseData = (ctx) => {\r\n  let mouseData = ctx.canvas[Symbol.for('mouseData')];\r\n  if (mouseData) {\r\n    mouseData.dx = mouseData.x - mouseData.previousX;\r\n    mouseData.dy = mouseData.y - mouseData.previousY;\r\n\r\n    mouseData.previousX = mouseData.x;\r\n    mouseData.previousY = mouseData.y;\r\n\r\n    mouseData.clicked = 0;\r\n  }\r\n};\r\n\r\nmodule.exports = cycleMouseData;\n\n/***/ },\n/* 5 */\n/***/ function(module, exports) {\n\nlet det = 0;\r\nlet invertMatrix = ([a, b, c, d, e, f]) => (\r\n  det = 1 / (a * d - c * b),\r\n  [\r\n    d * det,\r\n    -c * det,\r\n    -b * det,\r\n    a * det,\r\n    (b * f - e * d) * det,\r\n    (e * b - a * f) * det\r\n  ]\r\n);\r\n module.exports = invertMatrix;\n\n/***/ },\n/* 6 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0);\r\n\r\nlet lineTo = (x, y) => new Instruction('lineTo', { x, y });\r\n\r\nmodule.exports = lineTo;\r\n\n\n/***/ },\n/* 7 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0);\r\n\r\nlet moveTo = (x, y) => new Instruction('moveTo', { x, y });\r\n\r\nmodule.exports = moveTo;\r\n\n\n/***/ },\n/* 8 */\n/***/ function(module, exports) {\n\nlet pointInRect = ([px, py], [[x, y], [width, height]]) => px > x && py > y && px < width && py < height;\r\n\r\nmodule.exports = pointInRect;\n\n/***/ },\n/* 9 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0);\r\nlet end = new Instruction('restore');\r\n\r\nlet setTransform = (matrix, ...children) => [\r\n  new Instruction('setTransform', [\r\n    matrix[0],\r\n    matrix[1],\r\n    matrix[2],\r\n    matrix[3],\r\n    matrix[4],\r\n    matrix[5]\r\n  ]),\r\n  children,\r\n  end\r\n];\r\n\r\nmodule.exports = setTransform;\n\n/***/ },\n/* 10 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet pointInPolygon = __webpack_require__(57);\r\nlet transformPoints = __webpack_require__(1);\r\nlet invertMatrix = __webpack_require__(5);\r\nlet pointInRect = __webpack_require__(8);\r\n\r\nlet matrix = new Float64Array(6);\r\n\r\nmodule.exports = (ctx) => {\r\n  let regions = ctx.canvas[Symbol.for('regions')],\r\n    mousePoints = ctx.canvas[Symbol.for('mousePoints')],\r\n    mouseData = ctx.canvas[Symbol.for('mouseData')],\r\n    results = {};\r\n\r\n  //the mouse might have held still, add the current mouse position\r\n  if (mousePoints.length === 0) {\r\n    mousePoints.push([mouseData.x, mouseData.y, mouseData.state]);\r\n  }\r\n\r\n  for(let region of regions) {\r\n\r\n    //invert the region matrix and transform the mouse points\r\n    let transformedMousePoints = transformPoints(mousePoints, invertMatrix(region.matrix));\r\n    //the mouse points are now relative to the mouse region\r\n\r\n    if (!region.polygon) {\r\n      for (let mousePoint of transformedMousePoints) {\r\n        if (pointInRect(mousePoint, region.points)) {\r\n          region.hover = true;\r\n          region.clicked = !!mouseData.clicked;\r\n          results[region.id] = region;\r\n          break;\r\n        }\r\n      }\r\n      continue;\r\n    }\r\n\r\n    //loop over each point until one is matched\r\n    for(let mousePoint of transformedMousePoints) {\r\n      if (pointInPolygon(mousePoint, region.points)) {\r\n        region.hover = true;\r\n        region.clicked = !!mouseData.clicked;\r\n        results[region.id] = region;\r\n        break;\r\n      }\r\n    }\r\n  }\r\n  return results;\r\n};\n\n/***/ },\n/* 11 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0),\r\n    pi2 = Math.PI * 2;\r\n\r\nlet arc = (...args) => {\r\n  let  [x, y, r, startAngle, endAngle, counterclockwise] = args;\r\n  let props = { x: 0, y: 0, r: x, startAngle: 0, endAngle: pi2, counterclockwise: false };\r\n\r\n\r\n  if (args.length > 3) {\r\n    props.startAngle = startAngle;\r\n    props.endAngle = endAngle;\r\n    props.counterclockwise = !!counterclockwise;\r\n  }\r\n\r\n  if (args.length > 1){\r\n    props.x = x;\r\n    props.y = y;\r\n    props.r = r;\r\n  }\r\n\r\n  return new Instruction(\"arc\",  props);\r\n};\r\n\r\nmodule.exports = arc;\r\n\n\n/***/ },\n/* 12 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0);\r\n\r\nlet arcTo = (x1, y1, x2, y2, r) => new Instruction('arcTo', { x1, y1, x2, y2, r });\r\n\r\nmodule.exports = arcTo;\r\n\n\n/***/ },\n/* 13 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0);\r\n\r\nlet bezierCurveTo = (cp1x, cp1y, cp2x, cp2y, x, y) => new Instruction('bezierCurveTo', {\r\n  cp1x,\r\n  cp1y,\r\n  cp2x,\r\n  cp2y,\r\n  x,\r\n  y\r\n});\r\n\r\n\r\nmodule.exports = bezierCurveTo;\r\n\n\n/***/ },\n/* 14 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0);\r\n\r\nlet clearRect = (...args) => new Instruction('clearRect',\r\n  args.length > 2 ?\r\n    { x: args[0], y: args[1], width: args[2], height: args[3] } :\r\n    { x: 0, y: 0, width: args[0], height: args[1] }\r\n);\r\n\r\n\r\nmodule.exports = clearRect;\r\n\n\n/***/ },\n/* 15 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0);\r\n\r\nlet begin = new Instruction('beginClip'),\r\n  performClip = new Instruction('clip'),\r\n  end = new Instruction('endClip');\r\n\r\nlet clip = (path, ...children) => [\r\n  begin,\r\n  path,\r\n  performClip,\r\n  children,\r\n  end\r\n];\r\n\r\nmodule.exports = clip;\r\n\n\n/***/ },\n/* 16 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0);\r\nlet cache = new Instruction('clipPath');\r\n\r\nlet clipPath = () => cache;\r\n\r\nmodule.exports = clipPath;\r\n\n\n/***/ },\n/* 17 */\n/***/ function(module, exports) {\n\nlet createRegularPolygon = (radius = 0, position = [0, 0], sides = 3) => {\r\n  let polygon = [];\r\n  for(let i = 0; i < sides; i++) {\r\n    polygon.push([\r\n      position[0] + radius * Math.cos(Math.PI * 2 * i / sides),\r\n      position[1] + radius * Math.sin(Math.PI * 2 * i / sides)\r\n    ]);\r\n  }\r\n  return polygon;\r\n};\r\n\r\nmodule.exports = createRegularPolygon;\r\n\n\n/***/ },\n/* 18 */\n/***/ function(module, exports) {\n\nlet concat = [].concat;\r\n\r\nlet createWrapper = (...args) => {\r\n  for(let i = 0; i < args.length; i++) {\r\n    //parse and flatten the arguments\r\n    while (args[i] && args[i].constructor === Array) {\r\n      args = concat.apply([], args).filter(Boolean);\r\n    }\r\n\r\n    if (!args[i]) {\r\n      continue;\r\n    }\r\n\r\n    let { type } = args[i];\r\n    if (type === 'placeholder') {\r\n      // i is set to the placeholder index now\r\n\r\n      //now grab all the elements to the left of the placeHolder\r\n      let left = args.splice(0, i);\r\n\r\n      //remove the placeHolder from the array\r\n      args.shift();\r\n\r\n      return (...children) => [left, children, args];\r\n    }\r\n  }\r\n\r\n  throw new Error('Could not find placeholder, did you forget the e2d.placeHolder() call?');\r\n};\r\n\r\nmodule.exports = concat;\r\n\n\n/***/ },\n/* 19 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0);\r\n\r\nlet drawImage = (...args) => {\r\n  let [img, sx, sy, sWidth, sHeight, dx, dy, dWidth, dHeight] = args;\r\n\r\n  if (args.length === 9) {\r\n    return new Instruction('drawImageSource', {\r\n      img,\r\n      sx,\r\n      sy,\r\n      sWidth,\r\n      sHeight,\r\n      dx,\r\n      dy,\r\n      dWidth,\r\n      dHeight\r\n    });\r\n  }\r\n\r\n  if (args.length >= 5) {\r\n    return new Instruction('drawImageSize', {\r\n      img,\r\n      dx: sx,\r\n      dy: sy,\r\n      dWidth: sWidth,\r\n      dHeight: sHeight\r\n    });\r\n  }\r\n\r\n  if (args.length >= 3) {\r\n    return new Instruction('drawImage', {\r\n      img,\r\n      dx: sx,\r\n      dy: sy\r\n    });\r\n  }\r\n\r\n  return new Instruction('drawImage', {\r\n    img,\r\n    dx: 0,\r\n    dy: 0\r\n  });\r\n};\r\n\r\nmodule.exports = drawImage;\r\n\n\n/***/ },\n/* 20 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0),\r\n    pi2 = Math.PI * 2;\r\n\r\nlet ellipse = (...args) => {\r\n  let [x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise] = args;\r\n\r\n  let props = { x: 0, y: 0, radiusX: x, radiusY: y, rotation: 0, startAngle: 0, endAngle: pi2, anticlockwise: false };\r\n\r\n  if (args.length > 5) {\r\n    props.startAngle = startAngle;\r\n    props.endAngle = endAngle;\r\n    props.anticlockwise = !!anticlockwise;\r\n  }\r\n\r\n  if (args.length > 4) {\r\n    props.rotation = rotation;\r\n  }\r\n\r\n  if (args.length > 2){\r\n    props.x = x;\r\n    props.y = y;\r\n    props.radiusX = radiusX;\r\n    props.radiusY = radiusY;\r\n  }\r\n\r\n  return new Instruction(\"ellipse\",  props);\r\n};\r\n\r\nmodule.exports = ellipse;\r\n\n\n/***/ },\n/* 21 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0);\r\nlet cache = new Instruction('fill');\r\n\r\nlet fill = () => cache;\r\n\r\nmodule.exports = fill;\r\n\n\n/***/ },\n/* 22 */\n/***/ function(module, exports, __webpack_require__) {\n\n\r\n\r\nlet Instruction = __webpack_require__(0),\r\n    pi2 = Math.PI * 2;\r\n\r\nlet fillArc = (...args) => {\r\n  let [x, y, r, startAngle, endAngle, counterclockwise] = args;\r\n  let props = { x: 0, y: 0, r: x, startAngle: 0, endAngle: pi2, counterclockwise: false };\r\n\r\n\r\n  if (args.length > 3) {\r\n    props.startAngle = startAngle;\r\n    props.endAngle = endAngle;\r\n    props.counterclockwise = !!counterclockwise;\r\n  }\r\n\r\n  if (args.length >= 2) {\r\n    props.x = x;\r\n    props.y = y;\r\n    props.r = r;\r\n  }\r\n\r\n  return new Instruction(\"fillArc\",  props);\r\n};\r\n\r\nmodule.exports = fillArc;\r\n\n\n/***/ },\n/* 23 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0);\r\n\r\nlet fillRect = (...args) => new Instruction('fillRect',\r\n  args.length > 2 ?\r\n    { x: args[0], y: args[1], width: args[2], height: args[3] } :\r\n    { x: 0, y: 0, width: args[0], height: args[1] }\r\n);\r\n\r\nmodule.exports = fillRect;\r\n\n\n/***/ },\n/* 24 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0);\r\nlet end = new Instruction('endFillStyle');\r\n\r\nlet fillStyle = (value, ...children) => [\r\n    new Instruction('fillStyle', { value }),\r\n    children,\r\n    end\r\n];\r\n\r\nmodule.exports = fillStyle;\r\n\n\n/***/ },\n/* 25 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0);\r\n\r\nlet fillText = (...args) => {\r\n  let [text, x, y, maxWidth] = args;\r\n  if (args.length < 4) {\r\n    maxWidth = null;\r\n  }\r\n  if (args.length < 3) {\r\n    x = 0;\r\n    y = 0;\r\n  }\r\n  return new Instruction('fillText', { text, x, y, maxWidth });\r\n};\r\n\r\nmodule.exports = fillText;\n\n/***/ },\n/* 26 */\n/***/ function(module, exports, __webpack_require__) {\n\n\r\n\r\nlet Instruction = __webpack_require__(0);\r\nlet end = new Instruction('endGlobalAlpha');\r\n\r\nlet globalAlpha = (value, ...children) => [\r\n  new Instruction('globalAlpha', { value }),\r\n  children,\r\n  end\r\n];\r\nmodule.exports = globalAlpha;\r\n\n\n/***/ },\n/* 27 */\n/***/ function(module, exports, __webpack_require__) {\n\n\r\n\r\nvar Instruction = __webpack_require__(0);\r\n\r\nlet end = new Instruction('endGlobalCompositeOperation');\r\n\r\nlet globalCompositeOperation = (value, ...children) => [\r\n  new Instruction('globalCompositeOperation', { value }),\r\n  children,\r\n  end\r\n];\r\n\r\nmodule.exports = globalCompositeOperation;\r\n\n\n/***/ },\n/* 28 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0);\r\n\r\nlet hitRect = (id, ...args) => {\r\n  let [x, y, width, height] = args;\r\n  if (args.length <= 3) {\r\n    width = x;\r\n    height = y;\r\n    x = 0;\r\n    y = 0;\r\n  }\r\n  return new Instruction('hitRect', {\r\n    id,\r\n    points: [\r\n      [x, y],\r\n      [x + width, y + height]\r\n    ]\r\n  });\r\n};\r\n\r\nmodule.exports = hitRect;\n\n/***/ },\n/* 29 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0);\r\n\r\nlet hitRegion = (id, points) => new Instruction('hitRegion', { id, points });\r\n\r\nmodule.exports = hitRegion;\r\n\n\n/***/ },\n/* 30 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0);\r\nlet end = new Instruction('endImageSmoothingEnabled');\r\n\r\nlet imageSmoothingEnabled = (value, ...children) => [\r\n  new Instruction('imageSmoothingEnabled', { value }),\r\n  children,\r\n  end\r\n];\r\nmodule.exports = imageSmoothingEnabled;\r\n\n\n/***/ },\n/* 31 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet keycode = __webpack_require__(56);\r\n\r\nmodule.exports = (ctx) => {\r\n  let { canvas } = ctx;\r\n\r\n  //mouseData\r\n  canvas[Symbol.for('mouseData')] = {\r\n    x: 0,\r\n    y: 0,\r\n    dx: 0,\r\n    dy: 0,\r\n    previousX: 0,\r\n    previousY: 0,\r\n    state: false,\r\n    clicked: 0\r\n  };\r\n\r\n  let keys = canvas[Symbol.for('keyData')] = {};\r\n\r\n  for (let name in keycode.code) {\r\n    if (keycode.code.hasOwnProperty(name)) {\r\n      keys[name] = false;\r\n    }\r\n  }\r\n\r\n  //mouse regions\r\n  canvas[Symbol.for('regions')] = [];\r\n  canvas[Symbol.for('mousePoints')] = [];\r\n\r\n  //make the canvas receive touch and mouse events\r\n  canvas.tabIndex = 1;\r\n\r\n  let mouseMove = (evt) => {\r\n    let { clientX, clientY } = evt;\r\n    //get left and top coordinates\r\n    let { left, top } = canvas.getBoundingClientRect();\r\n\r\n    let mouseData = canvas[Symbol.for('mouseData')];\r\n\r\n    let point = [clientX - left, clientY - top, mouseData.state];\r\n\r\n    mouseData.x = point[0];\r\n    mouseData.y = point[1];\r\n\r\n    let points = canvas[Symbol.for('mousePoints')];\r\n\r\n    points.push(point);\r\n\r\n    //store the last 100 stored positions for hover detection\r\n    if (points.length > 100) {\r\n      points.splice(0, points.length - 100);\r\n    }\r\n\r\n    evt.preventDefault();\r\n    return false;\r\n  };\r\n\r\n  canvas.addEventListener('mousemove', (evt) => mouseMove(evt));\r\n  canvas.addEventListener('mousedown', (evt) => {\r\n    let { target } = evt;\r\n    if (target === canvas) {\r\n      let mouseData = canvas[Symbol.for('mouseData')];\r\n\r\n      if (!mouseData.state) {\r\n        mouseData.clicked += 1;\r\n      }\r\n\r\n      mouseData.state = true;\r\n      return mouseMove(evt);\r\n    }\r\n  });\r\n  canvas.addEventListener('mouseup', (evt) => {\r\n    let mouseData = canvas[Symbol.for('mouseData')];\r\n    mouseData.state = false;\r\n    return mouseMove(evt);\r\n  });\r\n  canvas.addEventListener('keydown', (evt) => {\r\n    canvas[Symbol.for('keyData')][keycode(evt.keyCode)] = true;\r\n    evt.preventDefault();\r\n    return false;\r\n  });\r\n  canvas.addEventListener('keyup', (evt) => {\r\n    canvas[Symbol.for('keyData')][keycode(evt.keyCode)] = false;\r\n    evt.preventDefault();\r\n    return false;\r\n  });\r\n};\n\n/***/ },\n/* 32 */\n/***/ function(module, exports) {\n\nmodule.exports = (ctx) => ctx.canvas[Symbol.for('keyData')];\n\n/***/ },\n/* 33 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0);\r\nlet end = new Instruction('endLineStyle');\r\n\r\nlet lineStyle = (value, ...children) => {\r\n\r\n  value = value || {};\r\n  var result = {\r\n    lineWidth: null,\r\n    lineCap: null,\r\n    lineJoin: null,\r\n    miterLimit: null,\r\n    lineDash: null,\r\n    lineDashOffset: null\r\n  };\r\n\r\n  if (typeof value.lineWidth !== 'undefined') {\r\n    result.lineWidth = value.lineWidth;\r\n  }\r\n  if (typeof value.lineCap !== 'undefined') {\r\n    result.lineCap = value.lineCap;\r\n  }\r\n  if (typeof value.lineJoin !== 'undefined') {\r\n    result.lineJoin = value.lineJoin;\r\n  }\r\n  if (typeof value.miterLimit !== 'undefined') {\r\n    result.miterLimit = value.miterLimit;\r\n  }\r\n  if (typeof value.lineDash !== 'undefined') {\r\n    result.lineDash = value.lineDash || [];\r\n  }\r\n  if (typeof value.lineDashOffset !== 'undefined') {\r\n    result.lineDashOffset = value.lineDashOffset;\r\n  }\r\n  return [\r\n    new Instruction('lineStyle', result),\r\n    children,\r\n    end\r\n  ];\r\n};\r\n\r\nmodule.exports = lineStyle;\r\n\n\n/***/ },\n/* 34 */\n/***/ function(module, exports) {\n\nmodule.exports = (ctx) => ctx.canvas[Symbol.for('mouseData')];\n\n/***/ },\n/* 35 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet moveTo = __webpack_require__(7), lineTo = __webpack_require__(6);\r\n\r\nlet moveToLineTo = (point, index) => index === 0 ?\r\n  moveTo(point[0], point[1]) :\r\n  lineTo(point[0], point[1]);\r\n\r\nmodule.exports = moveToLineTo;\r\n\n\n/***/ },\n/* 36 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet beginPath = __webpack_require__(2)(),\r\n    closePath = __webpack_require__(3)();\r\n\r\nlet path = (...children) => [\r\n  beginPath,\r\n  children,\r\n  closePath\r\n];\r\n\r\nmodule.exports = path;\r\n\n\n/***/ },\n/* 37 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0);\r\n\r\nlet cache = new Instruction('placeholder');\r\nlet placeHolder = () => cache;\r\n\r\nmodule.exports = placeHolder;\r\n\n\n/***/ },\n/* 38 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0);\r\n\r\nlet quadraticCurveTo = (cpx, cpy, x, y) => new Instruction('quadraticCurveTo', {\r\n  cpx,\r\n  cpy,\r\n  x,\r\n  y\r\n});\r\n\r\nmodule.exports = quadraticCurveTo;\r\n\n\n/***/ },\n/* 39 */\n/***/ function(module, exports) {\n\nlet raf = (func) => {\r\n  requestAnimationFrame(() => raf(func));\r\n  return func();\r\n};\r\n\r\nmodule.exports = raf;\n\n/***/ },\n/* 40 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0);\r\n\r\nlet rect = (...args) => new Instruction('rect',\r\n  args.length > 2 ?\r\n    { x: args[0], y: args[1], width: args[2], height: args[3] } :\r\n    { x: 0, y: 0, width: args[0], height: args[1] }\r\n);\r\n\r\nmodule.exports = rect;\r\n\n\n/***/ },\n/* 41 */\n/***/ function(module, exports, __webpack_require__) {\n\n\r\n//initialize all the properties\r\n\r\nlet identity = [1, 0, 0, 1, 0, 0],\r\n  matrix = new Float64Array(identity),\r\n  fillStyleStack = [],\r\n  strokeStyleStack = [],\r\n  lineStyleStack = [],\r\n  textStyleStack = [],\r\n  shadowStyleStack = [],\r\n  globalCompositeOperationStack = [],\r\n  globalAlphaStack = [],\r\n  imageSmoothingEnabledStack = [],\r\n  transformStack = new Float64Array(501 * 6),\r\n  transformStackIndex = 6,\r\n  concat = [].concat,\r\n  supportsEllipse = false;\r\n\r\nif (typeof CanvasRenderingContext2D !== 'undefined') {\r\n  supportsEllipse = CanvasRenderingContext2D.prototype.hasOwnProperty('ellipse');\r\n}\r\n\r\n//transform points function\r\nconst transformPoints = __webpack_require__(1);\r\nconst cycleMouseData = __webpack_require__(4);\r\n\r\nconst increaseTransformStackSize = () => {\r\n  let cache = transformStack;\r\n  transformStack = new Float64Array(transformStack.length + 600); //add 100 more\r\n  transformStack.set(cache);\r\n  return this;\r\n};\r\n\r\ntransformStack.set(identity);\r\n\r\nconst PI2 = Math.PI * 2;\r\n\r\nlet empty = (target) => target && target.splice(0, target.length);\r\n\r\nmodule.exports = (...args) => {\r\n  let children = args.slice(0, -1),\r\n   ctx = args[args.length - 1];\r\n\r\n  let regions = ctx.canvas[Symbol.for('regions')],\r\n    mousePoints = ctx.canvas[Symbol.for('mousePoints')],\r\n    extensions = ctx.canvas[Symbol.for('extensions')];\r\n\r\n  let cache;\r\n\r\n  cycleMouseData(ctx);\r\n\r\n  empty(regions);\r\n  empty(mousePoints);\r\n\r\n  let len = children.length;\r\n\r\n  //flatten children during the loop process to save cpu\r\n  for (let i = 0; i < len; i++) {\r\n    let child = children[i];\r\n\r\n    //flattening algorithm\r\n    if (child && child.constructor === Array) {\r\n      children = concat.apply([], children);\r\n      child = children[i];\r\n\r\n      //repeat as necessary\r\n      while (child && child.constructor === Array) {\r\n        children = concat.apply([], children);\r\n        child = children[i];\r\n      }\r\n\r\n      len = children.length;\r\n    }\r\n\r\n    //child must be truthy\r\n    if (!child) {\r\n      continue;\r\n    }\r\n\r\n    let { props, type } = child;\r\n\r\n    if (type === 'transform') {\r\n\r\n      //copy transformStack values to matrix\r\n      matrix[0] = transformStack[transformStackIndex - 6];\r\n      matrix[1] = transformStack[transformStackIndex - 5];\r\n      matrix[2] = transformStack[transformStackIndex - 4];\r\n      matrix[3] = transformStack[transformStackIndex - 3];\r\n      matrix[4] = transformStack[transformStackIndex - 2];\r\n      matrix[5] = transformStack[transformStackIndex - 1];\r\n\r\n      //increase the index\r\n      transformStackIndex += 6;\r\n      if (transformStackIndex > transformStack.length) {\r\n        increaseTransformStackSize();\r\n      }\r\n\r\n      //perform the transform math\r\n      transformStack[transformStackIndex - 6] = //d\r\n        matrix[0] * props[0] + matrix[2] * props[1];\r\n      transformStack[transformStackIndex - 5] = //b\r\n        matrix[1] * props[0] + matrix[3] * props[1];\r\n      transformStack[transformStackIndex - 4] = //c\r\n        matrix[0] * props[2] + matrix[2] * props[3];\r\n      transformStack[transformStackIndex - 3] = //d\r\n        matrix[1] * props[2] + matrix[3] * props[3];\r\n      transformStack[transformStackIndex - 2] = //e\r\n        matrix[0] * props[4] + matrix[2] * props[5] + matrix[4];\r\n      transformStack[transformStackIndex - 1] = //f\r\n        matrix[1] * props[4] + matrix[3] * props[5] + matrix[5];\r\n\r\n      //modify the ctx\r\n      ctx.setTransform(\r\n        transformStack[transformStackIndex - 6],\r\n        transformStack[transformStackIndex - 5],\r\n        transformStack[transformStackIndex - 4],\r\n        transformStack[transformStackIndex - 3],\r\n        transformStack[transformStackIndex - 2],\r\n        transformStack[transformStackIndex - 1]\r\n      );\r\n      continue;\r\n    }\r\n\r\n    if (type === 'setTransform') {\r\n      transformStackIndex += 6;\r\n      if (transformStackIndex > transformStack.length) {\r\n        increaseTransformStackSize();\r\n      }\r\n\r\n      transformStack[transformStackIndex - 6] = props[0];//a\r\n      transformStack[transformStackIndex - 5] = props[1];//b\r\n      transformStack[transformStackIndex - 4] = props[2];//c\r\n      transformStack[transformStackIndex - 3] = props[3];//d\r\n      transformStack[transformStackIndex - 2] = props[4];//e\r\n      transformStack[transformStackIndex - 1] = props[5];//f\r\n      ctx.setTransform(props[0], props[1], props[2], props[3], props[4], props[5]);\r\n\r\n      continue;\r\n    }\r\n\r\n    if (type === 'scale') {\r\n      matrix[0] = transformStack[transformStackIndex - 6];\r\n      matrix[1] = transformStack[transformStackIndex - 5];\r\n      matrix[2] = transformStack[transformStackIndex - 4];\r\n      matrix[3] = transformStack[transformStackIndex - 3];\r\n      matrix[4] = transformStack[transformStackIndex - 2];\r\n      matrix[5] = transformStack[transformStackIndex - 1];\r\n\r\n      transformStackIndex += 6;\r\n      if (transformStackIndex > transformStack.length) {\r\n        increaseTransformStackSize();\r\n      }\r\n\r\n      transformStack[transformStackIndex - 6] = matrix[0] * props.x; //a\r\n      transformStack[transformStackIndex - 5] = matrix[1] * props.x; //b\r\n      transformStack[transformStackIndex - 4] = matrix[2] * props.y; //c\r\n      transformStack[transformStackIndex - 3] = matrix[3] * props.y; //d\r\n      transformStack[transformStackIndex - 2] = matrix[4]; //e\r\n      transformStack[transformStackIndex - 1] = matrix[5]; //f\r\n\r\n      ctx.setTransform(\r\n        transformStack[transformStackIndex - 6],\r\n        transformStack[transformStackIndex - 5],\r\n        transformStack[transformStackIndex - 4],\r\n        transformStack[transformStackIndex - 3],\r\n        transformStack[transformStackIndex - 2],\r\n        transformStack[transformStackIndex - 1]\r\n      );\r\n\r\n      continue;\r\n    }\r\n\r\n    if (type === 'translate') {\r\n      matrix[0] = transformStack[transformStackIndex - 6];\r\n      matrix[1] = transformStack[transformStackIndex - 5];\r\n      matrix[2] = transformStack[transformStackIndex - 4];\r\n      matrix[3] = transformStack[transformStackIndex - 3];\r\n      matrix[4] = transformStack[transformStackIndex - 2];\r\n      matrix[5] = transformStack[transformStackIndex - 1];\r\n\r\n      transformStackIndex += 6;\r\n      if (transformStackIndex > transformStack.length) {\r\n        increaseTransformStackSize();\r\n      }\r\n\r\n      transformStack[transformStackIndex - 6] = matrix[0]; //a\r\n      transformStack[transformStackIndex - 5] = matrix[1]; //b\r\n      transformStack[transformStackIndex - 4] = matrix[2]; //c\r\n      transformStack[transformStackIndex - 3] = matrix[3]; //d\r\n      transformStack[transformStackIndex - 2] = matrix[4] + matrix[0] * props.x + matrix[2] * props.y; //e\r\n      transformStack[transformStackIndex - 1] = matrix[5] + matrix[1] * props.x + matrix[3] * props.y; //f\r\n\r\n      ctx.setTransform(\r\n        transformStack[transformStackIndex - 6],\r\n        transformStack[transformStackIndex - 5],\r\n        transformStack[transformStackIndex - 4],\r\n        transformStack[transformStackIndex - 3],\r\n        transformStack[transformStackIndex - 2],\r\n        transformStack[transformStackIndex - 1]\r\n      );\r\n      continue;\r\n    }\r\n\r\n    if (type === 'rotate') {\r\n      matrix[0] = transformStack[transformStackIndex - 6];\r\n      matrix[1] = transformStack[transformStackIndex - 5];\r\n      matrix[2] = transformStack[transformStackIndex - 4];\r\n      matrix[3] = transformStack[transformStackIndex - 3];\r\n      matrix[4] = transformStack[transformStackIndex - 2];\r\n      matrix[5] = transformStack[transformStackIndex - 1];\r\n\r\n      transformStackIndex += 6;\r\n      if (transformStackIndex > transformStack.length) {\r\n        increaseTransformStackSize();\r\n      }\r\n\r\n      transformStack[transformStackIndex - 6] =\r\n        matrix[0] * props.cos + matrix[2] * props.sin; //a\r\n      transformStack[transformStackIndex - 5] =\r\n        matrix[1] * props.cos + matrix[3] * props.sin; //b\r\n      transformStack[transformStackIndex - 4] =\r\n        matrix[0] * -props.sin + matrix[2] * props.cos; //c\r\n      transformStack[transformStackIndex - 3] =\r\n        matrix[1] * -props.sin + matrix[3] * props.cos; //d\r\n      transformStack[transformStackIndex - 2] = matrix[4]; //e\r\n      transformStack[transformStackIndex - 1] = matrix[5];//f\r\n\r\n      ctx.setTransform(\r\n        transformStack[transformStackIndex - 6],\r\n        transformStack[transformStackIndex - 5],\r\n        transformStack[transformStackIndex - 4],\r\n        transformStack[transformStackIndex - 3],\r\n        transformStack[transformStackIndex - 2],\r\n        transformStack[transformStackIndex - 1]\r\n      );\r\n      continue;\r\n    }\r\n\r\n    if (type === 'skewX') {\r\n      matrix[0] = transformStack[transformStackIndex - 6];\r\n      matrix[1] = transformStack[transformStackIndex - 5];\r\n      matrix[2] = transformStack[transformStackIndex - 4];\r\n      matrix[3] = transformStack[transformStackIndex - 3];\r\n      matrix[4] = transformStack[transformStackIndex - 2];\r\n      matrix[5] = transformStack[transformStackIndex - 1];\r\n\r\n      transformStackIndex += 6;\r\n      if (transformStackIndex > transformStack.length) {\r\n        increaseTransformStackSize();\r\n      }\r\n\r\n      transformStack[transformStackIndex - 6] = matrix[0]; //a\r\n      transformStack[transformStackIndex - 5] = matrix[1]; //b\r\n      transformStack[transformStackIndex - 4] = //c\r\n        matrix[0] * props.x + matrix[2];\r\n      transformStack[transformStackIndex - 3] = //d\r\n        matrix[1] * props.x + matrix[3];\r\n      transformStack[transformStackIndex - 2] = matrix[4]; //e\r\n      transformStack[transformStackIndex - 1] = matrix[5]; //f\r\n\r\n\r\n      ctx.setTransform(\r\n        transformStack[transformStackIndex - 6],\r\n        transformStack[transformStackIndex - 5],\r\n        transformStack[transformStackIndex - 4],\r\n        transformStack[transformStackIndex - 3],\r\n        transformStack[transformStackIndex - 2],\r\n        transformStack[transformStackIndex - 1]\r\n      );\r\n      continue;\r\n    }\r\n\r\n    if (type === 'skewY') {\r\n      matrix[0] = transformStack[transformStackIndex - 6];\r\n      matrix[1] = transformStack[transformStackIndex - 5];\r\n      matrix[2] = transformStack[transformStackIndex - 4];\r\n      matrix[3] = transformStack[transformStackIndex - 3];\r\n      matrix[4] = transformStack[transformStackIndex - 2];\r\n      matrix[5] = transformStack[transformStackIndex - 1];\r\n\r\n      transformStackIndex += 6;\r\n      if (transformStackIndex > transformStack.length) {\r\n        increaseTransformStackSize();\r\n      }\r\n\r\n      transformStack[transformStackIndex - 6] =\r\n        matrix[0] * 1 + matrix[2] * props.y; //a\r\n      transformStack[transformStackIndex - 5] =\r\n        matrix[1] * 1 + matrix[3] * props.y; //b\r\n      transformStack[transformStackIndex - 4] = matrix[2]; //c\r\n      transformStack[transformStackIndex - 3] = matrix[3]; //d\r\n\r\n      transformStack[transformStackIndex - 2] = matrix[4]; //e\r\n      transformStack[transformStackIndex - 1] = matrix[5]; //f\r\n\r\n      ctx.setTransform(\r\n        transformStack[transformStackIndex - 6],\r\n        transformStack[transformStackIndex - 5],\r\n        transformStack[transformStackIndex - 4],\r\n        transformStack[transformStackIndex - 3],\r\n        transformStack[transformStackIndex - 2],\r\n        transformStack[transformStackIndex - 1]\r\n      );\r\n      continue;\r\n    }\r\n\r\n    if (type === 'restore') {\r\n      transformStackIndex -= 6;\r\n      matrix[0] = transformStack[transformStackIndex - 6];\r\n      matrix[1] = transformStack[transformStackIndex - 5];\r\n      matrix[2] = transformStack[transformStackIndex - 4];\r\n      matrix[3] = transformStack[transformStackIndex - 3];\r\n      matrix[4] = transformStack[transformStackIndex - 2];\r\n      matrix[5] = transformStack[transformStackIndex - 1];\r\n\r\n      ctx.setTransform(matrix[0], matrix[1], matrix[2], matrix[3], matrix[4], matrix[5]);\r\n      continue;\r\n    }\r\n\r\n    if (type === 'fillRect') {\r\n      ctx.fillRect(props.x, props.y, props.width, props.height);\r\n      continue;\r\n    }\r\n\r\n    if (type === 'strokeRect') {\r\n      ctx.strokeRect(props.x, props.y, props.width, props.height);\r\n      continue;\r\n    }\r\n\r\n    if (type === 'clearRect') {\r\n      ctx.clearRect(props.x, props.y, props.width, props.height);\r\n      continue;\r\n    }\r\n\r\n    if (type === 'rect') {\r\n      ctx.rect(props.x, props.y, props.width, props.height);\r\n      continue;\r\n    }\r\n\r\n    if (type === 'fillStyle') {\r\n      fillStyleStack.push(ctx.fillStyle);\r\n      ctx.fillStyle = props.value;\r\n      continue;\r\n    }\r\n\r\n    if (type === 'strokeStyle') {\r\n      strokeStyleStack.push(ctx.strokeStyle);\r\n      ctx.strokeStyle = props.value;\r\n      continue;\r\n    }\r\n\r\n    if (type === 'endFillStyle') {\r\n      ctx.fillStyle = fillStyleStack.pop();\r\n\r\n      continue;\r\n    }\r\n\r\n    if (type === 'endStrokeStyle') {\r\n      ctx.strokeStyle = strokeStyleStack.pop();\r\n      continue;\r\n    }\r\n    if (type === 'lineStyle') {\r\n      lineStyleStack.push({\r\n        lineWidth: ctx.lineWidth,\r\n        lineCap: ctx.lineCap,\r\n        lineJoin: ctx.lineJoin,\r\n        miterLimit: ctx.miterLimit,\r\n        lineDash: ctx.getLineDash(),\r\n        lineDashOffset: ctx.lineDashOffset\r\n      });\r\n\r\n      if (props.lineWidth !== null) {\r\n        ctx.lineWidth = props.lineWidth;\r\n      }\r\n      if (props.lineCap !== null) {\r\n        ctx.lineCap = props.lineCap;\r\n      }\r\n      if (props.lineJoin !== null) {\r\n        ctx.lineJoin = props.lineJoin;\r\n      }\r\n      if (props.miterLimit !== null) {\r\n        ctx.miterLimit = props.miterLimit;\r\n      }\r\n      if (props.lineDash !== null) {\r\n        ctx.setLineDash(props.lineDash);\r\n      }\r\n\r\n      if (props.lineDashOffset !== null) {\r\n        ctx.lineDashOffset = props.lineDashOffset;\r\n      }\r\n      continue;\r\n    }\r\n\r\n    if (type === 'endLineStyle') {\r\n      cache = lineStyleStack.pop();\r\n      ctx.lineWidth = cache.lineWidth;\r\n      ctx.lineCap = cache.lineCap;\r\n      ctx.lineJoin = cache.lineJoin;\r\n      ctx.miterLimit = cache.miterLimit;\r\n      ctx.setLineDash(cache.lineDash);\r\n      ctx.lineDashOffset = cache.lineDashOffset;\r\n      continue;\r\n    }\r\n\r\n    if (type === 'textStyle') {\r\n      textStyleStack.push({\r\n        font: ctx.font,\r\n        textAlign: ctx.textAlign,\r\n        textBaseline: ctx.textBaseline,\r\n        direction: ctx.direction\r\n      });\r\n      if (props.font !== null) {\r\n        ctx.font = props.font;\r\n      }\r\n      if (props.textAlign !== null) {\r\n        ctx.textAlign = props.textAlign;\r\n      }\r\n      if (props.textBaseline !== null) {\r\n        ctx.textBaseline = props.textBaseline;\r\n      }\r\n      if (props.direction !== null) {\r\n        ctx.direction = props.direction;\r\n      }\r\n      continue;\r\n    }\r\n\r\n    if (type === 'endTextStyle') {\r\n      cache = textStyleStack.pop();\r\n      ctx.font = cache.font;\r\n      ctx.textAlign = cache.textAlign;\r\n      ctx.textBaseline = cache.textBaseline;\r\n      ctx.direction = cache.direction;\r\n      continue;\r\n    }\r\n\r\n    if (type === 'shadowStyle') {\r\n      shadowStyleStack.push({\r\n        shadowBlur: ctx.shadowBlur,\r\n        shadowColor: ctx.shadowColor,\r\n        shadowOffsetX: ctx.shadowOffsetX,\r\n        shadowOffsetY: ctx.shadowOffsetY\r\n      });\r\n      if (props.shadowBlur !== null) {\r\n        ctx.shadowBlur = props.shadowBlur;\r\n      }\r\n      if (props.shadowColor !== null) {\r\n        ctx.shadowColor = props.shadowColor;\r\n      }\r\n      if (props.shadowOffsetX !== null) {\r\n        ctx.shadowOffsetX = props.shadowOffsetX;\r\n      }\r\n      if (props.shadowOffsetY !== null) {\r\n        ctx.shadowOffsetY = props.shadowOffsetY;\r\n      }\r\n      continue;\r\n    }\r\n\r\n    if (type === 'endShadowStyle') {\r\n      cache = shadowStyleStack.pop();\r\n      ctx.shadowBlur = cache.shadowBlur;\r\n      ctx.shadowColor = cache.shadowColor;\r\n      ctx.shadowOffsetX = cache.shadowOffsetX;\r\n      ctx.shadowOffsetY = cache.shadowOffsetY;\r\n      continue;\r\n    }\r\n\r\n    if (type === 'strokeText') {\r\n      if (props.maxWidth) {\r\n        ctx.strokeText(props.text, props.x, props.y, props.maxWidth);\r\n        continue;\r\n      }\r\n      ctx.strokeText(props.text, props.x, props.y);\r\n      continue;\r\n    }\r\n\r\n    if (type === 'fillText') {\r\n      if (props.maxWidth) {\r\n        ctx.fillText(props.text, props.x, props.y, props.maxWidth);\r\n        continue;\r\n      }\r\n      ctx.fillText(props.text, props.x, props.y);\r\n      continue;\r\n    }\r\n\r\n    if (type === 'drawImage') {\r\n      ctx.drawImage(props.img, props.dx, props.dy);\r\n      continue;\r\n    }\r\n\r\n    if (type === 'drawImageSize') {\r\n      ctx.drawImage(props.img, props.dx, props.dy, props.dWidth, props.dHeight);\r\n      continue;\r\n    }\r\n\r\n    if (type === 'drawImageSource') {\r\n      ctx.drawImage(props.img, props.sx, props.sy, props.sWidth, props.sHeight, props.dx, props.dy, props.dWidth, props.dHeight);\r\n      continue;\r\n    }\r\n\r\n    if (type === 'strokeArc') {\r\n      ctx.beginPath();\r\n      ctx.arc(props.x, props.y, props.r, props.startAngle, props.endAngle, props.counterclockwise);\r\n      ctx.closePath();\r\n      ctx.stroke();\r\n      continue;\r\n    }\r\n\r\n    if (type === 'fillArc') {\r\n      ctx.beginPath();\r\n      ctx.arc(props.x, props.y, props.r, props.startAngle, props.endAngle, props.counterclockwise);\r\n      ctx.closePath();\r\n      ctx.fill();\r\n      continue;\r\n    }\r\n\r\n    if (type === 'moveTo') {\r\n      ctx.moveTo(props.x, props.y);\r\n      continue;\r\n    }\r\n\r\n    if (type === 'lineTo') {\r\n      ctx.lineTo(props.x, props.y);\r\n      continue;\r\n    }\r\n\r\n    if (type === 'bezierCurveTo') {\r\n      ctx.bezierCurveTo(props.cp1x, props.cp1y, props.cp2x, props.cp2y, props.x, props.y);\r\n      continue;\r\n    }\r\n\r\n    if (type === 'quadraticCurveTo') {\r\n      ctx.quadraticCurveTo(props.cpx, props.cpy, props.x, props.y);\r\n      continue;\r\n    }\r\n\r\n    if (type === 'arc') {\r\n      ctx.arc(props.x, props.y, props.r, props.startAngle, props.endAngle, props.counterclockwise);\r\n      continue;\r\n    }\r\n\r\n    if (type === 'arcTo') {\r\n      ctx.arcTo(props.x1, props.y1, props.x2, props.y2, props.r);\r\n      continue;\r\n    }\r\n\r\n    if (type === 'ellipse') {\r\n      //if the method is provided by the browser\r\n      if (supportsEllipse) {\r\n        ctx.ellipse(\r\n          props.x,\r\n          props.y,\r\n          props.radiusX,\r\n          props.radiusY,\r\n          props.rotation,\r\n          props.startAngle,\r\n          props.endAngle,\r\n          props.anticlockwise\r\n        );\r\n        continue;\r\n      }\r\n      ctx.save();\r\n      ctx.translate(props.x, props.y);\r\n      ctx.rotate(props.rotation);\r\n      ctx.scale(props.radiusX, props.radiusY);\r\n      ctx.arc(0, 0, 1, props.startAngle, props.endAngle, props.anticlockwise);\r\n      ctx.restore();\r\n      continue;\r\n    }\r\n\r\n    if (type === 'globalCompositeOperation') {\r\n      globalCompositeOperationStack.push(ctx.globalCompositeOperation);\r\n      ctx.globalCompositeOperation = props.value;\r\n      continue;\r\n    }\r\n\r\n    if (type === 'endGlobalCompositeOperation') {\r\n      ctx.globalCompositeOperation = globalCompositeOperationStack.pop();\r\n      continue;\r\n    }\r\n\r\n    if (type === 'fill') {\r\n      ctx.fill();\r\n      continue;\r\n    }\r\n\r\n    if (type === 'stroke') {\r\n      ctx.stroke();\r\n      continue;\r\n    }\r\n\r\n    if (type === 'beginClip') {\r\n      ctx.save();\r\n      ctx.beginPath();\r\n      continue;\r\n    }\r\n\r\n    if (type === 'clip') {\r\n      ctx.clip();\r\n      continue;\r\n    }\r\n\r\n    if (type === 'endClip') {\r\n      ctx.restore();\r\n      continue;\r\n    }\r\n\r\n    if (type === 'beginPath') {\r\n      ctx.beginPath();\r\n      continue;\r\n    }\r\n\r\n    if (type === 'closePath') {\r\n      ctx.closePath();\r\n      continue;\r\n    }\r\n\r\n    if (type === 'globalAlpha') {\r\n      globalAlphaStack.push(ctx.globalAlpha);\r\n      ctx.globalAlpha *= props.value;\r\n      continue;\r\n    }\r\n\r\n    if (type === 'endGlobalAlpha') {\r\n      ctx.globalAlpha = globalAlphaStack.pop();\r\n      continue;\r\n    }\r\n\r\n    if (type === 'hitRect' && regions) {\r\n      cache = [\r\n        transformStack[transformStackIndex - 6],\r\n        transformStack[transformStackIndex - 5],\r\n        transformStack[transformStackIndex - 4],\r\n        transformStack[transformStackIndex - 3],\r\n        transformStack[transformStackIndex - 2],\r\n        transformStack[transformStackIndex - 1]\r\n      ];\r\n\r\n      regions.push({\r\n        id: props.id,\r\n        points: props.points,\r\n        matrix: cache,\r\n        //rectangle!\r\n        polygon: false,\r\n        hover: false,\r\n        touched: false,\r\n        clicked: false\r\n      });\r\n    }\r\n\r\n    if (type === 'hitRegion' && regions) {\r\n      cache = [\r\n        transformStack[transformStackIndex - 6],\r\n        transformStack[transformStackIndex - 5],\r\n        transformStack[transformStackIndex - 4],\r\n        transformStack[transformStackIndex - 3],\r\n        transformStack[transformStackIndex - 2],\r\n        transformStack[transformStackIndex - 1]\r\n      ];\r\n\r\n      regions.push({\r\n        id: props.id,\r\n        points: props.points,\r\n        matrix: cache,\r\n        polygon: true,\r\n        hover: false,\r\n        touched: false,\r\n        clicked: false\r\n      });\r\n\r\n      continue;\r\n    }\r\n\r\n    if (type === 'imageSmoothingEnabled') {\r\n      imageSmoothingEnabledStack.push(ctx.imageSmoothingEnabled);\r\n      ctx.imageSmoothingEnabled = props.value;\r\n\r\n      continue;\r\n    }\r\n\r\n    if (type === 'endImageSmoothingEnabled') {\r\n      ctx.imageSmoothingEnabled = imageSmoothingEnabledStack.pop();\r\n      continue;\r\n    }\r\n\r\n    if (extensions && extensions[type]) {\r\n      extensions[type](props, ctx);\r\n      continue;\r\n    }\r\n  }\r\n};\n\n/***/ },\n/* 42 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet setTransform = __webpack_require__(9);\r\n\r\nlet resetTransform = (...children) => setTransform([1, 0, 0, 1, 0, 0], children);\r\n\r\nmodule.exports = resetTransform;\n\n/***/ },\n/* 43 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0);\r\nlet end = new Instruction('restore');\r\n\r\nlet rotate = (r, ...children) => [\r\n  new Instruction('rotate', { cos: Math.cos(r), sin: Math.sin(r) }),\r\n  children,\r\n  end\r\n];\r\n\r\nmodule.exports = rotate;\r\n\n\n/***/ },\n/* 44 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0);\r\nlet end = new Instruction('restore');\r\n\r\nlet scale = (x, y, ...children) => {\r\n  if (typeof y !== 'number') {\r\n    children = [y].concat(children);\r\n    y = x;\r\n  }\r\n\r\n  return [\r\n    new Instruction('scale', { x, y }),\r\n    children,\r\n    end\r\n  ];\r\n};\r\n\r\nmodule.exports = scale;\r\n\n\n/***/ },\n/* 45 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0);\r\nlet end = new Instruction('endShadowStyle');\r\n\r\nlet shadowStyle = (value, ...children) => {\r\n  value = value || {};\r\n  var result = {\r\n    shadowBlur: null,\r\n    shadowColor: null,\r\n    shadowOffsetX: null,\r\n    shadowOffsetY: null\r\n  };\r\n\r\n  if (typeof value.shadowBlur !== 'undefined') {\r\n    result.shadowBlur = value.shadowBlur;\r\n  }\r\n  if (typeof value.shadowColor !== 'undefined') {\r\n    result.shadowColor = value.shadowColor;\r\n  }\r\n  if (typeof value.shadowOffsetX !== 'undefined') {\r\n    result.shadowOffsetX = value.shadowOffsetX;\r\n  }\r\n  if (typeof value.direction !== 'undefined') {\r\n    result.shadowOffsetY = value.shadowOffsetY;\r\n  }\r\n\r\n  return [\r\n    new Instruction('shadowStyle', value),\r\n    children,\r\n    end\r\n  ];\r\n};\r\n\r\nmodule.exports = shadowStyle;\r\n\n\n/***/ },\n/* 46 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0);\r\nlet end = new Instruction('restore');\r\n\r\nlet skewX = (x, ...children) => [\r\n  new Instruction('skewX', { x: Math.tan(x) }),\r\n  children,\r\n  end\r\n];\r\n\r\nmodule.exports = skewX;\r\n\n\n/***/ },\n/* 47 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0);\r\nlet end = new Instruction('restore');\r\n\r\nlet skewY = (x, ...children) => [\r\n  new Instruction('skewY', { y: Math.tan(y) }),\r\n  children,\r\n  end\r\n];\r\n\r\nmodule.exports = skewY;\r\n\n\n/***/ },\n/* 48 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0);\r\nlet cache = new Instruction('stroke');\r\n\r\nlet stroke = () => cache;\r\nmodule.exports = stroke;\r\n\n\n/***/ },\n/* 49 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0),\r\n    pi2 = Math.PI * 2;\r\n\r\nlet strokeArc = (...args) => {\r\n  let [x, y, r, startAngle, endAngle, counterclockwise] = args;\r\n  let props = { x: 0, y: 0, r: x, startAngle: 0, endAngle: pi2, counterclockwise: false };\r\n\r\n\r\n  if (args.length > 3) {\r\n    props.startAngle = startAngle;\r\n    props.endAngle = endAngle;\r\n    props.counterclockwise = !!counterclockwise;\r\n  }\r\n\r\n  if (args.length > 1){\r\n    props.x = x;\r\n    props.y = y;\r\n    props.r = r;\r\n  }\r\n\r\n  return new Instruction(\"strokeArc\",  props);\r\n};\r\n\r\nmodule.exports = strokeArc;\r\n\n\n/***/ },\n/* 50 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0);\r\n\r\nlet strokeRect = (...args) => new Instruction('strokeRect',\r\n  args.length > 2 ?\r\n    { x: args[0], y: args[1], width: args[2], height: args[3] } :\r\n    { x: 0, y: 0, width: args[0], height: args[1] }\r\n);\r\n\r\nmodule.exports = strokeRect;\r\n\n\n/***/ },\n/* 51 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0);\r\nlet end = new Instruction('endStrokeStyle');\r\n\r\nlet strokeStyle = (value, ...children) => [\r\n  new Instruction('strokeStyle', { value }),\r\n  children,\r\n  end\r\n];\r\n\r\nmodule.exports = strokeStyle;\r\n\n\n/***/ },\n/* 52 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0);\r\n\r\nlet strokeText = (...args) => {\r\n  let [text, x, y, maxWidth] = args;\r\n\r\n  if (args.length < 4) {\r\n    maxWidth = null;\r\n  }\r\n  if (args.length < 3) {\r\n    x = 0;\r\n    y = 0;\r\n  }\r\n  return new Instruction('strokeText', {\r\n    text,\r\n    x,\r\n    y,\r\n    maxWidth\r\n  });\r\n};\r\n\r\nmodule.exports = strokeText;\n\n/***/ },\n/* 53 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0);\r\nlet end = new Instruction('endTextStyle');\r\n\r\nlet textStyle = (value, ...children) => {\r\n  value = value || {};\r\n  var result = {\r\n    font: null,\r\n    textAlign: null,\r\n    textBaseline: null,\r\n    direction: null\r\n  };\r\n\r\n  if (typeof value.font !== 'undefined') {\r\n    result.font = value.font;\r\n  }\r\n  if (typeof value.textAlign !== 'undefined') {\r\n    result.textAlign = value.textAlign;\r\n  }\r\n  if (typeof value.textBaseline !== 'undefined') {\r\n    result.textBaseline = value.textBaseline;\r\n  }\r\n  if (typeof value.direction !== 'undefined') {\r\n    result.direction = value.direction;\r\n  }\r\n\r\n  return [\r\n    new Instruction('textStyle', result),\r\n    children,\r\n    end\r\n  ];\r\n};\r\n\r\nmodule.exports = textStyle;\r\n\n\n/***/ },\n/* 54 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0);\r\nlet end = new Instruction('restore');\r\n\r\nlet transform = (values, ...children) => {\r\n  return [\r\n    new Instruction('transform',[\r\n      values[0],\r\n      values[1],\r\n      values[2],\r\n      values[3],\r\n      values[4],\r\n      values[5]\r\n    ]),\r\n    children,\r\n    end\r\n  ];\r\n};\r\n\r\n\r\nmodule.exports = transform;\r\n\n\n/***/ },\n/* 55 */\n/***/ function(module, exports, __webpack_require__) {\n\nlet Instruction = __webpack_require__(0);\r\nlet end = new Instruction('restore');\r\n\r\nlet translate = (x, y, ...children) => [\r\n  new Instruction('translate', { x: x, y: y }),\r\n  children,\r\n  end\r\n];\r\n\r\nmodule.exports = translate;\r\n\n\n/***/ },\n/* 56 */\n/***/ function(module, exports) {\n\n// Source: http://jsfiddle.net/vWx8V/\n// http://stackoverflow.com/questions/5603195/full-list-of-javascript-keycodes\n\n/**\n * Conenience method returns corresponding value for given keyName or keyCode.\n *\n * @param {Mixed} keyCode {Number} or keyName {String}\n * @return {Mixed}\n * @api public\n */\n\nexports = module.exports = function(searchInput) {\n  // Keyboard Events\n  if (searchInput && 'object' === typeof searchInput) {\n    var hasKeyCode = searchInput.which || searchInput.keyCode || searchInput.charCode\n    if (hasKeyCode) searchInput = hasKeyCode\n  }\n\n  // Numbers\n  if ('number' === typeof searchInput) return names[searchInput]\n\n  // Everything else (cast to string)\n  var search = String(searchInput)\n\n  // check codes\n  var foundNamedKey = codes[search.toLowerCase()]\n  if (foundNamedKey) return foundNamedKey\n\n  // check aliases\n  var foundNamedKey = aliases[search.toLowerCase()]\n  if (foundNamedKey) return foundNamedKey\n\n  // weird character?\n  if (search.length === 1) return search.charCodeAt(0)\n\n  return undefined\n}\n\n/**\n * Get by name\n *\n *   exports.code['enter'] // => 13\n */\n\nvar codes = exports.code = exports.codes = {\n  'backspace': 8,\n  'tab': 9,\n  'enter': 13,\n  'shift': 16,\n  'ctrl': 17,\n  'alt': 18,\n  'pause/break': 19,\n  'caps lock': 20,\n  'esc': 27,\n  'space': 32,\n  'page up': 33,\n  'page down': 34,\n  'end': 35,\n  'home': 36,\n  'left': 37,\n  'up': 38,\n  'right': 39,\n  'down': 40,\n  'insert': 45,\n  'delete': 46,\n  'command': 91,\n  'left command': 91,\n  'right command': 93,\n  'numpad *': 106,\n  'numpad +': 107,\n  'numpad -': 109,\n  'numpad .': 110,\n  'numpad /': 111,\n  'num lock': 144,\n  'scroll lock': 145,\n  'my computer': 182,\n  'my calculator': 183,\n  ';': 186,\n  '=': 187,\n  ',': 188,\n  '-': 189,\n  '.': 190,\n  '/': 191,\n  '`': 192,\n  '[': 219,\n  '\\\\': 220,\n  ']': 221,\n  \"'\": 222\n}\n\n// Helper aliases\n\nvar aliases = exports.aliases = {\n  'windows': 91,\n  '⇧': 16,\n  '⌥': 18,\n  '⌃': 17,\n  '⌘': 91,\n  'ctl': 17,\n  'control': 17,\n  'option': 18,\n  'pause': 19,\n  'break': 19,\n  'caps': 20,\n  'return': 13,\n  'escape': 27,\n  'spc': 32,\n  'pgup': 33,\n  'pgdn': 34,\n  'ins': 45,\n  'del': 46,\n  'cmd': 91\n}\n\n\n/*!\n * Programatically add the following\n */\n\n// lower case chars\nfor (i = 97; i < 123; i++) codes[String.fromCharCode(i)] = i - 32\n\n// numbers\nfor (var i = 48; i < 58; i++) codes[i - 48] = i\n\n// function keys\nfor (i = 1; i < 13; i++) codes['f'+i] = i + 111\n\n// numpad keys\nfor (i = 0; i < 10; i++) codes['numpad '+i] = i + 96\n\n/**\n * Get by code\n *\n *   exports.name[13] // => 'Enter'\n */\n\nvar names = exports.names = exports.title = {} // title for backward compat\n\n// Create reverse mapping\nfor (i in codes) names[codes[i]] = i\n\n// Add aliases\nfor (var alias in aliases) {\n  codes[alias] = aliases[alias]\n}\n\n\n/***/ },\n/* 57 */\n/***/ function(module, exports) {\n\nmodule.exports = function (point, vs) {\n    // ray-casting algorithm based on\n    // http://www.ecse.rpi.edu/Homepages/wrf/Research/Short_Notes/pnpoly.html\n    \n    var x = point[0], y = point[1];\n    \n    var inside = false;\n    for (var i = 0, j = vs.length - 1; i < vs.length; j = i++) {\n        var xi = vs[i][0], yi = vs[i][1];\n        var xj = vs[j][0], yj = vs[j][1];\n        \n        var intersect = ((yi > y) != (yj > y))\n            && (x < (xj - xi) * (y - yi) / (yj - yi) + xi);\n        if (intersect) inside = !inside;\n    }\n    \n    return inside;\n};\n\n\n/***/ },\n/* 58 */\n/***/ function(module, exports, __webpack_require__) {\n\nmodule.exports = {\n  'activeRegions': __webpack_require__(10),\n  'arc': __webpack_require__(11),\n  'arcTo': __webpack_require__(12),\n  'beginPath': __webpack_require__(2),\n  'bezierCurveTo': __webpack_require__(13),\n  'clearRect': __webpack_require__(14),\n  'clip': __webpack_require__(15),\n  'clipPath': __webpack_require__(16),\n  'closePath': __webpack_require__(3),\n  'createRegularPolygon': __webpack_require__(17),\n  'createWrapper': __webpack_require__(18),\n  'cycleMouseData': __webpack_require__(4),\n  'drawImage': __webpack_require__(19),\n  'ellipse': __webpack_require__(20),\n  'fill': __webpack_require__(21),\n  'fillArc': __webpack_require__(22),\n  'fillRect': __webpack_require__(23),\n  'fillStyle': __webpack_require__(24),\n  'fillText': __webpack_require__(25),\n  'globalAlpha': __webpack_require__(26),\n  'globalCompositeOperation': __webpack_require__(27),\n  'hitRect': __webpack_require__(28),\n  'hitRegion': __webpack_require__(29),\n  'imageSmoothingEnabled': __webpack_require__(30),\n  'initialize': __webpack_require__(31),\n  'Instruction': __webpack_require__(0),\n  'invertMatrix': __webpack_require__(5),\n  'keyData': __webpack_require__(32),\n  'lineStyle': __webpack_require__(33),\n  'lineTo': __webpack_require__(6),\n  'mouseData': __webpack_require__(34),\n  'moveTo': __webpack_require__(7),\n  'moveToLineTo': __webpack_require__(35),\n  'path': __webpack_require__(36),\n  'placeHolder': __webpack_require__(37),\n  'pointInRect': __webpack_require__(8),\n  'quadraticCurveTo': __webpack_require__(38),\n  'raf': __webpack_require__(39),\n  'rect': __webpack_require__(40),\n  'render': __webpack_require__(41),\n  'resetTransform': __webpack_require__(42),\n  'rotate': __webpack_require__(43),\n  'scale': __webpack_require__(44),\n  'setTransform': __webpack_require__(9),\n  'shadowStyle': __webpack_require__(45),\n  'skewX': __webpack_require__(46),\n  'skewY': __webpack_require__(47),\n  'stroke': __webpack_require__(48),\n  'strokeArc': __webpack_require__(49),\n  'strokeRect': __webpack_require__(50),\n  'strokeStyle': __webpack_require__(51),\n  'strokeText': __webpack_require__(52),\n  'textStyle': __webpack_require__(53),\n  'transform': __webpack_require__(54),\n  'transformPoints': __webpack_require__(1),\n  'translate': __webpack_require__(55)\n};\n\n/***/ }\n/******/ ]);\n});"]}
const rbush = require( "rbush" );
const ctx = document.createElement( "canvas" ).getContext( "2d" );
const width = ctx.canvas.width = 800;
const height = ctx.canvas.height = 600;
const e2d = require( "e2d" );
document.body.appendChild( ctx.canvas );
const tree = rbush();
const rects = [];
for ( let i = 0; i < 100; i++ ) {
const rectWidth = 10 + Math.random() * 90;
const rectHeight = 10 + Math.random() * 90;
const minX = 0 + Math.random() * ( width - rectWidth );
const minY = 0 + Math.random() * ( height - rectHeight );
const maxX = minX + rectWidth;
const maxY = minY + rectHeight;
const rect = {
rectWidth,
rectHeight,
minX,
minY,
maxX,
maxY,
fill: e2d.fillRect( minX, minY, rectWidth, rectHeight ),
};
rects.push( e2d.strokeRect( minX, minY, rectWidth, rectHeight ) );
tree.insert( rect );
}
e2d.initialize( ctx );
e2d.raf(frame => {
const { x, y } = e2d.mouseData( ctx );
const mouseRect = e2d.fillStyle( "red", e2d.strokeRect( x - 10, y - 10, 20, 20 ) );
e2d.render(
e2d.clearRect( width, height ),
tree.search({
minX: x - 10,
minY: y - 10,
maxX: x + 10,
maxY: y + 10
}).map(z => z.fill),
mouseRect,
rects,
ctx
);
});
;}, 0)
Raw
package.json
{
"name": "requirebin-sketch",
"version": "1.0.0",
"dependencies": {
"rbush": "2.0.1",
"e2d": "4.0.0-rc.1"
}
}
Raw
page-body.html
<!-- contents of this file will be placed inside the <body> -->
Raw
page-head.html
<!-- contents of this file will be placed inside the <head> -->
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment